commands/flex-2.5.4/MISC/parse.c

   1 #ifndef lint
   2 static char yysccsid[] = "@(#)yaccpar   1.9 (Berkeley) 02/21/93";
   3 #endif
   4 #define YYBYACC 1
   5 #define YYMAJOR 1
   6 #define YYMINOR 9
   7 #define yyclearin (yychar=(-1))
   8 #define yyerrok (yyerrflag=0)
   9 #define YYRECOVERING (yyerrflag!=0)
  10 #define YYPREFIX "yy"
  11 #line 10 "./parse.y"
  12 /*-
  13  * Copyright (c) 1990 The Regents of the University of California.
  14  * All rights reserved.
  15  *
  16  * This code is derived from software contributed to Berkeley by
  17  * Vern Paxson.
  18  *
  19  * The United States Government has rights in this work pursuant
  20  * to contract no. DE-AC03-76SF00098 between the United States
  21  * Department of Energy and the University of California.
  22  *
  23  * Redistribution and use in source and binary forms with or without
  24  * modification are permitted provided that: (1) source distributions retain
  25  * this entire copyright notice and comment, and (2) distributions including
  26  * binaries display the following acknowledgement:  ``This product includes
  27  * software developed by the University of California, Berkeley and its
  28  * contributors'' in the documentation or other materials provided with the
  29  * distribution and in all advertising materials mentioning features or use
  30  * of this software.  Neither the name of the University nor the names of
  31  * its contributors may be used to endorse or promote products derived from
  32  * this software without specific prior written permission.
  33  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  34  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  35  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  36  */
  37
  38 /* $Header$ */
  39
  40
  41 /* Some versions of bison are broken in that they use alloca() but don't
  42  * declare it properly.  The following is the patented (just kidding!)
  43  * #ifdef chud to fix the problem, courtesy of Francois Pinard.
  44  */
  45 #ifdef YYBISON
  46 /* AIX requires this to be the first thing in the file.  What a piece.  */
  47 # ifdef _AIX
  48  #pragma alloca
  49 # endif
  50 #endif
  51
  52 #include "flexdef.h"
  53
  54 /* The remainder of the alloca() cruft has to come after including flexdef.h,
  55  * so HAVE_ALLOCA_H is (possibly) defined.
  56  */
  57 #ifdef YYBISON
  58 # ifdef __GNUC__
  59 #  ifndef alloca
  60 #   define alloca __builtin_alloca
  61 #  endif
  62 # else
  63 #  if HAVE_ALLOCA_H
  64 #   include <alloca.h>
  65 #  else
  66 #   ifdef __hpux
  67 void *alloca ();
  68 #   else
  69 #    ifdef __TURBOC__
  70 #     include <malloc.h>
  71 #    else
  72 char *alloca ();
  73 #    endif
  74 #   endif
  75 #  endif
  76 # endif
  77 #endif
  78
  79 /* Bletch, ^^^^ that was ugly! */
  80
  81
  82 int pat, scnum, eps, headcnt, trailcnt, anyccl, lastchar, i, rulelen;
  83 int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
  84
  85 int *scon_stk;
  86 int scon_stk_ptr;
  87
  88 static int madeany = false;  /* whether we've made the '.' character class */
  89 int previous_continued_action;  /* whether the previous rule's action was '|' */
  90
  91 /* Expand a POSIX character class expression. */
  92 #define CCL_EXPR(func) \
  93         { \
  94         int c; \
  95         for ( c = 0; c < csize; ++c ) \
  96                 if ( isascii(c) && func(c) ) \
  97                         ccladd( currccl, c ); \
  98         }
  99
 100 /* While POSIX defines isblank(), it's not ANSI C. */
 101 #define IS_BLANK(c) ((c) == ' ' || (c) == '\t')
 102
 103 /* On some over-ambitious machines, such as DEC Alpha's, the default
 104  * token type is "long" instead of "int"; this leads to problems with
 105  * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
 106  * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
 107  * following should ensure that the default token type is "int".
 108  */
 109 #define YYSTYPE int
 110
 111 #line 112 "y.tab.c"
 112 #define CHAR 257
 113 #define NUMBER 258
 114 #define SECTEND 259
 115 #define SCDECL 260
 116 #define XSCDECL 261
 117 #define NAME 262
 118 #define PREVCCL 263
 119 #define EOF_OP 264
 120 #define OPTION_OP 265
 121 #define OPT_OUTFILE 266
 122 #define OPT_PREFIX 267
 123 #define OPT_YYCLASS 268
 124 #define CCE_ALNUM 269
 125 #define CCE_ALPHA 270
 126 #define CCE_BLANK 271
 127 #define CCE_CNTRL 272
 128 #define CCE_DIGIT 273
 129 #define CCE_GRAPH 274
 130 #define CCE_LOWER 275
 131 #define CCE_PRINT 276
 132 #define CCE_PUNCT 277
 133 #define CCE_SPACE 278
 134 #define CCE_UPPER 279
 135 #define CCE_XDIGIT 280
 136 #define YYERRCODE 256
 137 short yylhs[] = {                                        -1,
 138     0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
 139     7,    7,    8,    9,    9,   10,   10,   10,    4,    4,
 140     4,    5,   12,   12,   12,   12,   14,   11,   11,   11,
 141    15,   15,   15,   16,   13,   13,   13,   13,   18,   18,
 142    17,   19,   19,   20,   20,   20,   20,   20,   20,   20,
 143    20,   20,   20,   20,   20,   21,   21,   23,   23,   23,
 144    23,   24,   24,   24,   24,   24,   24,   24,   24,   24,
 145    24,   24,   24,   22,   22,
 146 };
 147 short yylen[] = {                                         2,
 148     5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
 149     1,    1,    2,    2,    0,    3,    3,    3,    5,    5,
 150     0,    0,    2,    1,    1,    1,    0,    4,    3,    0,
 151     3,    1,    1,    1,    2,    3,    2,    1,    3,    1,
 152     2,    2,    1,    2,    2,    2,    6,    5,    4,    1,
 153     1,    1,    3,    3,    1,    3,    4,    4,    2,    2,
 154     0,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 155     1,    1,    1,    2,    0,
 156 };
 157 short yydefred[] = {                                      2,
 158     0,    0,    6,    0,    7,    8,    9,   15,   21,    0,
 159     4,    0,    0,   12,   11,    0,    0,    0,    0,   14,
 160     0,    1,    0,   10,    0,    0,    0,    0,    0,   21,
 161     0,   16,   17,   18,   29,   33,   34,    0,   32,    0,
 162    26,   55,   52,   25,    0,   50,   75,    0,    0,    0,
 163    24,    0,    0,    0,    0,   51,   28,    0,   20,   23,
 164     0,    0,   61,    0,   19,    0,   37,    0,   41,    0,
 165     0,   44,   45,   46,   31,   74,   53,   54,    0,    0,
 166    62,   63,   64,   65,   66,   67,   68,   69,   70,   71,
 167    72,   73,   56,   60,   36,    0,    0,   57,    0,   49,
 168     0,   58,    0,   48,   47,
 169 };
 170 short yydgoto[] = {                                       1,
 171     2,    4,    9,   13,   22,   10,   16,   11,   12,   20,
 172    23,   50,   51,   29,   38,   39,   52,   53,   54,   55,
 173    56,   61,   64,   94,
 174 };
 175 short yysindex[] = {                                      0,
 176     0, -235,    0, -191,    0,    0,    0,    0,    0, -207,
 177     0, -215,  -18,    0,    0, -202,    4,   26,   32,    0,
 178    41,    0,  -35,    0, -168, -166, -165,   38, -180,    0,
 179   -30,    0,    0,    0,    0,    0,    0,  -16,    0,  -40,
 180     0,    0,    0,    0,   -2,    0,    0,   -2,    8,   93,
 181     0,   -2,  -25,   -2,   15,    0,    0, -153,    0,    0,
 182   -27,  -26,    0,  -88,    0,  -23,    0,   -2,    0,   15,
 183  -150,    0,    0,    0,    0,    0,    0,    0,   -3,   65,
 184     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 185     0,    0,    0,    0,    0,   -2,  -21,    0, -145,    0,
 186  -116,    0,  -12,    0,    0,
 187 };
 188 short yyrindex[] = {                                      0,
 189     0, -188,    0,    0,    0,    0,    0,    0,    0,    0,
 190     0, -154,    1,    0,    0, -140,    0,    0,    0,    0,
 191  -176,    0,  -28,    0,    0,    0,    0,    0,    0,    0,
 192     0,    0,    0,    0,    0,    0,    0,    0,    0,  -32,
 193     0,    0,    0,    0,    0,    0,    0,    0,   22,    0,
 194     0,    0,  106,    7,  -10,    0,    0,    0,    0,    0,
 195     0,    0,    0,    0,    0,  108,    0,    0,    0,   -7,
 196     0,    0,    0,    0,    0,    0,    0,    0,    0,   46,
 197     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 198     0,    0,    0,    0,    0,    9,    0,    0,    0,    0,
 199     0,    0,    0,    0,    0,
 200 };
 201 short yygindex[] = {                                      0,
 202     0,    0,    0,   92,  100,    0,    0,    0,    0,    0,
 203     0,    0,   81,    0,    0,   69,    0,   27,   60,  -29,
 204     0,    0,   66,    0,
 205 };
 206 #define YYTABLESIZE 326
 207 short yytable[] = {                                      43,
 208    22,   30,   42,   47,   93,   22,   77,   30,  104,   48,
 209    67,   22,   95,   30,   78,   46,   40,   22,   39,   21,
 210     3,   69,  101,   43,   70,   43,   42,   58,   42,   43,
 211    43,   47,   42,   42,   30,   43,   43,   48,   42,   42,
 212    30,   21,   40,   46,   39,   57,   30,   40,   14,   39,
 213    17,   18,   19,   40,   15,   39,   72,   73,   30,   24,
 214    49,   30,   22,   45,   25,   22,   70,    5,    6,    7,
 215     5,    5,    5,    8,   62,   36,    5,   74,   66,   27,
 216    43,   37,   28,   42,   59,   27,   26,   30,   49,   98,
 217    30,   30,   27,   32,   30,   33,   34,   68,   68,   35,
 218    68,   63,   65,  100,   13,   13,   13,   97,   37,   99,
 219    13,  102,  105,   43,   61,   38,   42,   35,    3,    3,
 220     3,   40,   31,   30,    3,   60,   75,   96,   79,    0,
 221    40,    0,   39,    0,    0,    0,    0,   71,   59,    0,
 222     0,  103,    0,    0,    0,    0,    0,    0,    0,    0,
 223     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 224     0,    0,    0,    0,    0,    0,    0,    0,   80,    0,
 225     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 226    81,   82,   83,   84,   85,   86,   87,   88,   89,   90,
 227    91,   92,    0,    0,    0,    0,    0,    0,    0,    0,
 228     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 229     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 230     0,    0,    0,   30,   30,   41,   42,   22,   22,   76,
 231    30,   30,   43,   44,   22,   22,    0,    0,    0,    0,
 232     0,    0,    0,    0,    0,    0,   43,    0,    0,   42,
 233     0,    0,   43,   80,   42,   42,   30,   30,    0,    0,
 234    43,    0,    0,   30,   30,   81,   82,   83,   84,   85,
 235    86,   87,   88,   89,   90,   91,   92,    0,   61,    0,
 236     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 237    61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
 238    61,   61,   59,    0,    0,    0,    0,    0,    0,    0,
 239     0,    0,    0,    0,   59,   59,   59,   59,   59,   59,
 240    59,   59,   59,   59,   59,   59,
 241 };
 242 short yycheck[] = {                                      10,
 243     0,   34,   10,   34,   93,   34,   34,   40,  125,   40,
 244    36,   40,   36,   46,   41,   46,   10,   46,   10,   60,
 245   256,   47,   44,   34,   54,   36,   34,   44,   36,   40,
 246    41,   34,   40,   41,   34,   46,   47,   40,   46,   47,
 247    40,   60,   36,   46,   36,   62,   46,   41,  256,   41,
 248   266,  267,  268,   47,  262,   47,   42,   43,   91,  262,
 249    91,   94,   91,   94,   61,   94,   96,  259,  260,  261,
 250   259,  260,  261,  265,   48,  256,  265,   63,   52,  256,
 251    91,  262,   42,   91,  125,  262,   61,  123,   91,   93,
 252   123,   91,   61,  262,   94,  262,  262,  124,  124,   62,
 253   124,   94,   10,  125,  259,  260,  261,  258,  262,   45,
 254   265,  257,  125,  124,   93,   10,  124,   10,  259,  260,
 255   261,   30,   23,  123,  265,   45,   58,   68,   63,   -1,
 256   124,   -1,  124,   -1,   -1,   -1,   -1,  123,   93,   -1,
 257    -1,  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 258    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 259    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,
 260    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 261   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
 262   279,  280,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 263    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 264    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 265    -1,   -1,   -1,  256,  257,  256,  257,  256,  257,  257,
 266   263,  264,  263,  264,  263,  264,   -1,   -1,   -1,   -1,
 267    -1,   -1,   -1,   -1,   -1,   -1,  257,   -1,   -1,  257,
 268    -1,   -1,  263,  257,  257,  263,  256,  257,   -1,   -1,
 269   263,   -1,   -1,  263,  264,  269,  270,  271,  272,  273,
 270   274,  275,  276,  277,  278,  279,  280,   -1,  257,   -1,
 271    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 272   269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
 273   279,  280,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 274    -1,   -1,   -1,   -1,  269,  270,  271,  272,  273,  274,
 275   275,  276,  277,  278,  279,  280,
 276 };
 277 #define YYFINAL 1
 278 #ifndef YYDEBUG
 279 #define YYDEBUG 0
 280 #endif
 281 #define YYMAXTOKEN 280
 282 #if YYDEBUG
 283 char *yyname[] = {
 284 "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,
 285 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
 286 0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 287 0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 288 0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 289 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 290 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 291 0,0,0,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",
 292 "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
 293 "OPT_PREFIX","OPT_YYCLASS","CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL",
 294 "CCE_DIGIT","CCE_GRAPH","CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE",
 295 "CCE_UPPER","CCE_XDIGIT",
 296 };
 297 char *yyrule[] = {
 298 "$accept : goal",
 299 "goal : initlex sect1 sect1end sect2 initforrule",
 300 "initlex :",
 301 "sect1 : sect1 startconddecl namelist1",
 302 "sect1 : sect1 options",
 303 "sect1 :",
 304 "sect1 : error",
 305 "sect1end : SECTEND",
 306 "startconddecl : SCDECL",
 307 "startconddecl : XSCDECL",
 308 "namelist1 : namelist1 NAME",
 309 "namelist1 : NAME",
 310 "namelist1 : error",
 311 "options : OPTION_OP optionlist",
 312 "optionlist : optionlist option",
 313 "optionlist :",
 314 "option : OPT_OUTFILE '=' NAME",
 315 "option : OPT_PREFIX '=' NAME",
 316 "option : OPT_YYCLASS '=' NAME",
 317 "sect2 : sect2 scon initforrule flexrule '\\n'",
 318 "sect2 : sect2 scon '{' sect2 '}'",
 319 "sect2 :",
 320 "initforrule :",
 321 "flexrule : '^' rule",
 322 "flexrule : rule",
 323 "flexrule : EOF_OP",
 324 "flexrule : error",
 325 "scon_stk_ptr :",
 326 "scon : '<' scon_stk_ptr namelist2 '>'",
 327 "scon : '<' '*' '>'",
 328 "scon :",
 329 "namelist2 : namelist2 ',' sconname",
 330 "namelist2 : sconname",
 331 "namelist2 : error",
 332 "sconname : NAME",
 333 "rule : re2 re",
 334 "rule : re2 re '$'",
 335 "rule : re '$'",
 336 "rule : re",
 337 "re : re '|' series",
 338 "re : series",
 339 "re2 : re '/'",
 340 "series : series singleton",
 341 "series : singleton",
 342 "singleton : singleton '*'",
 343 "singleton : singleton '+'",
 344 "singleton : singleton '?'",
 345 "singleton : singleton '{' NUMBER ',' NUMBER '}'",
 346 "singleton : singleton '{' NUMBER ',' '}'",
 347 "singleton : singleton '{' NUMBER '}'",
 348 "singleton : '.'",
 349 "singleton : fullccl",
 350 "singleton : PREVCCL",
 351 "singleton : '\"' string '\"'",
 352 "singleton : '(' re ')'",
 353 "singleton : CHAR",
 354 "fullccl : '[' ccl ']'",
 355 "fullccl : '[' '^' ccl ']'",
 356 "ccl : ccl CHAR '-' CHAR",
 357 "ccl : ccl CHAR",
 358 "ccl : ccl ccl_expr",
 359 "ccl :",
 360 "ccl_expr : CCE_ALNUM",
 361 "ccl_expr : CCE_ALPHA",
 362 "ccl_expr : CCE_BLANK",
 363 "ccl_expr : CCE_CNTRL",
 364 "ccl_expr : CCE_DIGIT",
 365 "ccl_expr : CCE_GRAPH",
 366 "ccl_expr : CCE_LOWER",
 367 "ccl_expr : CCE_PRINT",
 368 "ccl_expr : CCE_PUNCT",
 369 "ccl_expr : CCE_SPACE",
 370 "ccl_expr : CCE_UPPER",
 371 "ccl_expr : CCE_XDIGIT",
 372 "string : string CHAR",
 373 "string :",
 374 };
 375 #endif
 376 #ifndef YYSTYPE
 377 typedef int YYSTYPE;
 378 #endif
 379 #ifdef YYSTACKSIZE
 380 #undef YYMAXDEPTH
 381 #define YYMAXDEPTH YYSTACKSIZE
 382 #else
 383 #ifdef YYMAXDEPTH
 384 #define YYSTACKSIZE YYMAXDEPTH
 385 #else
 386 #define YYSTACKSIZE 500
 387 #define YYMAXDEPTH 500
 388 #endif
 389 #endif
 390 int yydebug;
 391 int yynerrs;
 392 int yyerrflag;
 393 int yychar;
 394 short *yyssp;
 395 YYSTYPE *yyvsp;
 396 YYSTYPE yyval;
 397 YYSTYPE yylval;
 398 short yyss[YYSTACKSIZE];
 399 YYSTYPE yyvs[YYSTACKSIZE];
 400 #define yystacksize YYSTACKSIZE
 401 #line 776 "./parse.y"
 402
 403
 404 /* build_eof_action - build the "<<EOF>>" action for the active start
 405  *                    conditions
 406  */
 407
 408 void build_eof_action()
 409         {
 410         register int i;
 411         char action_text[MAXLINE];
 412
 413         for ( i = 1; i <= scon_stk_ptr; ++i )
 414                 {
 415                 if ( sceof[scon_stk[i]] )
 416                         format_pinpoint_message(
 417                                 "multiple <<EOF>> rules for start condition %s",
 418                                 scname[scon_stk[i]] );
 419
 420                 else
 421                         {
 422                         sceof[scon_stk[i]] = true;
 423                         sprintf( action_text, "case YY_STATE_EOF(%s):\n",
 424                                 scname[scon_stk[i]] );
 425                         add_action( action_text );
 426                         }
 427                 }
 428
 429         line_directive_out( (FILE *) 0, 1 );
 430
 431         /* This isn't a normal rule after all - don't count it as
 432          * such, so we don't have any holes in the rule numbering
 433          * (which make generating "rule can never match" warnings
 434          * more difficult.
 435          */
 436         --num_rules;
 437         ++num_eof_rules;
 438         }
 439
 440
 441 /* format_synerr - write out formatted syntax error */
 442
 443 void format_synerr( msg, arg )
 444 char msg[], arg[];
 445         {
 446         char errmsg[MAXLINE];
 447
 448         (void) sprintf( errmsg, msg, arg );
 449         synerr( errmsg );
 450         }
 451
 452
 453 /* synerr - report a syntax error */
 454
 455 void synerr( str )
 456 char str[];
 457         {
 458         syntaxerror = true;
 459         pinpoint_message( str );
 460         }
 461
 462
 463 /* format_warn - write out formatted warning */
 464
 465 void format_warn( msg, arg )
 466 char msg[], arg[];
 467         {
 468         char warn_msg[MAXLINE];
 469
 470         (void) sprintf( warn_msg, msg, arg );
 471         warn( warn_msg );
 472         }
 473
 474
 475 /* warn - report a warning, unless -w was given */
 476
 477 void warn( str )
 478 char str[];
 479         {
 480         line_warning( str, linenum );
 481         }
 482
 483 /* format_pinpoint_message - write out a message formatted with one string,
 484  *                           pinpointing its location
 485  */
 486
 487 void format_pinpoint_message( msg, arg )
 488 char msg[], arg[];
 489         {
 490         char errmsg[MAXLINE];
 491
 492         (void) sprintf( errmsg, msg, arg );
 493         pinpoint_message( errmsg );
 494         }
 495
 496
 497 /* pinpoint_message - write out a message, pinpointing its location */
 498
 499 void pinpoint_message( str )
 500 char str[];
 501         {
 502         line_pinpoint( str, linenum );
 503         }
 504
 505
 506 /* line_warning - report a warning at a given line, unless -w was given */
 507
 508 void line_warning( str, line )
 509 char str[];
 510 int line;
 511         {
 512         char warning[MAXLINE];
 513
 514         if ( ! nowarn )
 515                 {
 516                 sprintf( warning, "warning, %s", str );
 517                 line_pinpoint( warning, line );
 518                 }
 519         }
 520
 521
 522 /* line_pinpoint - write out a message, pinpointing it at the given line */
 523
 524 void line_pinpoint( str, line )
 525 char str[];
 526 int line;
 527         {
 528         fprintf( stderr, "\"%s\", line %d: %s\n", infilename, line, str );
 529         }
 530
 531
 532 /* yyerror - eat up an error message from the parser;
 533  *           currently, messages are ignore
 534  */
 535
 536 void yyerror( msg )
 537 char msg[];
 538         {
 539         }
 540 #line 541 "y.tab.c"
 541 #define YYABORT goto yyabort
 542 #define YYREJECT goto yyabort
 543 #define YYACCEPT goto yyaccept
 544 #define YYERROR goto yyerrlab
 545 int
 546 yyparse()
 547 {
 548     register int yym, yyn, yystate;
 549 #if YYDEBUG
 550     register char *yys;
 551     extern char *getenv();
 552
 553     if (yys = getenv("YYDEBUG"))
 554     {
 555         yyn = *yys;
 556         if (yyn >= '0' && yyn <= '9')
 557             yydebug = yyn - '0';
 558     }
 559 #endif
 560
 561     yynerrs = 0;
 562     yyerrflag = 0;
 563     yychar = (-1);
 564
 565     yyssp = yyss;
 566     yyvsp = yyvs;
 567     *yyssp = yystate = 0;
 568
 569 yyloop:
 570     if (yyn = yydefred[yystate]) goto yyreduce;
 571     if (yychar < 0)
 572     {
 573         if ((yychar = yylex()) < 0) yychar = 0;
 574 #if YYDEBUG
 575         if (yydebug)
 576         {
 577             yys = 0;
 578             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 579             if (!yys) yys = "illegal-symbol";
 580             printf("%sdebug: state %d, reading %d (%s)\n",
 581                     YYPREFIX, yystate, yychar, yys);
 582         }
 583 #endif
 584     }
 585     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 586             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 587     {
 588 #if YYDEBUG
 589         if (yydebug)
 590             printf("%sdebug: state %d, shifting to state %d\n",
 591                     YYPREFIX, yystate, yytable[yyn]);
 592 #endif
 593         if (yyssp >= yyss + yystacksize - 1)
 594         {
 595             goto yyoverflow;
 596         }
 597         *++yyssp = yystate = yytable[yyn];
 598         *++yyvsp = yylval;
 599         yychar = (-1);
 600         if (yyerrflag > 0)  --yyerrflag;
 601         goto yyloop;
 602     }
 603     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 604             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 605     {
 606         yyn = yytable[yyn];
 607         goto yyreduce;
 608     }
 609     if (yyerrflag) goto yyinrecovery;
 610 #ifdef lint
 611     goto yynewerror;
 612 #endif
 613 yynewerror:
 614     yyerror("syntax error");
 615 #ifdef lint
 616     goto yyerrlab;
 617 #endif
 618 yyerrlab:
 619     ++yynerrs;
 620 yyinrecovery:
 621     if (yyerrflag < 3)
 622     {
 623         yyerrflag = 3;
 624         for (;;)
 625         {
 626             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 627                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 628             {
 629 #if YYDEBUG
 630                 if (yydebug)
 631                     printf("%sdebug: state %d, error recovery shifting\
 632  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 633 #endif
 634                 if (yyssp >= yyss + yystacksize - 1)
 635                 {
 636                     goto yyoverflow;
 637                 }
 638                 *++yyssp = yystate = yytable[yyn];
 639                 *++yyvsp = yylval;
 640                 goto yyloop;
 641             }
 642             else
 643             {
 644 #if YYDEBUG
 645                 if (yydebug)
 646                     printf("%sdebug: error recovery discarding state %d\n",
 647                             YYPREFIX, *yyssp);
 648 #endif
 649                 if (yyssp <= yyss) goto yyabort;
 650                 --yyssp;
 651                 --yyvsp;
 652             }
 653         }
 654     }
 655     else
 656     {
 657         if (yychar == 0) goto yyabort;
 658 #if YYDEBUG
 659         if (yydebug)
 660         {
 661             yys = 0;
 662             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 663             if (!yys) yys = "illegal-symbol";
 664             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 665                     YYPREFIX, yystate, yychar, yys);
 666         }
 667 #endif
 668         yychar = (-1);
 669         goto yyloop;
 670     }
 671 yyreduce:
 672 #if YYDEBUG
 673     if (yydebug)
 674         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 675                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 676 #endif
 677     yym = yylen[yyn];
 678     yyval = yyvsp[1-yym];
 679     switch (yyn)
 680     {
 681 case 1:
 682 #line 113 "./parse.y"
 683 { /* add default rule */
 684                         int def_rule;
 685
 686                         pat = cclinit();
 687                         cclnegate( pat );
 688
 689                         def_rule = mkstate( -pat );
 690
 691                         /* Remember the number of the default rule so we
 692                          * don't generate "can't match" warnings for it.
 693                          */
 694                         default_rule = num_rules;
 695
 696                         finish_rule( def_rule, false, 0, 0 );
 697
 698                         for ( i = 1; i <= lastsc; ++i )
 699                                 scset[i] = mkbranch( scset[i], def_rule );
 700
 701                         if ( spprdflt )
 702                                 add_action(
 703                                 "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
 704                         else
 705                                 add_action( "ECHO" );
 706
 707                         add_action( ";\n\tYY_BREAK\n" );
 708                         }
 709 break;
 710 case 2:
 711 #line 142 "./parse.y"
 712 { /* initialize for processing rules */
 713
 714                         /* Create default DFA start condition. */
 715                         scinstal( "INITIAL", false );
 716                         }
 717 break;
 718 case 6:
 719 #line 153 "./parse.y"
 720 { synerr( "unknown error processing section 1" ); }
 721 break;
 722 case 7:
 723 #line 157 "./parse.y"
 724 {
 725                         check_options();
 726                         scon_stk = allocate_integer_array( lastsc + 1 );
 727                         scon_stk_ptr = 0;
 728                         }
 729 break;
 730 case 8:
 731 #line 165 "./parse.y"
 732 { xcluflg = false; }
 733 break;
 734 case 9:
 735 #line 168 "./parse.y"
 736 { xcluflg = true; }
 737 break;
 738 case 10:
 739 #line 172 "./parse.y"
 740 { scinstal( nmstr, xcluflg ); }
 741 break;
 742 case 11:
 743 #line 175 "./parse.y"
 744 { scinstal( nmstr, xcluflg ); }
 745 break;
 746 case 12:
 747 #line 178 "./parse.y"
 748 { synerr( "bad start condition list" ); }
 749 break;
 750 case 16:
 751 #line 189 "./parse.y"
 752 {
 753                         outfilename = copy_string( nmstr );
 754                         did_outfilename = 1;
 755                         }
 756 break;
 757 case 17:
 758 #line 194 "./parse.y"
 759 { prefix = copy_string( nmstr ); }
 760 break;
 761 case 18:
 762 #line 196 "./parse.y"
 763 { yyclass = copy_string( nmstr ); }
 764 break;
 765 case 19:
 766 #line 200 "./parse.y"
 767 { scon_stk_ptr = yyvsp[-3]; }
 768 break;
 769 case 20:
 770 #line 202 "./parse.y"
 771 { scon_stk_ptr = yyvsp[-3]; }
 772 break;
 773 case 22:
 774 #line 207 "./parse.y"
 775 {
 776                         /* Initialize for a parse of one rule. */
 777                         trlcontxt = variable_trail_rule = varlength = false;
 778                         trailcnt = headcnt = rulelen = 0;
 779                         current_state_type = STATE_NORMAL;
 780                         previous_continued_action = continued_action;
 781                         in_rule = true;
 782
 783                         new_rule();
 784                         }
 785 break;
 786 case 23:
 787 #line 220 "./parse.y"
 788 {
 789                         pat = yyvsp[0];
 790                         finish_rule( pat, variable_trail_rule,
 791                                 headcnt, trailcnt );
 792
 793                         if ( scon_stk_ptr > 0 )
 794                                 {
 795                                 for ( i = 1; i <= scon_stk_ptr; ++i )
 796                                         scbol[scon_stk[i]] =
 797                                                 mkbranch( scbol[scon_stk[i]],
 798                                                                 pat );
 799                                 }
 800
 801                         else
 802                                 {
 803                                 /* Add to all non-exclusive start conditions,
 804                                  * including the default (0) start condition.
 805                                  */
 806
 807                                 for ( i = 1; i <= lastsc; ++i )
 808                                         if ( ! scxclu[i] )
 809                                                 scbol[i] = mkbranch( scbol[i],
 810                                                                         pat );
 811                                 }
 812
 813                         if ( ! bol_needed )
 814                                 {
 815                                 bol_needed = true;
 816
 817                                 if ( performance_report > 1 )
 818                                         pinpoint_message(
 819                         "'^' operator results in sub-optimal performance" );
 820                                 }
 821                         }
 822 break;
 823 case 24:
 824 #line 256 "./parse.y"
 825 {
 826                         pat = yyvsp[0];
 827                         finish_rule( pat, variable_trail_rule,
 828                                 headcnt, trailcnt );
 829
 830                         if ( scon_stk_ptr > 0 )
 831                                 {
 832                                 for ( i = 1; i <= scon_stk_ptr; ++i )
 833                                         scset[scon_stk[i]] =
 834                                                 mkbranch( scset[scon_stk[i]],
 835                                                                 pat );
 836                                 }
 837
 838                         else
 839                                 {
 840                                 for ( i = 1; i <= lastsc; ++i )
 841                                         if ( ! scxclu[i] )
 842                                                 scset[i] =
 843                                                         mkbranch( scset[i],
 844                                                                 pat );
 845                                 }
 846                         }
 847 break;
 848 case 25:
 849 #line 280 "./parse.y"
 850 {
 851                         if ( scon_stk_ptr > 0 )
 852                                 build_eof_action();
 853
 854                         else
 855                                 {
 856                                 /* This EOF applies to all start conditions
 857                                  * which don't already have EOF actions.
 858                                  */
 859                                 for ( i = 1; i <= lastsc; ++i )
 860                                         if ( ! sceof[i] )
 861                                                 scon_stk[++scon_stk_ptr] = i;
 862
 863                                 if ( scon_stk_ptr == 0 )
 864                                         warn(
 865                         "all start conditions already have <<EOF>> rules" );
 866
 867                                 else
 868                                         build_eof_action();
 869                                 }
 870                         }
 871 break;
 872 case 26:
 873 #line 303 "./parse.y"
 874 { synerr( "unrecognized rule" ); }
 875 break;
 876 case 27:
 877 #line 307 "./parse.y"
 878 { yyval = scon_stk_ptr; }
 879 break;
 880 case 28:
 881 #line 311 "./parse.y"
 882 { yyval = yyvsp[-2]; }
 883 break;
 884 case 29:
 885 #line 314 "./parse.y"
 886 {
 887                         yyval = scon_stk_ptr;
 888
 889                         for ( i = 1; i <= lastsc; ++i )
 890                                 {
 891                                 int j;
 892
 893                                 for ( j = 1; j <= scon_stk_ptr; ++j )
 894                                         if ( scon_stk[j] == i )
 895                                                 break;
 896
 897                                 if ( j > scon_stk_ptr )
 898                                         scon_stk[++scon_stk_ptr] = i;
 899                                 }
 900                         }
 901 break;
 902 case 30:
 903 #line 331 "./parse.y"
 904 { yyval = scon_stk_ptr; }
 905 break;
 906 case 33:
 907 #line 339 "./parse.y"
 908 { synerr( "bad start condition list" ); }
 909 break;
 910 case 34:
 911 #line 343 "./parse.y"
 912 {
 913                         if ( (scnum = sclookup( nmstr )) == 0 )
 914                                 format_pinpoint_message(
 915                                         "undeclared start condition %s",
 916                                         nmstr );
 917                         else
 918                                 {
 919                                 for ( i = 1; i <= scon_stk_ptr; ++i )
 920                                         if ( scon_stk[i] == scnum )
 921                                                 {
 922                                                 format_warn(
 923                                                         "<%s> specified twice",
 924                                                         scname[scnum] );
 925                                                 break;
 926                                                 }
 927
 928                                 if ( i > scon_stk_ptr )
 929                                         scon_stk[++scon_stk_ptr] = scnum;
 930                                 }
 931                         }
 932 break;
 933 case 35:
 934 #line 366 "./parse.y"
 935 {
 936                         if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
 937                                 /* Provide final transition \now/ so it
 938                                  * will be marked as a trailing context
 939                                  * state.
 940                                  */
 941                                 yyvsp[0] = link_machines( yyvsp[0],
 942                                                 mkstate( SYM_EPSILON ) );
 943
 944                         mark_beginning_as_normal( yyvsp[0] );
 945                         current_state_type = STATE_NORMAL;
 946
 947                         if ( previous_continued_action )
 948                                 {
 949                                 /* We need to treat this as variable trailing
 950                                  * context so that the backup does not happen
 951                                  * in the action but before the action switch
 952                                  * statement.  If the backup happens in the
 953                                  * action, then the rules "falling into" this
 954                                  * one's action will *also* do the backup,
 955                                  * erroneously.
 956                                  */
 957                                 if ( ! varlength || headcnt != 0 )
 958                                         warn(
 959                 "trailing context made variable due to preceding '|' action" );
 960
 961                                 /* Mark as variable. */
 962                                 varlength = true;
 963                                 headcnt = 0;
 964                                 }
 965
 966                         if ( lex_compat || (varlength && headcnt == 0) )
 967                                 { /* variable trailing context rule */
 968                                 /* Mark the first part of the rule as the
 969                                  * accepting "head" part of a trailing
 970                                  * context rule.
 971                                  *
 972                                  * By the way, we didn't do this at the
 973                                  * beginning of this production because back
 974                                  * then current_state_type was set up for a
 975                                  * trail rule, and add_accept() can create
 976                                  * a new state ...
 977                                  */
 978                                 add_accept( yyvsp[-1],
 979                                         num_rules | YY_TRAILING_HEAD_MASK );
 980                                 variable_trail_rule = true;
 981                                 }
 982
 983                         else
 984                                 trailcnt = rulelen;
 985
 986                         yyval = link_machines( yyvsp[-1], yyvsp[0] );
 987                         }
 988 break;
 989 case 36:
 990 #line 421 "./parse.y"
 991 { synerr( "trailing context used twice" ); }
 992 break;
 993 case 37:
 994 #line 424 "./parse.y"
 995 {
 996                         headcnt = 0;
 997                         trailcnt = 1;
 998                         rulelen = 1;
 999                         varlength = false;
1000
1001                         current_state_type = STATE_TRAILING_CONTEXT;
1002
1003                         if ( trlcontxt )
1004                                 {
1005                                 synerr( "trailing context used twice" );
1006                                 yyval = mkstate( SYM_EPSILON );
1007                                 }
1008
1009                         else if ( previous_continued_action )
1010                                 {
1011                                 /* See the comment in the rule for "re2 re"
1012                                  * above.
1013                                  */
1014                                 warn(
1015                 "trailing context made variable due to preceding '|' action" );
1016
1017                                 varlength = true;
1018                                 }
1019
1020                         if ( lex_compat || varlength )
1021                                 {
1022                                 /* Again, see the comment in the rule for
1023                                  * "re2 re" above.
1024                                  */
1025                                 add_accept( yyvsp[-1],
1026                                         num_rules | YY_TRAILING_HEAD_MASK );
1027                                 variable_trail_rule = true;
1028                                 }
1029
1030                         trlcontxt = true;
1031
1032                         eps = mkstate( SYM_EPSILON );
1033                         yyval = link_machines( yyvsp[-1],
1034                                 link_machines( eps, mkstate( '\n' ) ) );
1035                         }
1036 break;
1037 case 38:
1038 #line 467 "./parse.y"
1039 {
1040                         yyval = yyvsp[0];
1041
1042                         if ( trlcontxt )
1043                                 {
1044                                 if ( lex_compat || (varlength && headcnt == 0) )
1045                                         /* Both head and trail are
1046                                          * variable-length.
1047                                          */
1048                                         variable_trail_rule = true;
1049                                 else
1050                                         trailcnt = rulelen;
1051                                 }
1052                         }
1053 break;
1054 case 39:
1055 #line 485 "./parse.y"
1056 {
1057                         varlength = true;
1058                         yyval = mkor( yyvsp[-2], yyvsp[0] );
1059                         }
1060 break;
1061 case 40:
1062 #line 491 "./parse.y"
1063 { yyval = yyvsp[0]; }
1064 break;
1065 case 41:
1066 #line 496 "./parse.y"
1067 {
1068                         /* This rule is written separately so the
1069                          * reduction will occur before the trailing
1070                          * series is parsed.
1071                          */
1072
1073                         if ( trlcontxt )
1074                                 synerr( "trailing context used twice" );
1075                         else
1076                                 trlcontxt = true;
1077
1078                         if ( varlength )
1079                                 /* We hope the trailing context is
1080                                  * fixed-length.
1081                                  */
1082                                 varlength = false;
1083                         else
1084                                 headcnt = rulelen;
1085
1086                         rulelen = 0;
1087
1088                         current_state_type = STATE_TRAILING_CONTEXT;
1089                         yyval = yyvsp[-1];
1090                         }
1091 break;
1092 case 42:
1093 #line 523 "./parse.y"
1094 {
1095                         /* This is where concatenation of adjacent patterns
1096                          * gets done.
1097                          */
1098                         yyval = link_machines( yyvsp[-1], yyvsp[0] );
1099                         }
1100 break;
1101 case 43:
1102 #line 531 "./parse.y"
1103 { yyval = yyvsp[0]; }
1104 break;
1105 case 44:
1106 #line 535 "./parse.y"
1107 {
1108                         varlength = true;
1109
1110                         yyval = mkclos( yyvsp[-1] );
1111                         }
1112 break;
1113 case 45:
1114 #line 542 "./parse.y"
1115 {
1116                         varlength = true;
1117                         yyval = mkposcl( yyvsp[-1] );
1118                         }
1119 break;
1120 case 46:
1121 #line 548 "./parse.y"
1122 {
1123                         varlength = true;
1124                         yyval = mkopt( yyvsp[-1] );
1125                         }
1126 break;
1127 case 47:
1128 #line 554 "./parse.y"
1129 {
1130                         varlength = true;
1131
1132                         if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
1133                                 {
1134                                 synerr( "bad iteration values" );
1135                                 yyval = yyvsp[-5];
1136                                 }
1137                         else
1138                                 {
1139                                 if ( yyvsp[-3] == 0 )
1140                                         {
1141                                         if ( yyvsp[-1] <= 0 )
1142                                                 {
1143                                                 synerr(
1144                                                 "bad iteration values" );
1145                                                 yyval = yyvsp[-5];
1146                                                 }
1147                                         else
1148                                                 yyval = mkopt(
1149                                                         mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
1150                                         }
1151                                 else
1152                                         yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
1153                                 }
1154                         }
1155 break;
1156 case 48:
1157 #line 582 "./parse.y"
1158 {
1159                         varlength = true;
1160
1161                         if ( yyvsp[-2] <= 0 )
1162                                 {
1163                                 synerr( "iteration value must be positive" );
1164                                 yyval = yyvsp[-4];
1165                                 }
1166
1167                         else
1168                                 yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITY );
1169                         }
1170 break;
1171 case 49:
1172 #line 596 "./parse.y"
1173 {
1174                         /* The singleton could be something like "(foo)",
1175                          * in which case we have no idea what its length
1176                          * is, so we punt here.
1177                          */
1178                         varlength = true;
1179
1180                         if ( yyvsp[-1] <= 0 )
1181                                 {
1182                                 synerr( "iteration value must be positive" );
1183                                 yyval = yyvsp[-3];
1184                                 }
1185
1186                         else
1187                                 yyval = link_machines( yyvsp[-3],
1188                                                 copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
1189                         }
1190 break;
1191 case 50:
1192 #line 615 "./parse.y"
1193 {
1194                         if ( ! madeany )
1195                                 {
1196                                 /* Create the '.' character class. */
1197                                 anyccl = cclinit();
1198                                 ccladd( anyccl, '\n' );
1199                                 cclnegate( anyccl );
1200
1201                                 if ( useecs )
1202                                         mkeccl( ccltbl + cclmap[anyccl],
1203                                                 ccllen[anyccl], nextecm,
1204                                                 ecgroup, csize, csize );
1205
1206                                 madeany = true;
1207                                 }
1208
1209                         ++rulelen;
1210
1211                         yyval = mkstate( -anyccl );
1212                         }
1213 break;
1214 case 51:
1215 #line 637 "./parse.y"
1216 {
1217                         if ( ! cclsorted )
1218                                 /* Sort characters for fast searching.  We
1219                                  * use a shell sort since this list could
1220                                  * be large.
1221                                  */
1222                                 cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
1223
1224                         if ( useecs )
1225                                 mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
1226                                         nextecm, ecgroup, csize, csize );
1227
1228                         ++rulelen;
1229
1230                         yyval = mkstate( -yyvsp[0] );
1231                         }
1232 break;
1233 case 52:
1234 #line 655 "./parse.y"
1235 {
1236                         ++rulelen;
1237
1238                         yyval = mkstate( -yyvsp[0] );
1239                         }
1240 break;
1241 case 53:
1242 #line 662 "./parse.y"
1243 { yyval = yyvsp[-1]; }
1244 break;
1245 case 54:
1246 #line 665 "./parse.y"
1247 { yyval = yyvsp[-1]; }
1248 break;
1249 case 55:
1250 #line 668 "./parse.y"
1251 {
1252                         ++rulelen;
1253
1254                         if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1255                                 yyvsp[0] = clower( yyvsp[0] );
1256
1257                         yyval = mkstate( yyvsp[0] );
1258                         }
1259 break;
1260 case 56:
1261 #line 679 "./parse.y"
1262 { yyval = yyvsp[-1]; }
1263 break;
1264 case 57:
1265 #line 682 "./parse.y"
1266 {
1267                         cclnegate( yyvsp[-1] );
1268                         yyval = yyvsp[-1];
1269                         }
1270 break;
1271 case 58:
1272 #line 689 "./parse.y"
1273 {
1274                         if ( caseins )
1275                                 {
1276                                 if ( yyvsp[-2] >= 'A' && yyvsp[-2] <= 'Z' )
1277                                         yyvsp[-2] = clower( yyvsp[-2] );
1278                                 if ( yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1279                                         yyvsp[0] = clower( yyvsp[0] );
1280                                 }
1281
1282                         if ( yyvsp[-2] > yyvsp[0] )
1283                                 synerr( "negative range in character class" );
1284
1285                         else
1286                                 {
1287                                 for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
1288                                         ccladd( yyvsp[-3], i );
1289
1290                                 /* Keep track if this ccl is staying in
1291                                  * alphabetical order.
1292                                  */
1293                                 cclsorted = cclsorted && (yyvsp[-2] > lastchar);
1294                                 lastchar = yyvsp[0];
1295                                 }
1296
1297                         yyval = yyvsp[-3];
1298                         }
1299 break;
1300 case 59:
1301 #line 717 "./parse.y"
1302 {
1303                         if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1304                                 yyvsp[0] = clower( yyvsp[0] );
1305
1306                         ccladd( yyvsp[-1], yyvsp[0] );
1307                         cclsorted = cclsorted && (yyvsp[0] > lastchar);
1308                         lastchar = yyvsp[0];
1309                         yyval = yyvsp[-1];
1310                         }
1311 break;
1312 case 60:
1313 #line 728 "./parse.y"
1314 {
1315                         /* Too hard to properly maintain cclsorted. */
1316                         cclsorted = false;
1317                         yyval = yyvsp[-1];
1318                         }
1319 break;
1320 case 61:
1321 #line 735 "./parse.y"
1322 {
1323                         cclsorted = true;
1324                         lastchar = 0;
1325                         currccl = yyval = cclinit();
1326                         }
1327 break;
1328 case 62:
1329 #line 742 "./parse.y"
1330 { CCL_EXPR(isalnum) }
1331 break;
1332 case 63:
1333 #line 743 "./parse.y"
1334 { CCL_EXPR(isalpha) }
1335 break;
1336 case 64:
1337 #line 744 "./parse.y"
1338 { CCL_EXPR(IS_BLANK) }
1339 break;
1340 case 65:
1341 #line 745 "./parse.y"
1342 { CCL_EXPR(iscntrl) }
1343 break;
1344 case 66:
1345 #line 746 "./parse.y"
1346 { CCL_EXPR(isdigit) }
1347 break;
1348 case 67:
1349 #line 747 "./parse.y"
1350 { CCL_EXPR(isgraph) }
1351 break;
1352 case 68:
1353 #line 748 "./parse.y"
1354 { CCL_EXPR(islower) }
1355 break;
1356 case 69:
1357 #line 749 "./parse.y"
1358 { CCL_EXPR(isprint) }
1359 break;
1360 case 70:
1361 #line 750 "./parse.y"
1362 { CCL_EXPR(ispunct) }
1363 break;
1364 case 71:
1365 #line 751 "./parse.y"
1366 { CCL_EXPR(isspace) }
1367 break;
1368 case 72:
1369 #line 752 "./parse.y"
1370 {
1371                                 if ( caseins )
1372                                         CCL_EXPR(islower)
1373                                 else
1374                                         CCL_EXPR(isupper)
1375                                 }
1376 break;
1377 case 73:
1378 #line 758 "./parse.y"
1379 { CCL_EXPR(isxdigit) }
1380 break;
1381 case 74:
1382 #line 762 "./parse.y"
1383 {
1384                         if ( caseins && yyvsp[0] >= 'A' && yyvsp[0] <= 'Z' )
1385                                 yyvsp[0] = clower( yyvsp[0] );
1386
1387                         ++rulelen;
1388
1389                         yyval = link_machines( yyvsp[-1], mkstate( yyvsp[0] ) );
1390                         }
1391 break;
1392 case 75:
1393 #line 772 "./parse.y"
1394 { yyval = mkstate( SYM_EPSILON ); }
1395 break;
1396 #line 1397 "y.tab.c"
1397     }
1398     yyssp -= yym;
1399     yystate = *yyssp;
1400     yyvsp -= yym;
1401     yym = yylhs[yyn];
1402     if (yystate == 0 && yym == 0)
1403     {
1404 #if YYDEBUG
1405         if (yydebug)
1406             printf("%sdebug: after reduction, shifting from state 0 to\
1407  state %d\n", YYPREFIX, YYFINAL);
1408 #endif
1409         yystate = YYFINAL;
1410         *++yyssp = YYFINAL;
1411         *++yyvsp = yyval;
1412         if (yychar < 0)
1413         {
1414             if ((yychar = yylex()) < 0) yychar = 0;
1415 #if YYDEBUG
1416             if (yydebug)
1417             {
1418                 yys = 0;
1419                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
1420                 if (!yys) yys = "illegal-symbol";
1421                 printf("%sdebug: state %d, reading %d (%s)\n",
1422                         YYPREFIX, YYFINAL, yychar, yys);
1423             }
1424 #endif
1425         }
1426         if (yychar == 0) goto yyaccept;
1427         goto yyloop;
1428     }
1429     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
1430             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
1431         yystate = yytable[yyn];
1432     else
1433         yystate = yydgoto[yym];
1434 #if YYDEBUG
1435     if (yydebug)
1436         printf("%sdebug: after reduction, shifting from state %d \
1437 to state %d\n", YYPREFIX, *yyssp, yystate);
1438 #endif
1439     if (yyssp >= yyss + yystacksize - 1)
1440     {
1441         goto yyoverflow;
1442     }
1443     *++yyssp = yystate;
1444     *++yyvsp = yyval;
1445     goto yyloop;
1446 yyoverflow:
1447     yyerror("yacc stack overflow");
1448 yyabort:
1449     return (1);
1450 yyaccept:
1451     return (0);
1452 }