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