1%{
2/*
3 * CDDL HEADER START
4 *
5 * The contents of this file are subject to the terms of the
6 * Common Development and Distribution License, Version 1.0 only
7 * (the "License").  You may not use this file except in compliance
8 * with the License.
9 *
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11 * or http://www.opensolaris.org/os/licensing.
12 * See the License for the specific language governing permissions
13 * and limitations under the License.
14 *
15 * When distributing Covered Code, include this CDDL HEADER in each
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17 * If applicable, add the following below this CDDL HEADER, with the
18 * fields enclosed by brackets "[]" replaced with your own identifying
19 * information: Portions Copyright [yyyy] [name of copyright owner]
20 *
21 * CDDL HEADER END
22 */
23%}
24/*
25 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
26 * Use is subject to license terms.
27 */
28
29/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
30/*	  All Rights Reserved  	*/
31
32%{
33#ident	"%Z%%M%	%I%	%E% SMI"	/* SVr4.0 2.10	*/
34%}
35
36%{
37#include "awk.h"
38int yywrap(void) { return(1); }
39#ifndef	DEBUG
40#	define	PUTS(x)
41#endif
42Node	*beginloc = 0, *endloc = 0;
43int	infunc	= 0;	/* = 1 if in arglist or body of func */
44uchar	*curfname = 0;
45Node	*arglist = 0;	/* list of args for current function */
46static void	setfname(Cell *);
47static int	constnode(Node *);
48static uchar	*strnode(Node *);
49static Node	*notnull();
50%}
51
52%union {
53	Node	*p;
54	Cell	*cp;
55	int	i;
56	uchar	*s;
57}
58
59%token	<i>	FIRSTTOKEN	/* must be first */
60%token	<p>	PROGRAM PASTAT PASTAT2 XBEGIN XEND
61%token	<i>	NL ',' '{' '(' '|' ';' '/' ')' '}' '[' ']'
62%token	<i>	ARRAY
63%token	<i>	MATCH NOTMATCH MATCHOP
64%token	<i>	FINAL DOT ALL CCL NCCL CHAR OR STAR QUEST PLUS
65%token	<i>	AND BOR APPEND EQ GE GT LE LT NE IN
66%token	<i>	ARG BLTIN BREAK CLOSE CONTINUE DELETE DO EXIT FOR FUNC
67%token	<i>	SUB GSUB IF INDEX LSUBSTR MATCHFCN NEXT
68%token	<i>	ADD MINUS MULT DIVIDE MOD
69%token	<i>	ASSIGN ASGNOP ADDEQ SUBEQ MULTEQ DIVEQ MODEQ POWEQ
70%token	<i>	PRINT PRINTF SPRINTF
71%token	<p>	ELSE INTEST CONDEXPR
72%token	<i>	POSTINCR PREINCR POSTDECR PREDECR
73%token	<cp>	VAR IVAR VARNF CALL NUMBER STRING FIELD
74%token	<s>	REGEXPR
75
76%type	<p>	pas pattern ppattern plist pplist patlist prarg term
77%type	<p>	pa_pat pa_stat pa_stats
78%type	<s>	reg_expr
79%type	<p>	simple_stmt opt_simple_stmt stmt stmtlist
80%type	<p>	var varname funcname varlist
81%type	<p>	for if while
82%type	<i>	pst opt_pst lbrace rparen comma nl opt_nl and bor
83%type	<i>	subop print
84
85%right	ASGNOP
86%right	'?'
87%right	':'
88%left	BOR
89%left	AND
90%left	GETLINE
91%nonassoc APPEND EQ GE GT LE LT NE MATCHOP IN '|'
92%left	ARG BLTIN BREAK CALL CLOSE CONTINUE DELETE DO EXIT FOR FIELD FUNC
93%left	GSUB IF INDEX LSUBSTR MATCHFCN NEXT NUMBER
94%left	PRINT PRINTF RETURN SPLIT SPRINTF STRING SUB SUBSTR
95%left	REGEXPR VAR VARNF IVAR WHILE '('
96%left	CAT
97%left	'+' '-'
98%left	'*' '/' '%'
99%left	NOT UMINUS
100%right	POWER
101%right	DECR INCR
102%left	INDIRECT
103%token	LASTTOKEN	/* must be last */
104
105%%
106
107program:
108	  pas	{ if (errorflag==0)
109			winner = (Node *)stat3(PROGRAM, beginloc, $1, endloc); }
110	| error	{ yyclearin; bracecheck(); ERROR "bailing out" SYNTAX; }
111	;
112
113and:
114	  AND | and NL
115	;
116
117bor:
118	  BOR | bor NL
119	;
120
121comma:
122	  ',' | comma NL
123	;
124
125do:
126	  DO | do NL
127	;
128
129else:
130	  ELSE | else NL
131	;
132
133for:
134	  FOR '(' opt_simple_stmt ';' pattern ';' opt_simple_stmt rparen stmt
135		{ $$ = stat4(FOR, $3, notnull($5), $7, $9); }
136	| FOR '(' opt_simple_stmt ';'  ';' opt_simple_stmt rparen stmt
137		{ $$ = stat4(FOR, $3, NIL, $6, $8); }
138	| FOR '(' varname IN varname rparen stmt
139		{ $$ = stat3(IN, $3, makearr($5), $7); }
140	;
141
142funcname:
143	  VAR	{ setfname($1); }
144	| CALL	{ setfname($1); }
145	;
146
147if:
148	  IF '(' pattern rparen		{ $$ = notnull($3); }
149	;
150
151lbrace:
152	  '{' | lbrace NL
153	;
154
155nl:
156	  NL | nl NL
157	;
158
159opt_nl:
160	  /* empty */	{ $$ = 0; }
161	| nl
162	;
163
164opt_pst:
165	  /* empty */	{ $$ = 0; }
166	| pst
167	;
168
169
170opt_simple_stmt:
171	  /* empty */			{ $$ = 0; }
172	| simple_stmt
173	;
174
175pas:
176	  opt_pst			{ $$ = 0; }
177	| opt_pst pa_stats opt_pst	{ $$ = $2; }
178	;
179
180pa_pat:
181	  pattern	{ $$ = notnull($1); }
182	;
183
184pa_stat:
185	  pa_pat			{ $$ = stat2(PASTAT, $1, stat2(PRINT, rectonode(), NIL)); }
186	| pa_pat lbrace stmtlist '}'	{ $$ = stat2(PASTAT, $1, $3); }
187	| pa_pat ',' pa_pat		{ $$ = pa2stat($1, $3, stat2(PRINT, rectonode(), NIL)); }
188	| pa_pat ',' pa_pat lbrace stmtlist '}'	{ $$ = pa2stat($1, $3, $5); }
189	| lbrace stmtlist '}'		{ $$ = stat2(PASTAT, NIL, $2); }
190	| XBEGIN lbrace stmtlist '}'
191		{ beginloc = linkum(beginloc, $3); $$ = 0; }
192	| XEND lbrace stmtlist '}'
193		{ endloc = linkum(endloc, $3); $$ = 0; }
194	| FUNC funcname '(' varlist rparen {infunc++;} lbrace stmtlist '}'
195		{ infunc--; curfname=0; defn((Cell *)$2, $4, $8); $$ = 0; }
196	;
197
198pa_stats:
199	  pa_stat
200	| pa_stats opt_pst pa_stat	{ $$ = linkum($1, $3); }
201	;
202
203patlist:
204	  pattern
205	| patlist comma pattern	{ $$ = linkum($1, $3); }
206	;
207
208ppattern:
209	  var ASGNOP ppattern		{ $$ = op2($2, $1, $3); }
210	| ppattern '?' ppattern ':' ppattern %prec '?'
211	 	{ $$ = op3(CONDEXPR, notnull($1), $3, $5); }
212	| ppattern bor ppattern %prec BOR
213		{ $$ = op2(BOR, notnull($1), notnull($3)); }
214	| ppattern and ppattern %prec AND
215		{ $$ = op2(AND, notnull($1), notnull($3)); }
216	| NOT ppattern
217		{ $$ = op1(NOT, notnull($2)); }
218	| ppattern MATCHOP reg_expr	{ $$ = op3($2, NIL, $1, (Node*)makedfa($3, 0)); }
219	| ppattern MATCHOP ppattern
220		{ if (constnode($3))
221			$$ = op3($2, NIL, $1, (Node*)makedfa(strnode($3), 0));
222		  else
223			$$ = op3($2, (Node *)1, $1, $3); }
224	| ppattern IN varname		{ $$ = op2(INTEST, $1, makearr($3)); }
225	| '(' plist ')' IN varname	{ $$ = op2(INTEST, $2, makearr($5)); }
226	| ppattern term %prec CAT	{ $$ = op2(CAT, $1, $2); }
227	| reg_expr
228		{ $$ = op3(MATCH, NIL, rectonode(), (Node*)makedfa($1, 0)); }
229	| term
230	;
231
232pattern:
233	  var ASGNOP pattern		{ $$ = op2($2, $1, $3); }
234	| pattern '?' pattern ':' pattern %prec '?'
235	 	{ $$ = op3(CONDEXPR, notnull($1), $3, $5); }
236	| pattern bor pattern %prec BOR
237		{ $$ = op2(BOR, notnull($1), notnull($3)); }
238	| pattern and pattern %prec AND
239		{ $$ = op2(AND, notnull($1), notnull($3)); }
240	| NOT pattern
241		{ $$ = op1(NOT, op2(NE,$2,valtonode(lookup((uchar *)"$zero&null",symtab),CCON))); }
242	| pattern EQ pattern		{ $$ = op2($2, $1, $3); }
243	| pattern GE pattern		{ $$ = op2($2, $1, $3); }
244	| pattern GT pattern		{ $$ = op2($2, $1, $3); }
245	| pattern LE pattern		{ $$ = op2($2, $1, $3); }
246	| pattern LT pattern		{ $$ = op2($2, $1, $3); }
247	| pattern NE pattern		{ $$ = op2($2, $1, $3); }
248	| pattern MATCHOP reg_expr	{ $$ = op3($2, NIL, $1, (Node*)makedfa($3, 0)); }
249	| pattern MATCHOP pattern
250		{ if (constnode($3))
251			$$ = op3($2, NIL, $1, (Node*)makedfa(strnode($3), 0));
252		  else
253			$$ = op3($2, (Node *)1, $1, $3); }
254	| pattern IN varname		{ $$ = op2(INTEST, $1, makearr($3)); }
255	| '(' plist ')' IN varname	{ $$ = op2(INTEST, $2, makearr($5)); }
256	| pattern '|' GETLINE var	{ $$ = op3(GETLINE, $4, (Node*)$2, $1); }
257	| pattern '|' GETLINE		{ $$ = op3(GETLINE, (Node*)0, (Node*)$2, $1); }
258	| pattern term %prec CAT	{ $$ = op2(CAT, $1, $2); }
259	| reg_expr
260		{ $$ = op3(MATCH, NIL, rectonode(), (Node*)makedfa($1, 0)); }
261	| term
262	;
263
264plist:
265	  pattern comma pattern		{ $$ = linkum($1, $3); }
266	| plist comma pattern		{ $$ = linkum($1, $3); }
267	;
268
269pplist:
270	  ppattern
271	| pplist comma ppattern		{ $$ = linkum($1, $3); }
272
273prarg:
274	  /* empty */			{ $$ = rectonode(); }
275	| pplist
276	| '(' plist ')'			{ $$ = $2; }
277	;
278
279print:
280	  PRINT | PRINTF
281	;
282
283pst:
284	  NL | ';' | pst NL | pst ';'
285	;
286
287rbrace:
288	  '}' | rbrace NL
289	;
290
291reg_expr:
292	  '/' {startreg();} REGEXPR '/'		{ $$ = $3; }
293	;
294
295rparen:
296	  ')' | rparen NL
297	;
298
299simple_stmt:
300	  print prarg '|' term		{ $$ = stat3($1, $2, (Node *) $3, $4); }
301	| print prarg APPEND term	{ $$ = stat3($1, $2, (Node *) $3, $4); }
302	| print prarg GT term		{ $$ = stat3($1, $2, (Node *) $3, $4); }
303	| print prarg			{ $$ = stat3($1, $2, NIL, NIL); }
304	| DELETE varname '[' patlist ']' { $$ = stat2(DELETE, makearr($2), $4); }
305	| DELETE varname		{ yyclearin; ERROR "you can only delete array[element]" SYNTAX; $$ = stat1(DELETE, $2); }
306	| pattern			{ $$ = exptostat($1); }
307	| error				{ yyclearin; ERROR "illegal statement" SYNTAX; }
308	;
309
310st:
311	  nl | ';' opt_nl
312	;
313
314stmt:
315	  BREAK st		{ $$ = stat1(BREAK, NIL); }
316	| CLOSE pattern st	{ $$ = stat1(CLOSE, $2); }
317	| CONTINUE st		{ $$ = stat1(CONTINUE, NIL); }
318	| do stmt WHILE '(' pattern ')' st
319		{ $$ = stat2(DO, $2, notnull($5)); }
320	| EXIT pattern st	{ $$ = stat1(EXIT, $2); }
321	| EXIT st		{ $$ = stat1(EXIT, NIL); }
322	| for
323	| if stmt else stmt	{ $$ = stat3(IF, $1, $2, $4); }
324	| if stmt		{ $$ = stat3(IF, $1, $2, NIL); }
325	| lbrace stmtlist rbrace { $$ = $2; }
326	| NEXT st	{ if (infunc)
327				ERROR "next is illegal inside a function" SYNTAX;
328			  $$ = stat1(NEXT, NIL); }
329	| RETURN pattern st	{ $$ = stat1(RETURN, $2); }
330	| RETURN st		{ $$ = stat1(RETURN, NIL); }
331	| simple_stmt st
332	| while stmt		{ $$ = stat2(WHILE, $1, $2); }
333	| ';' opt_nl		{ $$ = 0; }
334	;
335
336stmtlist:
337	  stmt
338	| stmtlist stmt		{ $$ = linkum($1, $2); }
339	;
340
341subop:
342	  SUB | GSUB
343	;
344
345term:
346	  term '+' term			{ $$ = op2(ADD, $1, $3); }
347	| term '-' term			{ $$ = op2(MINUS, $1, $3); }
348	| term '*' term			{ $$ = op2(MULT, $1, $3); }
349	| term '/' term			{ $$ = op2(DIVIDE, $1, $3); }
350	| term '%' term			{ $$ = op2(MOD, $1, $3); }
351	| term POWER term		{ $$ = op2(POWER, $1, $3); }
352	| '-' term %prec UMINUS		{ $$ = op1(UMINUS, $2); }
353	| '+' term %prec UMINUS		{ $$ = $2; }
354	| BLTIN '(' ')'			{ $$ = op2(BLTIN, (Node *) $1, rectonode()); }
355	| BLTIN '(' patlist ')'		{ $$ = op2(BLTIN, (Node *) $1, $3); }
356	| BLTIN				{ $$ = op2(BLTIN, (Node *) $1, rectonode()); }
357	| CALL '(' ')'			{ $$ = op2(CALL, valtonode($1,CVAR), NIL); }
358	| CALL '(' patlist ')'		{ $$ = op2(CALL, valtonode($1,CVAR), $3); }
359	| DECR var			{ $$ = op1(PREDECR, $2); }
360	| INCR var			{ $$ = op1(PREINCR, $2); }
361	| var DECR			{ $$ = op1(POSTDECR, $1); }
362	| var INCR			{ $$ = op1(POSTINCR, $1); }
363	| GETLINE var LT term		{ $$ = op3(GETLINE, $2, (Node *)$3, $4); }
364	| GETLINE LT term		{ $$ = op3(GETLINE, NIL, (Node *)$2, $3); }
365	| GETLINE var			{ $$ = op3(GETLINE, $2, NIL, NIL); }
366	| GETLINE			{ $$ = op3(GETLINE, NIL, NIL, NIL); }
367	| INDEX '(' pattern comma pattern ')'
368		{ $$ = op2(INDEX, $3, $5); }
369	| INDEX '(' pattern comma reg_expr ')'
370		{ ERROR "index() doesn't permit regular expressions" SYNTAX;
371		  $$ = op2(INDEX, $3, (Node*)$5); }
372	| '(' pattern ')'		{ $$ = $2; }
373	| MATCHFCN '(' pattern comma reg_expr ')'
374		{ $$ = op3(MATCHFCN, NIL, $3, (Node*)makedfa($5, 1)); }
375	| MATCHFCN '(' pattern comma pattern ')'
376		{ if (constnode($5))
377			$$ = op3(MATCHFCN, NIL, $3, (Node*)makedfa(strnode($5), 1));
378		  else
379			$$ = op3(MATCHFCN, (Node *)1, $3, $5); }
380	| NUMBER			{ $$ = valtonode($1, CCON); }
381	| SPLIT '(' pattern comma varname comma pattern ')'     /* string */
382		{ $$ = op4(SPLIT, $3, makearr($5), $7, (Node*)STRING); }
383	| SPLIT '(' pattern comma varname comma reg_expr ')'    /* const /regexp/ */
384		{ $$ = op4(SPLIT, $3, makearr($5), (Node*)makedfa($7, 1), (Node *)REGEXPR); }
385	| SPLIT '(' pattern comma varname ')'
386		{ $$ = op4(SPLIT, $3, makearr($5), NIL, (Node*)STRING); }  /* default */
387	| SPRINTF '(' patlist ')'	{ $$ = op1($1, $3); }
388	| STRING	 		{ $$ = valtonode($1, CCON); }
389	| subop '(' reg_expr comma pattern ')'
390		{ $$ = op4($1, NIL, (Node*)makedfa($3, 1), $5, rectonode()); }
391	| subop '(' pattern comma pattern ')'
392		{ if (constnode($3))
393			$$ = op4($1, NIL, (Node*)makedfa(strnode($3), 1), $5, rectonode());
394		  else
395			$$ = op4($1, (Node *)1, $3, $5, rectonode()); }
396	| subop '(' reg_expr comma pattern comma var ')'
397		{ $$ = op4($1, NIL, (Node*)makedfa($3, 1), $5, $7); }
398	| subop '(' pattern comma pattern comma var ')'
399		{ if (constnode($3))
400			$$ = op4($1, NIL, (Node*)makedfa(strnode($3), 1), $5, $7);
401		  else
402			$$ = op4($1, (Node *)1, $3, $5, $7); }
403	| SUBSTR '(' pattern comma pattern comma pattern ')'
404		{ $$ = op3(SUBSTR, $3, $5, $7); }
405	| SUBSTR '(' pattern comma pattern ')'
406		{ $$ = op3(SUBSTR, $3, $5, NIL); }
407	| var
408	;
409
410var:
411	  varname
412	| varname '[' patlist ']'	{ $$ = op2(ARRAY, makearr($1), $3); }
413	| FIELD				{ $$ = valtonode($1, CFLD); }
414	| IVAR				{ $$ = op1(INDIRECT, valtonode($1, CVAR)); }
415	| INDIRECT term	 		{ $$ = op1(INDIRECT, $2); }
416	;
417
418varlist:
419	  /* nothing */		{ arglist = $$ = 0; }
420	| VAR			{ arglist = $$ = valtonode($1,CVAR); }
421	| varlist comma VAR	{ arglist = $$ = linkum($1,valtonode($3,CVAR)); }
422	;
423
424varname:
425	  VAR			{ $$ = valtonode($1, CVAR); }
426	| ARG 			{ $$ = op1(ARG, (Node *) $1); }
427	| VARNF			{ $$ = op1(VARNF, (Node *) $1); }
428	;
429
430
431while:
432	  WHILE '(' pattern rparen	{ $$ = notnull($3); }
433	;
434
435%%
436
437static void
438setfname(Cell *p)
439{
440	if (isarr(p))
441		ERROR "%s is an array, not a function", p->nval SYNTAX;
442	else if (isfunc(p))
443		ERROR "you can't define function %s more than once", p->nval SYNTAX;
444	curfname = p->nval;
445}
446
447
448static int
449constnode(Node *p)
450{
451	return p->ntype == NVALUE && ((Cell *) (p->narg[0]))->csub == CCON;
452}
453
454static uchar *
455strnode(Node *p)
456{
457	return ((Cell *)(p->narg[0]))->sval;
458}
459
460static Node *
461notnull(Node *n)
462{
463	switch (n->nobj) {
464	case LE: case LT: case EQ: case NE: case GT: case GE:
465	case BOR: case AND: case NOT:
466		return n;
467	default:
468		return op2(NE, n, nullnode);
469	}
470}
471