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