Return to awkgram.y CVS log

Up to [local] / rpl / rplawk

Quelques patches pour rplawk et ncurses.

    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: }