commands/bc/sbc.y

   1 , %{
   2 /* sbc.y: A POSIX bc processor written for minix with no extensions.  */
   3
   4 /*  This file is part of bc written for MINIX.
   5     Copyright (C) 1991, 1992 Free Software Foundation, Inc.
   6
   7     This program is free software; you can redistribute it and/or modify
   8     it under the terms of the GNU General Public License as published by
   9     the Free Software Foundation; either version 2 of the License , or
  10     (at your option) any later version.
  11
  12     This program is distributed in the hope that it will be useful,
  13     but WITHOUT ANY WARRANTY; without even the implied warranty of
  14     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15     GNU General Public License for more details.
  16
  17     You should have received a copy of the GNU General Public License
  18     along with this program; see the file COPYING.  If not, write to
  19     the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21     You may contact the author by:
  22        e-mail:  phil@cs.wwu.edu
  23       us-mail:  Philip A. Nelson
  24                 Computer Science Department, 9062
  25                 Western Washington University
  26                 Bellingham, WA 98226-9062
  27
  28 *************************************************************************/
  29
  30 #include "bcdefs.h"
  31 #include "global.h"     /* To get the global variables. */
  32 #include "proto.h"
  33 %}
  34
  35 %start program
  36
  37 %union {
  38         char *s_value;
  39         char  c_value;
  40         int   i_value;
  41         arg_list *a_value;
  42        }
  43
  44 %token <i_value> NEWLINE AND OR NOT
  45 %token <s_value> STRING NAME NUMBER
  46 /*     '-', '+' are tokens themselves           */
  47 %token <c_value> MUL_OP
  48 /*     '*', '/', '%'                            */
  49 %token <c_value> ASSIGN_OP
  50 /*     '=', '+=',  '-=', '*=', '/=', '%=', '^=' */
  51 %token <s_value> REL_OP
  52 /*     '==', '<=', '>=', '!=', '<', '>'         */
  53 %token <c_value> INCR_DECR
  54 /*     '++', '--'                               */
  55 %token <i_value> Define    Break    Quit    Length
  56 /*     'define', 'break', 'quit', 'length'      */
  57 %token <i_value> Return    For    If    While    Sqrt  Else
  58 /*     'return', 'for', 'if', 'while', 'sqrt',  'else'  */
  59 %token <i_value> Scale    Ibase    Obase    Auto  Read
  60 /*     'scale', 'ibase', 'obase', 'auto', 'read'        */
  61 %token <i_value> Warranty, Halt, Last, Continue, Print, Limits
  62 /*     'warranty', 'halt', 'last', 'continue', 'print', 'limits'  */
  63
  64 /* The types of all other non-terminals. */
  65 %type <i_value> expression named_expression return_expression
  66 %type <a_value> opt_parameter_list parameter_list opt_auto_define_list
  67 %type <a_value> define_list opt_argument_list argument_list
  68 %type <i_value> program input_item semicolon_list statement_list
  69 %type <i_value> statement_or_error statement function relational_expression
  70
  71 /* precedence */
  72 %nonassoc REL_OP
  73 %right ASSIGN_OP
  74 %left '+' '-'
  75 %left MUL_OP
  76 %right '^'
  77 %nonassoc UNARY_MINUS
  78 %nonassoc INCR_DECR
  79
  80 %%
  81 program                 : /* empty */
  82                             {
  83                               $$ = 0;
  84                               std_only = TRUE;
  85                               if (interactive)
  86                                 {
  87                                   printf ("s%s\n", BC_VERSION);
  88                                   welcome();
  89                                 }
  90                             }
  91                         | program input_item
  92                         ;
  93 input_item              : semicolon_list NEWLINE
  94                             { run_code(); }
  95                         | function
  96                             { run_code(); }
  97                         | error NEWLINE
  98                             {
  99                               yyerrok;
 100                               init_gen() ;
 101                             }
 102                         ;
 103 semicolon_list          : /* empty */
 104                             { $$ = 0; }
 105                         | statement_or_error
 106                         | semicolon_list ';' statement_or_error
 107                         | semicolon_list ';'
 108                         ;
 109 statement_list          : /* empty */
 110                             { $$ = 0; }
 111                         | statement
 112                         | statement_list NEWLINE
 113                         | statement_list NEWLINE statement
 114                         | statement_list ';'
 115                         | statement_list ';' statement
 116                         ;
 117 statement_or_error      : statement
 118                         | error statement
 119                             { $$ = $2; }
 120                         ;
 121 statement               : Warranty
 122                             { warranty("s"); }
 123                         | expression
 124                             {
 125                               if ($1 & 1)
 126                                 generate ("W");
 127                               else
 128                                 generate ("p");
 129                             }
 130                         | STRING
 131                             {
 132                               $$ = 0;
 133                               generate ("w");
 134                               generate ($1);
 135                               free ($1);
 136                             }
 137                         | Break
 138                             {
 139                               if (break_label == 0)
 140                                 yyerror ("Break outside a for/while");
 141                               else
 142                                 {
 143                                   sprintf (genstr, "J%1d:", break_label);
 144                                   generate (genstr);
 145                                 }
 146                             }
 147                         | Quit
 148                             { exit(0); }
 149                         | Return
 150                             { generate ("0R"); }
 151                         | Return '(' return_expression ')'
 152                             { generate ("R"); }
 153                         | For
 154                             {
 155                               $1 = break_label;
 156                               break_label = next_label++;
 157                             }
 158                           '(' expression ';'
 159                             {
 160                               $4 = next_label++;
 161                               sprintf (genstr, "pN%1d:", $4);
 162                               generate (genstr);
 163                             }
 164                           relational_expression ';'
 165                             {
 166                               $7 = next_label++;
 167                               sprintf (genstr, "B%1d:J%1d:", $7, break_label);
 168                               generate (genstr);
 169                               $<i_value>$ = next_label++;
 170                               sprintf (genstr, "N%1d:", $<i_value>$);
 171                               generate (genstr);
 172                             }
 173                           expression ')'
 174                             {
 175                               sprintf (genstr, "pJ%1d:N%1d:", $4, $7);
 176                               generate (genstr);
 177                             }
 178                           statement
 179                             {
 180                               sprintf (genstr, "J%1d:N%1d:", $<i_value>9,
 181                                        break_label);
 182                               generate (genstr);
 183                               break_label = $1;
 184                             }
 185                         | If '(' relational_expression ')'
 186                             {
 187                               $3 = next_label++;
 188                               sprintf (genstr, "Z%1d:", $3);
 189                               generate (genstr);
 190                             }
 191                           statement
 192                             {
 193                               sprintf (genstr, "N%1d:", $3);
 194                               generate (genstr);
 195                             }
 196                         | While
 197                             {
 198                               $1 = next_label++;
 199                               sprintf (genstr, "N%1d:", $1);
 200                               generate (genstr);
 201                             }
 202                         '(' relational_expression
 203                             {
 204                               $4 = break_label;
 205                               break_label = next_label++;
 206                               sprintf (genstr, "Z%1d:", break_label);
 207                               generate (genstr);
 208                             }
 209                         ')' statement
 210                             {
 211                               sprintf (genstr, "J%1d:N%1d:", $1, break_label);
 212                               generate (genstr);
 213                               break_label = $4;
 214                             }
 215                         | '{' statement_list '}'
 216                             { $$ = 0; }
 217                         ;
 218 function                : Define NAME '(' opt_parameter_list ')' '{'
 219                           NEWLINE opt_auto_define_list
 220                             {
 221                               check_params ($4,$8);
 222                               sprintf (genstr, "F%d,%s.%s[", lookup($2,FUNCT),
 223                                        arg_str ($4,TRUE), arg_str ($8,TRUE));
 224                               generate (genstr);
 225                               free_args ($4);
 226                               free_args ($8);
 227                               $1 = next_label;
 228                               next_label = 0;
 229                             }
 230                           statement_list NEWLINE '}'
 231                             {
 232                               generate ("0R]");
 233                               next_label = $1;
 234                             }
 235                         ;
 236 opt_parameter_list      : /* empty */
 237                             { $$ = NULL; }
 238                         | parameter_list
 239                         ;
 240 parameter_list          : NAME
 241                             { $$ = nextarg (NULL, lookup($1,SIMPLE)); }
 242                         | define_list ',' NAME
 243                             { $$ = nextarg ($1, lookup($3,SIMPLE)); }
 244                         ;
 245 opt_auto_define_list    : /* empty */
 246                             { $$ = NULL; }
 247                         | Auto define_list NEWLINE
 248                             { $$ = $2; }
 249                         | Auto define_list ';'
 250                             { $$ = $2; }
 251                         ;
 252 define_list             : NAME
 253                             { $$ = nextarg (NULL, lookup($1,SIMPLE)); }
 254                         | NAME '[' ']'
 255                             { $$ = nextarg (NULL, lookup($1,ARRAY)); }
 256                         | define_list ',' NAME
 257                             { $$ = nextarg ($1, lookup($3,SIMPLE)); }
 258                         | define_list ',' NAME '[' ']'
 259                             { $$ = nextarg ($1, lookup($3,ARRAY)); }
 260                         ;
 261 opt_argument_list       : /* empty */
 262                             { $$ = NULL; }
 263                         | argument_list
 264                         ;
 265 argument_list           : expression
 266                             { $$ = nextarg (NULL,0); }
 267                         | argument_list ',' expression
 268                             { $$ = nextarg ($1,0); }
 269                         ;
 270 relational_expression   : expression
 271                             { $$ = 0; }
 272                         | expression REL_OP expression
 273                             {
 274                               $$ = 0;
 275                               switch (*($2))
 276                                 {
 277                                 case '=':
 278                                   generate ("=");
 279                                   break;
 280                                 case '!':
 281                                   generate ("#");
 282                                   break;
 283                                 case '<':
 284                                   if ($2[1] == '=')
 285                                     generate ("{");
 286                                   else
 287                                     generate ("<");
 288                                   break;
 289                                 case '>':
 290                                   if ($2[1] == '=')
 291                                     generate ("}");
 292                                   else
 293                                     generate (">");
 294                                   break;
 295                                 }
 296                             }
 297                         ;
 298 return_expression       : /* empty */
 299                             {
 300                               $$ = 0;
 301                               generate ("0");
 302                             }
 303                         | expression
 304                         ;
 305 expression              : named_expression ASSIGN_OP
 306                             {
 307                               if ($2 != '=')
 308                                 {
 309                                   if ($1 < 0)
 310                                     sprintf (genstr, "DL%d:", -$1);
 311                                   else
 312                                     sprintf (genstr, "l%d:", $1);
 313                                   generate (genstr);
 314                                 }
 315                             }
 316                           expression
 317                             {
 318                               $$ = 0;
 319                               if ($2 != '=')
 320                                 {
 321                                   sprintf (genstr, "%c", $2);
 322                                   generate (genstr);
 323                                 }
 324                               if ($1 < 0)
 325                                 sprintf (genstr, "S%d:", -$1);
 326                               else
 327                                 sprintf (genstr, "s%d:", $1);
 328                               generate (genstr);
 329                             }
 330                         | expression '+' expression
 331                             { generate ("+"); }
 332                         | expression '-' expression
 333                             { generate ("-"); }
 334                         | expression MUL_OP expression
 335                             {
 336                               genstr[0] = $2;
 337                               genstr[1] = 0;
 338                               generate (genstr);
 339                             }
 340                         | expression '^' expression
 341                             { generate ("^"); }
 342                         | '-' expression           %prec UNARY_MINUS
 343                             { generate ("n"); $$ = 1;}
 344                         | named_expression
 345                             {
 346                               $$ = 1;
 347                               if ($1 < 0)
 348                                 sprintf (genstr, "L%d:", -$1);
 349                               else
 350                                 sprintf (genstr, "l%d:", $1);
 351                               generate (genstr);
 352                             }
 353                         | NUMBER
 354                             {
 355                               int len = strlen($1);
 356                               $$ = 1;
 357                               if (len == 1 && *$1 == '0')
 358                                 generate ("0");
 359                               else
 360                                 {
 361                                   if (len == 1 && *$1 == '1')
 362                                     generate ("1");
 363                                   else
 364                                     {
 365                                       generate ("K");
 366                                       generate ($1);
 367                                       generate (":");
 368                                     }
 369                                   free ($1);
 370                                 }
 371                             }
 372                         | '(' expression ')'
 373                             { $$ = 1; }
 374                         | NAME '(' opt_argument_list ')'
 375                             {
 376                               $$ = 1;
 377                               if ($3 != NULL)
 378                                 {
 379                                   sprintf (genstr, "C%d,%s:", lookup($1,FUNCT),
 380                                            arg_str ($3,FALSE));
 381                                   free_args ($3);
 382                                 }
 383                               else
 384                                   sprintf (genstr, "C%d:", lookup($1,FUNCT));
 385                               generate (genstr);
 386                             }
 387                         | INCR_DECR named_expression
 388                             {
 389                               $$ = 1;
 390                               if ($2 < 0)
 391                                 {
 392                                   if ($1 == '+')
 393                                     sprintf (genstr, "DA%d:L%d:", -$2, -$2);
 394                                   else
 395                                     sprintf (genstr, "DM%d:L%d:", -$2, -$2);
 396                                 }
 397                               else
 398                                 {
 399                                   if ($1 == '+')
 400                                     sprintf (genstr, "i%d:l%d:", $2, $2);
 401                                   else
 402                                     sprintf (genstr, "d%d:l%d:", $2, $2);
 403                                 }
 404                               generate (genstr);
 405                             }
 406                         | named_expression INCR_DECR
 407                             {
 408                               $$ = 1;
 409                               if ($1 < 0)
 410                                 {
 411                                   sprintf (genstr, "DL%d:x", -$1);
 412                                   generate (genstr);
 413                                   if ($2 == '+')
 414                                     sprintf (genstr, "A%d:", -$1);
 415                                   else
 416                                     sprintf (genstr, "M%d:", -$1);
 417                                 }
 418                               else
 419                                 {
 420                                   sprintf (genstr, "l%d:", $1);
 421                                   generate (genstr);
 422                                   if ($2 == '+')
 423                                     sprintf (genstr, "i%d:", $1);
 424                                   else
 425                                     sprintf (genstr, "d%d:", $1);
 426                                 }
 427                               generate (genstr);
 428                             }
 429                         | Length '(' expression ')'
 430                             { generate ("cL"); $$ = 1;}
 431                         | Sqrt '(' expression ')'
 432                             { generate ("cR"); $$ = 1;}
 433                         | Scale '(' expression ')'
 434                             { generate ("cS"); $$ = 1;}
 435                         ;
 436 named_expression        : NAME
 437                             { $$ = lookup($1,SIMPLE); }
 438                         | NAME '[' expression ']'
 439                             { $$ = lookup($1,ARRAY); }
 440                         | Ibase
 441                             { $$ = 0; }
 442                         | Obase
 443                             { $$ = 1; }
 444                         | Scale
 445                             { $$ = 2; }
 446                         ;
 447
 448 %%