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