?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ipfw: Support all possible ICMP types.
[dragonfly.git] / contrib / flex / parse.c
bloba884a9a40880018b8cebbe98b524d7b9a8e92d06
1
2 /* A Bison parser, made by GNU Bison 2.4.1. */
3
4 /* Skeleton implementation for Bison's Yacc-like parsers in C
5
6 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 Free Software Foundation, Inc.
8
9 This program is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 /* As a special exception, you may create a larger work that contains
23 part or all of the Bison parser skeleton and distribute that work
24 under terms of your choice, so long as that work isn't itself a
25 parser generator using the skeleton or a modified version thereof
26 as a parser skeleton. Alternatively, if you modify or redistribute
27 the parser skeleton itself, you may (at your option) remove this
28 special exception, which will cause the skeleton and the resulting
29 Bison output files to be licensed under the GNU General Public
30 License without this special exception.
31
32 This special exception was added by the Free Software Foundation in
33 version 2.2 of Bison. */
34
35 /* C LALR(1) parser skeleton written by Richard Stallman, by
36 simplifying the original so-called "semantic" parser. */
37
38 /* All symbols defined below should begin with yy or YY, to avoid
39 infringing on user name space. This should be done even for local
40 variables, as they might otherwise be expanded by user macros.
41 There are some unavoidable exceptions within include files to
42 define necessary library symbols; they are noted "INFRINGES ON
43 USER NAME SPACE" below. */
44
45 /* Identify Bison output. */
46 #define YYBISON 1
47
48 /* Bison version. */
49 #define YYBISON_VERSION "2.4.1"
50
51 /* Skeleton name. */
52 #define YYSKELETON_NAME "yacc.c"
53
54 /* Pure parsers. */
55 #define YYPURE 0
56
57 /* Push parsers. */
58 #define YYPUSH 0
59
60 /* Pull parsers. */
61 #define YYPULL 1
62
63 /* Using locations. */
64 #define YYLSP_NEEDED 0
65
66
67
68 /* Copy the first part of user declarations. */
69
70 /* Line 189 of yacc.c */
71 #line 34 "parse.y"
72
73 /* Copyright (c) 1990 The Regents of the University of California. */
74 /* All rights reserved. */
75
76 /* This code is derived from software contributed to Berkeley by */
77 /* Vern Paxson. */
78
79 /* The United States Government has rights in this work pursuant */
80 /* to contract no. DE-AC03-76SF00098 between the United States */
81 /* Department of Energy and the University of California. */
82
83 /* This file is part of flex. */
84
85 /* Redistribution and use in source and binary forms, with or without */
86 /* modification, are permitted provided that the following conditions */
87 /* are met: */
88
89 /* 1. Redistributions of source code must retain the above copyright */
90 /* notice, this list of conditions and the following disclaimer. */
91 /* 2. Redistributions in binary form must reproduce the above copyright */
92 /* notice, this list of conditions and the following disclaimer in the */
93 /* documentation and/or other materials provided with the distribution. */
94
95 /* Neither the name of the University nor the names of its contributors */
96 /* may be used to endorse or promote products derived from this software */
97 /* without specific prior written permission. */
98
99 /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
100 /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
101 /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
102 /* PURPOSE. */
103
104 #include "flexdef.h"
105 #include "tables.h"
106
107 int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
108 int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
109
110 int *scon_stk;
111 int scon_stk_ptr;
112
113 static int madeany = false; /* whether we've made the '.' character class */
114 static int ccldot, cclany;
115 int previous_continued_action; /* whether the previous rule's action was '|' */
116
117 #define format_warn3(fmt, a1, a2) \
118 do{ \
119 char fw3_msg[MAXLINE];\
120 snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
121 warn( fw3_msg );\
122 }while(0)
123
124 /* Expand a POSIX character class expression. */
125 #define CCL_EXPR(func) \
126 do{ \
127 int c; \
128 for ( c = 0; c < csize; ++c ) \
129 if ( isascii(c) && func(c) ) \
130 ccladd( currccl, c ); \
131 }while(0)
132
133 /* negated class */
134 #define CCL_NEG_EXPR(func) \
135 do{ \
136 int c; \
137 for ( c = 0; c < csize; ++c ) \
138 if ( !func(c) ) \
139 ccladd( currccl, c ); \
140 }while(0)
141
142 /* While POSIX defines isblank(), it's not ANSI C. */
143 #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
144
145 /* On some over-ambitious machines, such as DEC Alpha's, the default
146 * token type is "long" instead of "int"; this leads to problems with
147 * declaring yylval in flexdef.h. But so far, all the yacc's I've seen
148 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
149 * following should ensure that the default token type is "int".
150 */
151 #define YYSTYPE int
152
153
154
155 /* Line 189 of yacc.c */
156 #line 157 "parse.c"
157
158 /* Enabling traces. */
159 #ifndef YYDEBUG
160 # define YYDEBUG 0
161 #endif
162
163 /* Enabling verbose error messages. */
164 #ifdef YYERROR_VERBOSE
165 # undef YYERROR_VERBOSE
166 # define YYERROR_VERBOSE 1
167 #else
168 # define YYERROR_VERBOSE 0
169 #endif
170
171 /* Enabling the token table. */
172 #ifndef YYTOKEN_TABLE
173 # define YYTOKEN_TABLE 0
174 #endif
175
176
177 /* Tokens. */
178 #ifndef YYTOKENTYPE
179 # define YYTOKENTYPE
180 /* Put the tokens into the symbol table, so that GDB and other debuggers
181 know about them. */
182 enum yytokentype {
183 CHAR = 258,
184 NUMBER = 259,
185 SECTEND = 260,
186 SCDECL = 261,
187 XSCDECL = 262,
188 NAME = 263,
189 PREVCCL = 264,
190 EOF_OP = 265,
191 OPTION_OP = 266,
192 OPT_OUTFILE = 267,
193 OPT_PREFIX = 268,
194 OPT_YYCLASS = 269,
195 OPT_HEADER = 270,
196 OPT_EXTRA_TYPE = 271,
197 OPT_TABLES = 272,
198 CCE_ALNUM = 273,
199 CCE_ALPHA = 274,
200 CCE_BLANK = 275,
201 CCE_CNTRL = 276,
202 CCE_DIGIT = 277,
203 CCE_GRAPH = 278,
204 CCE_LOWER = 279,
205 CCE_PRINT = 280,
206 CCE_PUNCT = 281,
207 CCE_SPACE = 282,
208 CCE_UPPER = 283,
209 CCE_XDIGIT = 284,
210 CCE_NEG_ALNUM = 285,
211 CCE_NEG_ALPHA = 286,
212 CCE_NEG_BLANK = 287,
213 CCE_NEG_CNTRL = 288,
214 CCE_NEG_DIGIT = 289,
215 CCE_NEG_GRAPH = 290,
216 CCE_NEG_LOWER = 291,
217 CCE_NEG_PRINT = 292,
218 CCE_NEG_PUNCT = 293,
219 CCE_NEG_SPACE = 294,
220 CCE_NEG_UPPER = 295,
221 CCE_NEG_XDIGIT = 296,
222 CCL_OP_UNION = 297,
223 CCL_OP_DIFF = 298,
224 BEGIN_REPEAT_POSIX = 299,
225 END_REPEAT_POSIX = 300,
226 BEGIN_REPEAT_FLEX = 301,
227 END_REPEAT_FLEX = 302
228 };
229 #endif
230 /* Tokens. */
231 #define CHAR 258
232 #define NUMBER 259
233 #define SECTEND 260
234 #define SCDECL 261
235 #define XSCDECL 262
236 #define NAME 263
237 #define PREVCCL 264
238 #define EOF_OP 265
239 #define OPTION_OP 266
240 #define OPT_OUTFILE 267
241 #define OPT_PREFIX 268
242 #define OPT_YYCLASS 269
243 #define OPT_HEADER 270
244 #define OPT_EXTRA_TYPE 271
245 #define OPT_TABLES 272
246 #define CCE_ALNUM 273
247 #define CCE_ALPHA 274
248 #define CCE_BLANK 275
249 #define CCE_CNTRL 276
250 #define CCE_DIGIT 277
251 #define CCE_GRAPH 278
252 #define CCE_LOWER 279
253 #define CCE_PRINT 280
254 #define CCE_PUNCT 281
255 #define CCE_SPACE 282
256 #define CCE_UPPER 283
257 #define CCE_XDIGIT 284
258 #define CCE_NEG_ALNUM 285
259 #define CCE_NEG_ALPHA 286
260 #define CCE_NEG_BLANK 287
261 #define CCE_NEG_CNTRL 288
262 #define CCE_NEG_DIGIT 289
263 #define CCE_NEG_GRAPH 290
264 #define CCE_NEG_LOWER 291
265 #define CCE_NEG_PRINT 292
266 #define CCE_NEG_PUNCT 293
267 #define CCE_NEG_SPACE 294
268 #define CCE_NEG_UPPER 295
269 #define CCE_NEG_XDIGIT 296
270 #define CCL_OP_UNION 297
271 #define CCL_OP_DIFF 298
272 #define BEGIN_REPEAT_POSIX 299
273 #define END_REPEAT_POSIX 300
274 #define BEGIN_REPEAT_FLEX 301
275 #define END_REPEAT_FLEX 302
276
277
278
279
280 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
281 typedef int YYSTYPE;
282 # define YYSTYPE_IS_TRIVIAL 1
283 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
284 # define YYSTYPE_IS_DECLARED 1
285 #endif
286
287
288 /* Copy the second part of user declarations. */
289
290
291 /* Line 264 of yacc.c */
292 #line 293 "parse.c"
293
294 #ifdef short
295 # undef short
296 #endif
297
298 #ifdef YYTYPE_UINT8
299 typedef YYTYPE_UINT8 yytype_uint8;
300 #else
301 typedef unsigned char yytype_uint8;
302 #endif
303
304 #ifdef YYTYPE_INT8
305 typedef YYTYPE_INT8 yytype_int8;
306 #elif (defined __STDC__ || defined __C99__FUNC__ \
307 || defined __cplusplus || defined _MSC_VER)
308 typedef signed char yytype_int8;
309 #else
310 typedef short int yytype_int8;
311 #endif
312
313 #ifdef YYTYPE_UINT16
314 typedef YYTYPE_UINT16 yytype_uint16;
315 #else
316 typedef unsigned short int yytype_uint16;
317 #endif
318
319 #ifdef YYTYPE_INT16
320 typedef YYTYPE_INT16 yytype_int16;
321 #else
322 typedef short int yytype_int16;
323 #endif
324
325 #ifndef YYSIZE_T
326 # ifdef __SIZE_TYPE__
327 # define YYSIZE_T __SIZE_TYPE__
328 # elif defined size_t
329 # define YYSIZE_T size_t
330 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
331 || defined __cplusplus || defined _MSC_VER)
332 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
333 # define YYSIZE_T size_t
334 # else
335 # define YYSIZE_T unsigned int
336 # endif
337 #endif
338
339 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
340
341 #ifndef YY_
342 # if YYENABLE_NLS
343 # if ENABLE_NLS
344 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
345 # define YY_(msgid) dgettext ("bison-runtime", msgid)
346 # endif
347 # endif
348 # ifndef YY_
349 # define YY_(msgid) msgid
350 # endif
351 #endif
352
353 /* Suppress unused-variable warnings by "using" E. */
354 #if ! defined lint || defined __GNUC__
355 # define YYUSE(e) ((void) (e))
356 #else
357 # define YYUSE(e) /* empty */
358 #endif
359
360 /* Identity function, used to suppress warnings about constant conditions. */
361 #ifndef lint
362 # define YYID(n) (n)
363 #else
364 #if (defined __STDC__ || defined __C99__FUNC__ \
365 || defined __cplusplus || defined _MSC_VER)
366 static int
367 YYID (int yyi)
368 #else
369 static int
370 YYID (yyi)
371 int yyi;
372 #endif
373 {
374 return yyi;
375 }
376 #endif
377
378 #if ! defined yyoverflow || YYERROR_VERBOSE
379
380 /* The parser invokes alloca or malloc; define the necessary symbols. */
381
382 # ifdef YYSTACK_USE_ALLOCA
383 # if YYSTACK_USE_ALLOCA
384 # ifdef __GNUC__
385 # define YYSTACK_ALLOC __builtin_alloca
386 # elif defined __BUILTIN_VA_ARG_INCR
387 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
388 # elif defined _AIX
389 # define YYSTACK_ALLOC __alloca
390 # elif defined _MSC_VER
391 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
392 # define alloca _alloca
393 # else
394 # define YYSTACK_ALLOC alloca
395 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
396 || defined __cplusplus || defined _MSC_VER)
397 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
398 # ifndef _STDLIB_H
399 # define _STDLIB_H 1
400 # endif
401 # endif
402 # endif
403 # endif
404 # endif
405
406 # ifdef YYSTACK_ALLOC
407 /* Pacify GCC's `empty if-body' warning. */
408 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
409 # ifndef YYSTACK_ALLOC_MAXIMUM
410 /* The OS might guarantee only one guard page at the bottom of the stack,
411 and a page size can be as small as 4096 bytes. So we cannot safely
412 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
413 to allow for a few compiler-allocated temporary stack slots. */
414 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
415 # endif
416 # else
417 # define YYSTACK_ALLOC YYMALLOC
418 # define YYSTACK_FREE YYFREE
419 # ifndef YYSTACK_ALLOC_MAXIMUM
420 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
421 # endif
422 # if (defined __cplusplus && ! defined _STDLIB_H \
423 && ! ((defined YYMALLOC || defined malloc) \
424 && (defined YYFREE || defined free)))
425 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
426 # ifndef _STDLIB_H
427 # define _STDLIB_H 1
428 # endif
429 # endif
430 # ifndef YYMALLOC
431 # define YYMALLOC malloc
432 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
433 || defined __cplusplus || defined _MSC_VER)
434 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
435 # endif
436 # endif
437 # ifndef YYFREE
438 # define YYFREE free
439 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
440 || defined __cplusplus || defined _MSC_VER)
441 void free (void *); /* INFRINGES ON USER NAME SPACE */
442 # endif
443 # endif
444 # endif
445 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
446
447
448 #if (! defined yyoverflow \
449 && (! defined __cplusplus \
450 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
451
452 /* A type that is properly aligned for any stack member. */
453 union yyalloc
454 {
455 yytype_int16 yyss_alloc;
456 YYSTYPE yyvs_alloc;
457 };
458
459 /* The size of the maximum gap between one aligned stack and the next. */
460 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
461
462 /* The size of an array large to enough to hold all stacks, each with
463 N elements. */
464 # define YYSTACK_BYTES(N) \
465 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
466 + YYSTACK_GAP_MAXIMUM)
467
468 /* Copy COUNT objects from FROM to TO. The source and destination do
469 not overlap. */
470 # ifndef YYCOPY
471 # if defined __GNUC__ && 1 < __GNUC__
472 # define YYCOPY(To, From, Count) \
473 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
474 # else
475 # define YYCOPY(To, From, Count) \
476 do \
477 { \
478 YYSIZE_T yyi; \
479 for (yyi = 0; yyi < (Count); yyi++) \
480 (To)[yyi] = (From)[yyi]; \
481 } \
482 while (YYID (0))
483 # endif
484 # endif
485
486 /* Relocate STACK from its old location to the new one. The
487 local variables YYSIZE and YYSTACKSIZE give the old and new number of
488 elements in the stack, and YYPTR gives the new location of the
489 stack. Advance YYPTR to a properly aligned location for the next
490 stack. */
491 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
492 do \
493 { \
494 YYSIZE_T yynewbytes; \
495 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
496 Stack = &yyptr->Stack_alloc; \
497 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
498 yyptr += yynewbytes / sizeof (*yyptr); \
499 } \
500 while (YYID (0))
501
502 #endif
503
504 /* YYFINAL -- State number of the termination state. */
505 #define YYFINAL 3
506 /* YYLAST -- Last index in YYTABLE. */
507 #define YYLAST 161
508
509 /* YYNTOKENS -- Number of terminals. */
510 #define YYNTOKENS 69
511 /* YYNNTS -- Number of nonterminals. */
512 #define YYNNTS 27
513 /* YYNRULES -- Number of rules. */
514 #define YYNRULES 97
515 /* YYNRULES -- Number of states. */
516 #define YYNSTATES 140
517
518 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
519 #define YYUNDEFTOK 2
520 #define YYMAXUTOK 302
521
522 #define YYTRANSLATE(YYX) \
523 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
524
525 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
526 static const yytype_uint8 yytranslate[] =
527 {
528 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
529 49, 2, 2, 2, 2, 2, 2, 2, 2, 2,
530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
531 2, 2, 2, 2, 63, 2, 57, 2, 2, 2,
532 64, 65, 55, 60, 56, 68, 62, 59, 2, 2,
533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534 53, 48, 54, 61, 2, 2, 2, 2, 2, 2,
535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
537 2, 66, 2, 67, 52, 2, 2, 2, 2, 2,
538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
540 2, 2, 2, 50, 58, 51, 2, 2, 2, 2,
541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
545 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
546 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
547 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
548 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
549 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
550 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
551 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
552 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
553 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
554 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
555 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
556 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
557 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
558 45, 46, 47
559 };
560
561 #if YYDEBUG
562 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
563 YYRHS. */
564 static const yytype_uint16 yyprhs[] =
565 {
566 0, 0, 3, 9, 10, 14, 17, 18, 20, 22,
567 24, 26, 29, 31, 33, 36, 39, 40, 44, 48,
568 52, 56, 60, 64, 70, 76, 77, 78, 81, 83,
569 85, 87, 88, 93, 97, 98, 102, 104, 106, 108,
570 111, 115, 118, 120, 124, 126, 129, 132, 134, 141,
571 147, 152, 155, 158, 161, 168, 174, 179, 181, 183,
572 185, 189, 193, 195, 199, 203, 205, 209, 214, 219,
573 222, 225, 226, 228, 230, 232, 234, 236, 238, 240,
574 242, 244, 246, 248, 250, 252, 254, 256, 258, 260,
575 262, 264, 266, 268, 270, 272, 274, 277
576 };
577
578 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
579 static const yytype_int8 yyrhs[] =
580 {
581 70, 0, -1, 71, 72, 73, 79, 80, -1, -1,
582 72, 74, 75, -1, 72, 76, -1, -1, 1, -1,
583 5, -1, 6, -1, 7, -1, 75, 8, -1, 8,
584 -1, 1, -1, 11, 77, -1, 77, 78, -1, -1,
585 12, 48, 8, -1, 16, 48, 8, -1, 13, 48,
586 8, -1, 14, 48, 8, -1, 15, 48, 8, -1,
587 17, 48, 8, -1, 79, 83, 80, 81, 49, -1,
588 79, 83, 50, 79, 51, -1, -1, -1, 52, 86,
589 -1, 86, -1, 10, -1, 1, -1, -1, 53, 82,
590 84, 54, -1, 53, 55, 54, -1, -1, 84, 56,
591 85, -1, 85, -1, 1, -1, 8, -1, 88, 87,
592 -1, 88, 87, 57, -1, 87, 57, -1, 87, -1,
593 87, 58, 89, -1, 89, -1, 87, 59, -1, 89,
594 90, -1, 90, -1, 89, 44, 4, 56, 4, 45,
595 -1, 89, 44, 4, 56, 45, -1, 89, 44, 4,
596 45, -1, 90, 55, -1, 90, 60, -1, 90, 61,
597 -1, 90, 46, 4, 56, 4, 47, -1, 90, 46,
598 4, 56, 47, -1, 90, 46, 4, 47, -1, 62,
599 -1, 91, -1, 9, -1, 63, 95, 63, -1, 64,
600 87, 65, -1, 3, -1, 91, 43, 92, -1, 91,
601 42, 92, -1, 92, -1, 66, 93, 67, -1, 66,
602 52, 93, 67, -1, 93, 3, 68, 3, -1, 93,
603 3, -1, 93, 94, -1, -1, 18, -1, 19, -1,
604 20, -1, 21, -1, 22, -1, 23, -1, 24, -1,
605 25, -1, 26, -1, 27, -1, 29, -1, 28, -1,
606 30, -1, 31, -1, 32, -1, 33, -1, 34, -1,
607 35, -1, 37, -1, 38, -1, 39, -1, 41, -1,
608 36, -1, 40, -1, 95, 3, -1, -1
609 };
610
611 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
612 static const yytype_uint16 yyrline[] =
613 {
614 0, 118, 118, 148, 155, 156, 157, 158, 162, 170,
615 173, 177, 180, 183, 187, 190, 191, 194, 199, 201,
616 203, 205, 207, 211, 213, 215, 219, 231, 267, 291,
617 314, 319, 322, 325, 343, 346, 348, 350, 354, 377,
618 433, 436, 479, 497, 503, 508, 535, 543, 546, 574,
619 588, 610, 617, 623, 629, 657, 671, 690, 724, 742,
620 752, 755, 758, 773, 774, 775, 780, 782, 789, 849,
621 867, 875, 883, 884, 885, 886, 887, 888, 889, 894,
622 895, 896, 897, 898, 904, 905, 906, 907, 908, 909,
623 910, 911, 912, 913, 914, 920, 928, 944
624 };
625 #endif
626
627 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
628 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
629 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
630 static const char *const yytname[] =
631 {
632 "$end", "error", "$undefined", "CHAR", "NUMBER", "SECTEND", "SCDECL",
633 "XSCDECL", "NAME", "PREVCCL", "EOF_OP", "OPTION_OP", "OPT_OUTFILE",
634 "OPT_PREFIX", "OPT_YYCLASS", "OPT_HEADER", "OPT_EXTRA_TYPE",
635 "OPT_TABLES", "CCE_ALNUM", "CCE_ALPHA", "CCE_BLANK", "CCE_CNTRL",
636 "CCE_DIGIT", "CCE_GRAPH", "CCE_LOWER", "CCE_PRINT", "CCE_PUNCT",
637 "CCE_SPACE", "CCE_UPPER", "CCE_XDIGIT", "CCE_NEG_ALNUM", "CCE_NEG_ALPHA",
638 "CCE_NEG_BLANK", "CCE_NEG_CNTRL", "CCE_NEG_DIGIT", "CCE_NEG_GRAPH",
639 "CCE_NEG_LOWER", "CCE_NEG_PRINT", "CCE_NEG_PUNCT", "CCE_NEG_SPACE",
640 "CCE_NEG_UPPER", "CCE_NEG_XDIGIT", "CCL_OP_UNION", "CCL_OP_DIFF",
641 "BEGIN_REPEAT_POSIX", "END_REPEAT_POSIX", "BEGIN_REPEAT_FLEX",
642 "END_REPEAT_FLEX", "'='", "'\\n'", "'{'", "'}'", "'^'", "'<'", "'>'",
643 "'*'", "','", "'$'", "'|'", "'/'", "'+'", "'?'", "'.'", "'\"'", "'('",
644 "')'", "'['", "']'", "'-'", "$accept", "goal", "initlex", "sect1",
645 "sect1end", "startconddecl", "namelist1", "options", "optionlist",
646 "option", "sect2", "initforrule", "flexrule", "scon_stk_ptr", "scon",
647 "namelist2", "sconname", "rule", "re", "re2", "series", "singleton",
648 "fullccl", "braceccl", "ccl", "ccl_expr", "string", 0
649 };
650 #endif
651
652 # ifdef YYPRINT
653 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
654 token YYLEX-NUM. */
655 static const yytype_uint16 yytoknum[] =
656 {
657 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
658 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
659 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
660 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
661 295, 296, 297, 298, 299, 300, 301, 302, 61, 10,
662 123, 125, 94, 60, 62, 42, 44, 36, 124, 47,
663 43, 63, 46, 34, 40, 41, 91, 93, 45
664 };
665 # endif
666
667 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
668 static const yytype_uint8 yyr1[] =
669 {
670 0, 69, 70, 71, 72, 72, 72, 72, 73, 74,
671 74, 75, 75, 75, 76, 77, 77, 78, 78, 78,
672 78, 78, 78, 79, 79, 79, 80, 81, 81, 81,
673 81, 82, 83, 83, 83, 84, 84, 84, 85, 86,
674 86, 86, 86, 87, 87, 88, 89, 89, 89, 89,
675 89, 90, 90, 90, 90, 90, 90, 90, 90, 90,
676 90, 90, 90, 91, 91, 91, 92, 92, 93, 93,
677 93, 93, 94, 94, 94, 94, 94, 94, 94, 94,
678 94, 94, 94, 94, 94, 94, 94, 94, 94, 94,
679 94, 94, 94, 94, 94, 94, 95, 95
680 };
681
682 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
683 static const yytype_uint8 yyr2[] =
684 {
685 0, 2, 5, 0, 3, 2, 0, 1, 1, 1,
686 1, 2, 1, 1, 2, 2, 0, 3, 3, 3,
687 3, 3, 3, 5, 5, 0, 0, 2, 1, 1,
688 1, 0, 4, 3, 0, 3, 1, 1, 1, 2,
689 3, 2, 1, 3, 1, 2, 2, 1, 6, 5,
690 4, 2, 2, 2, 6, 5, 4, 1, 1, 1,
691 3, 3, 1, 3, 3, 1, 3, 4, 4, 2,
692 2, 0, 1, 1, 1, 1, 1, 1, 1, 1,
693 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694 1, 1, 1, 1, 1, 1, 2, 0
695 };
696
697 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
698 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
699 means the default is an error. */
700 static const yytype_uint8 yydefact[] =
701 {
702 3, 0, 0, 1, 7, 0, 8, 9, 10, 16,
703 25, 0, 5, 14, 34, 13, 12, 4, 0, 0,
704 0, 0, 0, 0, 15, 31, 2, 26, 11, 0,
705 0, 0, 0, 0, 0, 0, 0, 25, 0, 17,
706 19, 20, 21, 18, 22, 33, 37, 38, 0, 36,
707 34, 30, 62, 59, 29, 0, 57, 97, 0, 71,
708 0, 28, 42, 0, 44, 47, 58, 65, 32, 0,
709 24, 27, 0, 0, 71, 0, 23, 41, 0, 45,
710 39, 0, 46, 0, 51, 52, 53, 0, 0, 35,
711 96, 60, 61, 0, 69, 72, 73, 74, 75, 76,
712 77, 78, 79, 80, 81, 83, 82, 84, 85, 86,
713 87, 88, 89, 94, 90, 91, 92, 95, 93, 66,
714 70, 43, 40, 0, 0, 64, 63, 67, 0, 50,
715 0, 56, 0, 68, 0, 49, 0, 55, 48, 54
716 };
717
718 /* YYDEFGOTO[NTERM-NUM]. */
719 static const yytype_int8 yydefgoto[] =
720 {
721 -1, 1, 2, 5, 10, 11, 17, 12, 13, 24,
722 14, 26, 60, 36, 27, 48, 49, 61, 62, 63,
723 64, 65, 66, 67, 75, 120, 72
724 };
725
726 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
727 STATE-NUM. */
728 #define YYPACT_NINF -52
729 static const yytype_int16 yypact[] =
730 {
731 -52, 17, 103, -52, -52, 113, -52, -52, -52, -52,
732 -52, 48, -52, 114, 6, -52, -52, 42, 7, 12,
733 58, 77, 88, 89, -52, 43, -52, 73, -52, 130,
734 131, 132, 133, 134, 135, 90, 91, -52, -1, -52,
735 -52, -52, -52, -52, -52, -52, -52, -52, 40, -52,
736 44, -52, -52, -52, -52, 39, -52, -52, 39, 93,
737 97, -52, -12, 39, 49, 61, -31, -52, -52, 139,
738 -52, -52, 1, -51, -52, 0, -52, -52, 39, -52,
739 75, 144, 61, 145, -52, -52, -52, 84, 84, -52,
740 -52, -52, -52, 50, 83, -52, -52, -52, -52, -52,
741 -52, -52, -52, -52, -52, -52, -52, -52, -52, -52,
742 -52, -52, -52, -52, -52, -52, -52, -52, -52, -52,
743 -52, 49, -52, -40, 10, -52, -52, -52, 149, -52,
744 9, -52, -3, -52, 108, -52, 107, -52, -52, -52
745 };
746
747 /* YYPGOTO[NTERM-NUM]. */
748 static const yytype_int16 yypgoto[] =
749 {
750 -52, -52, -52, -52, -52, -52, -52, -52, -52, -52,
751 118, 129, -52, -52, -52, -52, 92, 102, -48, -52,
752 80, -21, -52, 47, 85, -52, -52
753 };
754
755 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
756 positive, shift that token. If negative, reduce the rule which
757 number is the opposite. If zero, do what YYDEFACT says.
758 If YYTABLE_NINF, syntax error. */
759 #define YYTABLE_NINF -27
760 static const yytype_int16 yytable[] =
761 {
762 51, 136, 52, 94, 90, 129, -26, 78, 53, 54,
763 73, 87, 88, 134, 92, 80, 130, 3, 95, 96,
764 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
765 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
766 117, 118, 52, 82, 137, 77, 78, 79, 53, 15,
767 28, 55, 52, 94, 135, 29, 16, 131, 53, 25,
768 30, 56, 57, 58, 91, 59, 132, 119, 95, 96,
769 97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
770 107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
771 117, 118, 46, 81, 68, 70, 69, 25, 35, 47,
772 82, 56, 57, 58, 4, 59, 31, 83, -6, -6,
773 -6, 56, 57, 58, -6, 59, 84, 127, 6, 7,
774 8, 85, 86, 37, 9, 32, 18, 19, 20, 21,
775 22, 23, 122, 78, 125, 126, 33, 34, 39, 40,
776 41, 42, 43, 44, 45, 74, 76, 47, 123, 124,
777 59, 128, 133, 138, 139, 50, 38, 71, 121, 93,
778 0, 89
779 };
780
781 static const yytype_int8 yycheck[] =
782 {
783 1, 4, 3, 3, 3, 45, 0, 58, 9, 10,
784 58, 42, 43, 4, 65, 63, 56, 0, 18, 19,
785 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
786 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
787 40, 41, 3, 64, 47, 57, 58, 59, 9, 1,
788 8, 52, 3, 3, 45, 48, 8, 47, 9, 53,
789 48, 62, 63, 64, 63, 66, 56, 67, 18, 19,
790 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
791 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
792 40, 41, 1, 44, 54, 51, 56, 53, 55, 8,
793 121, 62, 63, 64, 1, 66, 48, 46, 5, 6,
794 7, 62, 63, 64, 11, 66, 55, 67, 5, 6,
795 7, 60, 61, 50, 11, 48, 12, 13, 14, 15,
796 16, 17, 57, 58, 87, 88, 48, 48, 8, 8,
797 8, 8, 8, 8, 54, 52, 49, 8, 4, 4,
798 66, 68, 3, 45, 47, 37, 27, 55, 78, 74,
799 -1, 69
800 };
801
802 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
803 symbol of state STATE-NUM. */
804 static const yytype_uint8 yystos[] =
805 {
806 0, 70, 71, 0, 1, 72, 5, 6, 7, 11,
807 73, 74, 76, 77, 79, 1, 8, 75, 12, 13,
808 14, 15, 16, 17, 78, 53, 80, 83, 8, 48,
809 48, 48, 48, 48, 48, 55, 82, 50, 80, 8,
810 8, 8, 8, 8, 8, 54, 1, 8, 84, 85,
811 79, 1, 3, 9, 10, 52, 62, 63, 64, 66,
812 81, 86, 87, 88, 89, 90, 91, 92, 54, 56,
813 51, 86, 95, 87, 52, 93, 49, 57, 58, 59,
814 87, 44, 90, 46, 55, 60, 61, 42, 43, 85,
815 3, 63, 65, 93, 3, 18, 19, 20, 21, 22,
816 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
817 33, 34, 35, 36, 37, 38, 39, 40, 41, 67,
818 94, 89, 57, 4, 4, 92, 92, 67, 68, 45,
819 56, 47, 56, 3, 4, 45, 4, 47, 45, 47
820 };
821
822 #define yyerrok (yyerrstatus = 0)
823 #define yyclearin (yychar = YYEMPTY)
824 #define YYEMPTY (-2)
825 #define YYEOF 0
826
827 #define YYACCEPT goto yyacceptlab
828 #define YYABORT goto yyabortlab
829 #define YYERROR goto yyerrorlab
830
831
832 /* Like YYERROR except do call yyerror. This remains here temporarily
833 to ease the transition to the new meaning of YYERROR, for GCC.
834 Once GCC version 2 has supplanted version 1, this can go. */
835
836 #define YYFAIL goto yyerrlab
837
838 #define YYRECOVERING() (!!yyerrstatus)
839
840 #define YYBACKUP(Token, Value) \
841 do \
842 if (yychar == YYEMPTY && yylen == 1) \
843 { \
844 yychar = (Token); \
845 yylval = (Value); \
846 yytoken = YYTRANSLATE (yychar); \
847 YYPOPSTACK (1); \
848 goto yybackup; \
849 } \
850 else \
851 { \
852 yyerror (YY_("syntax error: cannot back up")); \
853 YYERROR; \
854 } \
855 while (YYID (0))
856
857
858 #define YYTERROR 1
859 #define YYERRCODE 256
860
861
862 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
863 If N is 0, then set CURRENT to the empty location which ends
864 the previous symbol: RHS[0] (always defined). */
865
866 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
867 #ifndef YYLLOC_DEFAULT
868 # define YYLLOC_DEFAULT(Current, Rhs, N) \
869 do \
870 if (YYID (N)) \
871 { \
872 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
873 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
874 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
875 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
876 } \
877 else \
878 { \
879 (Current).first_line = (Current).last_line = \
880 YYRHSLOC (Rhs, 0).last_line; \
881 (Current).first_column = (Current).last_column = \
882 YYRHSLOC (Rhs, 0).last_column; \
883 } \
884 while (YYID (0))
885 #endif
886
887
888 /* YY_LOCATION_PRINT -- Print the location on the stream.
889 This macro was not mandated originally: define only if we know
890 we won't break user code: when these are the locations we know. */
891
892 #ifndef YY_LOCATION_PRINT
893 # if YYLTYPE_IS_TRIVIAL
894 # define YY_LOCATION_PRINT(File, Loc) \
895 fprintf (File, "%d.%d-%d.%d", \
896 (Loc).first_line, (Loc).first_column, \
897 (Loc).last_line, (Loc).last_column)
898 # else
899 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
900 # endif
901 #endif
902
903
904 /* YYLEX -- calling `yylex' with the right arguments. */
905
906 #ifdef YYLEX_PARAM
907 # define YYLEX yylex (YYLEX_PARAM)
908 #else
909 # define YYLEX yylex ()
910 #endif
911
912 /* Enable debugging if requested. */
913 #if YYDEBUG
914
915 # ifndef YYFPRINTF
916 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
917 # define YYFPRINTF fprintf
918 # endif
919
920 # define YYDPRINTF(Args) \
921 do { \
922 if (yydebug) \
923 YYFPRINTF Args; \
924 } while (YYID (0))
925
926 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
927 do { \
928 if (yydebug) \
929 { \
930 YYFPRINTF (stderr, "%s ", Title); \
931 yy_symbol_print (stderr, \
932 Type, Value); \
933 YYFPRINTF (stderr, "\n"); \
934 } \
935 } while (YYID (0))
936
937
938 /*--------------------------------.
939 | Print this symbol on YYOUTPUT. |
940 `--------------------------------*/
941
942 /*ARGSUSED*/
943 #if (defined __STDC__ || defined __C99__FUNC__ \
944 || defined __cplusplus || defined _MSC_VER)
945 static void
946 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
947 #else
948 static void
949 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
950 FILE *yyoutput;
951 int yytype;
952 YYSTYPE const * const yyvaluep;
953 #endif
954 {
955 if (!yyvaluep)
956 return;
957 # ifdef YYPRINT
958 if (yytype < YYNTOKENS)
959 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
960 # else
961 YYUSE (yyoutput);
962 # endif
963 switch (yytype)
964 {
965 default:
966 break;
967 }
968 }
969
970
971 /*--------------------------------.
972 | Print this symbol on YYOUTPUT. |
973 `--------------------------------*/
974
975 #if (defined __STDC__ || defined __C99__FUNC__ \
976 || defined __cplusplus || defined _MSC_VER)
977 static void
978 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
979 #else
980 static void
981 yy_symbol_print (yyoutput, yytype, yyvaluep)
982 FILE *yyoutput;
983 int yytype;
984 YYSTYPE const * const yyvaluep;
985 #endif
986 {
987 if (yytype < YYNTOKENS)
988 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
989 else
990 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
991
992 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
993 YYFPRINTF (yyoutput, ")");
994 }
995
996 /*------------------------------------------------------------------.
997 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
998 | TOP (included). |
999 `------------------------------------------------------------------*/
1000
1001 #if (defined __STDC__ || defined __C99__FUNC__ \
1002 || defined __cplusplus || defined _MSC_VER)
1003 static void
1004 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1005 #else
1006 static void
1007 yy_stack_print (yybottom, yytop)
1008 yytype_int16 *yybottom;
1009 yytype_int16 *yytop;
1010 #endif
1011 {
1012 YYFPRINTF (stderr, "Stack now");
1013 for (; yybottom <= yytop; yybottom++)
1014 {
1015 int yybot = *yybottom;
1016 YYFPRINTF (stderr, " %d", yybot);
1017 }
1018 YYFPRINTF (stderr, "\n");
1019 }
1020
1021 # define YY_STACK_PRINT(Bottom, Top) \
1022 do { \
1023 if (yydebug) \
1024 yy_stack_print ((Bottom), (Top)); \
1025 } while (YYID (0))
1026
1027
1028 /*------------------------------------------------.
1029 | Report that the YYRULE is going to be reduced. |
1030 `------------------------------------------------*/
1031
1032 #if (defined __STDC__ || defined __C99__FUNC__ \
1033 || defined __cplusplus || defined _MSC_VER)
1034 static void
1035 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1036 #else
1037 static void
1038 yy_reduce_print (yyvsp, yyrule)
1039 YYSTYPE *yyvsp;
1040 int yyrule;
1041 #endif
1042 {
1043 int yynrhs = yyr2[yyrule];
1044 int yyi;
1045 unsigned long int yylno = yyrline[yyrule];
1046 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1047 yyrule - 1, yylno);
1048 /* The symbols being reduced. */
1049 for (yyi = 0; yyi < yynrhs; yyi++)
1050 {
1051 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1052 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1053 &(yyvsp[(yyi + 1) - (yynrhs)])
1054 );
1055 YYFPRINTF (stderr, "\n");
1056 }
1057 }
1058
1059 # define YY_REDUCE_PRINT(Rule) \
1060 do { \
1061 if (yydebug) \
1062 yy_reduce_print (yyvsp, Rule); \
1063 } while (YYID (0))
1064
1065 /* Nonzero means print parse trace. It is left uninitialized so that
1066 multiple parsers can coexist. */
1067 int yydebug;
1068 #else /* !YYDEBUG */
1069 # define YYDPRINTF(Args)
1070 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1071 # define YY_STACK_PRINT(Bottom, Top)
1072 # define YY_REDUCE_PRINT(Rule)
1073 #endif /* !YYDEBUG */
1074
1075
1076 /* YYINITDEPTH -- initial size of the parser's stacks. */
1077 #ifndef YYINITDEPTH
1078 # define YYINITDEPTH 200
1079 #endif
1080
1081 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1082 if the built-in stack extension method is used).
1083
1084 Do not make this value too large; the results are undefined if
1085 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1086 evaluated with infinite-precision integer arithmetic. */
1087
1088 #ifndef YYMAXDEPTH
1089 # define YYMAXDEPTH 10000
1090 #endif
1091
1092 \f
1093
1094 #if YYERROR_VERBOSE
1095
1096 # ifndef yystrlen
1097 # if defined __GLIBC__ && defined _STRING_H
1098 # define yystrlen strlen
1099 # else
1100 /* Return the length of YYSTR. */
1101 #if (defined __STDC__ || defined __C99__FUNC__ \
1102 || defined __cplusplus || defined _MSC_VER)
1103 static YYSIZE_T
1104 yystrlen (const char *yystr)
1105 #else
1106 static YYSIZE_T
1107 yystrlen (yystr)
1108 const char *yystr;
1109 #endif
1110 {
1111 YYSIZE_T yylen;
1112 for (yylen = 0; yystr[yylen]; yylen++)
1113 continue;
1114 return yylen;
1115 }
1116 # endif
1117 # endif
1118
1119 # ifndef yystpcpy
1120 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1121 # define yystpcpy stpcpy
1122 # else
1123 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1124 YYDEST. */
1125 #if (defined __STDC__ || defined __C99__FUNC__ \
1126 || defined __cplusplus || defined _MSC_VER)
1127 static char *
1128 yystpcpy (char *yydest, const char *yysrc)
1129 #else
1130 static char *
1131 yystpcpy (yydest, yysrc)
1132 char *yydest;
1133 const char *yysrc;
1134 #endif
1135 {
1136 char *yyd = yydest;
1137 const char *yys = yysrc;
1138
1139 while ((*yyd++ = *yys++) != '\0')
1140 continue;
1141
1142 return yyd - 1;
1143 }
1144 # endif
1145 # endif
1146
1147 # ifndef yytnamerr
1148 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1149 quotes and backslashes, so that it's suitable for yyerror. The
1150 heuristic is that double-quoting is unnecessary unless the string
1151 contains an apostrophe, a comma, or backslash (other than
1152 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1153 null, do not copy; instead, return the length of what the result
1154 would have been. */
1155 static YYSIZE_T
1156 yytnamerr (char *yyres, const char *yystr)
1157 {
1158 if (*yystr == '"')
1159 {
1160 YYSIZE_T yyn = 0;
1161 char const *yyp = yystr;
1162
1163 for (;;)
1164 switch (*++yyp)
1165 {
1166 case '\'':
1167 case ',':
1168 goto do_not_strip_quotes;
1169
1170 case '\\':
1171 if (*++yyp != '\\')
1172 goto do_not_strip_quotes;
1173 /* Fall through. */
1174 default:
1175 if (yyres)
1176 yyres[yyn] = *yyp;
1177 yyn++;
1178 break;
1179
1180 case '"':
1181 if (yyres)
1182 yyres[yyn] = '\0';
1183 return yyn;
1184 }
1185 do_not_strip_quotes: ;
1186 }
1187
1188 if (! yyres)
1189 return yystrlen (yystr);
1190
1191 return yystpcpy (yyres, yystr) - yyres;
1192 }
1193 # endif
1194
1195 /* Copy into YYRESULT an error message about the unexpected token
1196 YYCHAR while in state YYSTATE. Return the number of bytes copied,
1197 including the terminating null byte. If YYRESULT is null, do not
1198 copy anything; just return the number of bytes that would be
1199 copied. As a special case, return 0 if an ordinary "syntax error"
1200 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1201 size calculation. */
1202 static YYSIZE_T
1203 yysyntax_error (char *yyresult, int yystate, int yychar)
1204 {
1205 int yyn = yypact[yystate];
1206
1207 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1208 return 0;
1209 else
1210 {
1211 int yytype = YYTRANSLATE (yychar);
1212 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1213 YYSIZE_T yysize = yysize0;
1214 YYSIZE_T yysize1;
1215 int yysize_overflow = 0;
1216 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1217 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1218 int yyx;
1219
1220 # if 0
1221 /* This is so xgettext sees the translatable formats that are
1222 constructed on the fly. */
1223 YY_("syntax error, unexpected %s");
1224 YY_("syntax error, unexpected %s, expecting %s");
1225 YY_("syntax error, unexpected %s, expecting %s or %s");
1226 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1227 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1228 # endif
1229 char *yyfmt;
1230 char const *yyf;
1231 static char const yyunexpected[] = "syntax error, unexpected %s";
1232 static char const yyexpecting[] = ", expecting %s";
1233 static char const yyor[] = " or %s";
1234 char yyformat[sizeof yyunexpected
1235 + sizeof yyexpecting - 1
1236 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1237 * (sizeof yyor - 1))];
1238 char const *yyprefix = yyexpecting;
1239
1240 /* Start YYX at -YYN if negative to avoid negative indexes in
1241 YYCHECK. */
1242 int yyxbegin = yyn < 0 ? -yyn : 0;
1243
1244 /* Stay within bounds of both yycheck and yytname. */
1245 int yychecklim = YYLAST - yyn + 1;
1246 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1247 int yycount = 1;
1248
1249 yyarg[0] = yytname[yytype];
1250 yyfmt = yystpcpy (yyformat, yyunexpected);
1251
1252 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1253 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1254 {
1255 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1256 {
1257 yycount = 1;
1258 yysize = yysize0;
1259 yyformat[sizeof yyunexpected - 1] = '\0';
1260 break;
1261 }
1262 yyarg[yycount++] = yytname[yyx];
1263 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1264 yysize_overflow |= (yysize1 < yysize);
1265 yysize = yysize1;
1266 yyfmt = yystpcpy (yyfmt, yyprefix);
1267 yyprefix = yyor;
1268 }
1269
1270 yyf = YY_(yyformat);
1271 yysize1 = yysize + yystrlen (yyf);
1272 yysize_overflow |= (yysize1 < yysize);
1273 yysize = yysize1;
1274
1275 if (yysize_overflow)
1276 return YYSIZE_MAXIMUM;
1277
1278 if (yyresult)
1279 {
1280 /* Avoid sprintf, as that infringes on the user's name space.
1281 Don't have undefined behavior even if the translation
1282 produced a string with the wrong number of "%s"s. */
1283 char *yyp = yyresult;
1284 int yyi = 0;
1285 while ((*yyp = *yyf) != '\0')
1286 {
1287 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1288 {
1289 yyp += yytnamerr (yyp, yyarg[yyi++]);
1290 yyf += 2;
1291 }
1292 else
1293 {
1294 yyp++;
1295 yyf++;
1296 }
1297 }
1298 }
1299 return yysize;
1300 }
1301 }
1302 #endif /* YYERROR_VERBOSE */
1303 \f
1304
1305 /*-----------------------------------------------.
1306 | Release the memory associated to this symbol. |
1307 `-----------------------------------------------*/
1308
1309 /*ARGSUSED*/
1310 #if (defined __STDC__ || defined __C99__FUNC__ \
1311 || defined __cplusplus || defined _MSC_VER)
1312 static void
1313 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1314 #else
1315 static void
1316 yydestruct (yymsg, yytype, yyvaluep)
1317 const char *yymsg;
1318 int yytype;
1319 YYSTYPE *yyvaluep;
1320 #endif
1321 {
1322 YYUSE (yyvaluep);
1323
1324 if (!yymsg)
1325 yymsg = "Deleting";
1326 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1327
1328 switch (yytype)
1329 {
1330
1331 default:
1332 break;
1333 }
1334 }
1335
1336 /* Prevent warnings from -Wmissing-prototypes. */
1337 #ifdef YYPARSE_PARAM
1338 #if defined __STDC__ || defined __cplusplus
1339 int yyparse (void *YYPARSE_PARAM);
1340 #else
1341 int yyparse ();
1342 #endif
1343 #else /* ! YYPARSE_PARAM */
1344 #if defined __STDC__ || defined __cplusplus
1345 int yyparse (void);
1346 #else
1347 int yyparse ();
1348 #endif
1349 #endif /* ! YYPARSE_PARAM */
1350
1351
1352 /* The lookahead symbol. */
1353 int yychar;
1354
1355 /* The semantic value of the lookahead symbol. */
1356 YYSTYPE yylval;
1357
1358 /* Number of syntax errors so far. */
1359 int yynerrs;
1360
1361
1362
1363 /*-------------------------.
1364 | yyparse or yypush_parse. |
1365 `-------------------------*/
1366
1367 #ifdef YYPARSE_PARAM
1368 #if (defined __STDC__ || defined __C99__FUNC__ \
1369 || defined __cplusplus || defined _MSC_VER)
1370 int
1371 yyparse (void *YYPARSE_PARAM)
1372 #else
1373 int
1374 yyparse (YYPARSE_PARAM)
1375 void *YYPARSE_PARAM;
1376 #endif
1377 #else /* ! YYPARSE_PARAM */
1378 #if (defined __STDC__ || defined __C99__FUNC__ \
1379 || defined __cplusplus || defined _MSC_VER)
1380 int
1381 yyparse (void)
1382 #else
1383 int
1384 yyparse ()
1385
1386 #endif
1387 #endif
1388 {
1389
1390
1391 int yystate;
1392 /* Number of tokens to shift before error messages enabled. */
1393 int yyerrstatus;
1394
1395 /* The stacks and their tools:
1396 `yyss': related to states.
1397 `yyvs': related to semantic values.
1398
1399 Refer to the stacks thru separate pointers, to allow yyoverflow
1400 to reallocate them elsewhere. */
1401
1402 /* The state stack. */
1403 yytype_int16 yyssa[YYINITDEPTH];
1404 yytype_int16 *yyss;
1405 yytype_int16 *yyssp;
1406
1407 /* The semantic value stack. */
1408 YYSTYPE yyvsa[YYINITDEPTH];
1409 YYSTYPE *yyvs;
1410 YYSTYPE *yyvsp;
1411
1412 YYSIZE_T yystacksize;
1413
1414 int yyn;
1415 int yyresult;
1416 /* Lookahead token as an internal (translated) token number. */
1417 int yytoken;
1418 /* The variables used to return semantic value and location from the
1419 action routines. */
1420 YYSTYPE yyval;
1421
1422 #if YYERROR_VERBOSE
1423 /* Buffer for error messages, and its allocated size. */
1424 char yymsgbuf[128];
1425 char *yymsg = yymsgbuf;
1426 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1427 #endif
1428
1429 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1430
1431 /* The number of symbols on the RHS of the reduced rule.
1432 Keep to zero when no symbol should be popped. */
1433 int yylen = 0;
1434
1435 yytoken = 0;
1436 yyss = yyssa;
1437 yyvs = yyvsa;
1438 yystacksize = YYINITDEPTH;
1439
1440 YYDPRINTF ((stderr, "Starting parse\n"));
1441
1442 yystate = 0;
1443 yyerrstatus = 0;
1444 yynerrs = 0;
1445 yychar = YYEMPTY; /* Cause a token to be read. */
1446
1447 /* Initialize stack pointers.
1448 Waste one element of value and location stack
1449 so that they stay on the same level as the state stack.
1450 The wasted elements are never initialized. */
1451 yyssp = yyss;
1452 yyvsp = yyvs;
1453
1454 goto yysetstate;
1455
1456 /*------------------------------------------------------------.
1457 | yynewstate -- Push a new state, which is found in yystate. |
1458 `------------------------------------------------------------*/
1459 yynewstate:
1460 /* In all cases, when you get here, the value and location stacks
1461 have just been pushed. So pushing a state here evens the stacks. */
1462 yyssp++;
1463
1464 yysetstate:
1465 *yyssp = yystate;
1466
1467 if (yyss + yystacksize - 1 <= yyssp)
1468 {
1469 /* Get the current used size of the three stacks, in elements. */
1470 YYSIZE_T yysize = yyssp - yyss + 1;
1471
1472 #ifdef yyoverflow
1473 {
1474 /* Give user a chance to reallocate the stack. Use copies of
1475 these so that the &'s don't force the real ones into
1476 memory. */
1477 YYSTYPE *yyvs1 = yyvs;
1478 yytype_int16 *yyss1 = yyss;
1479
1480 /* Each stack pointer address is followed by the size of the
1481 data in use in that stack, in bytes. This used to be a
1482 conditional around just the two extra args, but that might
1483 be undefined if yyoverflow is a macro. */
1484 yyoverflow (YY_("memory exhausted"),
1485 &yyss1, yysize * sizeof (*yyssp),
1486 &yyvs1, yysize * sizeof (*yyvsp),
1487 &yystacksize);
1488
1489 yyss = yyss1;
1490 yyvs = yyvs1;
1491 }
1492 #else /* no yyoverflow */
1493 # ifndef YYSTACK_RELOCATE
1494 goto yyexhaustedlab;
1495 # else
1496 /* Extend the stack our own way. */
1497 if (YYMAXDEPTH <= yystacksize)
1498 goto yyexhaustedlab;
1499 yystacksize *= 2;
1500 if (YYMAXDEPTH < yystacksize)
1501 yystacksize = YYMAXDEPTH;
1502
1503 {
1504 yytype_int16 *yyss1 = yyss;
1505 union yyalloc *yyptr =
1506 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1507 if (! yyptr)
1508 goto yyexhaustedlab;
1509 YYSTACK_RELOCATE (yyss_alloc, yyss);
1510 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1511 # undef YYSTACK_RELOCATE
1512 if (yyss1 != yyssa)
1513 YYSTACK_FREE (yyss1);
1514 }
1515 # endif
1516 #endif /* no yyoverflow */
1517
1518 yyssp = yyss + yysize - 1;
1519 yyvsp = yyvs + yysize - 1;
1520
1521 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1522 (unsigned long int) yystacksize));
1523
1524 if (yyss + yystacksize - 1 <= yyssp)
1525 YYABORT;
1526 }
1527
1528 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1529
1530 if (yystate == YYFINAL)
1531 YYACCEPT;
1532
1533 goto yybackup;
1534
1535 /*-----------.
1536 | yybackup. |
1537 `-----------*/
1538 yybackup:
1539
1540 /* Do appropriate processing given the current state. Read a
1541 lookahead token if we need one and don't already have one. */
1542
1543 /* First try to decide what to do without reference to lookahead token. */
1544 yyn = yypact[yystate];
1545 if (yyn == YYPACT_NINF)
1546 goto yydefault;
1547
1548 /* Not known => get a lookahead token if don't already have one. */
1549
1550 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1551 if (yychar == YYEMPTY)
1552 {
1553 YYDPRINTF ((stderr, "Reading a token: "));
1554 yychar = YYLEX;
1555 }
1556
1557 if (yychar <= YYEOF)
1558 {
1559 yychar = yytoken = YYEOF;
1560 YYDPRINTF ((stderr, "Now at end of input.\n"));
1561 }
1562 else
1563 {
1564 yytoken = YYTRANSLATE (yychar);
1565 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1566 }
1567
1568 /* If the proper action on seeing token YYTOKEN is to reduce or to
1569 detect an error, take that action. */
1570 yyn += yytoken;
1571 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1572 goto yydefault;
1573 yyn = yytable[yyn];
1574 if (yyn <= 0)
1575 {
1576 if (yyn == 0 || yyn == YYTABLE_NINF)
1577 goto yyerrlab;
1578 yyn = -yyn;
1579 goto yyreduce;
1580 }
1581
1582 /* Count tokens shifted since error; after three, turn off error
1583 status. */
1584 if (yyerrstatus)
1585 yyerrstatus--;
1586
1587 /* Shift the lookahead token. */
1588 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1589
1590 /* Discard the shifted token. */
1591 yychar = YYEMPTY;
1592
1593 yystate = yyn;
1594 *++yyvsp = yylval;
1595
1596 goto yynewstate;
1597
1598
1599 /*-----------------------------------------------------------.
1600 | yydefault -- do the default action for the current state. |
1601 `-----------------------------------------------------------*/
1602 yydefault:
1603 yyn = yydefact[yystate];
1604 if (yyn == 0)
1605 goto yyerrlab;
1606 goto yyreduce;
1607
1608
1609 /*-----------------------------.
1610 | yyreduce -- Do a reduction. |
1611 `-----------------------------*/
1612 yyreduce:
1613 /* yyn is the number of a rule to reduce with. */
1614 yylen = yyr2[yyn];
1615
1616 /* If YYLEN is nonzero, implement the default value of the action:
1617 `$$ = $1'.
1618
1619 Otherwise, the following line sets YYVAL to garbage.
1620 This behavior is undocumented and Bison
1621 users should not rely upon it. Assigning to YYVAL
1622 unconditionally makes the parser a bit smaller, and it avoids a
1623 GCC warning that YYVAL may be used uninitialized. */
1624 yyval = yyvsp[1-yylen];
1625
1626
1627 YY_REDUCE_PRINT (yyn);
1628 switch (yyn)
1629 {
1630 case 2:
1631
1632 /* Line 1455 of yacc.c */
1633 #line 119 "parse.y"
1634 { /* add default rule */
1635 int def_rule;
1636
1637 pat = cclinit();
1638 cclnegate( pat );
1639
1640 def_rule = mkstate( -pat );
1641
1642 /* Remember the number of the default rule so we
1643 * don't generate "can't match" warnings for it.
1644 */
1645 default_rule = num_rules;
1646
1647 finish_rule( def_rule, false, 0, 0, 0);
1648
1649 for ( i = 1; i <= lastsc; ++i )
1650 scset[i] = mkbranch( scset[i], def_rule );
1651
1652 if ( spprdflt )
1653 add_action(
1654 "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
1655 else
1656 add_action( "ECHO" );
1657
1658 add_action( ";\n\tYY_BREAK\n" );
1659 }
1660 break;
1661
1662 case 3:
1663
1664 /* Line 1455 of yacc.c */
1665 #line 148 "parse.y"
1666 { /* initialize for processing rules */
1667
1668 /* Create default DFA start condition. */
1669 scinstal( "INITIAL", false );
1670 }
1671 break;
1672
1673 case 7:
1674
1675 /* Line 1455 of yacc.c */
1676 #line 159 "parse.y"
1677 { synerr( _("unknown error processing section 1") ); }
1678 break;
1679
1680 case 8:
1681
1682 /* Line 1455 of yacc.c */
1683 #line 163 "parse.y"
1684 {
1685 check_options();
1686 scon_stk = allocate_integer_array( lastsc + 1 );
1687 scon_stk_ptr = 0;
1688 }
1689 break;
1690
1691 case 9:
1692
1693 /* Line 1455 of yacc.c */
1694 #line 171 "parse.y"
1695 { xcluflg = false; }
1696 break;
1697
1698 case 10:
1699
1700 /* Line 1455 of yacc.c */
1701 #line 174 "parse.y"
1702 { xcluflg = true; }
1703 break;
1704
1705 case 11:
1706
1707 /* Line 1455 of yacc.c */
1708 #line 178 "parse.y"
1709 { scinstal( nmstr, xcluflg ); }
1710 break;
1711
1712 case 12:
1713
1714 /* Line 1455 of yacc.c */
1715 #line 181 "parse.y"
1716 { scinstal( nmstr, xcluflg ); }
1717 break;
1718
1719 case 13:
1720
1721 /* Line 1455 of yacc.c */
1722 #line 184 "parse.y"
1723 { synerr( _("bad start condition list") ); }
1724 break;
1725
1726 case 17:
1727
1728 /* Line 1455 of yacc.c */
1729 #line 195 "parse.y"
1730 {
1731 outfilename = copy_string( nmstr );
1732 did_outfilename = 1;
1733 }
1734 break;
1735
1736 case 18:
1737
1738 /* Line 1455 of yacc.c */
1739 #line 200 "parse.y"
1740 { extra_type = copy_string( nmstr ); }
1741 break;
1742
1743 case 19:
1744
1745 /* Line 1455 of yacc.c */
1746 #line 202 "parse.y"
1747 { prefix = copy_string( nmstr ); }
1748 break;
1749
1750 case 20:
1751
1752 /* Line 1455 of yacc.c */
1753 #line 204 "parse.y"
1754 { yyclass = copy_string( nmstr ); }
1755 break;
1756
1757 case 21:
1758
1759 /* Line 1455 of yacc.c */
1760 #line 206 "parse.y"
1761 { headerfilename = copy_string( nmstr ); }
1762 break;
1763
1764 case 22:
1765
1766 /* Line 1455 of yacc.c */
1767 #line 208 "parse.y"
1768 { tablesext = true; tablesfilename = copy_string( nmstr ); }
1769 break;
1770
1771 case 23:
1772
1773 /* Line 1455 of yacc.c */
1774 #line 212 "parse.y"
1775 { scon_stk_ptr = (yyvsp[(2) - (5)]); }
1776 break;
1777
1778 case 24:
1779
1780 /* Line 1455 of yacc.c */
1781 #line 214 "parse.y"
1782 { scon_stk_ptr = (yyvsp[(2) - (5)]); }
1783 break;
1784
1785 case 26:
1786
1787 /* Line 1455 of yacc.c */
1788 #line 219 "parse.y"
1789 {
1790 /* Initialize for a parse of one rule. */
1791 trlcontxt = variable_trail_rule = varlength = false;
1792 trailcnt = headcnt = rulelen = 0;
1793 current_state_type = STATE_NORMAL;
1794 previous_continued_action = continued_action;
1795 in_rule = true;
1796
1797 new_rule();
1798 }
1799 break;
1800
1801 case 27:
1802
1803 /* Line 1455 of yacc.c */
1804 #line 232 "parse.y"
1805 {
1806 pat = (yyvsp[(2) - (2)]);
1807 finish_rule( pat, variable_trail_rule,
1808 headcnt, trailcnt , previous_continued_action);
1809
1810 if ( scon_stk_ptr > 0 )
1811 {
1812 for ( i = 1; i <= scon_stk_ptr; ++i )
1813 scbol[scon_stk[i]] =
1814 mkbranch( scbol[scon_stk[i]],
1815 pat );
1816 }
1817
1818 else
1819 {
1820 /* Add to all non-exclusive start conditions,
1821 * including the default (0) start condition.
1822 */
1823
1824 for ( i = 1; i <= lastsc; ++i )
1825 if ( ! scxclu[i] )
1826 scbol[i] = mkbranch( scbol[i],
1827 pat );
1828 }
1829
1830 if ( ! bol_needed )
1831 {
1832 bol_needed = true;
1833
1834 if ( performance_report > 1 )
1835 pinpoint_message(
1836 "'^' operator results in sub-optimal performance" );
1837 }
1838 }
1839 break;
1840
1841 case 28:
1842
1843 /* Line 1455 of yacc.c */
1844 #line 268 "parse.y"
1845 {
1846 pat = (yyvsp[(1) - (1)]);
1847 finish_rule( pat, variable_trail_rule,
1848 headcnt, trailcnt , previous_continued_action);
1849
1850 if ( scon_stk_ptr > 0 )
1851 {
1852 for ( i = 1; i <= scon_stk_ptr; ++i )
1853 scset[scon_stk[i]] =
1854 mkbranch( scset[scon_stk[i]],
1855 pat );
1856 }
1857
1858 else
1859 {
1860 for ( i = 1; i <= lastsc; ++i )
1861 if ( ! scxclu[i] )
1862 scset[i] =
1863 mkbranch( scset[i],
1864 pat );
1865 }
1866 }
1867 break;
1868
1869 case 29:
1870
1871 /* Line 1455 of yacc.c */
1872 #line 292 "parse.y"
1873 {
1874 if ( scon_stk_ptr > 0 )
1875 build_eof_action();
1876
1877 else
1878 {
1879 /* This EOF applies to all start conditions
1880 * which don't already have EOF actions.
1881 */
1882 for ( i = 1; i <= lastsc; ++i )
1883 if ( ! sceof[i] )
1884 scon_stk[++scon_stk_ptr] = i;
1885
1886 if ( scon_stk_ptr == 0 )
1887 warn(
1888 "all start conditions already have <<EOF>> rules" );
1889
1890 else
1891 build_eof_action();
1892 }
1893 }
1894 break;
1895
1896 case 30:
1897
1898 /* Line 1455 of yacc.c */
1899 #line 315 "parse.y"
1900 { synerr( _("unrecognized rule") ); }
1901 break;
1902
1903 case 31:
1904
1905 /* Line 1455 of yacc.c */
1906 #line 319 "parse.y"
1907 { (yyval) = scon_stk_ptr; }
1908 break;
1909
1910 case 32:
1911
1912 /* Line 1455 of yacc.c */
1913 #line 323 "parse.y"
1914 { (yyval) = (yyvsp[(2) - (4)]); }
1915 break;
1916
1917 case 33:
1918
1919 /* Line 1455 of yacc.c */
1920 #line 326 "parse.y"
1921 {
1922 (yyval) = scon_stk_ptr;
1923
1924 for ( i = 1; i <= lastsc; ++i )
1925 {
1926 int j;
1927
1928 for ( j = 1; j <= scon_stk_ptr; ++j )
1929 if ( scon_stk[j] == i )
1930 break;
1931
1932 if ( j > scon_stk_ptr )
1933 scon_stk[++scon_stk_ptr] = i;
1934 }
1935 }
1936 break;
1937
1938 case 34:
1939
1940 /* Line 1455 of yacc.c */
1941 #line 343 "parse.y"
1942 { (yyval) = scon_stk_ptr; }
1943 break;
1944
1945 case 37:
1946
1947 /* Line 1455 of yacc.c */
1948 #line 351 "parse.y"
1949 { synerr( _("bad start condition list") ); }
1950 break;
1951
1952 case 38:
1953
1954 /* Line 1455 of yacc.c */
1955 #line 355 "parse.y"
1956 {
1957 if ( (scnum = sclookup( nmstr )) == 0 )
1958 format_pinpoint_message(
1959 "undeclared start condition %s",
1960 nmstr );
1961 else
1962 {
1963 for ( i = 1; i <= scon_stk_ptr; ++i )
1964 if ( scon_stk[i] == scnum )
1965 {
1966 format_warn(
1967 "<%s> specified twice",
1968 scname[scnum] );
1969 break;
1970 }
1971
1972 if ( i > scon_stk_ptr )
1973 scon_stk[++scon_stk_ptr] = scnum;
1974 }
1975 }
1976 break;
1977
1978 case 39:
1979
1980 /* Line 1455 of yacc.c */
1981 #line 378 "parse.y"
1982 {
1983 if ( transchar[lastst[(yyvsp[(2) - (2)])]] != SYM_EPSILON )
1984 /* Provide final transition \now/ so it
1985 * will be marked as a trailing context
1986 * state.
1987 */
1988 (yyvsp[(2) - (2)]) = link_machines( (yyvsp[(2) - (2)]),
1989 mkstate( SYM_EPSILON ) );
1990
1991 mark_beginning_as_normal( (yyvsp[(2) - (2)]) );
1992 current_state_type = STATE_NORMAL;
1993
1994 if ( previous_continued_action )
1995 {
1996 /* We need to treat this as variable trailing
1997 * context so that the backup does not happen
1998 * in the action but before the action switch
1999 * statement. If the backup happens in the
2000 * action, then the rules "falling into" this
2001 * one's action will *also* do the backup,
2002 * erroneously.
2003 */
2004 if ( ! varlength || headcnt != 0 )
2005 warn(
2006 "trailing context made variable due to preceding '|' action" );
2007
2008 /* Mark as variable. */
2009 varlength = true;
2010 headcnt = 0;
2011
2012 }
2013
2014 if ( lex_compat || (varlength && headcnt == 0) )
2015 { /* variable trailing context rule */
2016 /* Mark the first part of the rule as the
2017 * accepting "head" part of a trailing
2018 * context rule.
2019 *
2020 * By the way, we didn't do this at the
2021 * beginning of this production because back
2022 * then current_state_type was set up for a
2023 * trail rule, and add_accept() can create
2024 * a new state ...
2025 */
2026 add_accept( (yyvsp[(1) - (2)]),
2027 num_rules | YY_TRAILING_HEAD_MASK );
2028 variable_trail_rule = true;
2029 }
2030
2031 else
2032 trailcnt = rulelen;
2033
2034 (yyval) = link_machines( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) );
2035 }
2036 break;
2037
2038 case 40:
2039
2040 /* Line 1455 of yacc.c */
2041 #line 434 "parse.y"
2042 { synerr( _("trailing context used twice") ); }
2043 break;
2044
2045 case 41:
2046
2047 /* Line 1455 of yacc.c */
2048 #line 437 "parse.y"
2049 {
2050 headcnt = 0;
2051 trailcnt = 1;
2052 rulelen = 1;
2053 varlength = false;
2054
2055 current_state_type = STATE_TRAILING_CONTEXT;
2056
2057 if ( trlcontxt )
2058 {
2059 synerr( _("trailing context used twice") );
2060 (yyval) = mkstate( SYM_EPSILON );
2061 }
2062
2063 else if ( previous_continued_action )
2064 {
2065 /* See the comment in the rule for "re2 re"
2066 * above.
2067 */
2068 warn(
2069 "trailing context made variable due to preceding '|' action" );
2070
2071 varlength = true;
2072 }
2073
2074 if ( lex_compat || varlength )
2075 {
2076 /* Again, see the comment in the rule for
2077 * "re2 re" above.
2078 */
2079 add_accept( (yyvsp[(1) - (2)]),
2080 num_rules | YY_TRAILING_HEAD_MASK );
2081 variable_trail_rule = true;
2082 }
2083
2084 trlcontxt = true;
2085
2086 eps = mkstate( SYM_EPSILON );
2087 (yyval) = link_machines( (yyvsp[(1) - (2)]),
2088 link_machines( eps, mkstate( '\n' ) ) );
2089 }
2090 break;
2091
2092 case 42:
2093
2094 /* Line 1455 of yacc.c */
2095 #line 480 "parse.y"
2096 {
2097 (yyval) = (yyvsp[(1) - (1)]);
2098
2099 if ( trlcontxt )
2100 {
2101 if ( lex_compat || (varlength && headcnt == 0) )
2102 /* Both head and trail are
2103 * variable-length.
2104 */
2105 variable_trail_rule = true;
2106 else
2107 trailcnt = rulelen;
2108 }
2109 }
2110 break;
2111
2112 case 43:
2113
2114 /* Line 1455 of yacc.c */
2115 #line 498 "parse.y"
2116 {
2117 varlength = true;
2118 (yyval) = mkor( (yyvsp[(1) - (3)]), (yyvsp[(3) - (3)]) );
2119 }
2120 break;
2121
2122 case 44:
2123
2124 /* Line 1455 of yacc.c */
2125 #line 504 "parse.y"
2126 { (yyval) = (yyvsp[(1) - (1)]); }
2127 break;
2128
2129 case 45:
2130
2131 /* Line 1455 of yacc.c */
2132 #line 509 "parse.y"
2133 {
2134 /* This rule is written separately so the
2135 * reduction will occur before the trailing
2136 * series is parsed.
2137 */
2138
2139 if ( trlcontxt )
2140 synerr( _("trailing context used twice") );
2141 else
2142 trlcontxt = true;
2143
2144 if ( varlength )
2145 /* We hope the trailing context is
2146 * fixed-length.
2147 */
2148 varlength = false;
2149 else
2150 headcnt = rulelen;
2151
2152 rulelen = 0;
2153
2154 current_state_type = STATE_TRAILING_CONTEXT;
2155 (yyval) = (yyvsp[(1) - (2)]);
2156 }
2157 break;
2158
2159 case 46:
2160
2161 /* Line 1455 of yacc.c */
2162 #line 536 "parse.y"
2163 {
2164 /* This is where concatenation of adjacent patterns
2165 * gets done.
2166 */
2167 (yyval) = link_machines( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) );
2168 }
2169 break;
2170
2171 case 47:
2172
2173 /* Line 1455 of yacc.c */
2174 #line 544 "parse.y"
2175 { (yyval) = (yyvsp[(1) - (1)]); }
2176 break;
2177
2178 case 48:
2179
2180 /* Line 1455 of yacc.c */
2181 #line 547 "parse.y"
2182 {
2183 varlength = true;
2184
2185 if ( (yyvsp[(3) - (6)]) > (yyvsp[(5) - (6)]) || (yyvsp[(3) - (6)]) < 0 )
2186 {
2187 synerr( _("bad iteration values") );
2188 (yyval) = (yyvsp[(1) - (6)]);
2189 }
2190 else
2191 {
2192 if ( (yyvsp[(3) - (6)]) == 0 )
2193 {
2194 if ( (yyvsp[(5) - (6)]) <= 0 )
2195 {
2196 synerr(
2197 _("bad iteration values") );
2198 (yyval) = (yyvsp[(1) - (6)]);
2199 }
2200 else
2201 (yyval) = mkopt(
2202 mkrep( (yyvsp[(1) - (6)]), 1, (yyvsp[(5) - (6)]) ) );
2203 }
2204 else
2205 (yyval) = mkrep( (yyvsp[(1) - (6)]), (yyvsp[(3) - (6)]), (yyvsp[(5) - (6)]) );
2206 }
2207 }
2208 break;
2209
2210 case 49:
2211
2212 /* Line 1455 of yacc.c */
2213 #line 575 "parse.y"
2214 {
2215 varlength = true;
2216
2217 if ( (yyvsp[(3) - (5)]) <= 0 )
2218 {
2219 synerr( _("iteration value must be positive") );
2220 (yyval) = (yyvsp[(1) - (5)]);
2221 }
2222
2223 else
2224 (yyval) = mkrep( (yyvsp[(1) - (5)]), (yyvsp[(3) - (5)]), INFINITE_REPEAT );
2225 }
2226 break;
2227
2228 case 50:
2229
2230 /* Line 1455 of yacc.c */
2231 #line 589 "parse.y"
2232 {
2233 /* The series could be something like "(foo)",
2234 * in which case we have no idea what its length
2235 * is, so we punt here.
2236 */
2237 varlength = true;
2238
2239 if ( (yyvsp[(3) - (4)]) <= 0 )
2240 {
2241 synerr( _("iteration value must be positive")
2242 );
2243 (yyval) = (yyvsp[(1) - (4)]);
2244 }
2245
2246 else
2247 (yyval) = link_machines( (yyvsp[(1) - (4)]),
2248 copysingl( (yyvsp[(1) - (4)]), (yyvsp[(3) - (4)]) - 1 ) );
2249 }
2250 break;
2251
2252 case 51:
2253
2254 /* Line 1455 of yacc.c */
2255 #line 611 "parse.y"
2256 {
2257 varlength = true;
2258
2259 (yyval) = mkclos( (yyvsp[(1) - (2)]) );
2260 }
2261 break;
2262
2263 case 52:
2264
2265 /* Line 1455 of yacc.c */
2266 #line 618 "parse.y"
2267 {
2268 varlength = true;
2269 (yyval) = mkposcl( (yyvsp[(1) - (2)]) );
2270 }
2271 break;
2272
2273 case 53:
2274
2275 /* Line 1455 of yacc.c */
2276 #line 624 "parse.y"
2277 {
2278 varlength = true;
2279 (yyval) = mkopt( (yyvsp[(1) - (2)]) );
2280 }
2281 break;
2282
2283 case 54:
2284
2285 /* Line 1455 of yacc.c */
2286 #line 630 "parse.y"
2287 {
2288 varlength = true;
2289
2290 if ( (yyvsp[(3) - (6)]) > (yyvsp[(5) - (6)]) || (yyvsp[(3) - (6)]) < 0 )
2291 {
2292 synerr( _("bad iteration values") );
2293 (yyval) = (yyvsp[(1) - (6)]);
2294 }
2295 else
2296 {
2297 if ( (yyvsp[(3) - (6)]) == 0 )
2298 {
2299 if ( (yyvsp[(5) - (6)]) <= 0 )
2300 {
2301 synerr(
2302 _("bad iteration values") );
2303 (yyval) = (yyvsp[(1) - (6)]);
2304 }
2305 else
2306 (yyval) = mkopt(
2307 mkrep( (yyvsp[(1) - (6)]), 1, (yyvsp[(5) - (6)]) ) );
2308 }
2309 else
2310 (yyval) = mkrep( (yyvsp[(1) - (6)]), (yyvsp[(3) - (6)]), (yyvsp[(5) - (6)]) );
2311 }
2312 }
2313 break;
2314
2315 case 55:
2316
2317 /* Line 1455 of yacc.c */
2318 #line 658 "parse.y"
2319 {
2320 varlength = true;
2321
2322 if ( (yyvsp[(3) - (5)]) <= 0 )
2323 {
2324 synerr( _("iteration value must be positive") );
2325 (yyval) = (yyvsp[(1) - (5)]);
2326 }
2327
2328 else
2329 (yyval) = mkrep( (yyvsp[(1) - (5)]), (yyvsp[(3) - (5)]), INFINITE_REPEAT );
2330 }
2331 break;
2332
2333 case 56:
2334
2335 /* Line 1455 of yacc.c */
2336 #line 672 "parse.y"
2337 {
2338 /* The singleton could be something like "(foo)",
2339 * in which case we have no idea what its length
2340 * is, so we punt here.
2341 */
2342 varlength = true;
2343
2344 if ( (yyvsp[(3) - (4)]) <= 0 )
2345 {
2346 synerr( _("iteration value must be positive") );
2347 (yyval) = (yyvsp[(1) - (4)]);
2348 }
2349
2350 else
2351 (yyval) = link_machines( (yyvsp[(1) - (4)]),
2352 copysingl( (yyvsp[(1) - (4)]), (yyvsp[(3) - (4)]) - 1 ) );
2353 }
2354 break;
2355
2356 case 57:
2357
2358 /* Line 1455 of yacc.c */
2359 #line 691 "parse.y"
2360 {
2361 if ( ! madeany )
2362 {
2363 /* Create the '.' character class. */
2364 ccldot = cclinit();
2365 ccladd( ccldot, '\n' );
2366 cclnegate( ccldot );
2367
2368 if ( useecs )
2369 mkeccl( ccltbl + cclmap[ccldot],
2370 ccllen[ccldot], nextecm,
2371 ecgroup, csize, csize );
2372
2373 /* Create the (?s:'.') character class. */
2374 cclany = cclinit();
2375 cclnegate( cclany );
2376
2377 if ( useecs )
2378 mkeccl( ccltbl + cclmap[cclany],
2379 ccllen[cclany], nextecm,
2380 ecgroup, csize, csize );
2381
2382 madeany = true;
2383 }
2384
2385 ++rulelen;
2386
2387 if (sf_dot_all())
2388 (yyval) = mkstate( -cclany );
2389 else
2390 (yyval) = mkstate( -ccldot );
2391 }
2392 break;
2393
2394 case 58:
2395
2396 /* Line 1455 of yacc.c */
2397 #line 725 "parse.y"
2398 {
2399 /* Sort characters for fast searching.
2400 */
2401 qsort( ccltbl + cclmap[(yyvsp[(1) - (1)])], ccllen[(yyvsp[(1) - (1)])], sizeof (*ccltbl), cclcmp );
2402
2403 if ( useecs )
2404 mkeccl( ccltbl + cclmap[(yyvsp[(1) - (1)])], ccllen[(yyvsp[(1) - (1)])],
2405 nextecm, ecgroup, csize, csize );
2406
2407 ++rulelen;
2408
2409 if (ccl_has_nl[(yyvsp[(1) - (1)])])
2410 rule_has_nl[num_rules] = true;
2411
2412 (yyval) = mkstate( -(yyvsp[(1) - (1)]) );
2413 }
2414 break;
2415
2416 case 59:
2417
2418 /* Line 1455 of yacc.c */
2419 #line 743 "parse.y"
2420 {
2421 ++rulelen;
2422
2423 if (ccl_has_nl[(yyvsp[(1) - (1)])])
2424 rule_has_nl[num_rules] = true;
2425
2426 (yyval) = mkstate( -(yyvsp[(1) - (1)]) );
2427 }
2428 break;
2429
2430 case 60:
2431
2432 /* Line 1455 of yacc.c */
2433 #line 753 "parse.y"
2434 { (yyval) = (yyvsp[(2) - (3)]); }
2435 break;
2436
2437 case 61:
2438
2439 /* Line 1455 of yacc.c */
2440 #line 756 "parse.y"
2441 { (yyval) = (yyvsp[(2) - (3)]); }
2442 break;
2443
2444 case 62:
2445
2446 /* Line 1455 of yacc.c */
2447 #line 759 "parse.y"
2448 {
2449 ++rulelen;
2450
2451 if ((yyvsp[(1) - (1)]) == nlch)
2452 rule_has_nl[num_rules] = true;
2453
2454 if (sf_case_ins() && has_case((yyvsp[(1) - (1)])))
2455 /* create an alternation, as in (a|A) */
2456 (yyval) = mkor (mkstate((yyvsp[(1) - (1)])), mkstate(reverse_case((yyvsp[(1) - (1)]))));
2457 else
2458 (yyval) = mkstate( (yyvsp[(1) - (1)]) );
2459 }
2460 break;
2461
2462 case 63:
2463
2464 /* Line 1455 of yacc.c */
2465 #line 773 "parse.y"
2466 { (yyval) = ccl_set_diff ((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2467 break;
2468
2469 case 64:
2470
2471 /* Line 1455 of yacc.c */
2472 #line 774 "parse.y"
2473 { (yyval) = ccl_set_union ((yyvsp[(1) - (3)]), (yyvsp[(3) - (3)])); }
2474 break;
2475
2476 case 66:
2477
2478 /* Line 1455 of yacc.c */
2479 #line 780 "parse.y"
2480 { (yyval) = (yyvsp[(2) - (3)]); }
2481 break;
2482
2483 case 67:
2484
2485 /* Line 1455 of yacc.c */
2486 #line 783 "parse.y"
2487 {
2488 cclnegate( (yyvsp[(3) - (4)]) );
2489 (yyval) = (yyvsp[(3) - (4)]);
2490 }
2491 break;
2492
2493 case 68:
2494
2495 /* Line 1455 of yacc.c */
2496 #line 790 "parse.y"
2497 {
2498
2499 if (sf_case_ins())
2500 {
2501
2502 /* If one end of the range has case and the other
2503 * does not, or the cases are different, then we're not
2504 * sure what range the user is trying to express.
2505 * Examples: [@-z] or [S-t]
2506 */
2507 if (has_case ((yyvsp[(2) - (4)])) != has_case ((yyvsp[(4) - (4)]))
2508 || (has_case ((yyvsp[(2) - (4)])) && (b_islower ((yyvsp[(2) - (4)])) != b_islower ((yyvsp[(4) - (4)]))))
2509 || (has_case ((yyvsp[(2) - (4)])) && (b_isupper ((yyvsp[(2) - (4)])) != b_isupper ((yyvsp[(4) - (4)])))))
2510 format_warn3 (
2511 _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
2512 (yyvsp[(2) - (4)]), (yyvsp[(4) - (4)]));
2513
2514 /* If the range spans uppercase characters but not
2515 * lowercase (or vice-versa), then should we automatically
2516 * include lowercase characters in the range?
2517 * Example: [@-_] spans [a-z] but not [A-Z]
2518 */
2519 else if (!has_case ((yyvsp[(2) - (4)])) && !has_case ((yyvsp[(4) - (4)])) && !range_covers_case ((yyvsp[(2) - (4)]), (yyvsp[(4) - (4)])))
2520 format_warn3 (
2521 _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
2522 (yyvsp[(2) - (4)]), (yyvsp[(4) - (4)]));
2523 }
2524
2525 if ( (yyvsp[(2) - (4)]) > (yyvsp[(4) - (4)]) )
2526 synerr( _("negative range in character class") );
2527
2528 else
2529 {
2530 for ( i = (yyvsp[(2) - (4)]); i <= (yyvsp[(4) - (4)]); ++i )
2531 ccladd( (yyvsp[(1) - (4)]), i );
2532
2533 /* Keep track if this ccl is staying in
2534 * alphabetical order.
2535 */
2536 cclsorted = cclsorted && ((yyvsp[(2) - (4)]) > lastchar);
2537 lastchar = (yyvsp[(4) - (4)]);
2538
2539 /* Do it again for upper/lowercase */
2540 if (sf_case_ins() && has_case((yyvsp[(2) - (4)])) && has_case((yyvsp[(4) - (4)]))){
2541 (yyvsp[(2) - (4)]) = reverse_case ((yyvsp[(2) - (4)]));
2542 (yyvsp[(4) - (4)]) = reverse_case ((yyvsp[(4) - (4)]));
2543
2544 for ( i = (yyvsp[(2) - (4)]); i <= (yyvsp[(4) - (4)]); ++i )
2545 ccladd( (yyvsp[(1) - (4)]), i );
2546
2547 cclsorted = cclsorted && ((yyvsp[(2) - (4)]) > lastchar);
2548 lastchar = (yyvsp[(4) - (4)]);
2549 }
2550
2551 }
2552
2553 (yyval) = (yyvsp[(1) - (4)]);
2554 }
2555 break;
2556
2557 case 69:
2558
2559 /* Line 1455 of yacc.c */
2560 #line 850 "parse.y"
2561 {
2562 ccladd( (yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]) );
2563 cclsorted = cclsorted && ((yyvsp[(2) - (2)]) > lastchar);
2564 lastchar = (yyvsp[(2) - (2)]);
2565
2566 /* Do it again for upper/lowercase */
2567 if (sf_case_ins() && has_case((yyvsp[(2) - (2)]))){
2568 (yyvsp[(2) - (2)]) = reverse_case ((yyvsp[(2) - (2)]));
2569 ccladd ((yyvsp[(1) - (2)]), (yyvsp[(2) - (2)]));
2570
2571 cclsorted = cclsorted && ((yyvsp[(2) - (2)]) > lastchar);
2572 lastchar = (yyvsp[(2) - (2)]);
2573 }
2574
2575 (yyval) = (yyvsp[(1) - (2)]);
2576 }
2577 break;
2578
2579 case 70:
2580
2581 /* Line 1455 of yacc.c */
2582 #line 868 "parse.y"
2583 {
2584 /* Too hard to properly maintain cclsorted. */
2585 cclsorted = false;
2586 (yyval) = (yyvsp[(1) - (2)]);
2587 }
2588 break;
2589
2590 case 71:
2591
2592 /* Line 1455 of yacc.c */
2593 #line 875 "parse.y"
2594 {
2595 cclsorted = true;
2596 lastchar = 0;
2597 currccl = (yyval) = cclinit();
2598 }
2599 break;
2600
2601 case 72:
2602
2603 /* Line 1455 of yacc.c */
2604 #line 883 "parse.y"
2605 { CCL_EXPR(isalnum); }
2606 break;
2607
2608 case 73:
2609
2610 /* Line 1455 of yacc.c */
2611 #line 884 "parse.y"
2612 { CCL_EXPR(isalpha); }
2613 break;
2614
2615 case 74:
2616
2617 /* Line 1455 of yacc.c */
2618 #line 885 "parse.y"
2619 { CCL_EXPR(IS_BLANK); }
2620 break;
2621
2622 case 75:
2623
2624 /* Line 1455 of yacc.c */
2625 #line 886 "parse.y"
2626 { CCL_EXPR(iscntrl); }
2627 break;
2628
2629 case 76:
2630
2631 /* Line 1455 of yacc.c */
2632 #line 887 "parse.y"
2633 { CCL_EXPR(isdigit); }
2634 break;
2635
2636 case 77:
2637
2638 /* Line 1455 of yacc.c */
2639 #line 888 "parse.y"
2640 { CCL_EXPR(isgraph); }
2641 break;
2642
2643 case 78:
2644
2645 /* Line 1455 of yacc.c */
2646 #line 889 "parse.y"
2647 {
2648 CCL_EXPR(islower);
2649 if (sf_case_ins())
2650 CCL_EXPR(isupper);
2651 }
2652 break;
2653
2654 case 79:
2655
2656 /* Line 1455 of yacc.c */
2657 #line 894 "parse.y"
2658 { CCL_EXPR(isprint); }
2659 break;
2660
2661 case 80:
2662
2663 /* Line 1455 of yacc.c */
2664 #line 895 "parse.y"
2665 { CCL_EXPR(ispunct); }
2666 break;
2667
2668 case 81:
2669
2670 /* Line 1455 of yacc.c */
2671 #line 896 "parse.y"
2672 { CCL_EXPR(isspace); }
2673 break;
2674
2675 case 82:
2676
2677 /* Line 1455 of yacc.c */
2678 #line 897 "parse.y"
2679 { CCL_EXPR(isxdigit); }
2680 break;
2681
2682 case 83:
2683
2684 /* Line 1455 of yacc.c */
2685 #line 898 "parse.y"
2686 {
2687 CCL_EXPR(isupper);
2688 if (sf_case_ins())
2689 CCL_EXPR(islower);
2690 }
2691 break;
2692
2693 case 84:
2694
2695 /* Line 1455 of yacc.c */
2696 #line 904 "parse.y"
2697 { CCL_NEG_EXPR(isalnum); }
2698 break;
2699
2700 case 85:
2701
2702 /* Line 1455 of yacc.c */
2703 #line 905 "parse.y"
2704 { CCL_NEG_EXPR(isalpha); }
2705 break;
2706
2707 case 86:
2708
2709 /* Line 1455 of yacc.c */
2710 #line 906 "parse.y"
2711 { CCL_NEG_EXPR(IS_BLANK); }
2712 break;
2713
2714 case 87:
2715
2716 /* Line 1455 of yacc.c */
2717 #line 907 "parse.y"
2718 { CCL_NEG_EXPR(iscntrl); }
2719 break;
2720
2721 case 88:
2722
2723 /* Line 1455 of yacc.c */
2724 #line 908 "parse.y"
2725 { CCL_NEG_EXPR(isdigit); }
2726 break;
2727
2728 case 89:
2729
2730 /* Line 1455 of yacc.c */
2731 #line 909 "parse.y"
2732 { CCL_NEG_EXPR(isgraph); }
2733 break;
2734
2735 case 90:
2736
2737 /* Line 1455 of yacc.c */
2738 #line 910 "parse.y"
2739 { CCL_NEG_EXPR(isprint); }
2740 break;
2741
2742 case 91:
2743
2744 /* Line 1455 of yacc.c */
2745 #line 911 "parse.y"
2746 { CCL_NEG_EXPR(ispunct); }
2747 break;
2748
2749 case 92:
2750
2751 /* Line 1455 of yacc.c */
2752 #line 912 "parse.y"
2753 { CCL_NEG_EXPR(isspace); }
2754 break;
2755
2756 case 93:
2757
2758 /* Line 1455 of yacc.c */
2759 #line 913 "parse.y"
2760 { CCL_NEG_EXPR(isxdigit); }
2761 break;
2762
2763 case 94:
2764
2765 /* Line 1455 of yacc.c */
2766 #line 914 "parse.y"
2767 {
2768 if ( sf_case_ins() )
2769 warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
2770 else
2771 CCL_NEG_EXPR(islower);
2772 }
2773 break;
2774
2775 case 95:
2776
2777 /* Line 1455 of yacc.c */
2778 #line 920 "parse.y"
2779 {
2780 if ( sf_case_ins() )
2781 warn(_("[:^upper:] ambiguous in case insensitive scanner"));
2782 else
2783 CCL_NEG_EXPR(isupper);
2784 }
2785 break;
2786
2787 case 96:
2788
2789 /* Line 1455 of yacc.c */
2790 #line 929 "parse.y"
2791 {
2792 if ( (yyvsp[(2) - (2)]) == nlch )
2793 rule_has_nl[num_rules] = true;
2794
2795 ++rulelen;
2796
2797 if (sf_case_ins() && has_case((yyvsp[(2) - (2)])))
2798 (yyval) = mkor (mkstate((yyvsp[(2) - (2)])), mkstate(reverse_case((yyvsp[(2) - (2)]))));
2799 else
2800 (yyval) = mkstate ((yyvsp[(2) - (2)]));
2801
2802 (yyval) = link_machines( (yyvsp[(1) - (2)]), (yyval));
2803 }
2804 break;
2805
2806 case 97:
2807
2808 /* Line 1455 of yacc.c */
2809 #line 944 "parse.y"
2810 { (yyval) = mkstate( SYM_EPSILON ); }
2811 break;
2812
2813
2814
2815 /* Line 1455 of yacc.c */
2816 #line 2817 "parse.c"
2817 default: break;
2818 }
2819 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2820
2821 YYPOPSTACK (yylen);
2822 yylen = 0;
2823 YY_STACK_PRINT (yyss, yyssp);
2824
2825 *++yyvsp = yyval;
2826
2827 /* Now `shift' the result of the reduction. Determine what state
2828 that goes to, based on the state we popped back to and the rule
2829 number reduced by. */
2830
2831 yyn = yyr1[yyn];
2832
2833 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2834 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2835 yystate = yytable[yystate];
2836 else
2837 yystate = yydefgoto[yyn - YYNTOKENS];
2838
2839 goto yynewstate;
2840
2841
2842 /*------------------------------------.
2843 | yyerrlab -- here on detecting error |
2844 `------------------------------------*/
2845 yyerrlab:
2846 /* If not already recovering from an error, report this error. */
2847 if (!yyerrstatus)
2848 {
2849 ++yynerrs;
2850 #if ! YYERROR_VERBOSE
2851 yyerror (YY_("syntax error"));
2852 #else
2853 {
2854 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
2855 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
2856 {
2857 YYSIZE_T yyalloc = 2 * yysize;
2858 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
2859 yyalloc = YYSTACK_ALLOC_MAXIMUM;
2860 if (yymsg != yymsgbuf)
2861 YYSTACK_FREE (yymsg);
2862 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
2863 if (yymsg)
2864 yymsg_alloc = yyalloc;
2865 else
2866 {
2867 yymsg = yymsgbuf;
2868 yymsg_alloc = sizeof yymsgbuf;
2869 }
2870 }
2871
2872 if (0 < yysize && yysize <= yymsg_alloc)
2873 {
2874 (void) yysyntax_error (yymsg, yystate, yychar);
2875 yyerror (yymsg);
2876 }
2877 else
2878 {
2879 yyerror (YY_("syntax error"));
2880 if (yysize != 0)
2881 goto yyexhaustedlab;
2882 }
2883 }
2884 #endif
2885 }
2886
2887
2888
2889 if (yyerrstatus == 3)
2890 {
2891 /* If just tried and failed to reuse lookahead token after an
2892 error, discard it. */
2893
2894 if (yychar <= YYEOF)
2895 {
2896 /* Return failure if at end of input. */
2897 if (yychar == YYEOF)
2898 YYABORT;
2899 }
2900 else
2901 {
2902 yydestruct ("Error: discarding",
2903 yytoken, &yylval);
2904 yychar = YYEMPTY;
2905 }
2906 }
2907
2908 /* Else will try to reuse lookahead token after shifting the error
2909 token. */
2910 goto yyerrlab1;
2911
2912
2913 /*---------------------------------------------------.
2914 | yyerrorlab -- error raised explicitly by YYERROR. |
2915 `---------------------------------------------------*/
2916 yyerrorlab:
2917
2918 /* Pacify compilers like GCC when the user code never invokes
2919 YYERROR and the label yyerrorlab therefore never appears in user
2920 code. */
2921 if (/*CONSTCOND*/ 0)
2922 goto yyerrorlab;
2923
2924 /* Do not reclaim the symbols of the rule which action triggered
2925 this YYERROR. */
2926 YYPOPSTACK (yylen);
2927 yylen = 0;
2928 YY_STACK_PRINT (yyss, yyssp);
2929 yystate = *yyssp;
2930 goto yyerrlab1;
2931
2932
2933 /*-------------------------------------------------------------.
2934 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2935 `-------------------------------------------------------------*/
2936 yyerrlab1:
2937 yyerrstatus = 3; /* Each real token shifted decrements this. */
2938
2939 for (;;)
2940 {
2941 yyn = yypact[yystate];
2942 if (yyn != YYPACT_NINF)
2943 {
2944 yyn += YYTERROR;
2945 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2946 {
2947 yyn = yytable[yyn];
2948 if (0 < yyn)
2949 break;
2950 }
2951 }
2952
2953 /* Pop the current state because it cannot handle the error token. */
2954 if (yyssp == yyss)
2955 YYABORT;
2956
2957
2958 yydestruct ("Error: popping",
2959 yystos[yystate], yyvsp);
2960 YYPOPSTACK (1);
2961 yystate = *yyssp;
2962 YY_STACK_PRINT (yyss, yyssp);
2963 }
2964
2965 *++yyvsp = yylval;
2966
2967
2968 /* Shift the error token. */
2969 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2970
2971 yystate = yyn;
2972 goto yynewstate;
2973
2974
2975 /*-------------------------------------.
2976 | yyacceptlab -- YYACCEPT comes here. |
2977 `-------------------------------------*/
2978 yyacceptlab:
2979 yyresult = 0;
2980 goto yyreturn;
2981
2982 /*-----------------------------------.
2983 | yyabortlab -- YYABORT comes here. |
2984 `-----------------------------------*/
2985 yyabortlab:
2986 yyresult = 1;
2987 goto yyreturn;
2988
2989 #if !defined(yyoverflow) || YYERROR_VERBOSE
2990 /*-------------------------------------------------.
2991 | yyexhaustedlab -- memory exhaustion comes here. |
2992 `-------------------------------------------------*/
2993 yyexhaustedlab:
2994 yyerror (YY_("memory exhausted"));
2995 yyresult = 2;
2996 /* Fall through. */
2997 #endif
2998
2999 yyreturn:
3000 if (yychar != YYEMPTY)
3001 yydestruct ("Cleanup: discarding lookahead",
3002 yytoken, &yylval);
3003 /* Do not reclaim the symbols of the rule which action triggered
3004 this YYABORT or YYACCEPT. */
3005 YYPOPSTACK (yylen);
3006 YY_STACK_PRINT (yyss, yyssp);
3007 while (yyssp != yyss)
3008 {
3009 yydestruct ("Cleanup: popping",
3010 yystos[*yyssp], yyvsp);
3011 YYPOPSTACK (1);
3012 }
3013 #ifndef yyoverflow
3014 if (yyss != yyssa)
3015 YYSTACK_FREE (yyss);
3016 #endif
3017 #if YYERROR_VERBOSE
3018 if (yymsg != yymsgbuf)
3019 YYSTACK_FREE (yymsg);
3020 #endif
3021 /* Make sure YYID is used. */
3022 return YYID (yyresult);
3023 }
3024
3025
3026
3027 /* Line 1675 of yacc.c */
3028 #line 947 "parse.y"
3029
3030
3031
3032 /* build_eof_action - build the "<<EOF>>" action for the active start
3033 * conditions
3034 */
3035
3036 void build_eof_action()
3037 {
3038 register int i;
3039 char action_text[MAXLINE];
3040
3041 for ( i = 1; i <= scon_stk_ptr; ++i )
3042 {
3043 if ( sceof[scon_stk[i]] )
3044 format_pinpoint_message(
3045 "multiple <<EOF>> rules for start condition %s",
3046 scname[scon_stk[i]] );
3047
3048 else
3049 {
3050 sceof[scon_stk[i]] = true;
3051
3052 if (previous_continued_action /* && previous action was regular */)
3053 add_action("YY_RULE_SETUP\n");
3054
3055 snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
3056 scname[scon_stk[i]] );
3057 add_action( action_text );
3058 }
3059 }
3060
3061 line_directive_out( (FILE *) 0, 1 );
3062
3063 /* This isn't a normal rule after all - don't count it as
3064 * such, so we don't have any holes in the rule numbering
3065 * (which make generating "rule can never match" warnings
3066 * more difficult.
3067 */
3068 --num_rules;
3069 ++num_eof_rules;
3070 }
3071
3072
3073 /* format_synerr - write out formatted syntax error */
3074
3075 void format_synerr( msg, arg )
3076 const char *msg, arg[];
3077 {
3078 char errmsg[MAXLINE];
3079
3080 (void) snprintf( errmsg, sizeof(errmsg), msg, arg );
3081 synerr( errmsg );
3082 }
3083
3084
3085 /* synerr - report a syntax error */
3086
3087 void synerr( str )
3088 const char *str;
3089 {
3090 syntaxerror = true;
3091 pinpoint_message( str );
3092 }
3093
3094
3095 /* format_warn - write out formatted warning */
3096
3097 void format_warn( msg, arg )
3098 const char *msg, arg[];
3099 {
3100 char warn_msg[MAXLINE];
3101
3102 snprintf( warn_msg, sizeof(warn_msg), msg, arg );
3103 warn( warn_msg );
3104 }
3105
3106
3107 /* warn - report a warning, unless -w was given */
3108
3109 void warn( str )
3110 const char *str;
3111 {
3112 line_warning( str, linenum );
3113 }
3114
3115 /* format_pinpoint_message - write out a message formatted with one string,
3116 * pinpointing its location
3117 */
3118
3119 void format_pinpoint_message( msg, arg )
3120 const char *msg, arg[];
3121 {
3122 char errmsg[MAXLINE];
3123
3124 snprintf( errmsg, sizeof(errmsg), msg, arg );
3125 pinpoint_message( errmsg );
3126 }
3127
3128
3129 /* pinpoint_message - write out a message, pinpointing its location */
3130
3131 void pinpoint_message( str )
3132 const char *str;
3133 {
3134 line_pinpoint( str, linenum );
3135 }
3136
3137
3138 /* line_warning - report a warning at a given line, unless -w was given */
3139
3140 void line_warning( str, line )
3141 const char *str;
3142 int line;
3143 {
3144 char warning[MAXLINE];
3145
3146 if ( ! nowarn )
3147 {
3148 snprintf( warning, sizeof(warning), "warning, %s", str );
3149 line_pinpoint( warning, line );
3150 }
3151 }
3152
3153
3154 /* line_pinpoint - write out a message, pinpointing it at the given line */
3155
3156 void line_pinpoint( str, line )
3157 const char *str;
3158 int line;
3159 {
3160 fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
3161 }
3162
3163
3164 /* yyerror - eat up an error message from the parser;
3165 * currently, messages are ignore
3166 */
3167
3168 void yyerror( msg )
3169 const char *msg;
3170 {
3171 }
3172
DragonFly BSD