1 #ifndef lint
2 static char const
3 yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";
4 #endif
5 #include <stdlib.h>
6 #define YYBYACC 1
7 #define YYMAJOR 1
8 #define YYMINOR 9
9 #define YYLEX yylex()
10 #define YYEMPTY -1
11 #define yyclearin (yychar=(YYEMPTY))
12 #define yyerrok (yyerrflag=0)
13 #define YYRECOVERING() (yyerrflag!=0)
14 static int yygrowstack();
15 #define YYPREFIX "yy"
16 #line 84 "jamgram.y"
17 
18 #include "jam.h"
19 
20 #include "lists.h"
21 #include "variable.h"
22 #include "parse.h"
23 #include "scan.h"
24 #include "compile.h"
25 #include "newstr.h"
26 #include "rules.h"
27 
28 # define YYMAXDEPTH 10000	/* for OSF and other less endowed yaccs */
29 
30 # define F0 (LIST *(*)(PARSE *, LOL *, int *))0
31 # define P0 (PARSE *)0
32 # define S0 (char *)0
33 
34 # define pappend( l,r )    	parse_make( compile_append,l,r,P0,S0,S0,0 )
35 # define pbreak( l,f )     	parse_make( compile_break,l,P0,P0,S0,S0,f )
36 # define peval( c,l,r )		parse_make( compile_eval,l,r,P0,S0,S0,c )
37 # define pfor( s,l,r )    	parse_make( compile_foreach,l,r,P0,s,S0,0 )
38 # define pif( l,r,t )	  	parse_make( compile_if,l,r,t,S0,S0,0 )
39 # define pincl( l )       	parse_make( compile_include,l,P0,P0,S0,S0,0 )
40 # define plist( s )	  	parse_make( compile_list,P0,P0,P0,s,S0,0 )
41 # define plocal( l,r,t )  	parse_make( compile_local,l,r,t,S0,S0,0 )
42 # define pnull()	  	parse_make( compile_null,P0,P0,P0,S0,S0,0 )
43 # define pon( l,r )	  	parse_make( compile_on,l,r,P0,S0,S0,0 )
44 # define prule( a,p )     	parse_make( compile_rule,a,p,P0,S0,S0,0 )
45 # define prules( l,r )	  	parse_make( compile_rules,l,r,P0,S0,S0,0 )
46 # define pset( l,r,a ) 	  	parse_make( compile_set,l,r,P0,S0,S0,a )
47 # define pset1( l,r,t,a )	parse_make( compile_settings,l,r,t,S0,S0,a )
48 # define psetc( s,l,r )     	parse_make( compile_setcomp,l,r,P0,s,S0,0 )
49 # define psete( s,l,s1,f ) 	parse_make( compile_setexec,l,P0,P0,s,s1,f )
50 # define pswitch( l,r )   	parse_make( compile_switch,l,r,P0,S0,S0,0 )
51 # define pwhile( l,r )   	parse_make( compile_while,l,r,P0,S0,S0,0 )
52 
53 # define pnode( l,r )    	parse_make( F0,l,r,P0,S0,S0,0 )
54 # define psnode( s,l )     	parse_make( F0,l,P0,P0,s,S0,0 )
55 
56 #line 57 "y.tab.c"
57 #define YYERRCODE 256
58 #define _LANGLE_t 257
59 #define _LANGLE_EQUALS_t 258
60 #define _EQUALS_t 259
61 #define _RANGLE_t 260
62 #define _RANGLE_EQUALS_t 261
63 #define _BAR_t 262
64 #define _BARBAR_t 263
65 #define _SEMIC_t 264
66 #define _COLON_t 265
67 #define _BANG_t 266
68 #define _BANG_EQUALS_t 267
69 #define _QUESTION_EQUALS_t 268
70 #define _LPAREN_t 269
71 #define _RPAREN_t 270
72 #define _LBRACKET_t 271
73 #define _RBRACKET_t 272
74 #define _LBRACE_t 273
75 #define _RBRACE_t 274
76 #define _AMPER_t 275
77 #define _AMPERAMPER_t 276
78 #define _PLUS_EQUALS_t 277
79 #define ACTIONS_t 278
80 #define BIND_t 279
81 #define BREAK_t 280
82 #define CASE_t 281
83 #define CONTINUE_t 282
84 #define DEFAULT_t 283
85 #define ELSE_t 284
86 #define EXISTING_t 285
87 #define FOR_t 286
88 #define IF_t 287
89 #define IGNORE_t 288
90 #define IN_t 289
91 #define INCLUDE_t 290
92 #define LOCAL_t 291
93 #define MAXLINE_t 292
94 #define ON_t 293
95 #define PIECEMEAL_t 294
96 #define QUIETLY_t 295
97 #define RETURN_t 296
98 #define RULE_t 297
99 #define SWITCH_t 298
100 #define TOGETHER_t 299
101 #define UPDATED_t 300
102 #define WHILE_t 301
103 #define ARG 302
104 #define STRING 303
105 const short yylhs[] = {                                        -1,
106     0,    0,    2,    2,    1,    1,    1,    1,    3,    3,
107     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
108     3,    3,    3,   13,   14,    3,    7,    7,    7,    7,
109     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
110     9,    9,    9,    9,    8,    8,   15,   10,   10,   10,
111     6,    6,    4,   16,   16,    5,   18,    5,   17,   17,
112    17,   11,   11,   19,   19,   19,   19,   19,   19,   19,
113    12,   12,
114 };
115 const short yylen[] = {                                         2,
116     0,    1,    0,    1,    1,    2,    4,    6,    3,    3,
117     3,    4,    6,    3,    3,    3,    7,    5,    5,    7,
118     5,    6,    3,    0,    0,    9,    1,    1,    1,    2,
119     1,    3,    3,    3,    3,    3,    3,    3,    3,    3,
120     3,    3,    2,    3,    0,    2,    4,    0,    3,    1,
121     1,    3,    1,    0,    2,    1,    0,    4,    2,    4,
122     4,    0,    2,    1,    1,    1,    1,    1,    1,    2,
123     0,    2,
124 };
125 const short yydefred[] = {                                      0,
126    57,    0,   62,   54,   54,    0,    0,   54,   54,    0,
127    54,    0,   54,    0,   56,    0,    2,    0,    0,    0,
128     4,    0,    0,    0,    0,    0,    0,    0,    0,    0,
129     0,    0,    0,    0,    0,    0,    0,    0,    6,   27,
130    29,   28,    0,   54,    0,    0,   54,    0,   54,    0,
131     9,   69,   66,    0,   68,   67,   65,   64,    0,   63,
132    14,   55,   15,   54,   43,    0,   54,    0,    0,    0,
133     0,    0,    0,    0,    0,    0,    0,    0,   10,   54,
134     0,   23,   16,    0,    0,    0,    0,   30,    0,   54,
135    11,    0,    0,   59,   58,   70,   54,    0,    0,   44,
136    42,   34,   35,    0,   36,   37,    0,    0,    0,    0,
137     0,    0,    0,    7,    0,    0,    0,    0,    0,    0,
138    54,   52,   12,   54,   54,   72,   24,    0,    0,    0,
139    49,    0,    0,   18,   46,   21,    0,   61,   60,    0,
140     0,    0,    8,   22,    0,   13,   25,   17,   20,   47,
141     0,   26,
142 };
143 const short yydgoto[] = {                                      16,
144    21,   22,   18,   45,   30,   46,   47,  118,   31,   85,
145    23,   98,  140,  151,  119,   25,   50,   20,   60,
146 };
147 const short yysindex[] = {                                   -134,
148     0, -134,    0,    0,    0, -294, -260,    0,    0, -253,
149     0, -288,    0, -260,    0,    0,    0, -134, -214, -261,
150     0, -240, -198, -218, -253, -206, -239, -260, -260, -228,
151    -9, -197, -199, -102, -191, -238, -193,   47,    0,    0,
152     0,    0, -177,    0, -181, -179,    0, -253,    0, -183,
153     0,    0,    0, -209,    0,    0,    0,    0, -184,    0,
154     0,    0,    0,    0,    0,   67,    0, -260, -260, -260,
155  -260, -260, -260, -260, -260, -134, -260, -260,    0,    0,
156  -134,    0,    0, -166, -173, -178, -134,    0, -200,    0,
157     0, -158, -245,    0,    0,    0,    0, -164, -155,    0,
158     0,    0,    0,  -71,    0,    0, -133, -133,  -71, -167,
159     2,    2, -142,    0, -238, -134, -162, -151, -178, -138,
160     0,    0,    0,    0,    0,    0,    0, -134, -139, -134,
161     0, -125, -114,    0,    0,    0, -110,    0,    0, -148,
162  -116, -102,    0,    0, -134,    0,    0,    0,    0,    0,
163  -113,    0,
164 };
165 const short yyrindex[] = {                                    160,
166     0, -109,    0,    0,    0,    0,    0,    0,    0,    0,
167     0,    0,    0,    0,    0,    0,    0,    3, -236,    0,
168     0,    0,    0,    0,  -56,    0,    0,    0,    0,  -29,
169     0,    0,    0,    0,    0, -107,    0,    0,    0,    0,
170     0,    0,    0,    0, -224,    0,    0,    0,    0,    0,
171     0,    0,    0,    0,    0,    0,    0,    0, -103,    0,
172     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
173     0,    0,    0,    0,    0, -109,    0,    0,    0,    0,
174     4,    0,    0, -101,    0, -100, -109,    0,    0,    0,
175     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
176     0,    0,    0,   77,    0,    0, -226, -132,   92,    0,
177   101,  110,    0,    0, -107, -109,    0,    0, -100,    0,
178     0,    0,    0,    0,    0,    0,    0, -109,    1,    4,
179     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
180     0,    0,    0,    0, -250,    0,    0,    0,    0,    0,
181     0,    0,
182 };
183 const short yygindex[] = {                                      0,
184    20,  -54,  -34,    8,    5,  -47,   84,   56,   42,   62,
185     0,    0,    0,    0,    0,    0,    0,    0,    0,
186 };
187 #define YYTABLESIZE 386
188 const short yytable[] = {                                      82,
189    19,   94,    5,    3,   19,   28,   19,   27,   29,    1,
190     1,   24,   26,   36,   34,   32,   33,    1,   35,   17,
191    37,  110,   19,    3,   49,    1,  114,   54,   54,   62,
192     3,   48,  120,   51,   54,   40,   40,   39,   19,   51,
193    15,   15,  122,   40,   40,   61,   40,   51,   15,   64,
194   124,   89,   93,   41,   92,   38,   15,   63,   40,   80,
195    67,  132,   42,   84,   81,   54,   79,   41,   43,   65,
196    66,   99,   83,  141,  101,  143,   42,  139,   44,   86,
197    19,   88,   43,   90,   91,   19,   52,  113,   95,   53,
198   150,   19,   96,   54,   97,   55,   56,  125,  115,  116,
199    57,   58,  117,   59,  126,  123,  129,  149,  127,  102,
200   103,  104,  105,  106,  107,  108,  109,  128,  111,  112,
201    19,  130,  134,   68,   69,   70,   71,   72,  137,   41,
202    41,  138,   19,   75,   19,  136,    1,   41,    2,  133,
203    41,   77,   78,    3,  142,    4,   19,    5,  144,   19,
204   145,    6,    7,  146,  147,    8,    9,  148,   10,    1,
205   152,   11,   12,   13,    3,   48,   14,   15,    1,   71,
206     2,   50,  121,   45,  135,    3,  131,    4,    0,    5,
207     0,    0,    0,    6,    7,   68,   69,    8,   71,   72,
208    10,    0,    0,   11,   12,   13,    0,    0,   14,   15,
209    53,   53,   53,   53,   53,   53,   53,   53,   53,    0,
210    53,   53,    0,   53,    0,   53,   53,    0,   53,   53,
211    53,    0,    0,    0,    0,    0,   53,   31,   31,   31,
212    31,   31,   31,   31,    0,    0,    0,   31,    0,    0,
213    31,    0,    0,   31,    0,   31,   31,   68,   69,   70,
214    71,   72,   73,   74,    0,    0,    0,   75,   68,   69,
215    70,   71,   72,   76,    0,   77,   78,    0,   75,    0,
216     0,   19,    0,   19,   19,    0,    5,    3,   19,    0,
217    19,   19,   19,    5,    3,    0,   19,   19,    0,    0,
218    19,   19,    0,   19,    0,    0,   19,   19,   19,    0,
219     0,   19,   19,   68,   69,   70,   71,   72,   73,   74,
220     0,    0,    0,   75,    0,    0,    0,    0,    0,   87,
221     0,   77,   78,   68,   69,   70,   71,   72,   73,   74,
222     0,    0,    0,   75,    0,   32,  100,    0,   32,   32,
223     0,   77,   78,   32,    0,    0,   32,    0,    0,   32,
224    33,   32,   32,   33,   33,    0,    0,    0,   33,    0,
225     0,   33,   38,   38,   33,    0,   33,   33,    0,    0,
226    38,   39,   39,   38,    0,   38,   38,    0,    0,   39,
227     0,    0,   39,    0,   39,   39,
228 };
229 const short yycheck[] = {                                      34,
230     0,   49,    0,    0,    0,  266,    2,  302,  269,  271,
231   271,    4,    5,  302,   10,    8,    9,  271,   11,    0,
232    13,   76,   18,  274,   20,  271,   81,  264,  265,   25,
233   281,  293,   87,  274,  271,  262,  263,   18,   34,  264,
234   302,  302,   90,  270,  259,  264,  273,  272,  302,  289,
235   296,   44,   48,  268,   47,   14,  302,  264,  259,  259,
236   289,  116,  277,  302,  264,  302,  264,  268,  283,   28,
237    29,   64,  264,  128,   67,  130,  277,  125,  293,  273,
238    76,  259,  283,  265,  264,   81,  285,   80,  272,  288,
239   145,   87,  302,  292,  279,  294,  295,   93,  265,  273,
240   299,  300,  281,  302,   97,  264,  274,  142,  273,   68,
241    69,   70,   71,   72,   73,   74,   75,  273,   77,   78,
242   116,  264,  274,  257,  258,  259,  260,  261,  121,  262,
243   263,  124,  128,  267,  130,  274,  271,  270,  273,  302,
244   273,  275,  276,  278,  284,  280,  142,  282,  274,  145,
245   265,  286,  287,  264,  303,  290,  291,  274,  293,    0,
246   274,  296,  297,  298,  274,  273,  301,  302,  271,  273,
247   273,  273,   89,  274,  119,  278,  115,  280,   -1,  282,
248    -1,   -1,   -1,  286,  287,  257,  258,  290,  260,  261,
249   293,   -1,   -1,  296,  297,  298,   -1,   -1,  301,  302,
250   257,  258,  259,  260,  261,  262,  263,  264,  265,   -1,
251   267,  268,   -1,  270,   -1,  272,  273,   -1,  275,  276,
252   277,   -1,   -1,   -1,   -1,   -1,  283,  257,  258,  259,
253   260,  261,  262,  263,   -1,   -1,   -1,  267,   -1,   -1,
254   270,   -1,   -1,  273,   -1,  275,  276,  257,  258,  259,
255   260,  261,  262,  263,   -1,   -1,   -1,  267,  257,  258,
256   259,  260,  261,  273,   -1,  275,  276,   -1,  267,   -1,
257    -1,  271,   -1,  273,  274,   -1,  274,  274,  278,   -1,
258   280,  281,  282,  281,  281,   -1,  286,  287,   -1,   -1,
259   290,  291,   -1,  293,   -1,   -1,  296,  297,  298,   -1,
260    -1,  301,  302,  257,  258,  259,  260,  261,  262,  263,
261    -1,   -1,   -1,  267,   -1,   -1,   -1,   -1,   -1,  273,
262    -1,  275,  276,  257,  258,  259,  260,  261,  262,  263,
263    -1,   -1,   -1,  267,   -1,  259,  270,   -1,  262,  263,
264    -1,  275,  276,  267,   -1,   -1,  270,   -1,   -1,  273,
265   259,  275,  276,  262,  263,   -1,   -1,   -1,  267,   -1,
266    -1,  270,  262,  263,  273,   -1,  275,  276,   -1,   -1,
267   270,  262,  263,  273,   -1,  275,  276,   -1,   -1,  270,
268    -1,   -1,  273,   -1,  275,  276,
269 };
270 #define YYFINAL 16
271 #ifndef YYDEBUG
272 #define YYDEBUG 0
273 #endif
274 #define YYMAXTOKEN 303
275 #if YYDEBUG
276 const char * const yyname[] = {
277 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
278 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
279 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
280 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
281 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
282 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
283 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"_LANGLE_t","_LANGLE_EQUALS_t",
284 "_EQUALS_t","_RANGLE_t","_RANGLE_EQUALS_t","_BAR_t","_BARBAR_t","_SEMIC_t",
285 "_COLON_t","_BANG_t","_BANG_EQUALS_t","_QUESTION_EQUALS_t","_LPAREN_t",
286 "_RPAREN_t","_LBRACKET_t","_RBRACKET_t","_LBRACE_t","_RBRACE_t","_AMPER_t",
287 "_AMPERAMPER_t","_PLUS_EQUALS_t","ACTIONS_t","BIND_t","BREAK_t","CASE_t",
288 "CONTINUE_t","DEFAULT_t","ELSE_t","EXISTING_t","FOR_t","IF_t","IGNORE_t","IN_t",
289 "INCLUDE_t","LOCAL_t","MAXLINE_t","ON_t","PIECEMEAL_t","QUIETLY_t","RETURN_t",
290 "RULE_t","SWITCH_t","TOGETHER_t","UPDATED_t","WHILE_t","ARG","STRING",
291 };
292 const char * const yyrule[] = {
293 "$accept : run",
294 "run :",
295 "run : rules",
296 "block :",
297 "block : rules",
298 "rules : rule",
299 "rules : rule rules",
300 "rules : LOCAL_t list _SEMIC_t block",
301 "rules : LOCAL_t list _EQUALS_t list _SEMIC_t block",
302 "rule : _LBRACE_t block _RBRACE_t",
303 "rule : INCLUDE_t list _SEMIC_t",
304 "rule : arg lol _SEMIC_t",
305 "rule : arg assign list _SEMIC_t",
306 "rule : arg ON_t list assign list _SEMIC_t",
307 "rule : BREAK_t list _SEMIC_t",
308 "rule : CONTINUE_t list _SEMIC_t",
309 "rule : RETURN_t list _SEMIC_t",
310 "rule : FOR_t ARG IN_t list _LBRACE_t block _RBRACE_t",
311 "rule : SWITCH_t list _LBRACE_t cases _RBRACE_t",
312 "rule : IF_t expr _LBRACE_t block _RBRACE_t",
313 "rule : IF_t expr _LBRACE_t block _RBRACE_t ELSE_t rule",
314 "rule : WHILE_t expr _LBRACE_t block _RBRACE_t",
315 "rule : RULE_t ARG params _LBRACE_t block _RBRACE_t",
316 "rule : ON_t arg rule",
317 "$$1 :",
318 "$$2 :",
319 "rule : ACTIONS_t eflags ARG bindlist _LBRACE_t $$1 STRING $$2 _RBRACE_t",
320 "assign : _EQUALS_t",
321 "assign : _PLUS_EQUALS_t",
322 "assign : _QUESTION_EQUALS_t",
323 "assign : DEFAULT_t _EQUALS_t",
324 "expr : arg",
325 "expr : expr _EQUALS_t expr",
326 "expr : expr _BANG_EQUALS_t expr",
327 "expr : expr _LANGLE_t expr",
328 "expr : expr _LANGLE_EQUALS_t expr",
329 "expr : expr _RANGLE_t expr",
330 "expr : expr _RANGLE_EQUALS_t expr",
331 "expr : expr _AMPER_t expr",
332 "expr : expr _AMPERAMPER_t expr",
333 "expr : expr _BAR_t expr",
334 "expr : expr _BARBAR_t expr",
335 "expr : arg IN_t list",
336 "expr : _BANG_t expr",
337 "expr : _LPAREN_t expr _RPAREN_t",
338 "cases :",
339 "cases : case cases",
340 "case : CASE_t ARG _COLON_t block",
341 "params :",
342 "params : ARG _COLON_t params",
343 "params : ARG",
344 "lol : list",
345 "lol : list _COLON_t lol",
346 "list : listp",
347 "listp :",
348 "listp : listp arg",
349 "arg : ARG",
350 "$$3 :",
351 "arg : _LBRACKET_t $$3 func _RBRACKET_t",
352 "func : arg lol",
353 "func : ON_t arg arg lol",
354 "func : ON_t arg RETURN_t list",
355 "eflags :",
356 "eflags : eflags eflag",
357 "eflag : UPDATED_t",
358 "eflag : TOGETHER_t",
359 "eflag : IGNORE_t",
360 "eflag : QUIETLY_t",
361 "eflag : PIECEMEAL_t",
362 "eflag : EXISTING_t",
363 "eflag : MAXLINE_t ARG",
364 "bindlist :",
365 "bindlist : BIND_t list",
366 };
367 #endif
368 #ifndef YYSTYPE
369 typedef int YYSTYPE;
370 #endif
371 #if YYDEBUG
372 #include <stdio.h>
373 #endif
374 #ifdef YYSTACKSIZE
375 #undef YYMAXDEPTH
376 #define YYMAXDEPTH YYSTACKSIZE
377 #else
378 #ifdef YYMAXDEPTH
379 #define YYSTACKSIZE YYMAXDEPTH
380 #else
381 #define YYSTACKSIZE 10000
382 #define YYMAXDEPTH 10000
383 #endif
384 #endif
385 #define YYINITSTACKSIZE 200
386 int yydebug;
387 int yynerrs;
388 int yyerrflag;
389 int yychar;
390 short *yyssp;
391 YYSTYPE *yyvsp;
392 YYSTYPE yyval;
393 YYSTYPE yylval;
394 short *yyss;
395 short *yysslim;
396 YYSTYPE *yyvs;
397 int yystacksize;
398 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack()399 static int yygrowstack()
400 {
401     int newsize, i;
402     short *newss;
403     YYSTYPE *newvs;
404 
405     if ((newsize = yystacksize) == 0)
406         newsize = YYINITSTACKSIZE;
407     else if (newsize >= YYMAXDEPTH)
408         return -1;
409     else if ((newsize *= 2) > YYMAXDEPTH)
410         newsize = YYMAXDEPTH;
411     i = yyssp - yyss;
412     newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
413       (short *)malloc(newsize * sizeof *newss);
414     if (newss == NULL)
415         return -1;
416     yyss = newss;
417     yyssp = newss + i;
418     newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
419       (YYSTYPE *)malloc(newsize * sizeof *newvs);
420     if (newvs == NULL)
421         return -1;
422     yyvs = newvs;
423     yyvsp = newvs + i;
424     yystacksize = newsize;
425     yysslim = yyss + newsize - 1;
426     return 0;
427 }
428 
429 #define YYABORT goto yyabort
430 #define YYREJECT goto yyabort
431 #define YYACCEPT goto yyaccept
432 #define YYERROR goto yyerrlab
433 
434 #ifndef YYPARSE_PARAM
435 #if defined(__cplusplus) || __STDC__
436 #define YYPARSE_PARAM_ARG void
437 #define YYPARSE_PARAM_DECL
438 #else	/* ! ANSI-C/C++ */
439 #define YYPARSE_PARAM_ARG
440 #define YYPARSE_PARAM_DECL
441 #endif	/* ANSI-C/C++ */
442 #else	/* YYPARSE_PARAM */
443 #ifndef YYPARSE_PARAM_TYPE
444 #define YYPARSE_PARAM_TYPE void *
445 #endif
446 #if defined(__cplusplus) || __STDC__
447 #define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM
448 #define YYPARSE_PARAM_DECL
449 #else	/* ! ANSI-C/C++ */
450 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
451 #define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;
452 #endif	/* ANSI-C/C++ */
453 #endif	/* ! YYPARSE_PARAM */
454 
455 int
yyparse(YYPARSE_PARAM_ARG)456 yyparse (YYPARSE_PARAM_ARG)
457     YYPARSE_PARAM_DECL
458 {
459     register int yym, yyn, yystate;
460 #if YYDEBUG
461     register const char *yys;
462 
463     if ((yys = getenv("YYDEBUG")))
464     {
465         yyn = *yys;
466         if (yyn >= '0' && yyn <= '9')
467             yydebug = yyn - '0';
468     }
469 #endif
470 
471     yynerrs = 0;
472     yyerrflag = 0;
473     yychar = (-1);
474 
475     if (yyss == NULL && yygrowstack()) goto yyoverflow;
476     yyssp = yyss;
477     yyvsp = yyvs;
478     *yyssp = yystate = 0;
479 
480 yyloop:
481     if ((yyn = yydefred[yystate])) goto yyreduce;
482     if (yychar < 0)
483     {
484         if ((yychar = yylex()) < 0) yychar = 0;
485 #if YYDEBUG
486         if (yydebug)
487         {
488             yys = 0;
489             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
490             if (!yys) yys = "illegal-symbol";
491             printf("%sdebug: state %d, reading %d (%s)\n",
492                     YYPREFIX, yystate, yychar, yys);
493         }
494 #endif
495     }
496     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
497             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
498     {
499 #if YYDEBUG
500         if (yydebug)
501             printf("%sdebug: state %d, shifting to state %d\n",
502                     YYPREFIX, yystate, yytable[yyn]);
503 #endif
504         if (yyssp >= yysslim && yygrowstack())
505         {
506             goto yyoverflow;
507         }
508         *++yyssp = yystate = yytable[yyn];
509         *++yyvsp = yylval;
510         yychar = (-1);
511         if (yyerrflag > 0)  --yyerrflag;
512         goto yyloop;
513     }
514     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
515             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
516     {
517         yyn = yytable[yyn];
518         goto yyreduce;
519     }
520     if (yyerrflag) goto yyinrecovery;
521 #if defined(lint) || defined(__GNUC__)
522     goto yynewerror;
523 #endif
524 yynewerror:
525     yyerror("syntax error");
526 #if defined(lint) || defined(__GNUC__)
527     goto yyerrlab;
528 #endif
529 yyerrlab:
530     ++yynerrs;
531 yyinrecovery:
532     if (yyerrflag < 3)
533     {
534         yyerrflag = 3;
535         for (;;)
536         {
537             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
538                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
539             {
540 #if YYDEBUG
541                 if (yydebug)
542                     printf("%sdebug: state %d, error recovery shifting\
543  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
544 #endif
545                 if (yyssp >= yysslim && yygrowstack())
546                 {
547                     goto yyoverflow;
548                 }
549                 *++yyssp = yystate = yytable[yyn];
550                 *++yyvsp = yylval;
551                 goto yyloop;
552             }
553             else
554             {
555 #if YYDEBUG
556                 if (yydebug)
557                     printf("%sdebug: error recovery discarding state %d\n",
558                             YYPREFIX, *yyssp);
559 #endif
560                 if (yyssp <= yyss) goto yyabort;
561                 --yyssp;
562                 --yyvsp;
563             }
564         }
565     }
566     else
567     {
568         if (yychar == 0) goto yyabort;
569 #if YYDEBUG
570         if (yydebug)
571         {
572             yys = 0;
573             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
574             if (!yys) yys = "illegal-symbol";
575             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
576                     YYPREFIX, yystate, yychar, yys);
577         }
578 #endif
579         yychar = (-1);
580         goto yyloop;
581     }
582 yyreduce:
583 #if YYDEBUG
584     if (yydebug)
585         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
586                 YYPREFIX, yystate, yyn, yyrule[yyn]);
587 #endif
588     yym = yylen[yyn];
589     yyval = yyvsp[1-yym];
590     switch (yyn)
591     {
592 case 2:
593 #line 130 "jamgram.y"
594 { parse_save( yyvsp[0].parse ); }
595 break;
596 case 3:
597 #line 141 "jamgram.y"
598 { yyval.parse = pnull(); }
599 break;
600 case 4:
601 #line 143 "jamgram.y"
602 { yyval.parse = yyvsp[0].parse; }
603 break;
604 case 5:
605 #line 147 "jamgram.y"
606 { yyval.parse = yyvsp[0].parse; }
607 break;
608 case 6:
609 #line 149 "jamgram.y"
610 { yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
611 break;
612 case 7:
613 #line 151 "jamgram.y"
614 { yyval.parse = plocal( yyvsp[-2].parse, pnull(), yyvsp[0].parse ); }
615 break;
616 case 8:
617 #line 153 "jamgram.y"
618 { yyval.parse = plocal( yyvsp[-4].parse, yyvsp[-2].parse, yyvsp[0].parse ); }
619 break;
620 case 9:
621 #line 157 "jamgram.y"
622 { yyval.parse = yyvsp[-1].parse; }
623 break;
624 case 10:
625 #line 159 "jamgram.y"
626 { yyval.parse = pincl( yyvsp[-1].parse ); }
627 break;
628 case 11:
629 #line 161 "jamgram.y"
630 { yyval.parse = prule( yyvsp[-2].parse, yyvsp[-1].parse ); }
631 break;
632 case 12:
633 #line 163 "jamgram.y"
634 { yyval.parse = pset( yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
635 break;
636 case 13:
637 #line 165 "jamgram.y"
638 { yyval.parse = pset1( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
639 break;
640 case 14:
641 #line 167 "jamgram.y"
642 { yyval.parse = pbreak( yyvsp[-1].parse, JMP_BREAK ); }
643 break;
644 case 15:
645 #line 169 "jamgram.y"
646 { yyval.parse = pbreak( yyvsp[-1].parse, JMP_CONTINUE ); }
647 break;
648 case 16:
649 #line 171 "jamgram.y"
650 { yyval.parse = pbreak( yyvsp[-1].parse, JMP_RETURN ); }
651 break;
652 case 17:
653 #line 173 "jamgram.y"
654 { yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse ); }
655 break;
656 case 18:
657 #line 175 "jamgram.y"
658 { yyval.parse = pswitch( yyvsp[-3].parse, yyvsp[-1].parse ); }
659 break;
660 case 19:
661 #line 177 "jamgram.y"
662 { yyval.parse = pif( yyvsp[-3].parse, yyvsp[-1].parse, pnull() ); }
663 break;
664 case 20:
665 #line 179 "jamgram.y"
666 { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
667 break;
668 case 21:
669 #line 181 "jamgram.y"
670 { yyval.parse = pwhile( yyvsp[-3].parse, yyvsp[-1].parse ); }
671 break;
672 case 22:
673 #line 183 "jamgram.y"
674 { yyval.parse = psetc( yyvsp[-4].string, yyvsp[-3].parse, yyvsp[-1].parse ); }
675 break;
676 case 23:
677 #line 185 "jamgram.y"
678 { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
679 break;
680 case 24:
681 #line 187 "jamgram.y"
682 { yymode( SCAN_STRING ); }
683 break;
684 case 25:
685 #line 189 "jamgram.y"
686 { yymode( SCAN_NORMAL ); }
687 break;
688 case 26:
689 #line 191 "jamgram.y"
690 { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
691 break;
692 case 27:
693 #line 199 "jamgram.y"
694 { yyval.number = VAR_SET; }
695 break;
696 case 28:
697 #line 201 "jamgram.y"
698 { yyval.number = VAR_APPEND; }
699 break;
700 case 29:
701 #line 203 "jamgram.y"
702 { yyval.number = VAR_DEFAULT; }
703 break;
704 case 30:
705 #line 205 "jamgram.y"
706 { yyval.number = VAR_DEFAULT; }
707 break;
708 case 31:
709 #line 213 "jamgram.y"
710 { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); }
711 break;
712 case 32:
713 #line 215 "jamgram.y"
714 { yyval.parse = peval( EXPR_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); }
715 break;
716 case 33:
717 #line 217 "jamgram.y"
718 { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
719 break;
720 case 34:
721 #line 219 "jamgram.y"
722 { yyval.parse = peval( EXPR_LESS, yyvsp[-2].parse, yyvsp[0].parse ); }
723 break;
724 case 35:
725 #line 221 "jamgram.y"
726 { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
727 break;
728 case 36:
729 #line 223 "jamgram.y"
730 { yyval.parse = peval( EXPR_MORE, yyvsp[-2].parse, yyvsp[0].parse ); }
731 break;
732 case 37:
733 #line 225 "jamgram.y"
734 { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
735 break;
736 case 38:
737 #line 227 "jamgram.y"
738 { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
739 break;
740 case 39:
741 #line 229 "jamgram.y"
742 { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
743 break;
744 case 40:
745 #line 231 "jamgram.y"
746 { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
747 break;
748 case 41:
749 #line 233 "jamgram.y"
750 { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
751 break;
752 case 42:
753 #line 235 "jamgram.y"
754 { yyval.parse = peval( EXPR_IN, yyvsp[-2].parse, yyvsp[0].parse ); }
755 break;
756 case 43:
757 #line 237 "jamgram.y"
758 { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
759 break;
760 case 44:
761 #line 239 "jamgram.y"
762 { yyval.parse = yyvsp[-1].parse; }
763 break;
764 case 45:
765 #line 249 "jamgram.y"
766 { yyval.parse = P0; }
767 break;
768 case 46:
769 #line 251 "jamgram.y"
770 { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
771 break;
772 case 47:
773 #line 255 "jamgram.y"
774 { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
775 break;
776 case 48:
777 #line 264 "jamgram.y"
778 { yyval.parse = P0; }
779 break;
780 case 49:
781 #line 266 "jamgram.y"
782 { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
783 break;
784 case 50:
785 #line 268 "jamgram.y"
786 { yyval.parse = psnode( yyvsp[0].string, P0 ); }
787 break;
788 case 51:
789 #line 277 "jamgram.y"
790 { yyval.parse = pnode( P0, yyvsp[0].parse ); }
791 break;
792 case 52:
793 #line 279 "jamgram.y"
794 { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
795 break;
796 case 53:
797 #line 289 "jamgram.y"
798 { yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); }
799 break;
800 case 54:
801 #line 293 "jamgram.y"
802 { yyval.parse = pnull(); yymode( SCAN_PUNCT ); }
803 break;
804 case 55:
805 #line 295 "jamgram.y"
806 { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
807 break;
808 case 56:
809 #line 299 "jamgram.y"
810 { yyval.parse = plist( yyvsp[0].string ); }
811 break;
812 case 57:
813 #line 300 "jamgram.y"
814 { yymode( SCAN_NORMAL ); }
815 break;
816 case 58:
817 #line 301 "jamgram.y"
818 { yyval.parse = yyvsp[-1].parse; }
819 break;
820 case 59:
821 #line 310 "jamgram.y"
822 { yyval.parse = prule( yyvsp[-1].parse, yyvsp[0].parse ); }
823 break;
824 case 60:
825 #line 312 "jamgram.y"
826 { yyval.parse = pon( yyvsp[-2].parse, prule( yyvsp[-1].parse, yyvsp[0].parse ) ); }
827 break;
828 case 61:
829 #line 314 "jamgram.y"
830 { yyval.parse = pon( yyvsp[-2].parse, yyvsp[0].parse ); }
831 break;
832 case 62:
833 #line 323 "jamgram.y"
834 { yyval.number = 0; }
835 break;
836 case 63:
837 #line 325 "jamgram.y"
838 { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
839 break;
840 case 64:
841 #line 329 "jamgram.y"
842 { yyval.number = RULE_UPDATED; }
843 break;
844 case 65:
845 #line 331 "jamgram.y"
846 { yyval.number = RULE_TOGETHER; }
847 break;
848 case 66:
849 #line 333 "jamgram.y"
850 { yyval.number = RULE_IGNORE; }
851 break;
852 case 67:
853 #line 335 "jamgram.y"
854 { yyval.number = RULE_QUIETLY; }
855 break;
856 case 68:
857 #line 337 "jamgram.y"
858 { yyval.number = RULE_PIECEMEAL; }
859 break;
860 case 69:
861 #line 339 "jamgram.y"
862 { yyval.number = RULE_EXISTING; }
863 break;
864 case 70:
865 #line 341 "jamgram.y"
866 { yyval.number = atoi( yyvsp[0].string ) * RULE_MAXLINE; }
867 break;
868 case 71:
869 #line 350 "jamgram.y"
870 { yyval.parse = pnull(); }
871 break;
872 case 72:
873 #line 352 "jamgram.y"
874 { yyval.parse = yyvsp[0].parse; }
875 break;
876 #line 877 "y.tab.c"
877     }
878     yyssp -= yym;
879     yystate = *yyssp;
880     yyvsp -= yym;
881     yym = yylhs[yyn];
882     if (yystate == 0 && yym == 0)
883     {
884 #if YYDEBUG
885         if (yydebug)
886             printf("%sdebug: after reduction, shifting from state 0 to\
887  state %d\n", YYPREFIX, YYFINAL);
888 #endif
889         yystate = YYFINAL;
890         *++yyssp = YYFINAL;
891         *++yyvsp = yyval;
892         if (yychar < 0)
893         {
894             if ((yychar = yylex()) < 0) yychar = 0;
895 #if YYDEBUG
896             if (yydebug)
897             {
898                 yys = 0;
899                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
900                 if (!yys) yys = "illegal-symbol";
901                 printf("%sdebug: state %d, reading %d (%s)\n",
902                         YYPREFIX, YYFINAL, yychar, yys);
903             }
904 #endif
905         }
906         if (yychar == 0) goto yyaccept;
907         goto yyloop;
908     }
909     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
910             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
911         yystate = yytable[yyn];
912     else
913         yystate = yydgoto[yym];
914 #if YYDEBUG
915     if (yydebug)
916         printf("%sdebug: after reduction, shifting from state %d \
917 to state %d\n", YYPREFIX, *yyssp, yystate);
918 #endif
919     if (yyssp >= yysslim && yygrowstack())
920     {
921         goto yyoverflow;
922     }
923     *++yyssp = yystate;
924     *++yyvsp = yyval;
925     goto yyloop;
926 yyoverflow:
927     yyerror("yacc stack overflow");
928 yyabort:
929     return (1);
930 yyaccept:
931     return (0);
932 }
933