usr.bin/lex/initparse.c

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