contrib/awk/awkgram.y

   1 /****************************************************************
   2 Copyright (C) Lucent Technologies 1997
   3 All Rights Reserved
   4
   5 Permission to use, copy, modify, and distribute this software and
   6 its documentation for any purpose and without fee is hereby
   7 granted, provided that the above copyright notice appear in all
   8 copies and that both that the copyright notice and this
   9 permission notice and warranty disclaimer appear in supporting
  10 documentation, and that the name Lucent Technologies or any of
  11 its entities not be used in advertising or publicity pertaining
  12 to distribution of the software without specific, written prior
  13 permission.
  14
  15 LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  16 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
  17 IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
  18 SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
  20 IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  21 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
  22 THIS SOFTWARE.
  23 ****************************************************************/
  24
  25 %{
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include "awk.h"
  29
  30 void checkdup(Node *list, Cell *item);
  31 int yywrap(void) { return(1); }
  32
  33 Node    *beginloc = 0;
  34 Node    *endloc = 0;
  35 int     infunc  = 0;    /* = 1 if in arglist or body of func */
  36 int     inloop  = 0;    /* = 1 if in while, for, do */
  37 char    *curfname = 0;  /* current function name */
  38 Node    *arglist = 0;   /* list of args for current function */
  39 %}
  40
  41 %union {
  42         Node    *p;
  43         Cell    *cp;
  44         int     i;
  45         char    *s;
  46 }
  47
  48 %token  <i>     FIRSTTOKEN      /* must be first */
  49 %token  <p>     PROGRAM PASTAT PASTAT2 XBEGIN XEND
  50 %token  <i>     NL ',' '{' '(' '|' ';' '/' ')' '}' '[' ']'
  51 %token  <i>     ARRAY
  52 %token  <i>     MATCH NOTMATCH MATCHOP
  53 %token  <i>     FINAL DOT ALL CCL NCCL CHAR OR STAR QUEST PLUS EMPTYRE
  54 %token  <i>     AND BOR APPEND EQ GE GT LE LT NE IN
  55 %token  <i>     ARG BLTIN BREAK CLOSE CONTINUE DELETE DO EXIT FOR FUNC
  56 %token  <i>     SUB GSUB IF INDEX LSUBSTR MATCHFCN NEXT NEXTFILE
  57 %token  <i>     ADD MINUS MULT DIVIDE MOD
  58 %token  <i>     ASSIGN ASGNOP ADDEQ SUBEQ MULTEQ DIVEQ MODEQ POWEQ
  59 %token  <i>     PRINT PRINTF SPRINTF
  60 %token  <p>     ELSE INTEST CONDEXPR
  61 %token  <i>     POSTINCR PREINCR POSTDECR PREDECR
  62 %token  <cp>    VAR IVAR VARNF CALL NUMBER STRING
  63 %token  <s>     REGEXPR
  64
  65 %type   <p>     pas pattern ppattern plist pplist patlist prarg term re
  66 %type   <p>     pa_pat pa_stat pa_stats
  67 %type   <s>     reg_expr
  68 %type   <p>     simple_stmt opt_simple_stmt stmt stmtlist
  69 %type   <p>     var varname funcname varlist
  70 %type   <p>     for if else while
  71 %type   <i>     do st
  72 %type   <i>     pst opt_pst lbrace rbrace rparen comma nl opt_nl and bor
  73 %type   <i>     subop print
  74
  75 %right  ASGNOP
  76 %right  '?'
  77 %right  ':'
  78 %left   BOR
  79 %left   AND
  80 %left   GETLINE
  81 %nonassoc APPEND EQ GE GT LE LT NE MATCHOP IN '|'
  82 %left   ARG BLTIN BREAK CALL CLOSE CONTINUE DELETE DO EXIT FOR FUNC
  83 %left   GSUB IF INDEX LSUBSTR MATCHFCN NEXT NUMBER
  84 %left   PRINT PRINTF RETURN SPLIT SPRINTF STRING SUB SUBSTR
  85 %left   REGEXPR VAR VARNF IVAR WHILE '('
  86 %left   CAT
  87 %left   '+' '-'
  88 %left   '*' '/' '%'
  89 %left   NOT UMINUS
  90 %right  POWER
  91 %right  DECR INCR
  92 %left   INDIRECT
  93 %token  LASTTOKEN       /* must be last */
  94
  95 %%
  96
  97 program:
  98           pas   { if (errorflag==0)
  99                         winner = (Node *)stat3(PROGRAM, beginloc, $1, endloc); }
 100         | error { yyclearin; bracecheck(); SYNTAX("bailing out"); }
 101         ;
 102
 103 and:
 104           AND | and NL
 105         ;
 106
 107 bor:
 108           BOR | bor NL
 109         ;
 110
 111 comma:
 112           ',' | comma NL
 113         ;
 114
 115 do:
 116           DO | do NL
 117         ;
 118
 119 else:
 120           ELSE | else NL
 121         ;
 122
 123 for:
 124           FOR '(' opt_simple_stmt ';' opt_nl pattern ';' opt_nl opt_simple_stmt rparen {inloop++;} stmt
 125                 { --inloop; $$ = stat4(FOR, $3, notnull($6), $9, $12); }
 126         | FOR '(' opt_simple_stmt ';'  ';' opt_nl opt_simple_stmt rparen {inloop++;} stmt
 127                 { --inloop; $$ = stat4(FOR, $3, NIL, $7, $10); }
 128         | FOR '(' varname IN varname rparen {inloop++;} stmt
 129                 { --inloop; $$ = stat3(IN, $3, makearr($5), $8); }
 130         ;
 131
 132 funcname:
 133           VAR   { setfname($1); }
 134         | CALL  { setfname($1); }
 135         ;
 136
 137 if:
 138           IF '(' pattern rparen         { $$ = notnull($3); }
 139         ;
 140
 141 lbrace:
 142           '{' | lbrace NL
 143         ;
 144
 145 nl:
 146           NL | nl NL
 147         ;
 148
 149 opt_nl:
 150           /* empty */   { $$ = 0; }
 151         | nl
 152         ;
 153
 154 opt_pst:
 155           /* empty */   { $$ = 0; }
 156         | pst
 157         ;
 158
 159
 160 opt_simple_stmt:
 161           /* empty */                   { $$ = 0; }
 162         | simple_stmt
 163         ;
 164
 165 pas:
 166           opt_pst                       { $$ = 0; }
 167         | opt_pst pa_stats opt_pst      { $$ = $2; }
 168         ;
 169
 170 pa_pat:
 171           pattern       { $$ = notnull($1); }
 172         ;
 173
 174 pa_stat:
 175           pa_pat                        { $$ = stat2(PASTAT, $1, stat2(PRINT, rectonode(), NIL)); }
 176         | pa_pat lbrace stmtlist '}'    { $$ = stat2(PASTAT, $1, $3); }
 177         | pa_pat ',' opt_nl pa_pat              { $$ = pa2stat($1, $4, stat2(PRINT, rectonode(), NIL)); }
 178         | pa_pat ',' opt_nl pa_pat lbrace stmtlist '}'  { $$ = pa2stat($1, $4, $6); }
 179         | lbrace stmtlist '}'           { $$ = stat2(PASTAT, NIL, $2); }
 180         | XBEGIN lbrace stmtlist '}'
 181                 { beginloc = linkum(beginloc, $3); $$ = 0; }
 182         | XEND lbrace stmtlist '}'
 183                 { endloc = linkum(endloc, $3); $$ = 0; }
 184         | FUNC funcname '(' varlist rparen {infunc++;} lbrace stmtlist '}'
 185                 { infunc--; curfname=0; defn((Cell *)$2, $4, $8); $$ = 0; }
 186         ;
 187
 188 pa_stats:
 189           pa_stat
 190         | pa_stats opt_pst pa_stat      { $$ = linkum($1, $3); }
 191         ;
 192
 193 patlist:
 194           pattern
 195         | patlist comma pattern         { $$ = linkum($1, $3); }
 196         ;
 197
 198 ppattern:
 199           var ASGNOP ppattern           { $$ = op2($2, $1, $3); }
 200         | ppattern '?' ppattern ':' ppattern %prec '?'
 201                 { $$ = op3(CONDEXPR, notnull($1), $3, $5); }
 202         | ppattern bor ppattern %prec BOR
 203                 { $$ = op2(BOR, notnull($1), notnull($3)); }
 204         | ppattern and ppattern %prec AND
 205                 { $$ = op2(AND, notnull($1), notnull($3)); }
 206         | ppattern MATCHOP reg_expr     { $$ = op3($2, NIL, $1, (Node*)makedfa($3, 0)); }
 207         | ppattern MATCHOP ppattern
 208                 { if (constnode($3))
 209                         $$ = op3($2, NIL, $1, (Node*)makedfa(strnode($3), 0));
 210                   else
 211                         $$ = op3($2, (Node *)1, $1, $3); }
 212         | ppattern IN varname           { $$ = op2(INTEST, $1, makearr($3)); }
 213         | '(' plist ')' IN varname      { $$ = op2(INTEST, $2, makearr($5)); }
 214         | ppattern term %prec CAT       { $$ = op2(CAT, $1, $2); }
 215         | re
 216         | term
 217         ;
 218
 219 pattern:
 220           var ASGNOP pattern            { $$ = op2($2, $1, $3); }
 221         | pattern '?' pattern ':' pattern %prec '?'
 222                 { $$ = op3(CONDEXPR, notnull($1), $3, $5); }
 223         | pattern bor pattern %prec BOR
 224                 { $$ = op2(BOR, notnull($1), notnull($3)); }
 225         | pattern and pattern %prec AND
 226                 { $$ = op2(AND, notnull($1), notnull($3)); }
 227         | pattern EQ pattern            { $$ = op2($2, $1, $3); }
 228         | pattern GE pattern            { $$ = op2($2, $1, $3); }
 229         | pattern GT pattern            { $$ = op2($2, $1, $3); }
 230         | pattern LE pattern            { $$ = op2($2, $1, $3); }
 231         | pattern LT pattern            { $$ = op2($2, $1, $3); }
 232         | pattern NE pattern            { $$ = op2($2, $1, $3); }
 233         | pattern MATCHOP reg_expr      { $$ = op3($2, NIL, $1, (Node*)makedfa($3, 0)); }
 234         | pattern MATCHOP pattern
 235                 { if (constnode($3))
 236                         $$ = op3($2, NIL, $1, (Node*)makedfa(strnode($3), 0));
 237                   else
 238                         $$ = op3($2, (Node *)1, $1, $3); }
 239         | pattern IN varname            { $$ = op2(INTEST, $1, makearr($3)); }
 240         | '(' plist ')' IN varname      { $$ = op2(INTEST, $2, makearr($5)); }
 241         | pattern '|' GETLINE var       {
 242                         if (safe) SYNTAX("cmd | getline is unsafe");
 243                         else $$ = op3(GETLINE, $4, itonp($2), $1); }
 244         | pattern '|' GETLINE           {
 245                         if (safe) SYNTAX("cmd | getline is unsafe");
 246                         else $$ = op3(GETLINE, (Node*)0, itonp($2), $1); }
 247         | pattern term %prec CAT        { $$ = op2(CAT, $1, $2); }
 248         | re
 249         | term
 250         ;
 251
 252 plist:
 253           pattern comma pattern         { $$ = linkum($1, $3); }
 254         | plist comma pattern           { $$ = linkum($1, $3); }
 255         ;
 256
 257 pplist:
 258           ppattern
 259         | pplist comma ppattern         { $$ = linkum($1, $3); }
 260         ;
 261
 262 prarg:
 263           /* empty */                   { $$ = rectonode(); }
 264         | pplist
 265         | '(' plist ')'                 { $$ = $2; }
 266         ;
 267
 268 print:
 269           PRINT | PRINTF
 270         ;
 271
 272 pst:
 273           NL | ';' | pst NL | pst ';'
 274         ;
 275
 276 rbrace:
 277           '}' | rbrace NL
 278         ;
 279
 280 re:
 281            reg_expr
 282                 { $$ = op3(MATCH, NIL, rectonode(), (Node*)makedfa($1, 0)); }
 283         | NOT re        { $$ = op1(NOT, notnull($2)); }
 284         ;
 285
 286 reg_expr:
 287           '/' {startreg();} REGEXPR '/'         { $$ = $3; }
 288         ;
 289
 290 rparen:
 291           ')' | rparen NL
 292         ;
 293
 294 simple_stmt:
 295           print prarg '|' term          {
 296                         if (safe) SYNTAX("print | is unsafe");
 297                         else $$ = stat3($1, $2, itonp($3), $4); }
 298         | print prarg APPEND term       {
 299                         if (safe) SYNTAX("print >> is unsafe");
 300                         else $$ = stat3($1, $2, itonp($3), $4); }
 301         | print prarg GT term           {
 302                         if (safe) SYNTAX("print > is unsafe");
 303                         else $$ = stat3($1, $2, itonp($3), $4); }
 304         | print prarg                   { $$ = stat3($1, $2, NIL, NIL); }
 305         | DELETE varname '[' patlist ']' { $$ = stat2(DELETE, makearr($2), $4); }
 306         | DELETE varname                 { $$ = stat2(DELETE, makearr($2), 0); }
 307         | pattern                       { $$ = exptostat($1); }
 308         | error                         { yyclearin; SYNTAX("illegal statement"); }
 309         ;
 310
 311 st:
 312           nl
 313         | ';' opt_nl
 314         ;
 315
 316 stmt:
 317           BREAK st              { if (!inloop) SYNTAX("break illegal outside of loops");
 318                                   $$ = stat1(BREAK, NIL); }
 319         | CONTINUE st           {  if (!inloop) SYNTAX("continue illegal outside of loops");
 320                                   $$ = stat1(CONTINUE, NIL); }
 321         | do {inloop++;} stmt {--inloop;} WHILE '(' pattern ')' st
 322                 { $$ = stat2(DO, $3, notnull($7)); }
 323         | EXIT pattern st       { $$ = stat1(EXIT, $2); }
 324         | EXIT st               { $$ = stat1(EXIT, NIL); }
 325         | for
 326         | if stmt else stmt     { $$ = stat3(IF, $1, $2, $4); }
 327         | if stmt               { $$ = stat3(IF, $1, $2, NIL); }
 328         | lbrace stmtlist rbrace { $$ = $2; }
 329         | NEXT st       { if (infunc)
 330                                 SYNTAX("next is illegal inside a function");
 331                           $$ = stat1(NEXT, NIL); }
 332         | NEXTFILE st   { if (infunc)
 333                                 SYNTAX("nextfile is illegal inside a function");
 334                           $$ = stat1(NEXTFILE, NIL); }
 335         | RETURN pattern st     { $$ = stat1(RETURN, $2); }
 336         | RETURN st             { $$ = stat1(RETURN, NIL); }
 337         | simple_stmt st
 338         | while {inloop++;} stmt        { --inloop; $$ = stat2(WHILE, $1, $3); }
 339         | ';' opt_nl            { $$ = 0; }
 340         ;
 341
 342 stmtlist:
 343           stmt
 344         | stmtlist stmt         { $$ = linkum($1, $2); }
 345         ;
 346
 347 subop:
 348           SUB | GSUB
 349         ;
 350
 351 term:
 352           term '/' ASGNOP term          { $$ = op2(DIVEQ, $1, $4); }
 353         | term '+' term                 { $$ = op2(ADD, $1, $3); }
 354         | term '-' term                 { $$ = op2(MINUS, $1, $3); }
 355         | term '*' term                 { $$ = op2(MULT, $1, $3); }
 356         | term '/' term                 { $$ = op2(DIVIDE, $1, $3); }
 357         | term '%' term                 { $$ = op2(MOD, $1, $3); }
 358         | term POWER term               { $$ = op2(POWER, $1, $3); }
 359         | '-' term %prec UMINUS         { $$ = op1(UMINUS, $2); }
 360         | '+' term %prec UMINUS         { $$ = $2; }
 361         | NOT term %prec UMINUS         { $$ = op1(NOT, notnull($2)); }
 362         | BLTIN '(' ')'                 { $$ = op2(BLTIN, itonp($1), rectonode()); }
 363         | BLTIN '(' patlist ')'         { $$ = op2(BLTIN, itonp($1), $3); }
 364         | BLTIN                         { $$ = op2(BLTIN, itonp($1), rectonode()); }
 365         | CALL '(' ')'                  { $$ = op2(CALL, celltonode($1,CVAR), NIL); }
 366         | CALL '(' patlist ')'          { $$ = op2(CALL, celltonode($1,CVAR), $3); }
 367         | CLOSE term                    { $$ = op1(CLOSE, $2); }
 368         | DECR var                      { $$ = op1(PREDECR, $2); }
 369         | INCR var                      { $$ = op1(PREINCR, $2); }
 370         | var DECR                      { $$ = op1(POSTDECR, $1); }
 371         | var INCR                      { $$ = op1(POSTINCR, $1); }
 372         | GETLINE var LT term           { $$ = op3(GETLINE, $2, itonp($3), $4); }
 373         | GETLINE LT term               { $$ = op3(GETLINE, NIL, itonp($2), $3); }
 374         | GETLINE var                   { $$ = op3(GETLINE, $2, NIL, NIL); }
 375         | GETLINE                       { $$ = op3(GETLINE, NIL, NIL, NIL); }
 376         | INDEX '(' pattern comma pattern ')'
 377                 { $$ = op2(INDEX, $3, $5); }
 378         | INDEX '(' pattern comma reg_expr ')'
 379                 { SYNTAX("index() doesn't permit regular expressions");
 380                   $$ = op2(INDEX, $3, (Node*)$5); }
 381         | '(' pattern ')'               { $$ = $2; }
 382         | MATCHFCN '(' pattern comma reg_expr ')'
 383                 { $$ = op3(MATCHFCN, NIL, $3, (Node*)makedfa($5, 1)); }
 384         | MATCHFCN '(' pattern comma pattern ')'
 385                 { if (constnode($5))
 386                         $$ = op3(MATCHFCN, NIL, $3, (Node*)makedfa(strnode($5), 1));
 387                   else
 388                         $$ = op3(MATCHFCN, (Node *)1, $3, $5); }
 389         | NUMBER                        { $$ = celltonode($1, CCON); }
 390         | SPLIT '(' pattern comma varname comma pattern ')'     /* string */
 391                 { $$ = op4(SPLIT, $3, makearr($5), $7, (Node*)STRING); }
 392         | SPLIT '(' pattern comma varname comma reg_expr ')'    /* const /regexp/ */
 393                 { $$ = op4(SPLIT, $3, makearr($5), (Node*)makedfa($7, 1), (Node *)REGEXPR); }
 394         | SPLIT '(' pattern comma varname ')'
 395                 { $$ = op4(SPLIT, $3, makearr($5), NIL, (Node*)STRING); }  /* default */
 396         | SPRINTF '(' patlist ')'       { $$ = op1($1, $3); }
 397         | STRING                        { $$ = celltonode($1, CCON); }
 398         | subop '(' reg_expr comma pattern ')'
 399                 { $$ = op4($1, NIL, (Node*)makedfa($3, 1), $5, rectonode()); }
 400         | subop '(' pattern comma pattern ')'
 401                 { if (constnode($3))
 402                         $$ = op4($1, NIL, (Node*)makedfa(strnode($3), 1), $5, rectonode());
 403                   else
 404                         $$ = op4($1, (Node *)1, $3, $5, rectonode()); }
 405         | subop '(' reg_expr comma pattern comma var ')'
 406                 { $$ = op4($1, NIL, (Node*)makedfa($3, 1), $5, $7); }
 407         | subop '(' pattern comma pattern comma var ')'
 408                 { if (constnode($3))
 409                         $$ = op4($1, NIL, (Node*)makedfa(strnode($3), 1), $5, $7);
 410                   else
 411                         $$ = op4($1, (Node *)1, $3, $5, $7); }
 412         | SUBSTR '(' pattern comma pattern comma pattern ')'
 413                 { $$ = op3(SUBSTR, $3, $5, $7); }
 414         | SUBSTR '(' pattern comma pattern ')'
 415                 { $$ = op3(SUBSTR, $3, $5, NIL); }
 416         | var
 417         ;
 418
 419 var:
 420           varname
 421         | varname '[' patlist ']'       { $$ = op2(ARRAY, makearr($1), $3); }
 422         | IVAR                          { $$ = op1(INDIRECT, celltonode($1, CVAR)); }
 423         | INDIRECT term                 { $$ = op1(INDIRECT, $2); }
 424         ;
 425
 426 varlist:
 427           /* nothing */         { arglist = $$ = 0; }
 428         | VAR                   { arglist = $$ = celltonode($1,CVAR); }
 429         | varlist comma VAR     {
 430                         checkdup($1, $3);
 431                         arglist = $$ = linkum($1,celltonode($3,CVAR)); }
 432         ;
 433
 434 varname:
 435           VAR                   { $$ = celltonode($1, CVAR); }
 436         | ARG                   { $$ = op1(ARG, itonp($1)); }
 437         | VARNF                 { $$ = op1(VARNF, (Node *) $1); }
 438         ;
 439
 440
 441 while:
 442           WHILE '(' pattern rparen      { $$ = notnull($3); }
 443         ;
 444
 445 %%
 446
 447 void setfname(Cell *p)
 448 {
 449         if (isarr(p))
 450                 SYNTAX("%s is an array, not a function", p->nval);
 451         else if (isfcn(p))
 452                 SYNTAX("you can't define function %s more than once", p->nval);
 453         curfname = p->nval;
 454 }
 455
 456 int constnode(Node *p)
 457 {
 458         return isvalue(p) && ((Cell *) (p->narg[0]))->csub == CCON;
 459 }
 460
 461 char *strnode(Node *p)
 462 {
 463         return ((Cell *)(p->narg[0]))->sval;
 464 }
 465
 466 Node *notnull(Node *n)
 467 {
 468         switch (n->nobj) {
 469         case LE: case LT: case EQ: case NE: case GT: case GE:
 470         case BOR: case AND: case NOT:
 471                 return n;
 472         default:
 473                 return op2(NE, n, nullnode);
 474         }
 475 }
 476
 477 void checkdup(Node *vl, Cell *cp)       /* check if name already in list */
 478 {
 479         char *s = cp->nval;
 480         for ( ; vl; vl = vl->nnext) {
 481                 if (strcmp(s, ((Cell *)(vl->narg[0]))->nval) == 0) {
 482                         SYNTAX("duplicate argument %s", s);
 483                         break;
 484                 }
 485         }
 486 }