| , %{ |
| /* sbc.y: A POSIX bc processor written for minix with no extensions. */ |
| |
| /* This file is part of bc written for MINIX. |
| Copyright (C) 1991, 1992 Free Software Foundation, Inc. |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License , or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; see the file COPYING. If not, write to |
| the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. |
| |
| You may contact the author by: |
| e-mail: phil@cs.wwu.edu |
| us-mail: Philip A. Nelson |
| Computer Science Department, 9062 |
| Western Washington University |
| Bellingham, WA 98226-9062 |
| |
| *************************************************************************/ |
| |
| #include "bcdefs.h" |
| #include "global.h" /* To get the global variables. */ |
| #include "proto.h" |
| %} |
| |
| %start program |
| |
| %union { |
| char *s_value; |
| char c_value; |
| int i_value; |
| arg_list *a_value; |
| } |
| |
| %token <i_value> NEWLINE AND OR NOT |
| %token <s_value> STRING NAME NUMBER |
| /* '-', '+' are tokens themselves */ |
| %token <c_value> MUL_OP |
| /* '*', '/', '%' */ |
| %token <c_value> ASSIGN_OP |
| /* '=', '+=', '-=', '*=', '/=', '%=', '^=' */ |
| %token <s_value> REL_OP |
| /* '==', '<=', '>=', '!=', '<', '>' */ |
| %token <c_value> INCR_DECR |
| /* '++', '--' */ |
| %token <i_value> Define Break Quit Length |
| /* 'define', 'break', 'quit', 'length' */ |
| %token <i_value> Return For If While Sqrt Else |
| /* 'return', 'for', 'if', 'while', 'sqrt', 'else' */ |
| %token <i_value> Scale Ibase Obase Auto Read |
| /* 'scale', 'ibase', 'obase', 'auto', 'read' */ |
| %token <i_value> Warranty, Halt, Last, Continue, Print, Limits |
| /* 'warranty', 'halt', 'last', 'continue', 'print', 'limits' */ |
| |
| /* The types of all other non-terminals. */ |
| %type <i_value> expression named_expression return_expression |
| %type <a_value> opt_parameter_list parameter_list opt_auto_define_list |
| %type <a_value> define_list opt_argument_list argument_list |
| %type <i_value> program input_item semicolon_list statement_list |
| %type <i_value> statement_or_error statement function relational_expression |
| |
| /* precedence */ |
| %nonassoc REL_OP |
| %right ASSIGN_OP |
| %left '+' '-' |
| %left MUL_OP |
| %right '^' |
| %nonassoc UNARY_MINUS |
| %nonassoc INCR_DECR |
| |
| %% |
| program : /* empty */ |
| { |
| $$ = 0; |
| std_only = TRUE; |
| if (interactive) |
| { |
| printf ("s%s\n", BC_VERSION); |
| welcome(); |
| } |
| } |
| | program input_item |
| ; |
| input_item : semicolon_list NEWLINE |
| { run_code(); } |
| | function |
| { run_code(); } |
| | error NEWLINE |
| { |
| yyerrok; |
| init_gen() ; |
| } |
| ; |
| semicolon_list : /* empty */ |
| { $$ = 0; } |
| | statement_or_error |
| | semicolon_list ';' statement_or_error |
| | semicolon_list ';' |
| ; |
| statement_list : /* empty */ |
| { $$ = 0; } |
| | statement |
| | statement_list NEWLINE |
| | statement_list NEWLINE statement |
| | statement_list ';' |
| | statement_list ';' statement |
| ; |
| statement_or_error : statement |
| | error statement |
| { $$ = $2; } |
| ; |
| statement : Warranty |
| { warranty("s"); } |
| | expression |
| { |
| if ($1 & 1) |
| generate ("W"); |
| else |
| generate ("p"); |
| } |
| | STRING |
| { |
| $$ = 0; |
| generate ("w"); |
| generate ($1); |
| free ($1); |
| } |
| | Break |
| { |
| if (break_label == 0) |
| yyerror ("Break outside a for/while"); |
| else |
| { |
| sprintf (genstr, "J%1d:", break_label); |
| generate (genstr); |
| } |
| } |
| | Quit |
| { exit(0); } |
| | Return |
| { generate ("0R"); } |
| | Return '(' return_expression ')' |
| { generate ("R"); } |
| | For |
| { |
| $1 = break_label; |
| break_label = next_label++; |
| } |
| '(' expression ';' |
| { |
| $4 = next_label++; |
| sprintf (genstr, "pN%1d:", $4); |
| generate (genstr); |
| } |
| relational_expression ';' |
| { |
| $7 = next_label++; |
| sprintf (genstr, "B%1d:J%1d:", $7, break_label); |
| generate (genstr); |
| $<i_value>$ = next_label++; |
| sprintf (genstr, "N%1d:", $<i_value>$); |
| generate (genstr); |
| } |
| expression ')' |
| { |
| sprintf (genstr, "pJ%1d:N%1d:", $4, $7); |
| generate (genstr); |
| } |
| statement |
| { |
| sprintf (genstr, "J%1d:N%1d:", $<i_value>9, |
| break_label); |
| generate (genstr); |
| break_label = $1; |
| } |
| | If '(' relational_expression ')' |
| { |
| $3 = next_label++; |
| sprintf (genstr, "Z%1d:", $3); |
| generate (genstr); |
| } |
| statement |
| { |
| sprintf (genstr, "N%1d:", $3); |
| generate (genstr); |
| } |
| | While |
| { |
| $1 = next_label++; |
| sprintf (genstr, "N%1d:", $1); |
| generate (genstr); |
| } |
| '(' relational_expression |
| { |
| $4 = break_label; |
| break_label = next_label++; |
| sprintf (genstr, "Z%1d:", break_label); |
| generate (genstr); |
| } |
| ')' statement |
| { |
| sprintf (genstr, "J%1d:N%1d:", $1, break_label); |
| generate (genstr); |
| break_label = $4; |
| } |
| | '{' statement_list '}' |
| { $$ = 0; } |
| ; |
| function : Define NAME '(' opt_parameter_list ')' '{' |
| NEWLINE opt_auto_define_list |
| { |
| check_params ($4,$8); |
| sprintf (genstr, "F%d,%s.%s[", lookup($2,FUNCT), |
| arg_str ($4,TRUE), arg_str ($8,TRUE)); |
| generate (genstr); |
| free_args ($4); |
| free_args ($8); |
| $1 = next_label; |
| next_label = 0; |
| } |
| statement_list NEWLINE '}' |
| { |
| generate ("0R]"); |
| next_label = $1; |
| } |
| ; |
| opt_parameter_list : /* empty */ |
| { $$ = NULL; } |
| | parameter_list |
| ; |
| parameter_list : NAME |
| { $$ = nextarg (NULL, lookup($1,SIMPLE)); } |
| | define_list ',' NAME |
| { $$ = nextarg ($1, lookup($3,SIMPLE)); } |
| ; |
| opt_auto_define_list : /* empty */ |
| { $$ = NULL; } |
| | Auto define_list NEWLINE |
| { $$ = $2; } |
| | Auto define_list ';' |
| { $$ = $2; } |
| ; |
| define_list : NAME |
| { $$ = nextarg (NULL, lookup($1,SIMPLE)); } |
| | NAME '[' ']' |
| { $$ = nextarg (NULL, lookup($1,ARRAY)); } |
| | define_list ',' NAME |
| { $$ = nextarg ($1, lookup($3,SIMPLE)); } |
| | define_list ',' NAME '[' ']' |
| { $$ = nextarg ($1, lookup($3,ARRAY)); } |
| ; |
| opt_argument_list : /* empty */ |
| { $$ = NULL; } |
| | argument_list |
| ; |
| argument_list : expression |
| { $$ = nextarg (NULL,0); } |
| | argument_list ',' expression |
| { $$ = nextarg ($1,0); } |
| ; |
| relational_expression : expression |
| { $$ = 0; } |
| | expression REL_OP expression |
| { |
| $$ = 0; |
| switch (*($2)) |
| { |
| case '=': |
| generate ("="); |
| break; |
| case '!': |
| generate ("#"); |
| break; |
| case '<': |
| if ($2[1] == '=') |
| generate ("{"); |
| else |
| generate ("<"); |
| break; |
| case '>': |
| if ($2[1] == '=') |
| generate ("}"); |
| else |
| generate (">"); |
| break; |
| } |
| } |
| ; |
| return_expression : /* empty */ |
| { |
| $$ = 0; |
| generate ("0"); |
| } |
| | expression |
| ; |
| expression : named_expression ASSIGN_OP |
| { |
| if ($2 != '=') |
| { |
| if ($1 < 0) |
| sprintf (genstr, "DL%d:", -$1); |
| else |
| sprintf (genstr, "l%d:", $1); |
| generate (genstr); |
| } |
| } |
| expression |
| { |
| $$ = 0; |
| if ($2 != '=') |
| { |
| sprintf (genstr, "%c", $2); |
| generate (genstr); |
| } |
| if ($1 < 0) |
| sprintf (genstr, "S%d:", -$1); |
| else |
| sprintf (genstr, "s%d:", $1); |
| generate (genstr); |
| } |
| | expression '+' expression |
| { generate ("+"); } |
| | expression '-' expression |
| { generate ("-"); } |
| | expression MUL_OP expression |
| { |
| genstr[0] = $2; |
| genstr[1] = 0; |
| generate (genstr); |
| } |
| | expression '^' expression |
| { generate ("^"); } |
| | '-' expression %prec UNARY_MINUS |
| { generate ("n"); $$ = 1;} |
| | named_expression |
| { |
| $$ = 1; |
| if ($1 < 0) |
| sprintf (genstr, "L%d:", -$1); |
| else |
| sprintf (genstr, "l%d:", $1); |
| generate (genstr); |
| } |
| | NUMBER |
| { |
| int len = strlen($1); |
| $$ = 1; |
| if (len == 1 && *$1 == '0') |
| generate ("0"); |
| else |
| { |
| if (len == 1 && *$1 == '1') |
| generate ("1"); |
| else |
| { |
| generate ("K"); |
| generate ($1); |
| generate (":"); |
| } |
| free ($1); |
| } |
| } |
| | '(' expression ')' |
| { $$ = 1; } |
| | NAME '(' opt_argument_list ')' |
| { |
| $$ = 1; |
| if ($3 != NULL) |
| { |
| sprintf (genstr, "C%d,%s:", lookup($1,FUNCT), |
| arg_str ($3,FALSE)); |
| free_args ($3); |
| } |
| else |
| sprintf (genstr, "C%d:", lookup($1,FUNCT)); |
| generate (genstr); |
| } |
| | INCR_DECR named_expression |
| { |
| $$ = 1; |
| if ($2 < 0) |
| { |
| if ($1 == '+') |
| sprintf (genstr, "DA%d:L%d:", -$2, -$2); |
| else |
| sprintf (genstr, "DM%d:L%d:", -$2, -$2); |
| } |
| else |
| { |
| if ($1 == '+') |
| sprintf (genstr, "i%d:l%d:", $2, $2); |
| else |
| sprintf (genstr, "d%d:l%d:", $2, $2); |
| } |
| generate (genstr); |
| } |
| | named_expression INCR_DECR |
| { |
| $$ = 1; |
| if ($1 < 0) |
| { |
| sprintf (genstr, "DL%d:x", -$1); |
| generate (genstr); |
| if ($2 == '+') |
| sprintf (genstr, "A%d:", -$1); |
| else |
| sprintf (genstr, "M%d:", -$1); |
| } |
| else |
| { |
| sprintf (genstr, "l%d:", $1); |
| generate (genstr); |
| if ($2 == '+') |
| sprintf (genstr, "i%d:", $1); |
| else |
| sprintf (genstr, "d%d:", $1); |
| } |
| generate (genstr); |
| } |
| | Length '(' expression ')' |
| { generate ("cL"); $$ = 1;} |
| | Sqrt '(' expression ')' |
| { generate ("cR"); $$ = 1;} |
| | Scale '(' expression ')' |
| { generate ("cS"); $$ = 1;} |
| ; |
| named_expression : NAME |
| { $$ = lookup($1,SIMPLE); } |
| | NAME '[' expression ']' |
| { $$ = lookup($1,ARRAY); } |
| | Ibase |
| { $$ = 0; } |
| | Obase |
| { $$ = 1; } |
| | Scale |
| { $$ = 2; } |
| ; |
| |
| %% |
