mirror/freebsd
1
0
Fork 0
mirror of https://git.FreeBSD.org/src.git synced 2024-12-21 11:13:30 +00:00
Code Issues Releases Activity
d6fb489498
freebsd/usr.bin/lex/initparse.c

1850 lines
48 KiB
C
Raw Blame History

/* $FreeBSD$ */
#ifndef lint
static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYEMPTY (-1)
#define yyclearin (yychar = YYEMPTY)
#define yyerrok (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)
#define YYPREFIX "yy"
#define YYPURE 0
#line 35 "parse.y"
/* Copyright (c) 1990 The Regents of the University of California. */
/* All rights reserved. */
/* This code is derived from software contributed to Berkeley by */
/* Vern Paxson. */
/* The United States Government has rights in this work pursuant */
/* to contract no. DE-AC03-76SF00098 between the United States */
/* Department of Energy and the University of California. */
/* This file is part of flex. */
/* Redistribution and use in source and binary forms, with or without */
/* modification, are permitted provided that the following conditions */
/* are met: */
/* 1. Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* 2. Redistributions in binary form must reproduce the above copyright */
/* notice, this list of conditions and the following disclaimer in the */
/* documentation and/or other materials provided with the distribution. */
/* Neither the name of the University nor the names of its contributors */
/* may be used to endorse or promote products derived from this software */
/* without specific prior written permission. */
/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/* PURPOSE. */
#include "flexdef.h"
#include "tables.h"
int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
int *scon_stk;
int scon_stk_ptr;
static int madeany = false; /* whether we've made the '.' character class */
static int ccldot, cclany;
int previous_continued_action; /* whether the previous rule's action was '|' */
#define format_warn3(fmt, a1, a2) \
do{ \
char fw3_msg[MAXLINE];\
snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
warn( fw3_msg );\
}while(0)
/* Expand a POSIX character class expression. */
#define CCL_EXPR(func) \
do{ \
int c; \
for ( c = 0; c < csize; ++c ) \
if ( isascii(c) && func(c) ) \
ccladd( currccl, c ); \
}while(0)
/* negated class */
#define CCL_NEG_EXPR(func) \
do{ \
int c; \
for ( c = 0; c < csize; ++c ) \
if ( !func(c) ) \
ccladd( currccl, c ); \
}while(0)
/* While POSIX defines isblank(), it's not ANSI C. */
#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
/* On some over-ambitious machines, such as DEC Alpha's, the default
* token type is "long" instead of "int"; this leads to problems with
* declaring yylval in flexdef.h. But so far, all the yacc's I've seen
* wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
* following should ensure that the default token type is "int".
*/
#define YYSTYPE int
#line 99 "parse.c"
#ifndef YYSTYPE
typedef int YYSTYPE;
#endif
/* compatibility with bison */
#ifdef YYPARSE_PARAM
/* compatibility with FreeBSD */
# ifdef YYPARSE_PARAM_TYPE
# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
# else
# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif
#else
# define YYPARSE_DECL() yyparse(void)
#endif
/* Parameters sent to lex. */
#ifdef YYLEX_PARAM
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM)
#else
# define YYLEX_DECL() yylex(void)
# define YYLEX yylex()
#endif
/* Parameters sent to yyerror. */
#ifndef YYERROR_DECL
#define YYERROR_DECL() yyerror(const char *s)
#endif
#ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(msg)
#endif
extern int YYPARSE_DECL();
#define CHAR 257
#define NUMBER 258
#define SECTEND 259
#define SCDECL 260
#define XSCDECL 261
#define NAME 262
#define PREVCCL 263
#define EOF_OP 264
#define OPTION_OP 265
#define OPT_OUTFILE 266
#define OPT_PREFIX 267
#define OPT_YYCLASS 268
#define OPT_HEADER 269
#define OPT_EXTRA_TYPE 270
#define OPT_TABLES 271
#define CCE_ALNUM 272
#define CCE_ALPHA 273
#define CCE_BLANK 274
#define CCE_CNTRL 275
#define CCE_DIGIT 276
#define CCE_GRAPH 277
#define CCE_LOWER 278
#define CCE_PRINT 279
#define CCE_PUNCT 280
#define CCE_SPACE 281
#define CCE_UPPER 282
#define CCE_XDIGIT 283
#define CCE_NEG_ALNUM 284
#define CCE_NEG_ALPHA 285
#define CCE_NEG_BLANK 286
#define CCE_NEG_CNTRL 287
#define CCE_NEG_DIGIT 288
#define CCE_NEG_GRAPH 289
#define CCE_NEG_LOWER 290
#define CCE_NEG_PRINT 291
#define CCE_NEG_PUNCT 292
#define CCE_NEG_SPACE 293
#define CCE_NEG_UPPER 294
#define CCE_NEG_XDIGIT 295
#define CCL_OP_DIFF 296
#define CCL_OP_UNION 297
#define BEGIN_REPEAT_POSIX 298
#define END_REPEAT_POSIX 299
#define BEGIN_REPEAT_FLEX 300
#define END_REPEAT_FLEX 301
#define YYERRCODE 256
static const short yylhs[] = { -1,
0, 1, 2, 2, 2, 2, 3, 6, 6, 7,
7, 7, 8, 9, 9, 10, 10, 10, 10, 10,
10, 4, 4, 4, 5, 12, 12, 12, 12, 14,
11, 11, 11, 15, 15, 15, 16, 13, 13, 13,
13, 18, 18, 17, 19, 19, 19, 19, 19, 20,
20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
20, 21, 21, 21, 23, 23, 24, 24, 24, 24,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
25, 25, 25, 25, 22, 22,
};
static const short yylen[] = { 2,
5, 0, 3, 2, 0, 1, 1, 1, 1, 2,
1, 1, 2, 2, 0, 3, 3, 3, 3, 3,
3, 5, 5, 0, 0, 2, 1, 1, 1, 0,
4, 3, 0, 3, 1, 1, 1, 2, 3, 2,
1, 3, 1, 2, 2, 1, 6, 5, 4, 2,
2, 2, 6, 5, 4, 1, 1, 1, 3, 3,
1, 3, 3, 1, 3, 4, 4, 2, 2, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 2, 0,
};
static const short yydefred[] = { 2,
0, 0, 6, 0, 7, 8, 9, 15, 24, 0,
4, 0, 0, 12, 11, 0, 0, 0, 0, 0,
0, 0, 14, 0, 1, 0, 10, 0, 0, 0,
0, 0, 0, 0, 0, 24, 0, 16, 18, 19,
20, 17, 21, 32, 36, 37, 0, 35, 0, 29,
61, 58, 28, 0, 56, 96, 0, 0, 0, 27,
0, 0, 0, 0, 0, 64, 31, 0, 23, 26,
0, 0, 70, 0, 22, 0, 40, 0, 44, 0,
0, 0, 50, 51, 52, 0, 0, 34, 95, 59,
60, 0, 0, 71, 72, 73, 74, 75, 76, 77,
78, 79, 80, 82, 81, 83, 84, 85, 86, 87,
88, 93, 89, 90, 91, 94, 92, 65, 69, 39,
0, 0, 0, 62, 63, 66, 0, 49, 0, 55,
0, 67, 0, 48, 0, 54, 47, 53,
};
static const short yydgoto[] = { 1,
2, 4, 9, 13, 25, 10, 16, 11, 12, 23,
26, 59, 60, 35, 47, 48, 61, 62, 63, 64,
65, 71, 66, 74, 119,
};
static const short yysindex[] = { 0,
0, -222, 0, -155, 0, 0, 0, 0, 0, -215,
0, -123, 6, 0, 0, -193, 10, 21, 26, 31,
35, 37, 0, 59, 0, -44, 0, -147, -145, -140,
-133, -132, -129, 75, -214, 0, -19, 0, 0, 0,
0, 0, 0, 0, 0, 0, 23, 0, -48, 0,
0, 0, 0, -17, 0, 0, -17, 27, 128, 0,
-17, -1, -30, -41, -189, 0, 0, -121, 0, 0,
-31, -34, 0, -87, 0, -25, 0, -17, 0, -109,
-41, -108, 0, 0, 0, 60, 60, 0, 0, 0,
0, 46, 107, 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,
-30, -36, -39, 0, 0, 0, -104, 0, -219, 0,
-238, 0, -144, 0, -143, 0, 0, 0,
};
static const short yyrindex[] = { 0,
0, -141, 0, 0, 0, 0, 0, 0, 0, 0,
0, -134, 9, 0, 0, -125, 0, 0, 0, 0,
0, 0, 0, -178, 0, 22, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, -21, 0,
0, 0, 0, 0, 0, 0, 0, 85, 0, 0,
0, 144, 47, 4, -10, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 146, 0, 0, 0, 0,
18, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 124, 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,
50, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
};
static const short yygindex[] = { 0,
0, 0, 0, 121, 133, 0, 0, 0, 0, 0,
0, 0, 106, 0, 0, 93, 0, 32, 84, -45,
0, 0, 25, 90, 0,
};
#define YYTABLESIZE 419
static const short yytable[] = { 57,
83, 84, 90, 56, 131, 118, 91, 129, 25, 57,
120, 24, 33, 46, 56, 55, 56, 81, 33, 135,
57, 85, 57, 57, 33, 57, 55, 45, 55, 57,
57, 57, 57, 3, 77, 57, 57, 46, 133, 46,
14, 45, 33, 46, 46, 79, 15, 46, 33, 46,
46, 45, 57, 45, 33, 25, 43, 45, 45, 42,
58, 25, 136, 45, 45, 24, 68, 25, 27, 33,
28, 58, 33, 58, 54, 81, 69, 30, 36, 134,
57, 29, 43, 30, 67, 42, 30, 43, 72, 78,
42, 31, 76, 43, 46, 32, 42, 33, 78, 33,
34, 33, 33, 5, 6, 7, 86, 87, 45, 8,
124, 125, 25, 57, 38, 25, 39, 5, 5, 5,
73, 40, 78, 5, 13, 13, 13, 46, 41, 42,
13, 33, 43, 3, 3, 3, 44, 75, 126, 3,
46, 45, 17, 18, 19, 20, 21, 22, 122, 123,
58, 127, 132, 41, 137, 38, 49, 138, 37, 70,
88, 121, 92, 0, 0, 0, 0, 0, 0, 93,
43, 0, 0, 42, 0, 0, 0, 70, 0, 0,
0, 0, 0, 0, 94, 95, 96, 97, 98, 99,
100, 101, 102, 103, 104, 105, 106, 107, 108, 109,
110, 111, 112, 113, 114, 115, 116, 117, 0, 0,
0, 0, 0, 0, 0, 0, 68, 0, 0, 0,
0, 0, 0, 0, 0, 89, 51, 0, 0, 0,
0, 0, 52, 0, 33, 33, 50, 51, 0, 51,
0, 33, 33, 52, 53, 52, 57, 0, 0, 0,
0, 0, 57, 0, 0, 0, 0, 0, 82, 0,
46, 130, 128, 0, 33, 33, 46, 80, 0, 0,
0, 33, 33, 0, 45, 0, 0, 25, 25, 0,
45, 0, 0, 0, 25, 25, 0, 57, 0, 57,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 46, 93, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 45, 0, 94, 95, 96,
97, 98, 99, 100, 101, 102, 103, 104, 105, 106,
107, 108, 109, 110, 111, 112, 113, 114, 115, 116,
117, 70, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 70, 70, 70, 70,
70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
70, 70, 70, 70, 70, 70, 70, 70, 70, 70,
68, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 68, 68, 68, 68, 68,
68, 68, 68, 68, 68, 68, 68, 68, 68, 68,
68, 68, 68, 68, 68, 68, 68, 68, 68,
};
static const short yycheck[] = { 10,
42, 43, 34, 34, 44, 93, 41, 44, 0, 40,
36, 60, 34, 10, 34, 46, 34, 63, 40, 258,
40, 63, 40, 34, 46, 36, 46, 10, 46, 40,
41, 42, 43, 256, 36, 46, 47, 34, 258, 36,
256, 256, 34, 40, 41, 47, 262, 262, 40, 46,
47, 34, 63, 36, 46, 34, 10, 40, 41, 10,
91, 40, 301, 46, 47, 60, 44, 46, 262, 91,
61, 91, 94, 91, 94, 121, 125, 256, 123, 299,
91, 61, 36, 262, 62, 36, 61, 41, 57, 124,
41, 61, 61, 47, 91, 61, 47, 61, 124, 91,
42, 123, 94, 259, 260, 261, 296, 297, 91, 265,
86, 87, 91, 124, 262, 94, 262, 259, 260, 261,
94, 262, 124, 265, 259, 260, 261, 124, 262, 262,
265, 123, 262, 259, 260, 261, 62, 10, 93, 265,
262, 124, 266, 267, 268, 269, 270, 271, 258, 258,
91, 45, 257, 10, 299, 10, 36, 301, 26, 54,
68, 78, 73, -1, -1, -1, -1, -1, -1, 257,
124, -1, -1, 124, -1, -1, -1, 93, -1, -1,
-1, -1, -1, -1, 272, 273, 274, 275, 276, 277,
278, 279, 280, 281, 282, 283, 284, 285, 286, 287,
288, 289, 290, 291, 292, 293, 294, 295, -1, -1,
-1, -1, -1, -1, -1, -1, 93, -1, -1, -1,
-1, -1, -1, -1, -1, 257, 257, -1, -1, -1,
-1, -1, 263, -1, 256, 257, 256, 257, -1, 257,
-1, 263, 264, 263, 264, 263, 257, -1, -1, -1,
-1, -1, 263, -1, -1, -1, -1, -1, 300, -1,
257, 301, 299, -1, 256, 257, 263, 298, -1, -1,
-1, 263, 264, -1, 257, -1, -1, 256, 257, -1,
263, -1, -1, -1, 263, 264, -1, 298, -1, 300,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 298, 257, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 298, -1, 272, 273, 274,
275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
295, 257, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, 272, 273, 274, 275,
276, 277, 278, 279, 280, 281, 282, 283, 284, 285,
286, 287, 288, 289, 290, 291, 292, 293, 294, 295,
257, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, 272, 273, 274, 275, 276,
277, 278, 279, 280, 281, 282, 283, 284, 285, 286,
287, 288, 289, 290, 291, 292, 293, 294, 295,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 301
#if YYDEBUG
static const char *yyname[] = {
"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,
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,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,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,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,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,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
"SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
"OPT_PREFIX","OPT_YYCLASS","OPT_HEADER","OPT_EXTRA_TYPE","OPT_TABLES",
"CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL","CCE_DIGIT","CCE_GRAPH",
"CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE","CCE_UPPER","CCE_XDIGIT",
"CCE_NEG_ALNUM","CCE_NEG_ALPHA","CCE_NEG_BLANK","CCE_NEG_CNTRL","CCE_NEG_DIGIT",
"CCE_NEG_GRAPH","CCE_NEG_LOWER","CCE_NEG_PRINT","CCE_NEG_PUNCT","CCE_NEG_SPACE",
"CCE_NEG_UPPER","CCE_NEG_XDIGIT","CCL_OP_DIFF","CCL_OP_UNION",
"BEGIN_REPEAT_POSIX","END_REPEAT_POSIX","BEGIN_REPEAT_FLEX","END_REPEAT_FLEX",
};
static const char *yyrule[] = {
"$accept : goal",
"goal : initlex sect1 sect1end sect2 initforrule",
"initlex :",
"sect1 : sect1 startconddecl namelist1",
"sect1 : sect1 options",
"sect1 :",
"sect1 : error",
"sect1end : SECTEND",
"startconddecl : SCDECL",
"startconddecl : XSCDECL",
"namelist1 : namelist1 NAME",
"namelist1 : NAME",
"namelist1 : error",
"options : OPTION_OP optionlist",
"optionlist : optionlist option",
"optionlist :",
"option : OPT_OUTFILE '=' NAME",
"option : OPT_EXTRA_TYPE '=' NAME",
"option : OPT_PREFIX '=' NAME",
"option : OPT_YYCLASS '=' NAME",
"option : OPT_HEADER '=' NAME",
"option : OPT_TABLES '=' NAME",
"sect2 : sect2 scon initforrule flexrule '\\n'",
"sect2 : sect2 scon '{' sect2 '}'",
"sect2 :",
"initforrule :",
"flexrule : '^' rule",
"flexrule : rule",
"flexrule : EOF_OP",
"flexrule : error",
"scon_stk_ptr :",
"scon : '<' scon_stk_ptr namelist2 '>'",
"scon : '<' '*' '>'",
"scon :",
"namelist2 : namelist2 ',' sconname",
"namelist2 : sconname",
"namelist2 : error",
"sconname : NAME",
"rule : re2 re",
"rule : re2 re '$'",
"rule : re '$'",
"rule : re",
"re : re '|' series",
"re : series",
"re2 : re '/'",
"series : series singleton",
"series : singleton",
"series : series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX",
"series : series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX",
"series : series BEGIN_REPEAT_POSIX NUMBER END_REPEAT_POSIX",
"singleton : singleton '*'",
"singleton : singleton '+'",
"singleton : singleton '?'",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER END_REPEAT_FLEX",
"singleton : '.'",
"singleton : fullccl",
"singleton : PREVCCL",
"singleton : '\"' string '\"'",
"singleton : '(' re ')'",
"singleton : CHAR",
"fullccl : fullccl CCL_OP_DIFF braceccl",
"fullccl : fullccl CCL_OP_UNION braceccl",
"fullccl : braceccl",
"braceccl : '[' ccl ']'",
"braceccl : '[' '^' ccl ']'",
"ccl : ccl CHAR '-' CHAR",
"ccl : ccl CHAR",
"ccl : ccl ccl_expr",
"ccl :",
"ccl_expr : CCE_ALNUM",
"ccl_expr : CCE_ALPHA",
"ccl_expr : CCE_BLANK",
"ccl_expr : CCE_CNTRL",
"ccl_expr : CCE_DIGIT",
"ccl_expr : CCE_GRAPH",
"ccl_expr : CCE_LOWER",
"ccl_expr : CCE_PRINT",
"ccl_expr : CCE_PUNCT",
"ccl_expr : CCE_SPACE",
"ccl_expr : CCE_XDIGIT",
"ccl_expr : CCE_UPPER",
"ccl_expr : CCE_NEG_ALNUM",
"ccl_expr : CCE_NEG_ALPHA",
"ccl_expr : CCE_NEG_BLANK",
"ccl_expr : CCE_NEG_CNTRL",
"ccl_expr : CCE_NEG_DIGIT",
"ccl_expr : CCE_NEG_GRAPH",
"ccl_expr : CCE_NEG_PRINT",
"ccl_expr : CCE_NEG_PUNCT",
"ccl_expr : CCE_NEG_SPACE",
"ccl_expr : CCE_NEG_XDIGIT",
"ccl_expr : CCE_NEG_LOWER",
"ccl_expr : CCE_NEG_UPPER",
"string : string CHAR",
"string :",
};
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
YYSTYPE yyval;
YYSTYPE yylval;
/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#endif
#endif
#define YYINITSTACKSIZE 500
typedef struct {
unsigned stacksize;
short *s_base;
short *s_mark;
short *s_last;
YYSTYPE *l_base;
YYSTYPE *l_mark;
} YYSTACKDATA;
/* variables for the parser stack */
static YYSTACKDATA yystack;
#line 948 "parse.y"
/* build_eof_action - build the "<<EOF>>" action for the active start
* conditions
*/
void build_eof_action()
{
int i;
char action_text[MAXLINE];
for ( i = 1; i <= scon_stk_ptr; ++i )
{
if ( sceof[scon_stk[i]] )
format_pinpoint_message(
"multiple <<EOF>> rules for start condition %s",
scname[scon_stk[i]] );
else
{
sceof[scon_stk[i]] = true;
if (previous_continued_action /* && previous action was regular */)
add_action("YY_RULE_SETUP\n");
snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
scname[scon_stk[i]] );
add_action( action_text );
}
}
line_directive_out( (FILE *) 0, 1 );
/* This isn't a normal rule after all - don't count it as
* such, so we don't have any holes in the rule numbering
* (which make generating "rule can never match" warnings
* more difficult.
*/
--num_rules;
++num_eof_rules;
}
/* format_synerr - write out formatted syntax error */
void format_synerr( msg, arg )
const char *msg, arg[];
{
char errmsg[MAXLINE];
(void) snprintf( errmsg, sizeof(errmsg), msg, arg );
synerr( errmsg );
}
/* synerr - report a syntax error */
void synerr( str )
const char *str;
{
syntaxerror = true;
pinpoint_message( str );
}
/* format_warn - write out formatted warning */
void format_warn( msg, arg )
const char *msg, arg[];
{
char warn_msg[MAXLINE];
snprintf( warn_msg, sizeof(warn_msg), msg, arg );
warn( warn_msg );
}
/* warn - report a warning, unless -w was given */
void warn( str )
const char *str;
{
line_warning( str, linenum );
}
/* format_pinpoint_message - write out a message formatted with one string,
* pinpointing its location
*/
void format_pinpoint_message( msg, arg )
const char *msg, arg[];
{
char errmsg[MAXLINE];
snprintf( errmsg, sizeof(errmsg), msg, arg );
pinpoint_message( errmsg );
}
/* pinpoint_message - write out a message, pinpointing its location */
void pinpoint_message( str )
const char *str;
{
line_pinpoint( str, linenum );
}
/* line_warning - report a warning at a given line, unless -w was given */
void line_warning( str, line )
const char *str;
int line;
{
char warning[MAXLINE];
if ( ! nowarn )
{
snprintf( warning, sizeof(warning), "warning, %s", str );
line_pinpoint( warning, line );
}
}
/* line_pinpoint - write out a message, pinpointing it at the given line */
void line_pinpoint( str, line )
const char *str;
int line;
{
fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
}
/* yyerror - eat up an error message from the parser;
* currently, messages are ignore
*/
void yyerror( msg )
const char *msg;
{
}
#line 656 "parse.c"
#if YYDEBUG
#include <stdio.h> /* needed for printf */
#endif
#include <stdlib.h> /* needed for malloc, etc */
#include <string.h> /* needed for memset */
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data)
{
int i;
unsigned newsize;
short *newss;
YYSTYPE *newvs;
if ((newsize = data->stacksize) == 0)
newsize = YYINITSTACKSIZE;
else if (newsize >= YYMAXDEPTH)
return -1;
else if ((newsize *= 2) > YYMAXDEPTH)
newsize = YYMAXDEPTH;
i = data->s_mark - data->s_base;
newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
if (newss == 0)
return -1;
data->s_base = newss;
data->s_mark = newss + i;
newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
if (newvs == 0)
return -1;
data->l_base = newvs;
data->l_mark = newvs + i;
data->stacksize = newsize;
data->s_last = data->s_base + newsize - 1;
return 0;
}
#if YYPURE || defined(YY_NO_LEAKS)
static void yyfreestack(YYSTACKDATA *data)
{
free(data->s_base);
free(data->l_base);
memset(data, 0, sizeof(*data));
}
#else
#define yyfreestack(data) /* nothing */
#endif
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
YYPARSE_DECL()
{
int yym, yyn, yystate;
#if YYDEBUG
const char *yys;
if ((yys = getenv("YYDEBUG")) != 0)
{
yyn = *yys;
if (yyn >= '0' && yyn <= '9')
yydebug = yyn - '0';
}
#endif
yynerrs = 0;
yyerrflag = 0;
yychar = YYEMPTY;
yystate = 0;
#if YYPURE
memset(&yystack, 0, sizeof(yystack));
#endif
if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
yystack.s_mark = yystack.s_base;
yystack.l_mark = yystack.l_base;
yystate = 0;
*yystack.s_mark = 0;
yyloop:
if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
if (yychar < 0)
{
if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
}
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, shifting to state %d\n",
YYPREFIX, yystate, yytable[yyn]);
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
{
goto yyoverflow;
}
yystate = yytable[yyn];
*++yystack.s_mark = yytable[yyn];
*++yystack.l_mark = yylval;
yychar = YYEMPTY;
if (yyerrflag > 0) --yyerrflag;
goto yyloop;
}
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
{
yyn = yytable[yyn];
goto yyreduce;
}
if (yyerrflag) goto yyinrecovery;
yyerror("syntax error");
goto yyerrlab;
yyerrlab:
++yynerrs;
yyinrecovery:
if (yyerrflag < 3)
{
yyerrflag = 3;
for (;;)
{
if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, error recovery shifting\
to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
{
goto yyoverflow;
}
yystate = yytable[yyn];
*++yystack.s_mark = yytable[yyn];
*++yystack.l_mark = yylval;
goto yyloop;
}
else
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: error recovery discarding state %d\n",
YYPREFIX, *yystack.s_mark);
#endif
if (yystack.s_mark <= yystack.s_base) goto yyabort;
--yystack.s_mark;
--yystack.l_mark;
}
}
}
else
{
if (yychar == 0) goto yyabort;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
YYPREFIX, yystate, yychar, yys);
}
#endif
yychar = YYEMPTY;
goto yyloop;
}
yyreduce:
#if YYDEBUG
if (yydebug)
printf("%sdebug: state %d, reducing by rule %d (%s)\n",
YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
yym = yylen[yyn];
if (yym)
yyval = yystack.l_mark[1-yym];
else
memset(&yyval, 0, sizeof yyval);
switch (yyn)
{
case 1:
#line 119 "parse.y"
{ /* add default rule */
int def_rule;
pat = cclinit();
cclnegate( pat );
def_rule = mkstate( -pat );
/* Remember the number of the default rule so we
* don't generate "can't match" warnings for it.
*/
default_rule = num_rules;
finish_rule( def_rule, false, 0, 0, 0);
for ( i = 1; i <= lastsc; ++i )
scset[i] = mkbranch( scset[i], def_rule );
if ( spprdflt )
add_action(
"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
else
add_action( "ECHO" );
add_action( ";\n\tYY_BREAK\n" );
}
break;
case 2:
#line 148 "parse.y"
{ /* initialize for processing rules */
/* Create default DFA start condition. */
scinstal( "INITIAL", false );
}
break;
case 6:
#line 159 "parse.y"
{ synerr( _("unknown error processing section 1") ); }
break;
case 7:
#line 163 "parse.y"
{
check_options();
scon_stk = allocate_integer_array( lastsc + 1 );
scon_stk_ptr = 0;
}
break;
case 8:
#line 171 "parse.y"
{ xcluflg = false; }
break;
case 9:
#line 174 "parse.y"
{ xcluflg = true; }
break;
case 10:
#line 178 "parse.y"
{ scinstal( nmstr, xcluflg ); }
break;
case 11:
#line 181 "parse.y"
{ scinstal( nmstr, xcluflg ); }
break;
case 12:
#line 184 "parse.y"
{ synerr( _("bad start condition list") ); }
break;
case 16:
#line 195 "parse.y"
{
outfilename = copy_string( nmstr );
did_outfilename = 1;
}
break;
case 17:
#line 200 "parse.y"
{ extra_type = copy_string( nmstr ); }
break;
case 18:
#line 202 "parse.y"
{ prefix = copy_string( nmstr ); }
break;
case 19:
#line 204 "parse.y"
{ yyclass = copy_string( nmstr ); }
break;
case 20:
#line 206 "parse.y"
{ headerfilename = copy_string( nmstr ); }
break;
case 21:
#line 208 "parse.y"
{ tablesext = true; tablesfilename = copy_string( nmstr ); }
break;
case 22:
#line 212 "parse.y"
{ scon_stk_ptr = yystack.l_mark[-3]; }
break;
case 23:
#line 214 "parse.y"
{ scon_stk_ptr = yystack.l_mark[-3]; }
break;
case 25:
#line 219 "parse.y"
{
/* Initialize for a parse of one rule. */
trlcontxt = variable_trail_rule = varlength = false;
trailcnt = headcnt = rulelen = 0;
current_state_type = STATE_NORMAL;
previous_continued_action = continued_action;
in_rule = true;
new_rule();
}
break;
case 26:
#line 232 "parse.y"
{
pat = yystack.l_mark[0];
finish_rule( pat, variable_trail_rule,
headcnt, trailcnt , previous_continued_action);
if ( scon_stk_ptr > 0 )
{
for ( i = 1; i <= scon_stk_ptr; ++i )
scbol[scon_stk[i]] =
mkbranch( scbol[scon_stk[i]],
pat );
}
else
{
/* Add to all non-exclusive start conditions,
* including the default (0) start condition.
*/
for ( i = 1; i <= lastsc; ++i )
if ( ! scxclu[i] )
scbol[i] = mkbranch( scbol[i],
pat );
}
if ( ! bol_needed )
{
bol_needed = true;
if ( performance_report > 1 )
pinpoint_message(
"'^' operator results in sub-optimal performance" );
}
}
break;
case 27:
#line 268 "parse.y"
{
pat = yystack.l_mark[0];
finish_rule( pat, variable_trail_rule,
headcnt, trailcnt , previous_continued_action);
if ( scon_stk_ptr > 0 )
{
for ( i = 1; i <= scon_stk_ptr; ++i )
scset[scon_stk[i]] =
mkbranch( scset[scon_stk[i]],
pat );
}
else
{
for ( i = 1; i <= lastsc; ++i )
if ( ! scxclu[i] )
scset[i] =
mkbranch( scset[i],
pat );
}
}
break;
case 28:
#line 292 "parse.y"
{
if ( scon_stk_ptr > 0 )
build_eof_action();
else
{
/* This EOF applies to all start conditions
* which don't already have EOF actions.
*/
for ( i = 1; i <= lastsc; ++i )
if ( ! sceof[i] )
scon_stk[++scon_stk_ptr] = i;
if ( scon_stk_ptr == 0 )
warn(
"all start conditions already have <<EOF>> rules" );
else
build_eof_action();
}
}
break;
case 29:
#line 315 "parse.y"
{ synerr( _("unrecognized rule") ); }
break;
case 30:
#line 319 "parse.y"
{ yyval = scon_stk_ptr; }
break;
case 31:
#line 323 "parse.y"
{ yyval = yystack.l_mark[-2]; }
break;
case 32:
#line 326 "parse.y"
{
yyval = scon_stk_ptr;
for ( i = 1; i <= lastsc; ++i )
{
int j;
for ( j = 1; j <= scon_stk_ptr; ++j )
if ( scon_stk[j] == i )
break;
if ( j > scon_stk_ptr )
scon_stk[++scon_stk_ptr] = i;
}
}
break;
case 33:
#line 343 "parse.y"
{ yyval = scon_stk_ptr; }
break;
case 36:
#line 351 "parse.y"
{ synerr( _("bad start condition list") ); }
break;
case 37:
#line 355 "parse.y"
{
if ( (scnum = sclookup( nmstr )) == 0 )
format_pinpoint_message(
"undeclared start condition %s",
nmstr );
else
{
for ( i = 1; i <= scon_stk_ptr; ++i )
if ( scon_stk[i] == scnum )
{
format_warn(
"<%s> specified twice",
scname[scnum] );
break;
}
if ( i > scon_stk_ptr )
scon_stk[++scon_stk_ptr] = scnum;
}
}
break;
case 38:
#line 378 "parse.y"
{
if ( transchar[lastst[yystack.l_mark[0]]] != SYM_EPSILON )
/* Provide final transition \now/ so it
* will be marked as a trailing context
* state.
*/
yystack.l_mark[0] = link_machines( yystack.l_mark[0],
mkstate( SYM_EPSILON ) );
mark_beginning_as_normal( yystack.l_mark[0] );
current_state_type = STATE_NORMAL;
if ( previous_continued_action )
{
/* We need to treat this as variable trailing
* context so that the backup does not happen
* in the action but before the action switch
* statement. If the backup happens in the
* action, then the rules "falling into" this
* one's action will *also* do the backup,
* erroneously.
*/
if ( ! varlength || headcnt != 0 )
warn(
"trailing context made variable due to preceding '|' action" );
/* Mark as variable. */
varlength = true;
headcnt = 0;
}
if ( lex_compat || (varlength && headcnt == 0) )
{ /* variable trailing context rule */
/* Mark the first part of the rule as the
* accepting "head" part of a trailing
* context rule.
*
* By the way, we didn't do this at the
* beginning of this production because back
* then current_state_type was set up for a
* trail rule, and add_accept() can create
* a new state ...
*/
add_accept( yystack.l_mark[-1],
num_rules | YY_TRAILING_HEAD_MASK );
variable_trail_rule = true;
}
else
trailcnt = rulelen;
yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
}
break;
case 39:
#line 434 "parse.y"
{ synerr( _("trailing context used twice") ); }
break;
case 40:
#line 437 "parse.y"
{
headcnt = 0;
trailcnt = 1;
rulelen = 1;
varlength = false;
current_state_type = STATE_TRAILING_CONTEXT;
if ( trlcontxt )
{
synerr( _("trailing context used twice") );
yyval = mkstate( SYM_EPSILON );
}
else if ( previous_continued_action )
{
/* See the comment in the rule for "re2 re"
* above.
*/
warn(
"trailing context made variable due to preceding '|' action" );
varlength = true;
}
if ( lex_compat || varlength )
{
/* Again, see the comment in the rule for
* "re2 re" above.
*/
add_accept( yystack.l_mark[-1],
num_rules | YY_TRAILING_HEAD_MASK );
variable_trail_rule = true;
}
trlcontxt = true;
eps = mkstate( SYM_EPSILON );
yyval = link_machines( yystack.l_mark[-1],
link_machines( eps, mkstate( '\n' ) ) );
}
break;
case 41:
#line 480 "parse.y"
{
yyval = yystack.l_mark[0];
if ( trlcontxt )
{
if ( lex_compat || (varlength && headcnt == 0) )
/* Both head and trail are
* variable-length.
*/
variable_trail_rule = true;
else
trailcnt = rulelen;
}
}
break;
case 42:
#line 498 "parse.y"
{
varlength = true;
yyval = mkor( yystack.l_mark[-2], yystack.l_mark[0] );
}
break;
case 43:
#line 504 "parse.y"
{ yyval = yystack.l_mark[0]; }
break;
case 44:
#line 509 "parse.y"
{
/* This rule is written separately so the
* reduction will occur before the trailing
* series is parsed.
*/
if ( trlcontxt )
synerr( _("trailing context used twice") );
else
trlcontxt = true;
if ( varlength )
/* We hope the trailing context is
* fixed-length.
*/
varlength = false;
else
headcnt = rulelen;
rulelen = 0;
current_state_type = STATE_TRAILING_CONTEXT;
yyval = yystack.l_mark[-1];
}
break;
case 45:
#line 536 "parse.y"
{
/* This is where concatenation of adjacent patterns
* gets done.
*/
yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
}
break;
case 46:
#line 544 "parse.y"
{ yyval = yystack.l_mark[0]; }
break;
case 47:
#line 547 "parse.y"
{
varlength = true;
if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
{
synerr( _("bad iteration values") );
yyval = yystack.l_mark[-5];
}
else
{
if ( yystack.l_mark[-3] == 0 )
{
if ( yystack.l_mark[-1] <= 0 )
{
synerr(
_("bad iteration values") );
yyval = yystack.l_mark[-5];
}
else
yyval = mkopt(
mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
}
else
yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
}
}
break;
case 48:
#line 575 "parse.y"
{
varlength = true;
if ( yystack.l_mark[-2] <= 0 )
{
synerr( _("iteration value must be positive") );
yyval = yystack.l_mark[-4];
}
else
yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
}
break;
case 49:
#line 589 "parse.y"
{
/* The series could be something like "(foo)",
* in which case we have no idea what its length
* is, so we punt here.
*/
varlength = true;
if ( yystack.l_mark[-1] <= 0 )
{
synerr( _("iteration value must be positive")
);
yyval = yystack.l_mark[-3];
}
else
yyval = link_machines( yystack.l_mark[-3],
copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
}
break;
case 50:
#line 611 "parse.y"
{
varlength = true;
yyval = mkclos( yystack.l_mark[-1] );
}
break;
case 51:
#line 618 "parse.y"
{
varlength = true;
yyval = mkposcl( yystack.l_mark[-1] );
}
break;
case 52:
#line 624 "parse.y"
{
varlength = true;
yyval = mkopt( yystack.l_mark[-1] );
}
break;
case 53:
#line 630 "parse.y"
{
varlength = true;
if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
{
synerr( _("bad iteration values") );
yyval = yystack.l_mark[-5];
}
else
{
if ( yystack.l_mark[-3] == 0 )
{
if ( yystack.l_mark[-1] <= 0 )
{
synerr(
_("bad iteration values") );
yyval = yystack.l_mark[-5];
}
else
yyval = mkopt(
mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
}
else
yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
}
}
break;
case 54:
#line 658 "parse.y"
{
varlength = true;
if ( yystack.l_mark[-2] <= 0 )
{
synerr( _("iteration value must be positive") );
yyval = yystack.l_mark[-4];
}
else
yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
}
break;
case 55:
#line 672 "parse.y"
{
/* The singleton could be something like "(foo)",
* in which case we have no idea what its length
* is, so we punt here.
*/
varlength = true;
if ( yystack.l_mark[-1] <= 0 )
{
synerr( _("iteration value must be positive") );
yyval = yystack.l_mark[-3];
}
else
yyval = link_machines( yystack.l_mark[-3],
copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
}
break;
case 56:
#line 691 "parse.y"
{
if ( ! madeany )
{
/* Create the '.' character class. */
ccldot = cclinit();
ccladd( ccldot, '\n' );
cclnegate( ccldot );
if ( useecs )
mkeccl( ccltbl + cclmap[ccldot],
ccllen[ccldot], nextecm,
ecgroup, csize, csize );
/* Create the (?s:'.') character class. */
cclany = cclinit();
cclnegate( cclany );
if ( useecs )
mkeccl( ccltbl + cclmap[cclany],
ccllen[cclany], nextecm,
ecgroup, csize, csize );
madeany = true;
}
++rulelen;
if (sf_dot_all())
yyval = mkstate( -cclany );
else
yyval = mkstate( -ccldot );
}
break;
case 57:
#line 725 "parse.y"
{
/* Sort characters for fast searching.
*/
qsort( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]], sizeof (*ccltbl), cclcmp );
if ( useecs )
mkeccl( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]],
nextecm, ecgroup, csize, csize );
++rulelen;
if (ccl_has_nl[yystack.l_mark[0]])
rule_has_nl[num_rules] = true;
yyval = mkstate( -yystack.l_mark[0] );
}
break;
case 58:
#line 743 "parse.y"
{
++rulelen;
if (ccl_has_nl[yystack.l_mark[0]])
rule_has_nl[num_rules] = true;
yyval = mkstate( -yystack.l_mark[0] );
}
break;
case 59:
#line 753 "parse.y"
{ yyval = yystack.l_mark[-1]; }
break;
case 60:
#line 756 "parse.y"
{ yyval = yystack.l_mark[-1]; }
break;
case 61:
#line 759 "parse.y"
{
++rulelen;
if (yystack.l_mark[0] == nlch)
rule_has_nl[num_rules] = true;
if (sf_case_ins() && has_case(yystack.l_mark[0]))
/* create an alternation, as in (a|A) */
yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
else
yyval = mkstate( yystack.l_mark[0] );
}
break;
case 62:
#line 773 "parse.y"
{ yyval = ccl_set_diff (yystack.l_mark[-2], yystack.l_mark[0]); }
break;
case 63:
#line 774 "parse.y"
{ yyval = ccl_set_union (yystack.l_mark[-2], yystack.l_mark[0]); }
break;
case 65:
#line 780 "parse.y"
{ yyval = yystack.l_mark[-1]; }
break;
case 66:
#line 783 "parse.y"
{
cclnegate( yystack.l_mark[-1] );
yyval = yystack.l_mark[-1];
}
break;
case 67:
#line 790 "parse.y"
{
if (sf_case_ins())
{
/* If one end of the range has case and the other
* does not, or the cases are different, then we're not
* sure what range the user is trying to express.
* Examples: [@-z] or [S-t]
*/
if (has_case (yystack.l_mark[-2]) != has_case (yystack.l_mark[0])
|| (has_case (yystack.l_mark[-2]) && (b_islower (yystack.l_mark[-2]) != b_islower (yystack.l_mark[0])))
|| (has_case (yystack.l_mark[-2]) && (b_isupper (yystack.l_mark[-2]) != b_isupper (yystack.l_mark[0]))))
format_warn3 (
_("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
yystack.l_mark[-2], yystack.l_mark[0]);
/* If the range spans uppercase characters but not
* lowercase (or vice-versa), then should we automatically
* include lowercase characters in the range?
* Example: [@-_] spans [a-z] but not [A-Z]
*/
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]))
format_warn3 (
_("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
yystack.l_mark[-2], yystack.l_mark[0]);
}
if ( yystack.l_mark[-2] > yystack.l_mark[0] )
synerr( _("negative range in character class") );
else
{
for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
ccladd( yystack.l_mark[-3], i );
/* Keep track if this ccl is staying in
* alphabetical order.
*/
cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
lastchar = yystack.l_mark[0];
/* Do it again for upper/lowercase */
if (sf_case_ins() && has_case(yystack.l_mark[-2]) && has_case(yystack.l_mark[0])){
yystack.l_mark[-2] = reverse_case (yystack.l_mark[-2]);
yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
ccladd( yystack.l_mark[-3], i );
cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
lastchar = yystack.l_mark[0];
}
}
yyval = yystack.l_mark[-3];
}
break;
case 68:
#line 850 "parse.y"
{
ccladd( yystack.l_mark[-1], yystack.l_mark[0] );
cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
lastchar = yystack.l_mark[0];
/* Do it again for upper/lowercase */
if (sf_case_ins() && has_case(yystack.l_mark[0])){
yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
ccladd (yystack.l_mark[-1], yystack.l_mark[0]);
cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
lastchar = yystack.l_mark[0];
}
yyval = yystack.l_mark[-1];
}
break;
case 69:
#line 868 "parse.y"
{
/* Too hard to properly maintain cclsorted. */
cclsorted = false;
yyval = yystack.l_mark[-1];
}
break;
case 70:
#line 875 "parse.y"
{
cclsorted = true;
lastchar = 0;
currccl = yyval = cclinit();
}
break;
case 71:
#line 883 "parse.y"
{ CCL_EXPR(isalnum); }
break;
case 72:
#line 884 "parse.y"
{ CCL_EXPR(isalpha); }
break;
case 73:
#line 885 "parse.y"
{ CCL_EXPR(IS_BLANK); }
break;
case 74:
#line 886 "parse.y"
{ CCL_EXPR(iscntrl); }
break;
case 75:
#line 887 "parse.y"
{ CCL_EXPR(isdigit); }
break;
case 76:
#line 888 "parse.y"
{ CCL_EXPR(isgraph); }
break;
case 77:
#line 889 "parse.y"
{
CCL_EXPR(islower);
if (sf_case_ins())
CCL_EXPR(isupper);
}
break;
case 78:
#line 894 "parse.y"
{ CCL_EXPR(isprint); }
break;
case 79:
#line 895 "parse.y"
{ CCL_EXPR(ispunct); }
break;
case 80:
#line 896 "parse.y"
{ CCL_EXPR(isspace); }
break;
case 81:
#line 897 "parse.y"
{ CCL_EXPR(isxdigit); }
break;
case 82:
#line 898 "parse.y"
{
CCL_EXPR(isupper);
if (sf_case_ins())
CCL_EXPR(islower);
}
break;
case 83:
#line 904 "parse.y"
{ CCL_NEG_EXPR(isalnum); }
break;
case 84:
#line 905 "parse.y"
{ CCL_NEG_EXPR(isalpha); }
break;
case 85:
#line 906 "parse.y"
{ CCL_NEG_EXPR(IS_BLANK); }
break;
case 86:
#line 907 "parse.y"
{ CCL_NEG_EXPR(iscntrl); }
break;
case 87:
#line 908 "parse.y"
{ CCL_NEG_EXPR(isdigit); }
break;
case 88:
#line 909 "parse.y"
{ CCL_NEG_EXPR(isgraph); }
break;
case 89:
#line 910 "parse.y"
{ CCL_NEG_EXPR(isprint); }
break;
case 90:
#line 911 "parse.y"
{ CCL_NEG_EXPR(ispunct); }
break;
case 91:
#line 912 "parse.y"
{ CCL_NEG_EXPR(isspace); }
break;
case 92:
#line 913 "parse.y"
{ CCL_NEG_EXPR(isxdigit); }
break;
case 93:
#line 914 "parse.y"
{
if ( sf_case_ins() )
warn(_("[:^lower:] is ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(islower);
}
break;
case 94:
#line 920 "parse.y"
{
if ( sf_case_ins() )
warn(_("[:^upper:] ambiguous in case insensitive scanner"));
else
CCL_NEG_EXPR(isupper);
}
break;
case 95:
#line 929 "parse.y"
{
if ( yystack.l_mark[0] == nlch )
rule_has_nl[num_rules] = true;
++rulelen;
if (sf_case_ins() && has_case(yystack.l_mark[0]))
yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
else
yyval = mkstate (yystack.l_mark[0]);
yyval = link_machines( yystack.l_mark[-1], yyval);
}
break;
case 96:
#line 944 "parse.y"
{ yyval = mkstate( SYM_EPSILON ); }
break;
#line 1787 "parse.c"
}
yystack.s_mark -= yym;
yystate = *yystack.s_mark;
yystack.l_mark -= yym;
yym = yylhs[yyn];
if (yystate == 0 && yym == 0)
{
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state 0 to\
state %d\n", YYPREFIX, YYFINAL);
#endif
yystate = YYFINAL;
*++yystack.s_mark = YYFINAL;
*++yystack.l_mark = yyval;
if (yychar < 0)
{
if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
if (yydebug)
{
yys = 0;
if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
if (!yys) yys = "illegal-symbol";
printf("%sdebug: state %d, reading %d (%s)\n",
YYPREFIX, YYFINAL, yychar, yys);
}
#endif
}
if (yychar == 0) goto yyaccept;
goto yyloop;
}
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
yystate = yytable[yyn];
else
yystate = yydgoto[yym];
#if YYDEBUG
if (yydebug)
printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
#endif
if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
{
goto yyoverflow;
}
*++yystack.s_mark = (short) yystate;
*++yystack.l_mark = yyval;
goto yyloop;
yyoverflow:
yyerror("yacc stack overflow");
yyabort:
yyfreestack(&yystack);
return (1);
yyaccept:
yyfreestack(&yystack);
return (0);
}
Reference in New Issue View Git Blame Copy Permalink