1 /* $FreeBSD$ */
2 #ifndef lint
3 static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
4 #endif
5
6 #define YYBYACC 1
7 #define YYMAJOR 1
8 #define YYMINOR 9
9
10 #define YYEMPTY (-1)
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
14
15 #define YYPREFIX "yy"
16
17 #define YYPURE 0
18
19 #line 35 "parse.y"
20 /* Copyright (c) 1990 The Regents of the University of California. */
21 /* All rights reserved. */
22
23 /* This code is derived from software contributed to Berkeley by */
24 /* Vern Paxson. */
25
26 /* The United States Government has rights in this work pursuant */
27 /* to contract no. DE-AC03-76SF00098 between the United States */
28 /* Department of Energy and the University of California. */
29
30 /* This file is part of flex. */
31
32 /* Redistribution and use in source and binary forms, with or without */
33 /* modification, are permitted provided that the following conditions */
34 /* are met: */
35
36 /* 1. Redistributions of source code must retain the above copyright */
37 /* notice, this list of conditions and the following disclaimer. */
38 /* 2. Redistributions in binary form must reproduce the above copyright */
39 /* notice, this list of conditions and the following disclaimer in the */
40 /* documentation and/or other materials provided with the distribution. */
41
42 /* Neither the name of the University nor the names of its contributors */
43 /* may be used to endorse or promote products derived from this software */
44 /* without specific prior written permission. */
45
46 /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
47 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
48 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
49 /* PURPOSE. */
50
51 #include "flexdef.h"
52 #include "tables.h"
53
54 int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
55 int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
56
57 int *scon_stk;
58 int scon_stk_ptr;
59
60 static int madeany = false; /* whether we've made the '.' character class */
61 static int ccldot, cclany;
62 int previous_continued_action; /* whether the previous rule's action was '|' */
63
64 #define format_warn3(fmt, a1, a2) \
65 do{ \
66 char fw3_msg[MAXLINE];\
67 snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
68 warn( fw3_msg );\
69 }while(0)
70
71 /* Expand a POSIX character class expression. */
72 #define CCL_EXPR(func) \
73 do{ \
74 int c; \
75 for ( c = 0; c < csize; ++c ) \
76 if ( isascii(c) && func(c) ) \
77 ccladd( currccl, c ); \
78 }while(0)
79
80 /* negated class */
81 #define CCL_NEG_EXPR(func) \
82 do{ \
83 int c; \
84 for ( c = 0; c < csize; ++c ) \
85 if ( !func(c) ) \
86 ccladd( currccl, c ); \
87 }while(0)
88
89 /* While POSIX defines isblank(), it's not ANSI C. */
90 #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
91
92 /* On some over-ambitious machines, such as DEC Alpha's, the default
93 * token type is "long" instead of "int"; this leads to problems with
94 * declaring yylval in flexdef.h. But so far, all the yacc's I've seen
95 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
96 * following should ensure that the default token type is "int".
97 */
98 #define YYSTYPE int
99
100 #line 99 "parse.c"
101
102 #ifndef YYSTYPE
103 typedef int YYSTYPE;
104 #endif
105
106 /* compatibility with bison */
107 #ifdef YYPARSE_PARAM
108 /* compatibility with FreeBSD */
109 # ifdef YYPARSE_PARAM_TYPE
110 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
111 # else
112 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
113 # endif
114 #else
115 # define YYPARSE_DECL() yyparse(void)
116 #endif
117
118 /* Parameters sent to lex. */
119 #ifdef YYLEX_PARAM
120 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
121 # define YYLEX yylex(YYLEX_PARAM)
122 #else
123 # define YYLEX_DECL() yylex(void)
124 # define YYLEX yylex()
125 #endif
126
127 /* Parameters sent to yyerror. */
128 #ifndef YYERROR_DECL
129 #define YYERROR_DECL() yyerror(const char *s)
130 #endif
131 #ifndef YYERROR_CALL
132 #define YYERROR_CALL(msg) yyerror(msg)
133 #endif
134
135 extern int YYPARSE_DECL();
136
137 #define CHAR 257
138 #define NUMBER 258
139 #define SECTEND 259
140 #define SCDECL 260
141 #define XSCDECL 261
142 #define NAME 262
143 #define PREVCCL 263
144 #define EOF_OP 264
145 #define OPTION_OP 265
146 #define OPT_OUTFILE 266
147 #define OPT_PREFIX 267
148 #define OPT_YYCLASS 268
149 #define OPT_HEADER 269
150 #define OPT_EXTRA_TYPE 270
151 #define OPT_TABLES 271
152 #define CCE_ALNUM 272
153 #define CCE_ALPHA 273
154 #define CCE_BLANK 274
155 #define CCE_CNTRL 275
156 #define CCE_DIGIT 276
157 #define CCE_GRAPH 277
158 #define CCE_LOWER 278
159 #define CCE_PRINT 279
160 #define CCE_PUNCT 280
161 #define CCE_SPACE 281
162 #define CCE_UPPER 282
163 #define CCE_XDIGIT 283
164 #define CCE_NEG_ALNUM 284
165 #define CCE_NEG_ALPHA 285
166 #define CCE_NEG_BLANK 286
167 #define CCE_NEG_CNTRL 287
168 #define CCE_NEG_DIGIT 288
169 #define CCE_NEG_GRAPH 289
170 #define CCE_NEG_LOWER 290
171 #define CCE_NEG_PRINT 291
172 #define CCE_NEG_PUNCT 292
173 #define CCE_NEG_SPACE 293
174 #define CCE_NEG_UPPER 294
175 #define CCE_NEG_XDIGIT 295
176 #define CCL_OP_DIFF 296
177 #define CCL_OP_UNION 297
178 #define BEGIN_REPEAT_POSIX 298
179 #define END_REPEAT_POSIX 299
180 #define BEGIN_REPEAT_FLEX 300
181 #define END_REPEAT_FLEX 301
182 #define YYERRCODE 256
183 static const short yylhs[] = { -1,
184 0, 1, 2, 2, 2, 2, 3, 6, 6, 7,
185 7, 7, 8, 9, 9, 10, 10, 10, 10, 10,
186 10, 4, 4, 4, 5, 12, 12, 12, 12, 14,
187 11, 11, 11, 15, 15, 15, 16, 13, 13, 13,
188 13, 18, 18, 17, 19, 19, 19, 19, 19, 20,
189 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
190 20, 21, 21, 21, 23, 23, 24, 24, 24, 24,
191 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
192 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
193 25, 25, 25, 25, 22, 22,
194 };
195 static const short yylen[] = { 2,
196 5, 0, 3, 2, 0, 1, 1, 1, 1, 2,
197 1, 1, 2, 2, 0, 3, 3, 3, 3, 3,
198 3, 5, 5, 0, 0, 2, 1, 1, 1, 0,
199 4, 3, 0, 3, 1, 1, 1, 2, 3, 2,
200 1, 3, 1, 2, 2, 1, 6, 5, 4, 2,
201 2, 2, 6, 5, 4, 1, 1, 1, 3, 3,
202 1, 3, 3, 1, 3, 4, 4, 2, 2, 0,
203 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
204 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
205 1, 1, 1, 1, 2, 0,
206 };
207 static const short yydefred[] = { 2,
208 0, 0, 6, 0, 7, 8, 9, 15, 24, 0,
209 4, 0, 0, 12, 11, 0, 0, 0, 0, 0,
210 0, 0, 14, 0, 1, 0, 10, 0, 0, 0,
211 0, 0, 0, 0, 0, 24, 0, 16, 18, 19,
212 20, 17, 21, 32, 36, 37, 0, 35, 0, 29,
213 61, 58, 28, 0, 56, 96, 0, 0, 0, 27,
214 0, 0, 0, 0, 0, 64, 31, 0, 23, 26,
215 0, 0, 70, 0, 22, 0, 40, 0, 44, 0,
216 0, 0, 50, 51, 52, 0, 0, 34, 95, 59,
217 60, 0, 0, 71, 72, 73, 74, 75, 76, 77,
218 78, 79, 80, 82, 81, 83, 84, 85, 86, 87,
219 88, 93, 89, 90, 91, 94, 92, 65, 69, 39,
220 0, 0, 0, 62, 63, 66, 0, 49, 0, 55,
221 0, 67, 0, 48, 0, 54, 47, 53,
222 };
223 static const short yydgoto[] = { 1,
224 2, 4, 9, 13, 25, 10, 16, 11, 12, 23,
225 26, 59, 60, 35, 47, 48, 61, 62, 63, 64,
226 65, 71, 66, 74, 119,
227 };
228 static const short yysindex[] = { 0,
229 0, -222, 0, -155, 0, 0, 0, 0, 0, -215,
230 0, -123, 6, 0, 0, -193, 10, 21, 26, 31,
231 35, 37, 0, 59, 0, -44, 0, -147, -145, -140,
232 -133, -132, -129, 75, -214, 0, -19, 0, 0, 0,
233 0, 0, 0, 0, 0, 0, 23, 0, -48, 0,
234 0, 0, 0, -17, 0, 0, -17, 27, 128, 0,
235 -17, -1, -30, -41, -189, 0, 0, -121, 0, 0,
236 -31, -34, 0, -87, 0, -25, 0, -17, 0, -109,
237 -41, -108, 0, 0, 0, 60, 60, 0, 0, 0,
238 0, 46, 107, 0, 0, 0, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 -30, -36, -39, 0, 0, 0, -104, 0, -219, 0,
242 -238, 0, -144, 0, -143, 0, 0, 0,
243 };
244 static const short yyrindex[] = { 0,
245 0, -141, 0, 0, 0, 0, 0, 0, 0, 0,
246 0, -134, 9, 0, 0, -125, 0, 0, 0, 0,
247 0, 0, 0, -178, 0, 22, 0, 0, 0, 0,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, -21, 0,
250 0, 0, 0, 0, 0, 0, 0, 85, 0, 0,
251 0, 144, 47, 4, -10, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 146, 0, 0, 0, 0,
253 18, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 124, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 50, 0, 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0,
259 };
260 static const short yygindex[] = { 0,
261 0, 0, 0, 121, 133, 0, 0, 0, 0, 0,
262 0, 0, 106, 0, 0, 93, 0, 32, 84, -45,
263 0, 0, 25, 90, 0,
264 };
265 #define YYTABLESIZE 419
266 static const short yytable[] = { 57,
267 83, 84, 90, 56, 131, 118, 91, 129, 25, 57,
268 120, 24, 33, 46, 56, 55, 56, 81, 33, 135,
269 57, 85, 57, 57, 33, 57, 55, 45, 55, 57,
270 57, 57, 57, 3, 77, 57, 57, 46, 133, 46,
271 14, 45, 33, 46, 46, 79, 15, 46, 33, 46,
272 46, 45, 57, 45, 33, 25, 43, 45, 45, 42,
273 58, 25, 136, 45, 45, 24, 68, 25, 27, 33,
274 28, 58, 33, 58, 54, 81, 69, 30, 36, 134,
275 57, 29, 43, 30, 67, 42, 30, 43, 72, 78,
276 42, 31, 76, 43, 46, 32, 42, 33, 78, 33,
277 34, 33, 33, 5, 6, 7, 86, 87, 45, 8,
278 124, 125, 25, 57, 38, 25, 39, 5, 5, 5,
279 73, 40, 78, 5, 13, 13, 13, 46, 41, 42,
280 13, 33, 43, 3, 3, 3, 44, 75, 126, 3,
281 46, 45, 17, 18, 19, 20, 21, 22, 122, 123,
282 58, 127, 132, 41, 137, 38, 49, 138, 37, 70,
283 88, 121, 92, 0, 0, 0, 0, 0, 0, 93,
284 43, 0, 0, 42, 0, 0, 0, 70, 0, 0,
285 0, 0, 0, 0, 94, 95, 96, 97, 98, 99,
286 100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
287 110, 111, 112, 113, 114, 115, 116, 117, 0, 0,
288 0, 0, 0, 0, 0, 0, 68, 0, 0, 0,
289 0, 0, 0, 0, 0, 89, 51, 0, 0, 0,
290 0, 0, 52, 0, 33, 33, 50, 51, 0, 51,
291 0, 33, 33, 52, 53, 52, 57, 0, 0, 0,
292 0, 0, 57, 0, 0, 0, 0, 0, 82, 0,
293 46, 130, 128, 0, 33, 33, 46, 80, 0, 0,
294 0, 33, 33, 0, 45, 0, 0, 25, 25, 0,
295 45, 0, 0, 0, 25, 25, 0, 57, 0, 57,
296 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
297 0, 46, 93, 0, 0, 0, 0, 0, 0, 0,
298 0, 0, 0, 0, 0, 45, 0, 94, 95, 96,
299 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
300 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
301 117, 70, 0, 0, 0, 0, 0, 0, 0, 0,
302 0, 0, 0, 0, 0, 0, 70, 70, 70, 70,
303 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
304 70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
305 68, 0, 0, 0, 0, 0, 0, 0, 0, 0,
306 0, 0, 0, 0, 0, 68, 68, 68, 68, 68,
307 68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
308 68, 68, 68, 68, 68, 68, 68, 68, 68,
309 };
310 static const short yycheck[] = { 10,
311 42, 43, 34, 34, 44, 93, 41, 44, 0, 40,
312 36, 60, 34, 10, 34, 46, 34, 63, 40, 258,
313 40, 63, 40, 34, 46, 36, 46, 10, 46, 40,
314 41, 42, 43, 256, 36, 46, 47, 34, 258, 36,
315 256, 256, 34, 40, 41, 47, 262, 262, 40, 46,
316 47, 34, 63, 36, 46, 34, 10, 40, 41, 10,
317 91, 40, 301, 46, 47, 60, 44, 46, 262, 91,
318 61, 91, 94, 91, 94, 121, 125, 256, 123, 299,
319 91, 61, 36, 262, 62, 36, 61, 41, 57, 124,
320 41, 61, 61, 47, 91, 61, 47, 61, 124, 91,
321 42, 123, 94, 259, 260, 261, 296, 297, 91, 265,
322 86, 87, 91, 124, 262, 94, 262, 259, 260, 261,
323 94, 262, 124, 265, 259, 260, 261, 124, 262, 262,
324 265, 123, 262, 259, 260, 261, 62, 10, 93, 265,
325 262, 124, 266, 267, 268, 269, 270, 271, 258, 258,
326 91, 45, 257, 10, 299, 10, 36, 301, 26, 54,
327 68, 78, 73, -1, -1, -1, -1, -1, -1, 257,
328 124, -1, -1, 124, -1, -1, -1, 93, -1, -1,
329 -1, -1, -1, -1, 272, 273, 274, 275, 276, 277,
330 278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
331 288, 289, 290, 291, 292, 293, 294, 295, -1, -1,
332 -1, -1, -1, -1, -1, -1, 93, -1, -1, -1,
333 -1, -1, -1, -1, -1, 257, 257, -1, -1, -1,
334 -1, -1, 263, -1, 256, 257, 256, 257, -1, 257,
335 -1, 263, 264, 263, 264, 263, 257, -1, -1, -1,
336 -1, -1, 263, -1, -1, -1, -1, -1, 300, -1,
337 257, 301, 299, -1, 256, 257, 263, 298, -1, -1,
338 -1, 263, 264, -1, 257, -1, -1, 256, 257, -1,
339 263, -1, -1, -1, 263, 264, -1, 298, -1, 300,
340 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
341 -1, 298, 257, -1, -1, -1, -1, -1, -1, -1,
342 -1, -1, -1, -1, -1, 298, -1, 272, 273, 274,
343 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
344 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
345 295, 257, -1, -1, -1, -1, -1, -1, -1, -1,
346 -1, -1, -1, -1, -1, -1, 272, 273, 274, 275,
347 276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
348 286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
349 257, -1, -1, -1, -1, -1, -1, -1, -1, -1,
350 -1, -1, -1, -1, -1, 272, 273, 274, 275, 276,
351 277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
352 287, 288, 289, 290, 291, 292, 293, 294, 295,
353 };
354 #define YYFINAL 1
355 #ifndef YYDEBUG
356 #define YYDEBUG 0
357 #endif
358 #define YYMAXTOKEN 301
359 #if YYDEBUG
360 static const char *yyname[] = {
361
362 "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
363 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
364 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,
365 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,
366 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,
367 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,
368 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,
369 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,"CHAR","NUMBER","SECTEND",
370 "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
371 "OPT_PREFIX","OPT_YYCLASS","OPT_HEADER","OPT_EXTRA_TYPE","OPT_TABLES",
372 "CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL","CCE_DIGIT","CCE_GRAPH",
373 "CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE","CCE_UPPER","CCE_XDIGIT",
374 "CCE_NEG_ALNUM","CCE_NEG_ALPHA","CCE_NEG_BLANK","CCE_NEG_CNTRL","CCE_NEG_DIGIT",
375 "CCE_NEG_GRAPH","CCE_NEG_LOWER","CCE_NEG_PRINT","CCE_NEG_PUNCT","CCE_NEG_SPACE",
376 "CCE_NEG_UPPER","CCE_NEG_XDIGIT","CCL_OP_DIFF","CCL_OP_UNION",
377 "BEGIN_REPEAT_POSIX","END_REPEAT_POSIX","BEGIN_REPEAT_FLEX","END_REPEAT_FLEX",
378 };
379 static const char *yyrule[] = {
380 "$accept : goal",
381 "goal : initlex sect1 sect1end sect2 initforrule",
382 "initlex :",
383 "sect1 : sect1 startconddecl namelist1",
384 "sect1 : sect1 options",
385 "sect1 :",
386 "sect1 : error",
387 "sect1end : SECTEND",
388 "startconddecl : SCDECL",
389 "startconddecl : XSCDECL",
390 "namelist1 : namelist1 NAME",
391 "namelist1 : NAME",
392 "namelist1 : error",
393 "options : OPTION_OP optionlist",
394 "optionlist : optionlist option",
395 "optionlist :",
396 "option : OPT_OUTFILE '=' NAME",
397 "option : OPT_EXTRA_TYPE '=' NAME",
398 "option : OPT_PREFIX '=' NAME",
399 "option : OPT_YYCLASS '=' NAME",
400 "option : OPT_HEADER '=' NAME",
401 "option : OPT_TABLES '=' NAME",
402 "sect2 : sect2 scon initforrule flexrule '\\n'",
403 "sect2 : sect2 scon '{' sect2 '}'",
404 "sect2 :",
405 "initforrule :",
406 "flexrule : '^' rule",
407 "flexrule : rule",
408 "flexrule : EOF_OP",
409 "flexrule : error",
410 "scon_stk_ptr :",
411 "scon : '<' scon_stk_ptr namelist2 '>'",
412 "scon : '<' '*' '>'",
413 "scon :",
414 "namelist2 : namelist2 ',' sconname",
415 "namelist2 : sconname",
416 "namelist2 : error",
417 "sconname : NAME",
418 "rule : re2 re",
419 "rule : re2 re '$'",
420 "rule : re '$'",
421 "rule : re",
422 "re : re '|' series",
423 "re : series",
424 "re2 : re '/'",
425 "series : series singleton",
426 "series : singleton",
427 "series : series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX",
428 "series : series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX",
429 "series : series BEGIN_REPEAT_POSIX NUMBER END_REPEAT_POSIX",
430 "singleton : singleton '*'",
431 "singleton : singleton '+'",
432 "singleton : singleton '?'",
433 "singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX",
434 "singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX",
435 "singleton : singleton BEGIN_REPEAT_FLEX NUMBER END_REPEAT_FLEX",
436 "singleton : '.'",
437 "singleton : fullccl",
438 "singleton : PREVCCL",
439 "singleton : '\"' string '\"'",
440 "singleton : '(' re ')'",
441 "singleton : CHAR",
442 "fullccl : fullccl CCL_OP_DIFF braceccl",
443 "fullccl : fullccl CCL_OP_UNION braceccl",
444 "fullccl : braceccl",
445 "braceccl : '[' ccl ']'",
446 "braceccl : '[' '^' ccl ']'",
447 "ccl : ccl CHAR '-' CHAR",
448 "ccl : ccl CHAR",
449 "ccl : ccl ccl_expr",
450 "ccl :",
451 "ccl_expr : CCE_ALNUM",
452 "ccl_expr : CCE_ALPHA",
453 "ccl_expr : CCE_BLANK",
454 "ccl_expr : CCE_CNTRL",
455 "ccl_expr : CCE_DIGIT",
456 "ccl_expr : CCE_GRAPH",
457 "ccl_expr : CCE_LOWER",
458 "ccl_expr : CCE_PRINT",
459 "ccl_expr : CCE_PUNCT",
460 "ccl_expr : CCE_SPACE",
461 "ccl_expr : CCE_XDIGIT",
462 "ccl_expr : CCE_UPPER",
463 "ccl_expr : CCE_NEG_ALNUM",
464 "ccl_expr : CCE_NEG_ALPHA",
465 "ccl_expr : CCE_NEG_BLANK",
466 "ccl_expr : CCE_NEG_CNTRL",
467 "ccl_expr : CCE_NEG_DIGIT",
468 "ccl_expr : CCE_NEG_GRAPH",
469 "ccl_expr : CCE_NEG_PRINT",
470 "ccl_expr : CCE_NEG_PUNCT",
471 "ccl_expr : CCE_NEG_SPACE",
472 "ccl_expr : CCE_NEG_XDIGIT",
473 "ccl_expr : CCE_NEG_LOWER",
474 "ccl_expr : CCE_NEG_UPPER",
475 "string : string CHAR",
476 "string :",
477
478 };
479 #endif
480
481 int yydebug;
482 int yynerrs;
483
484 int yyerrflag;
485 int yychar;
486 YYSTYPE yyval;
487 YYSTYPE yylval;
488
489 /* define the initial stack-sizes */
490 #ifdef YYSTACKSIZE
491 #undef YYMAXDEPTH
492 #define YYMAXDEPTH YYSTACKSIZE
493 #else
494 #ifdef YYMAXDEPTH
495 #define YYSTACKSIZE YYMAXDEPTH
496 #else
497 #define YYSTACKSIZE 500
498 #define YYMAXDEPTH 500
499 #endif
500 #endif
501
502 #define YYINITSTACKSIZE 500
503
504 typedef struct {
505 unsigned stacksize;
506 short *s_base;
507 short *s_mark;
508 short *s_last;
509 YYSTYPE *l_base;
510 YYSTYPE *l_mark;
511 } YYSTACKDATA;
512 /* variables for the parser stack */
513 static YYSTACKDATA yystack;
514 #line 948 "parse.y"
515
516
517 /* build_eof_action - build the "<<EOF>>" action for the active start
518 * conditions
519 */
520
build_eof_action()521 void build_eof_action()
522 {
523 int i;
524 char action_text[MAXLINE];
525
526 for ( i = 1; i <= scon_stk_ptr; ++i )
527 {
528 if ( sceof[scon_stk[i]] )
529 format_pinpoint_message(
530 "multiple <<EOF>> rules for start condition %s",
531 scname[scon_stk[i]] );
532
533 else
534 {
535 sceof[scon_stk[i]] = true;
536
537 if (previous_continued_action /* && previous action was regular */)
538 add_action("YY_RULE_SETUP\n");
539
540 snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
541 scname[scon_stk[i]] );
542 add_action( action_text );
543 }
544 }
545
546 line_directive_out( (FILE *) 0, 1 );
547
548 /* This isn't a normal rule after all - don't count it as
549 * such, so we don't have any holes in the rule numbering
550 * (which make generating "rule can never match" warnings
551 * more difficult.
552 */
553 --num_rules;
554 ++num_eof_rules;
555 }
556
557
558 /* format_synerr - write out formatted syntax error */
559
format_synerr(msg,arg)560 void format_synerr( msg, arg )
561 const char *msg, arg[];
562 {
563 char errmsg[MAXLINE];
564
565 (void) snprintf( errmsg, sizeof(errmsg), msg, arg );
566 synerr( errmsg );
567 }
568
569
570 /* synerr - report a syntax error */
571
synerr(str)572 void synerr( str )
573 const char *str;
574 {
575 syntaxerror = true;
576 pinpoint_message( str );
577 }
578
579
580 /* format_warn - write out formatted warning */
581
format_warn(msg,arg)582 void format_warn( msg, arg )
583 const char *msg, arg[];
584 {
585 char warn_msg[MAXLINE];
586
587 snprintf( warn_msg, sizeof(warn_msg), msg, arg );
588 warn( warn_msg );
589 }
590
591
592 /* warn - report a warning, unless -w was given */
593
warn(str)594 void warn( str )
595 const char *str;
596 {
597 line_warning( str, linenum );
598 }
599
600 /* format_pinpoint_message - write out a message formatted with one string,
601 * pinpointing its location
602 */
603
format_pinpoint_message(msg,arg)604 void format_pinpoint_message( msg, arg )
605 const char *msg, arg[];
606 {
607 char errmsg[MAXLINE];
608
609 snprintf( errmsg, sizeof(errmsg), msg, arg );
610 pinpoint_message( errmsg );
611 }
612
613
614 /* pinpoint_message - write out a message, pinpointing its location */
615
pinpoint_message(str)616 void pinpoint_message( str )
617 const char *str;
618 {
619 line_pinpoint( str, linenum );
620 }
621
622
623 /* line_warning - report a warning at a given line, unless -w was given */
624
line_warning(str,line)625 void line_warning( str, line )
626 const char *str;
627 int line;
628 {
629 char warning[MAXLINE];
630
631 if ( ! nowarn )
632 {
633 snprintf( warning, sizeof(warning), "warning, %s", str );
634 line_pinpoint( warning, line );
635 }
636 }
637
638
639 /* line_pinpoint - write out a message, pinpointing it at the given line */
640
line_pinpoint(str,line)641 void line_pinpoint( str, line )
642 const char *str;
643 int line;
644 {
645 fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
646 }
647
648
649 /* yyerror - eat up an error message from the parser;
650 * currently, messages are ignore
651 */
652
yyerror(msg)653 void yyerror( msg )
654 const char *msg;
655 {
656 }
657 #line 656 "parse.c"
658
659 #if YYDEBUG
660 #include <stdio.h> /* needed for printf */
661 #endif
662
663 #include <stdlib.h> /* needed for malloc, etc */
664 #include <string.h> /* needed for memset */
665
666 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)667 static int yygrowstack(YYSTACKDATA *data)
668 {
669 int i;
670 unsigned newsize;
671 short *newss;
672 YYSTYPE *newvs;
673
674 if ((newsize = data->stacksize) == 0)
675 newsize = YYINITSTACKSIZE;
676 else if (newsize >= YYMAXDEPTH)
677 return -1;
678 else if ((newsize *= 2) > YYMAXDEPTH)
679 newsize = YYMAXDEPTH;
680
681 i = data->s_mark - data->s_base;
682 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
683 if (newss == 0)
684 return -1;
685
686 data->s_base = newss;
687 data->s_mark = newss + i;
688
689 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
690 if (newvs == 0)
691 return -1;
692
693 data->l_base = newvs;
694 data->l_mark = newvs + i;
695
696 data->stacksize = newsize;
697 data->s_last = data->s_base + newsize - 1;
698 return 0;
699 }
700
701 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)702 static void yyfreestack(YYSTACKDATA *data)
703 {
704 free(data->s_base);
705 free(data->l_base);
706 memset(data, 0, sizeof(*data));
707 }
708 #else
709 #define yyfreestack(data) /* nothing */
710 #endif
711
712 #define YYABORT goto yyabort
713 #define YYREJECT goto yyabort
714 #define YYACCEPT goto yyaccept
715 #define YYERROR goto yyerrlab
716
717 int
YYPARSE_DECL()718 YYPARSE_DECL()
719 {
720 int yym, yyn, yystate;
721 #if YYDEBUG
722 const char *yys;
723
724 if ((yys = getenv("YYDEBUG")) != 0)
725 {
726 yyn = *yys;
727 if (yyn >= '0' && yyn <= '9')
728 yydebug = yyn - '0';
729 }
730 #endif
731
732 yynerrs = 0;
733 yyerrflag = 0;
734 yychar = YYEMPTY;
735 yystate = 0;
736
737 #if YYPURE
738 memset(&yystack, 0, sizeof(yystack));
739 #endif
740
741 if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
742 yystack.s_mark = yystack.s_base;
743 yystack.l_mark = yystack.l_base;
744 yystate = 0;
745 *yystack.s_mark = 0;
746
747 yyloop:
748 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
749 if (yychar < 0)
750 {
751 if ((yychar = YYLEX) < 0) yychar = 0;
752 #if YYDEBUG
753 if (yydebug)
754 {
755 yys = 0;
756 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
757 if (!yys) yys = "illegal-symbol";
758 printf("%sdebug: state %d, reading %d (%s)\n",
759 YYPREFIX, yystate, yychar, yys);
760 }
761 #endif
762 }
763 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
764 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
765 {
766 #if YYDEBUG
767 if (yydebug)
768 printf("%sdebug: state %d, shifting to state %d\n",
769 YYPREFIX, yystate, yytable[yyn]);
770 #endif
771 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
772 {
773 goto yyoverflow;
774 }
775 yystate = yytable[yyn];
776 *++yystack.s_mark = yytable[yyn];
777 *++yystack.l_mark = yylval;
778 yychar = YYEMPTY;
779 if (yyerrflag > 0) --yyerrflag;
780 goto yyloop;
781 }
782 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
783 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
784 {
785 yyn = yytable[yyn];
786 goto yyreduce;
787 }
788 if (yyerrflag) goto yyinrecovery;
789
790 yyerror("syntax error");
791
792 goto yyerrlab;
793
794 yyerrlab:
795 ++yynerrs;
796
797 yyinrecovery:
798 if (yyerrflag < 3)
799 {
800 yyerrflag = 3;
801 for (;;)
802 {
803 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
804 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
805 {
806 #if YYDEBUG
807 if (yydebug)
808 printf("%sdebug: state %d, error recovery shifting\
809 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
810 #endif
811 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
812 {
813 goto yyoverflow;
814 }
815 yystate = yytable[yyn];
816 *++yystack.s_mark = yytable[yyn];
817 *++yystack.l_mark = yylval;
818 goto yyloop;
819 }
820 else
821 {
822 #if YYDEBUG
823 if (yydebug)
824 printf("%sdebug: error recovery discarding state %d\n",
825 YYPREFIX, *yystack.s_mark);
826 #endif
827 if (yystack.s_mark <= yystack.s_base) goto yyabort;
828 --yystack.s_mark;
829 --yystack.l_mark;
830 }
831 }
832 }
833 else
834 {
835 if (yychar == 0) goto yyabort;
836 #if YYDEBUG
837 if (yydebug)
838 {
839 yys = 0;
840 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
841 if (!yys) yys = "illegal-symbol";
842 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
843 YYPREFIX, yystate, yychar, yys);
844 }
845 #endif
846 yychar = YYEMPTY;
847 goto yyloop;
848 }
849
850 yyreduce:
851 #if YYDEBUG
852 if (yydebug)
853 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
854 YYPREFIX, yystate, yyn, yyrule[yyn]);
855 #endif
856 yym = yylen[yyn];
857 if (yym)
858 yyval = yystack.l_mark[1-yym];
859 else
860 memset(&yyval, 0, sizeof yyval);
861 switch (yyn)
862 {
863 case 1:
864 #line 119 "parse.y"
865 { /* add default rule */
866 int def_rule;
867
868 pat = cclinit();
869 cclnegate( pat );
870
871 def_rule = mkstate( -pat );
872
873 /* Remember the number of the default rule so we
874 * don't generate "can't match" warnings for it.
875 */
876 default_rule = num_rules;
877
878 finish_rule( def_rule, false, 0, 0, 0);
879
880 for ( i = 1; i <= lastsc; ++i )
881 scset[i] = mkbranch( scset[i], def_rule );
882
883 if ( spprdflt )
884 add_action(
885 "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
886 else
887 add_action( "ECHO" );
888
889 add_action( ";\n\tYY_BREAK\n" );
890 }
891 break;
892 case 2:
893 #line 148 "parse.y"
894 { /* initialize for processing rules */
895
896 /* Create default DFA start condition. */
897 scinstal( "INITIAL", false );
898 }
899 break;
900 case 6:
901 #line 159 "parse.y"
902 { synerr( _("unknown error processing section 1") ); }
903 break;
904 case 7:
905 #line 163 "parse.y"
906 {
907 check_options();
908 scon_stk = allocate_integer_array( lastsc + 1 );
909 scon_stk_ptr = 0;
910 }
911 break;
912 case 8:
913 #line 171 "parse.y"
914 { xcluflg = false; }
915 break;
916 case 9:
917 #line 174 "parse.y"
918 { xcluflg = true; }
919 break;
920 case 10:
921 #line 178 "parse.y"
922 { scinstal( nmstr, xcluflg ); }
923 break;
924 case 11:
925 #line 181 "parse.y"
926 { scinstal( nmstr, xcluflg ); }
927 break;
928 case 12:
929 #line 184 "parse.y"
930 { synerr( _("bad start condition list") ); }
931 break;
932 case 16:
933 #line 195 "parse.y"
934 {
935 outfilename = copy_string( nmstr );
936 did_outfilename = 1;
937 }
938 break;
939 case 17:
940 #line 200 "parse.y"
941 { extra_type = copy_string( nmstr ); }
942 break;
943 case 18:
944 #line 202 "parse.y"
945 { prefix = copy_string( nmstr ); }
946 break;
947 case 19:
948 #line 204 "parse.y"
949 { yyclass = copy_string( nmstr ); }
950 break;
951 case 20:
952 #line 206 "parse.y"
953 { headerfilename = copy_string( nmstr ); }
954 break;
955 case 21:
956 #line 208 "parse.y"
957 { tablesext = true; tablesfilename = copy_string( nmstr ); }
958 break;
959 case 22:
960 #line 212 "parse.y"
961 { scon_stk_ptr = yystack.l_mark[-3]; }
962 break;
963 case 23:
964 #line 214 "parse.y"
965 { scon_stk_ptr = yystack.l_mark[-3]; }
966 break;
967 case 25:
968 #line 219 "parse.y"
969 {
970 /* Initialize for a parse of one rule. */
971 trlcontxt = variable_trail_rule = varlength = false;
972 trailcnt = headcnt = rulelen = 0;
973 current_state_type = STATE_NORMAL;
974 previous_continued_action = continued_action;
975 in_rule = true;
976
977 new_rule();
978 }
979 break;
980 case 26:
981 #line 232 "parse.y"
982 {
983 pat = yystack.l_mark[0];
984 finish_rule( pat, variable_trail_rule,
985 headcnt, trailcnt , previous_continued_action);
986
987 if ( scon_stk_ptr > 0 )
988 {
989 for ( i = 1; i <= scon_stk_ptr; ++i )
990 scbol[scon_stk[i]] =
991 mkbranch( scbol[scon_stk[i]],
992 pat );
993 }
994
995 else
996 {
997 /* Add to all non-exclusive start conditions,
998 * including the default (0) start condition.
999 */
1000
1001 for ( i = 1; i <= lastsc; ++i )
1002 if ( ! scxclu[i] )
1003 scbol[i] = mkbranch( scbol[i],
1004 pat );
1005 }
1006
1007 if ( ! bol_needed )
1008 {
1009 bol_needed = true;
1010
1011 if ( performance_report > 1 )
1012 pinpoint_message(
1013 "'^' operator results in sub-optimal performance" );
1014 }
1015 }
1016 break;
1017 case 27:
1018 #line 268 "parse.y"
1019 {
1020 pat = yystack.l_mark[0];
1021 finish_rule( pat, variable_trail_rule,
1022 headcnt, trailcnt , previous_continued_action);
1023
1024 if ( scon_stk_ptr > 0 )
1025 {
1026 for ( i = 1; i <= scon_stk_ptr; ++i )
1027 scset[scon_stk[i]] =
1028 mkbranch( scset[scon_stk[i]],
1029 pat );
1030 }
1031
1032 else
1033 {
1034 for ( i = 1; i <= lastsc; ++i )
1035 if ( ! scxclu[i] )
1036 scset[i] =
1037 mkbranch( scset[i],
1038 pat );
1039 }
1040 }
1041 break;
1042 case 28:
1043 #line 292 "parse.y"
1044 {
1045 if ( scon_stk_ptr > 0 )
1046 build_eof_action();
1047
1048 else
1049 {
1050 /* This EOF applies to all start conditions
1051 * which don't already have EOF actions.
1052 */
1053 for ( i = 1; i <= lastsc; ++i )
1054 if ( ! sceof[i] )
1055 scon_stk[++scon_stk_ptr] = i;
1056
1057 if ( scon_stk_ptr == 0 )
1058 warn(
1059 "all start conditions already have <<EOF>> rules" );
1060
1061 else
1062 build_eof_action();
1063 }
1064 }
1065 break;
1066 case 29:
1067 #line 315 "parse.y"
1068 { synerr( _("unrecognized rule") ); }
1069 break;
1070 case 30:
1071 #line 319 "parse.y"
1072 { yyval = scon_stk_ptr; }
1073 break;
1074 case 31:
1075 #line 323 "parse.y"
1076 { yyval = yystack.l_mark[-2]; }
1077 break;
1078 case 32:
1079 #line 326 "parse.y"
1080 {
1081 yyval = scon_stk_ptr;
1082
1083 for ( i = 1; i <= lastsc; ++i )
1084 {
1085 int j;
1086
1087 for ( j = 1; j <= scon_stk_ptr; ++j )
1088 if ( scon_stk[j] == i )
1089 break;
1090
1091 if ( j > scon_stk_ptr )
1092 scon_stk[++scon_stk_ptr] = i;
1093 }
1094 }
1095 break;
1096 case 33:
1097 #line 343 "parse.y"
1098 { yyval = scon_stk_ptr; }
1099 break;
1100 case 36:
1101 #line 351 "parse.y"
1102 { synerr( _("bad start condition list") ); }
1103 break;
1104 case 37:
1105 #line 355 "parse.y"
1106 {
1107 if ( (scnum = sclookup( nmstr )) == 0 )
1108 format_pinpoint_message(
1109 "undeclared start condition %s",
1110 nmstr );
1111 else
1112 {
1113 for ( i = 1; i <= scon_stk_ptr; ++i )
1114 if ( scon_stk[i] == scnum )
1115 {
1116 format_warn(
1117 "<%s> specified twice",
1118 scname[scnum] );
1119 break;
1120 }
1121
1122 if ( i > scon_stk_ptr )
1123 scon_stk[++scon_stk_ptr] = scnum;
1124 }
1125 }
1126 break;
1127 case 38:
1128 #line 378 "parse.y"
1129 {
1130 if ( transchar[lastst[yystack.l_mark[0]]] != SYM_EPSILON )
1131 /* Provide final transition \now/ so it
1132 * will be marked as a trailing context
1133 * state.
1134 */
1135 yystack.l_mark[0] = link_machines( yystack.l_mark[0],
1136 mkstate( SYM_EPSILON ) );
1137
1138 mark_beginning_as_normal( yystack.l_mark[0] );
1139 current_state_type = STATE_NORMAL;
1140
1141 if ( previous_continued_action )
1142 {
1143 /* We need to treat this as variable trailing
1144 * context so that the backup does not happen
1145 * in the action but before the action switch
1146 * statement. If the backup happens in the
1147 * action, then the rules "falling into" this
1148 * one's action will *also* do the backup,
1149 * erroneously.
1150 */
1151 if ( ! varlength || headcnt != 0 )
1152 warn(
1153 "trailing context made variable due to preceding '|' action" );
1154
1155 /* Mark as variable. */
1156 varlength = true;
1157 headcnt = 0;
1158
1159 }
1160
1161 if ( lex_compat || (varlength && headcnt == 0) )
1162 { /* variable trailing context rule */
1163 /* Mark the first part of the rule as the
1164 * accepting "head" part of a trailing
1165 * context rule.
1166 *
1167 * By the way, we didn't do this at the
1168 * beginning of this production because back
1169 * then current_state_type was set up for a
1170 * trail rule, and add_accept() can create
1171 * a new state ...
1172 */
1173 add_accept( yystack.l_mark[-1],
1174 num_rules | YY_TRAILING_HEAD_MASK );
1175 variable_trail_rule = true;
1176 }
1177
1178 else
1179 trailcnt = rulelen;
1180
1181 yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
1182 }
1183 break;
1184 case 39:
1185 #line 434 "parse.y"
1186 { synerr( _("trailing context used twice") ); }
1187 break;
1188 case 40:
1189 #line 437 "parse.y"
1190 {
1191 headcnt = 0;
1192 trailcnt = 1;
1193 rulelen = 1;
1194 varlength = false;
1195
1196 current_state_type = STATE_TRAILING_CONTEXT;
1197
1198 if ( trlcontxt )
1199 {
1200 synerr( _("trailing context used twice") );
1201 yyval = mkstate( SYM_EPSILON );
1202 }
1203
1204 else if ( previous_continued_action )
1205 {
1206 /* See the comment in the rule for "re2 re"
1207 * above.
1208 */
1209 warn(
1210 "trailing context made variable due to preceding '|' action" );
1211
1212 varlength = true;
1213 }
1214
1215 if ( lex_compat || varlength )
1216 {
1217 /* Again, see the comment in the rule for
1218 * "re2 re" above.
1219 */
1220 add_accept( yystack.l_mark[-1],
1221 num_rules | YY_TRAILING_HEAD_MASK );
1222 variable_trail_rule = true;
1223 }
1224
1225 trlcontxt = true;
1226
1227 eps = mkstate( SYM_EPSILON );
1228 yyval = link_machines( yystack.l_mark[-1],
1229 link_machines( eps, mkstate( '\n' ) ) );
1230 }
1231 break;
1232 case 41:
1233 #line 480 "parse.y"
1234 {
1235 yyval = yystack.l_mark[0];
1236
1237 if ( trlcontxt )
1238 {
1239 if ( lex_compat || (varlength && headcnt == 0) )
1240 /* Both head and trail are
1241 * variable-length.
1242 */
1243 variable_trail_rule = true;
1244 else
1245 trailcnt = rulelen;
1246 }
1247 }
1248 break;
1249 case 42:
1250 #line 498 "parse.y"
1251 {
1252 varlength = true;
1253 yyval = mkor( yystack.l_mark[-2], yystack.l_mark[0] );
1254 }
1255 break;
1256 case 43:
1257 #line 504 "parse.y"
1258 { yyval = yystack.l_mark[0]; }
1259 break;
1260 case 44:
1261 #line 509 "parse.y"
1262 {
1263 /* This rule is written separately so the
1264 * reduction will occur before the trailing
1265 * series is parsed.
1266 */
1267
1268 if ( trlcontxt )
1269 synerr( _("trailing context used twice") );
1270 else
1271 trlcontxt = true;
1272
1273 if ( varlength )
1274 /* We hope the trailing context is
1275 * fixed-length.
1276 */
1277 varlength = false;
1278 else
1279 headcnt = rulelen;
1280
1281 rulelen = 0;
1282
1283 current_state_type = STATE_TRAILING_CONTEXT;
1284 yyval = yystack.l_mark[-1];
1285 }
1286 break;
1287 case 45:
1288 #line 536 "parse.y"
1289 {
1290 /* This is where concatenation of adjacent patterns
1291 * gets done.
1292 */
1293 yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
1294 }
1295 break;
1296 case 46:
1297 #line 544 "parse.y"
1298 { yyval = yystack.l_mark[0]; }
1299 break;
1300 case 47:
1301 #line 547 "parse.y"
1302 {
1303 varlength = true;
1304
1305 if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
1306 {
1307 synerr( _("bad iteration values") );
1308 yyval = yystack.l_mark[-5];
1309 }
1310 else
1311 {
1312 if ( yystack.l_mark[-3] == 0 )
1313 {
1314 if ( yystack.l_mark[-1] <= 0 )
1315 {
1316 synerr(
1317 _("bad iteration values") );
1318 yyval = yystack.l_mark[-5];
1319 }
1320 else
1321 yyval = mkopt(
1322 mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
1323 }
1324 else
1325 yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
1326 }
1327 }
1328 break;
1329 case 48:
1330 #line 575 "parse.y"
1331 {
1332 varlength = true;
1333
1334 if ( yystack.l_mark[-2] <= 0 )
1335 {
1336 synerr( _("iteration value must be positive") );
1337 yyval = yystack.l_mark[-4];
1338 }
1339
1340 else
1341 yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
1342 }
1343 break;
1344 case 49:
1345 #line 589 "parse.y"
1346 {
1347 /* The series could be something like "(foo)",
1348 * in which case we have no idea what its length
1349 * is, so we punt here.
1350 */
1351 varlength = true;
1352
1353 if ( yystack.l_mark[-1] <= 0 )
1354 {
1355 synerr( _("iteration value must be positive")
1356 );
1357 yyval = yystack.l_mark[-3];
1358 }
1359
1360 else
1361 yyval = link_machines( yystack.l_mark[-3],
1362 copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
1363 }
1364 break;
1365 case 50:
1366 #line 611 "parse.y"
1367 {
1368 varlength = true;
1369
1370 yyval = mkclos( yystack.l_mark[-1] );
1371 }
1372 break;
1373 case 51:
1374 #line 618 "parse.y"
1375 {
1376 varlength = true;
1377 yyval = mkposcl( yystack.l_mark[-1] );
1378 }
1379 break;
1380 case 52:
1381 #line 624 "parse.y"
1382 {
1383 varlength = true;
1384 yyval = mkopt( yystack.l_mark[-1] );
1385 }
1386 break;
1387 case 53:
1388 #line 630 "parse.y"
1389 {
1390 varlength = true;
1391
1392 if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
1393 {
1394 synerr( _("bad iteration values") );
1395 yyval = yystack.l_mark[-5];
1396 }
1397 else
1398 {
1399 if ( yystack.l_mark[-3] == 0 )
1400 {
1401 if ( yystack.l_mark[-1] <= 0 )
1402 {
1403 synerr(
1404 _("bad iteration values") );
1405 yyval = yystack.l_mark[-5];
1406 }
1407 else
1408 yyval = mkopt(
1409 mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
1410 }
1411 else
1412 yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
1413 }
1414 }
1415 break;
1416 case 54:
1417 #line 658 "parse.y"
1418 {
1419 varlength = true;
1420
1421 if ( yystack.l_mark[-2] <= 0 )
1422 {
1423 synerr( _("iteration value must be positive") );
1424 yyval = yystack.l_mark[-4];
1425 }
1426
1427 else
1428 yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
1429 }
1430 break;
1431 case 55:
1432 #line 672 "parse.y"
1433 {
1434 /* The singleton could be something like "(foo)",
1435 * in which case we have no idea what its length
1436 * is, so we punt here.
1437 */
1438 varlength = true;
1439
1440 if ( yystack.l_mark[-1] <= 0 )
1441 {
1442 synerr( _("iteration value must be positive") );
1443 yyval = yystack.l_mark[-3];
1444 }
1445
1446 else
1447 yyval = link_machines( yystack.l_mark[-3],
1448 copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
1449 }
1450 break;
1451 case 56:
1452 #line 691 "parse.y"
1453 {
1454 if ( ! madeany )
1455 {
1456 /* Create the '.' character class. */
1457 ccldot = cclinit();
1458 ccladd( ccldot, '\n' );
1459 cclnegate( ccldot );
1460
1461 if ( useecs )
1462 mkeccl( ccltbl + cclmap[ccldot],
1463 ccllen[ccldot], nextecm,
1464 ecgroup, csize, csize );
1465
1466 /* Create the (?s:'.') character class. */
1467 cclany = cclinit();
1468 cclnegate( cclany );
1469
1470 if ( useecs )
1471 mkeccl( ccltbl + cclmap[cclany],
1472 ccllen[cclany], nextecm,
1473 ecgroup, csize, csize );
1474
1475 madeany = true;
1476 }
1477
1478 ++rulelen;
1479
1480 if (sf_dot_all())
1481 yyval = mkstate( -cclany );
1482 else
1483 yyval = mkstate( -ccldot );
1484 }
1485 break;
1486 case 57:
1487 #line 725 "parse.y"
1488 {
1489 /* Sort characters for fast searching.
1490 */
1491 qsort( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]], sizeof (*ccltbl), cclcmp );
1492
1493 if ( useecs )
1494 mkeccl( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]],
1495 nextecm, ecgroup, csize, csize );
1496
1497 ++rulelen;
1498
1499 if (ccl_has_nl[yystack.l_mark[0]])
1500 rule_has_nl[num_rules] = true;
1501
1502 yyval = mkstate( -yystack.l_mark[0] );
1503 }
1504 break;
1505 case 58:
1506 #line 743 "parse.y"
1507 {
1508 ++rulelen;
1509
1510 if (ccl_has_nl[yystack.l_mark[0]])
1511 rule_has_nl[num_rules] = true;
1512
1513 yyval = mkstate( -yystack.l_mark[0] );
1514 }
1515 break;
1516 case 59:
1517 #line 753 "parse.y"
1518 { yyval = yystack.l_mark[-1]; }
1519 break;
1520 case 60:
1521 #line 756 "parse.y"
1522 { yyval = yystack.l_mark[-1]; }
1523 break;
1524 case 61:
1525 #line 759 "parse.y"
1526 {
1527 ++rulelen;
1528
1529 if (yystack.l_mark[0] == nlch)
1530 rule_has_nl[num_rules] = true;
1531
1532 if (sf_case_ins() && has_case(yystack.l_mark[0]))
1533 /* create an alternation, as in (a|A) */
1534 yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
1535 else
1536 yyval = mkstate( yystack.l_mark[0] );
1537 }
1538 break;
1539 case 62:
1540 #line 773 "parse.y"
1541 { yyval = ccl_set_diff (yystack.l_mark[-2], yystack.l_mark[0]); }
1542 break;
1543 case 63:
1544 #line 774 "parse.y"
1545 { yyval = ccl_set_union (yystack.l_mark[-2], yystack.l_mark[0]); }
1546 break;
1547 case 65:
1548 #line 780 "parse.y"
1549 { yyval = yystack.l_mark[-1]; }
1550 break;
1551 case 66:
1552 #line 783 "parse.y"
1553 {
1554 cclnegate( yystack.l_mark[-1] );
1555 yyval = yystack.l_mark[-1];
1556 }
1557 break;
1558 case 67:
1559 #line 790 "parse.y"
1560 {
1561
1562 if (sf_case_ins())
1563 {
1564
1565 /* If one end of the range has case and the other
1566 * does not, or the cases are different, then we're not
1567 * sure what range the user is trying to express.
1568 * Examples: [@-z] or [S-t]
1569 */
1570 if (has_case (yystack.l_mark[-2]) != has_case (yystack.l_mark[0])
1571 || (has_case (yystack.l_mark[-2]) && (b_islower (yystack.l_mark[-2]) != b_islower (yystack.l_mark[0])))
1572 || (has_case (yystack.l_mark[-2]) && (b_isupper (yystack.l_mark[-2]) != b_isupper (yystack.l_mark[0]))))
1573 format_warn3 (
1574 _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
1575 yystack.l_mark[-2], yystack.l_mark[0]);
1576
1577 /* If the range spans uppercase characters but not
1578 * lowercase (or vice-versa), then should we automatically
1579 * include lowercase characters in the range?
1580 * Example: [@-_] spans [a-z] but not [A-Z]
1581 */
1582 else if (!has_case (yystack.l_mark[-2]) && !has_case (yystack.l_mark[0]) && !range_covers_case (yystack.l_mark[-2], yystack.l_mark[0]))
1583 format_warn3 (
1584 _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
1585 yystack.l_mark[-2], yystack.l_mark[0]);
1586 }
1587
1588 if ( yystack.l_mark[-2] > yystack.l_mark[0] )
1589 synerr( _("negative range in character class") );
1590
1591 else
1592 {
1593 for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
1594 ccladd( yystack.l_mark[-3], i );
1595
1596 /* Keep track if this ccl is staying in
1597 * alphabetical order.
1598 */
1599 cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
1600 lastchar = yystack.l_mark[0];
1601
1602 /* Do it again for upper/lowercase */
1603 if (sf_case_ins() && has_case(yystack.l_mark[-2]) && has_case(yystack.l_mark[0])){
1604 yystack.l_mark[-2] = reverse_case (yystack.l_mark[-2]);
1605 yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
1606
1607 for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
1608 ccladd( yystack.l_mark[-3], i );
1609
1610 cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
1611 lastchar = yystack.l_mark[0];
1612 }
1613
1614 }
1615
1616 yyval = yystack.l_mark[-3];
1617 }
1618 break;
1619 case 68:
1620 #line 850 "parse.y"
1621 {
1622 ccladd( yystack.l_mark[-1], yystack.l_mark[0] );
1623 cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
1624 lastchar = yystack.l_mark[0];
1625
1626 /* Do it again for upper/lowercase */
1627 if (sf_case_ins() && has_case(yystack.l_mark[0])){
1628 yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
1629 ccladd (yystack.l_mark[-1], yystack.l_mark[0]);
1630
1631 cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
1632 lastchar = yystack.l_mark[0];
1633 }
1634
1635 yyval = yystack.l_mark[-1];
1636 }
1637 break;
1638 case 69:
1639 #line 868 "parse.y"
1640 {
1641 /* Too hard to properly maintain cclsorted. */
1642 cclsorted = false;
1643 yyval = yystack.l_mark[-1];
1644 }
1645 break;
1646 case 70:
1647 #line 875 "parse.y"
1648 {
1649 cclsorted = true;
1650 lastchar = 0;
1651 currccl = yyval = cclinit();
1652 }
1653 break;
1654 case 71:
1655 #line 883 "parse.y"
1656 { CCL_EXPR(isalnum); }
1657 break;
1658 case 72:
1659 #line 884 "parse.y"
1660 { CCL_EXPR(isalpha); }
1661 break;
1662 case 73:
1663 #line 885 "parse.y"
1664 { CCL_EXPR(IS_BLANK); }
1665 break;
1666 case 74:
1667 #line 886 "parse.y"
1668 { CCL_EXPR(iscntrl); }
1669 break;
1670 case 75:
1671 #line 887 "parse.y"
1672 { CCL_EXPR(isdigit); }
1673 break;
1674 case 76:
1675 #line 888 "parse.y"
1676 { CCL_EXPR(isgraph); }
1677 break;
1678 case 77:
1679 #line 889 "parse.y"
1680 {
1681 CCL_EXPR(islower);
1682 if (sf_case_ins())
1683 CCL_EXPR(isupper);
1684 }
1685 break;
1686 case 78:
1687 #line 894 "parse.y"
1688 { CCL_EXPR(isprint); }
1689 break;
1690 case 79:
1691 #line 895 "parse.y"
1692 { CCL_EXPR(ispunct); }
1693 break;
1694 case 80:
1695 #line 896 "parse.y"
1696 { CCL_EXPR(isspace); }
1697 break;
1698 case 81:
1699 #line 897 "parse.y"
1700 { CCL_EXPR(isxdigit); }
1701 break;
1702 case 82:
1703 #line 898 "parse.y"
1704 {
1705 CCL_EXPR(isupper);
1706 if (sf_case_ins())
1707 CCL_EXPR(islower);
1708 }
1709 break;
1710 case 83:
1711 #line 904 "parse.y"
1712 { CCL_NEG_EXPR(isalnum); }
1713 break;
1714 case 84:
1715 #line 905 "parse.y"
1716 { CCL_NEG_EXPR(isalpha); }
1717 break;
1718 case 85:
1719 #line 906 "parse.y"
1720 { CCL_NEG_EXPR(IS_BLANK); }
1721 break;
1722 case 86:
1723 #line 907 "parse.y"
1724 { CCL_NEG_EXPR(iscntrl); }
1725 break;
1726 case 87:
1727 #line 908 "parse.y"
1728 { CCL_NEG_EXPR(isdigit); }
1729 break;
1730 case 88:
1731 #line 909 "parse.y"
1732 { CCL_NEG_EXPR(isgraph); }
1733 break;
1734 case 89:
1735 #line 910 "parse.y"
1736 { CCL_NEG_EXPR(isprint); }
1737 break;
1738 case 90:
1739 #line 911 "parse.y"
1740 { CCL_NEG_EXPR(ispunct); }
1741 break;
1742 case 91:
1743 #line 912 "parse.y"
1744 { CCL_NEG_EXPR(isspace); }
1745 break;
1746 case 92:
1747 #line 913 "parse.y"
1748 { CCL_NEG_EXPR(isxdigit); }
1749 break;
1750 case 93:
1751 #line 914 "parse.y"
1752 {
1753 if ( sf_case_ins() )
1754 warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
1755 else
1756 CCL_NEG_EXPR(islower);
1757 }
1758 break;
1759 case 94:
1760 #line 920 "parse.y"
1761 {
1762 if ( sf_case_ins() )
1763 warn(_("[:^upper:] ambiguous in case insensitive scanner"));
1764 else
1765 CCL_NEG_EXPR(isupper);
1766 }
1767 break;
1768 case 95:
1769 #line 929 "parse.y"
1770 {
1771 if ( yystack.l_mark[0] == nlch )
1772 rule_has_nl[num_rules] = true;
1773
1774 ++rulelen;
1775
1776 if (sf_case_ins() && has_case(yystack.l_mark[0]))
1777 yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
1778 else
1779 yyval = mkstate (yystack.l_mark[0]);
1780
1781 yyval = link_machines( yystack.l_mark[-1], yyval);
1782 }
1783 break;
1784 case 96:
1785 #line 944 "parse.y"
1786 { yyval = mkstate( SYM_EPSILON ); }
1787 break;
1788 #line 1787 "parse.c"
1789 }
1790 yystack.s_mark -= yym;
1791 yystate = *yystack.s_mark;
1792 yystack.l_mark -= yym;
1793 yym = yylhs[yyn];
1794 if (yystate == 0 && yym == 0)
1795 {
1796 #if YYDEBUG
1797 if (yydebug)
1798 printf("%sdebug: after reduction, shifting from state 0 to\
1799 state %d\n", YYPREFIX, YYFINAL);
1800 #endif
1801 yystate = YYFINAL;
1802 *++yystack.s_mark = YYFINAL;
1803 *++yystack.l_mark = yyval;
1804 if (yychar < 0)
1805 {
1806 if ((yychar = YYLEX) < 0) yychar = 0;
1807 #if YYDEBUG
1808 if (yydebug)
1809 {
1810 yys = 0;
1811 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
1812 if (!yys) yys = "illegal-symbol";
1813 printf("%sdebug: state %d, reading %d (%s)\n",
1814 YYPREFIX, YYFINAL, yychar, yys);
1815 }
1816 #endif
1817 }
1818 if (yychar == 0) goto yyaccept;
1819 goto yyloop;
1820 }
1821 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
1822 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
1823 yystate = yytable[yyn];
1824 else
1825 yystate = yydgoto[yym];
1826 #if YYDEBUG
1827 if (yydebug)
1828 printf("%sdebug: after reduction, shifting from state %d \
1829 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
1830 #endif
1831 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
1832 {
1833 goto yyoverflow;
1834 }
1835 *++yystack.s_mark = (short) yystate;
1836 *++yystack.l_mark = yyval;
1837 goto yyloop;
1838
1839 yyoverflow:
1840 yyerror("yacc stack overflow");
1841
1842 yyabort:
1843 yyfreestack(&yystack);
1844 return (1);
1845
1846 yyaccept:
1847 yyfreestack(&yystack);
1848 return (0);
1849 }
1850