xref: /minix3/external/bsd/flex/dist/initparse.c (revision 0a6a1f1d05b60e214de2f05a7310ddd1f0e590e7)

/*	$NetBSD: initparse.c,v 1.5 2014/10/30 18:44:05 christos Exp $	*/

#include "flexdef.h"
__RCSID("$NetBSD: initparse.c,v 1.5 2014/10/30 18:44:05 christos Exp $");

#ifndef lint
static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#endif

#ifdef _LIBC
#include "namespace.h"
#endif
#include <stdlib.h>
#include <string.h>

#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9

#define YYEMPTY        (-1)
#define yyclearin      (yychar = YYEMPTY)
#define yyerrok        (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)

#define YYPREFIX "yy"

#define YYPURE 0

/*  Copyright (c) 1990 The Regents of the University of California. */
/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */
/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */
/*  to contract no. DE-AC03-76SF00098 between the United States */
/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */
/*  modification, are permitted provided that the following conditions */
/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */
/*     notice, this list of conditions and the following disclaimer. */
/*  2. Redistributions in binary form must reproduce the above copyright */
/*     notice, this list of conditions and the following disclaimer in the */
/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */
/*  may be used to endorse or promote products derived from this software */
/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/*  PURPOSE. */

#include "tables.h"

int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;

int *scon_stk;
int scon_stk_ptr;

static int madeany = false;  /* whether we've made the '.' character class */
static int ccldot, cclany;
int previous_continued_action;	/* whether the previous rule's action was '|' */

#define format_warn3(fmt, a1, a2) \
	do{ \
        char fw3_msg[MAXLINE];\
        snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
        lwarn( fw3_msg );\
	}while(0)

/* Expand a POSIX character class expression. */
#define CCL_EXPR(func) \
	do{ \
	int c; \
	for ( c = 0; c < csize; ++c ) \
		if ( isascii(c) && func(c) ) \
			ccladd( currccl, c ); \
	}while(0)

/* negated class */
#define CCL_NEG_EXPR(func) \
	do{ \
	int c; \
	for ( c = 0; c < csize; ++c ) \
		if ( !func(c) ) \
			ccladd( currccl, c ); \
	}while(0)

/* While POSIX defines isblank(), it's not ANSI C. */
#define IS_BLANK(c) ((c) == ' ' || (c) == '\t')

/* On some over-ambitious machines, such as DEC Alpha's, the default
 * token type is "long" instead of "int"; this leads to problems with
 * declaring yylval in flexdef.h.  But so far, all the yacc's I've seen
 * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the
 * following should ensure that the default token type is "int".
 */
#define YYSTYPE int


#ifndef YYSTYPE
typedef int YYSTYPE;
#endif

/* compatibility with bison */
#ifdef YYPARSE_PARAM
/* compatibility with FreeBSD */
# ifdef YYPARSE_PARAM_TYPE
#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
# else
#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif
#else
# define YYPARSE_DECL() yyparse(void)
#endif

/* Parameters sent to lex. */
#ifdef YYLEX_PARAM
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM)
#else
# define YYLEX_DECL() yylex(void)
# define YYLEX yylex()
#endif

/* Parameters sent to yyerror. */
#ifndef YYERROR_DECL
#define YYERROR_DECL() yyerror(const char *s)
#endif
#ifndef YYERROR_CALL
#define YYERROR_CALL(msg) yyerror(msg)
#endif

extern int YYPARSE_DECL();


#define CHAR 257
#define NUMBER 258
#define SECTEND 259
#define SCDECL 260
#define XSCDECL 261
#define NAME 262
#define PREVCCL 263
#define EOF_OP 264
#define OPTION_OP 265
#define OPT_OUTFILE 266
#define OPT_PREFIX 267
#define OPT_YYCLASS 268
#define OPT_HEADER 269
#define OPT_EXTRA_TYPE 270
#define OPT_TABLES 271
#define CCE_ALNUM 272
#define CCE_ALPHA 273
#define CCE_BLANK 274
#define CCE_CNTRL 275
#define CCE_DIGIT 276
#define CCE_GRAPH 277
#define CCE_LOWER 278
#define CCE_PRINT 279
#define CCE_PUNCT 280
#define CCE_SPACE 281
#define CCE_UPPER 282
#define CCE_XDIGIT 283
#define CCE_NEG_ALNUM 284
#define CCE_NEG_ALPHA 285
#define CCE_NEG_BLANK 286
#define CCE_NEG_CNTRL 287
#define CCE_NEG_DIGIT 288
#define CCE_NEG_GRAPH 289
#define CCE_NEG_LOWER 290
#define CCE_NEG_PRINT 291
#define CCE_NEG_PUNCT 292
#define CCE_NEG_SPACE 293
#define CCE_NEG_UPPER 294
#define CCE_NEG_XDIGIT 295
#define CCL_OP_DIFF 296
#define CCL_OP_UNION 297
#define BEGIN_REPEAT_POSIX 298
#define END_REPEAT_POSIX 299
#define BEGIN_REPEAT_FLEX 300
#define END_REPEAT_FLEX 301
#define YYERRCODE 256
static const short yylhs[] = {                           -1,
    0,    1,    2,    2,    2,    2,    3,    6,    6,    7,
    7,    7,    8,    9,    9,   10,   10,   10,   10,   10,
   10,    4,    4,    4,    5,   12,   12,   12,   12,   14,
   11,   11,   11,   15,   15,   15,   16,   13,   13,   13,
   13,   18,   18,   17,   19,   19,   19,   19,   19,   20,
   20,   20,   20,   20,   20,   20,   20,   20,   20,   20,
   20,   21,   21,   21,   23,   23,   24,   24,   24,   24,
   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
   25,   25,   25,   25,   22,   22,
};
static const short yylen[] = {                            2,
    5,    0,    3,    2,    0,    1,    1,    1,    1,    2,
    1,    1,    2,    2,    0,    3,    3,    3,    3,    3,
    3,    5,    5,    0,    0,    2,    1,    1,    1,    0,
    4,    3,    0,    3,    1,    1,    1,    2,    3,    2,
    1,    3,    1,    2,    2,    1,    6,    5,    4,    2,
    2,    2,    6,    5,    4,    1,    1,    1,    3,    3,
    1,    3,    3,    1,    3,    4,    4,    2,    2,    0,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    1,    1,    1,    1,    2,    0,
};
static const short yydefred[] = {                         2,
    0,    0,    6,    0,    7,    8,    9,   15,   24,    0,
    4,    0,    0,   12,   11,    0,    0,    0,    0,    0,
    0,    0,   14,    0,    1,    0,   10,    0,    0,    0,
    0,    0,    0,    0,    0,   24,    0,   16,   18,   19,
   20,   17,   21,   32,   36,   37,    0,   35,    0,   29,
   61,   58,   28,    0,   56,   96,    0,    0,    0,   27,
    0,    0,    0,    0,    0,   64,   31,    0,   23,   26,
    0,    0,   70,    0,   22,    0,   40,    0,   44,    0,
    0,    0,   50,   51,   52,    0,    0,   34,   95,   59,
   60,    0,    0,   71,   72,   73,   74,   75,   76,   77,
   78,   79,   80,   82,   81,   83,   84,   85,   86,   87,
   88,   93,   89,   90,   91,   94,   92,   65,   69,   39,
    0,    0,    0,   62,   63,   66,    0,   49,    0,   55,
    0,   67,    0,   48,    0,   54,   47,   53,
};
static const short yydgoto[] = {                          1,
    2,    4,    9,   13,   25,   10,   16,   11,   12,   23,
   26,   59,   60,   35,   47,   48,   61,   62,   63,   64,
   65,   71,   66,   74,  119,
};
static const short yysindex[] = {                         0,
    0, -222,    0, -155,    0,    0,    0,    0,    0, -215,
    0, -123,    6,    0,    0, -193,   10,   21,   26,   31,
   35,   37,    0,   59,    0,  -44,    0, -147, -145, -140,
 -133, -132, -129,   75, -214,    0,  -19,    0,    0,    0,
    0,    0,    0,    0,    0,    0,   23,    0,  -48,    0,
    0,    0,    0,  -17,    0,    0,  -17,   27,  128,    0,
  -17,   -1,  -30,  -41, -189,    0,    0, -121,    0,    0,
  -31,  -34,    0,  -87,    0,  -25,    0,  -17,    0, -109,
  -41, -108,    0,    0,    0,   60,   60,    0,    0,    0,
    0,   46,  107,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  -30,  -36,  -39,    0,    0,    0, -104,    0, -219,    0,
 -238,    0, -144,    0, -143,    0,    0,    0,
};
static const short yyrindex[] = {                         0,
    0, -141,    0,    0,    0,    0,    0,    0,    0,    0,
    0, -134,    9,    0,    0, -125,    0,    0,    0,    0,
    0,    0,    0, -178,    0,   22,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,  -21,    0,
    0,    0,    0,    0,    0,    0,    0,   85,    0,    0,
    0,  144,   47,    4,  -10,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,  146,    0,    0,    0,    0,
   18,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,  124,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   50,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,
};
static const short yygindex[] = {                         0,
    0,    0,    0,  121,  133,    0,    0,    0,    0,    0,
    0,    0,  106,    0,    0,   93,    0,   32,   84,  -45,
    0,    0,   25,   90,    0,
};
#define YYTABLESIZE 419
static const short yytable[] = {                         57,
   83,   84,   90,   56,  131,  118,   91,  129,   25,   57,
  120,   24,   33,   46,   56,   55,   56,   81,   33,  135,
   57,   85,   57,   57,   33,   57,   55,   45,   55,   57,
   57,   57,   57,    3,   77,   57,   57,   46,  133,   46,
   14,   45,   33,   46,   46,   79,   15,   46,   33,   46,
   46,   45,   57,   45,   33,   25,   43,   45,   45,   42,
   58,   25,  136,   45,   45,   24,   68,   25,   27,   33,
   28,   58,   33,   58,   54,   81,   69,   30,   36,  134,
   57,   29,   43,   30,   67,   42,   30,   43,   72,   78,
   42,   31,   76,   43,   46,   32,   42,   33,   78,   33,
   34,   33,   33,    5,    6,    7,   86,   87,   45,    8,
  124,  125,   25,   57,   38,   25,   39,    5,    5,    5,
   73,   40,   78,    5,   13,   13,   13,   46,   41,   42,
   13,   33,   43,    3,    3,    3,   44,   75,  126,    3,
   46,   45,   17,   18,   19,   20,   21,   22,  122,  123,
   58,  127,  132,   41,  137,   38,   49,  138,   37,   70,
   88,  121,   92,    0,    0,    0,    0,    0,    0,   93,
   43,    0,    0,   42,    0,    0,    0,   70,    0,    0,
    0,    0,    0,    0,   94,   95,   96,   97,   98,   99,
  100,  101,  102,  103,  104,  105,  106,  107,  108,  109,
  110,  111,  112,  113,  114,  115,  116,  117,    0,    0,
    0,    0,    0,    0,    0,    0,   68,    0,    0,    0,
    0,    0,    0,    0,    0,   89,   51,    0,    0,    0,
    0,    0,   52,    0,   33,   33,   50,   51,    0,   51,
    0,   33,   33,   52,   53,   52,   57,    0,    0,    0,
    0,    0,   57,    0,    0,    0,    0,    0,   82,    0,
   46,  130,  128,    0,   33,   33,   46,   80,    0,    0,
    0,   33,   33,    0,   45,    0,    0,   25,   25,    0,
   45,    0,    0,    0,   25,   25,    0,   57,    0,   57,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,   46,   93,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   45,    0,   94,   95,   96,
   97,   98,   99,  100,  101,  102,  103,  104,  105,  106,
  107,  108,  109,  110,  111,  112,  113,  114,  115,  116,
  117,   70,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   70,   70,   70,   70,   70,   70,   70,   70,   70,   70,
   68,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,   68,   68,   68,   68,   68,
   68,   68,   68,   68,   68,   68,   68,   68,   68,   68,
   68,   68,   68,   68,   68,   68,   68,   68,   68,
};
static const short yycheck[] = {                         10,
   42,   43,   34,   34,   44,   93,   41,   44,    0,   40,
   36,   60,   34,   10,   34,   46,   34,   63,   40,  258,
   40,   63,   40,   34,   46,   36,   46,   10,   46,   40,
   41,   42,   43,  256,   36,   46,   47,   34,  258,   36,
  256,  256,   34,   40,   41,   47,  262,  262,   40,   46,
   47,   34,   63,   36,   46,   34,   10,   40,   41,   10,
   91,   40,  301,   46,   47,   60,   44,   46,  262,   91,
   61,   91,   94,   91,   94,  121,  125,  256,  123,  299,
   91,   61,   36,  262,   62,   36,   61,   41,   57,  124,
   41,   61,   61,   47,   91,   61,   47,   61,  124,   91,
   42,  123,   94,  259,  260,  261,  296,  297,   91,  265,
   86,   87,   91,  124,  262,   94,  262,  259,  260,  261,
   94,  262,  124,  265,  259,  260,  261,  124,  262,  262,
  265,  123,  262,  259,  260,  261,   62,   10,   93,  265,
  262,  124,  266,  267,  268,  269,  270,  271,  258,  258,
   91,   45,  257,   10,  299,   10,   36,  301,   26,   54,
   68,   78,   73,   -1,   -1,   -1,   -1,   -1,   -1,  257,
  124,   -1,   -1,  124,   -1,   -1,   -1,   93,   -1,   -1,
   -1,   -1,   -1,   -1,  272,  273,  274,  275,  276,  277,
  278,  279,  280,  281,  282,  283,  284,  285,  286,  287,
  288,  289,  290,  291,  292,  293,  294,  295,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   93,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  257,  257,   -1,   -1,   -1,
   -1,   -1,  263,   -1,  256,  257,  256,  257,   -1,  257,
   -1,  263,  264,  263,  264,  263,  257,   -1,   -1,   -1,
   -1,   -1,  263,   -1,   -1,   -1,   -1,   -1,  300,   -1,
  257,  301,  299,   -1,  256,  257,  263,  298,   -1,   -1,
   -1,  263,  264,   -1,  257,   -1,   -1,  256,  257,   -1,
  263,   -1,   -1,   -1,  263,  264,   -1,  298,   -1,  300,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,  298,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  298,   -1,  272,  273,  274,
  275,  276,  277,  278,  279,  280,  281,  282,  283,  284,
  285,  286,  287,  288,  289,  290,  291,  292,  293,  294,
  295,  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,  272,  273,  274,  275,
  276,  277,  278,  279,  280,  281,  282,  283,  284,  285,
  286,  287,  288,  289,  290,  291,  292,  293,  294,  295,
  257,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,  272,  273,  274,  275,  276,
  277,  278,  279,  280,  281,  282,  283,  284,  285,  286,
  287,  288,  289,  290,  291,  292,  293,  294,  295,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 301
#if YYDEBUG
static const char *yyname[] = {

"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0,
0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND",
"SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE",
"OPT_PREFIX","OPT_YYCLASS","OPT_HEADER","OPT_EXTRA_TYPE","OPT_TABLES",
"CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL","CCE_DIGIT","CCE_GRAPH",
"CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE","CCE_UPPER","CCE_XDIGIT",
"CCE_NEG_ALNUM","CCE_NEG_ALPHA","CCE_NEG_BLANK","CCE_NEG_CNTRL","CCE_NEG_DIGIT",
"CCE_NEG_GRAPH","CCE_NEG_LOWER","CCE_NEG_PRINT","CCE_NEG_PUNCT","CCE_NEG_SPACE",
"CCE_NEG_UPPER","CCE_NEG_XDIGIT","CCL_OP_DIFF","CCL_OP_UNION",
"BEGIN_REPEAT_POSIX","END_REPEAT_POSIX","BEGIN_REPEAT_FLEX","END_REPEAT_FLEX",
};
static const char *yyrule[] = {
"$accept : goal",
"goal : initlex sect1 sect1end sect2 initforrule",
"initlex :",
"sect1 : sect1 startconddecl namelist1",
"sect1 : sect1 options",
"sect1 :",
"sect1 : error",
"sect1end : SECTEND",
"startconddecl : SCDECL",
"startconddecl : XSCDECL",
"namelist1 : namelist1 NAME",
"namelist1 : NAME",
"namelist1 : error",
"options : OPTION_OP optionlist",
"optionlist : optionlist option",
"optionlist :",
"option : OPT_OUTFILE '=' NAME",
"option : OPT_EXTRA_TYPE '=' NAME",
"option : OPT_PREFIX '=' NAME",
"option : OPT_YYCLASS '=' NAME",
"option : OPT_HEADER '=' NAME",
"option : OPT_TABLES '=' NAME",
"sect2 : sect2 scon initforrule flexrule '\\n'",
"sect2 : sect2 scon '{' sect2 '}'",
"sect2 :",
"initforrule :",
"flexrule : '^' rule",
"flexrule : rule",
"flexrule : EOF_OP",
"flexrule : error",
"scon_stk_ptr :",
"scon : '<' scon_stk_ptr namelist2 '>'",
"scon : '<' '*' '>'",
"scon :",
"namelist2 : namelist2 ',' sconname",
"namelist2 : sconname",
"namelist2 : error",
"sconname : NAME",
"rule : re2 re",
"rule : re2 re '$'",
"rule : re '$'",
"rule : re",
"re : re '|' series",
"re : series",
"re2 : re '/'",
"series : series singleton",
"series : singleton",
"series : series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX",
"series : series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX",
"series : series BEGIN_REPEAT_POSIX NUMBER END_REPEAT_POSIX",
"singleton : singleton '*'",
"singleton : singleton '+'",
"singleton : singleton '?'",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX",
"singleton : singleton BEGIN_REPEAT_FLEX NUMBER END_REPEAT_FLEX",
"singleton : '.'",
"singleton : fullccl",
"singleton : PREVCCL",
"singleton : '\"' string '\"'",
"singleton : '(' re ')'",
"singleton : CHAR",
"fullccl : fullccl CCL_OP_DIFF braceccl",
"fullccl : fullccl CCL_OP_UNION braceccl",
"fullccl : braceccl",
"braceccl : '[' ccl ']'",
"braceccl : '[' '^' ccl ']'",
"ccl : ccl CHAR '-' CHAR",
"ccl : ccl CHAR",
"ccl : ccl ccl_expr",
"ccl :",
"ccl_expr : CCE_ALNUM",
"ccl_expr : CCE_ALPHA",
"ccl_expr : CCE_BLANK",
"ccl_expr : CCE_CNTRL",
"ccl_expr : CCE_DIGIT",
"ccl_expr : CCE_GRAPH",
"ccl_expr : CCE_LOWER",
"ccl_expr : CCE_PRINT",
"ccl_expr : CCE_PUNCT",
"ccl_expr : CCE_SPACE",
"ccl_expr : CCE_XDIGIT",
"ccl_expr : CCE_UPPER",
"ccl_expr : CCE_NEG_ALNUM",
"ccl_expr : CCE_NEG_ALPHA",
"ccl_expr : CCE_NEG_BLANK",
"ccl_expr : CCE_NEG_CNTRL",
"ccl_expr : CCE_NEG_DIGIT",
"ccl_expr : CCE_NEG_GRAPH",
"ccl_expr : CCE_NEG_PRINT",
"ccl_expr : CCE_NEG_PUNCT",
"ccl_expr : CCE_NEG_SPACE",
"ccl_expr : CCE_NEG_XDIGIT",
"ccl_expr : CCE_NEG_LOWER",
"ccl_expr : CCE_NEG_UPPER",
"string : string CHAR",
"string :",

};
#endif

int      yydebug;
int      yynerrs;

int      yyerrflag;
int      yychar;
YYSTYPE  yyval;
YYSTYPE  yylval;

/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH  YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH  500
#endif
#endif

#define YYINITSTACKSIZE 500

typedef struct {
    unsigned stacksize;
    short    *s_base;
    short    *s_mark;
    short    *s_last;
    YYSTYPE  *l_base;
    YYSTYPE  *l_mark;
} YYSTACKDATA;
/* variables for the parser stack */
static YYSTACKDATA yystack;


/* build_eof_action - build the "<<EOF>>" action for the active start
 *                    conditions
 */

void build_eof_action()
	{
	register int i;
	char action_text[MAXLINE];

	for ( i = 1; i <= scon_stk_ptr; ++i )
		{
		if ( sceof[scon_stk[i]] )
			format_pinpoint_message(
				"multiple <<EOF>> rules for start condition %s",
				scname[scon_stk[i]] );

		else
			{
			sceof[scon_stk[i]] = true;

			if (previous_continued_action /* && previous action was regular */)
				add_action("YY_RULE_SETUP\n");

			snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n",
				scname[scon_stk[i]] );
			add_action( action_text );
			}
		}

	line_directive_out( (FILE *) 0, 1 );

	/* This isn't a normal rule after all - don't count it as
	 * such, so we don't have any holes in the rule numbering
	 * (which make generating "rule can never match" warnings
	 * more difficult.
	 */
	--num_rules;
	++num_eof_rules;
	}


/* format_synerr - write out formatted syntax error */

void format_synerr( msg, arg )
const char *msg, arg[];
	{
	char errmsg[MAXLINE];

	(void) snprintf( errmsg, sizeof(errmsg), msg, arg );
	synerr( errmsg );
	}


/* synerr - report a syntax error */

void synerr( str )
const char *str;
	{
	syntaxerror = true;
	pinpoint_message( str );
	}


/* format_warn - write out formatted warning */

void format_warn( msg, arg )
const char *msg, arg[];
	{
	char warn_msg[MAXLINE];

	snprintf( warn_msg, sizeof(warn_msg), msg, arg );
	lwarn( warn_msg );
	}


/* lwarn - report a warning, unless -w was given */

void lwarn( str )
const char *str;
	{
	line_warning( str, linenum );
	}

/* format_pinpoint_message - write out a message formatted with one string,
 *			     pinpointing its location
 */

void format_pinpoint_message( msg, arg )
const char *msg, arg[];
	{
	char errmsg[MAXLINE];

	snprintf( errmsg, sizeof(errmsg), msg, arg );
	pinpoint_message( errmsg );
	}


/* pinpoint_message - write out a message, pinpointing its location */

void pinpoint_message( str )
const char *str;
	{
	line_pinpoint( str, linenum );
	}


/* line_warning - report a warning at a given line, unless -w was given */

void line_warning( str, line )
const char *str;
int line;
	{
	char warning[MAXLINE];

	if ( ! nowarn )
		{
		snprintf( warning, sizeof(warning), "warning, %s", str );
		line_pinpoint( warning, line );
		}
	}


/* line_pinpoint - write out a message, pinpointing it at the given line */

void line_pinpoint( str, line )
const char *str;
int line;
	{
	fprintf( stderr, "%s:%d: %s\n", infilename, line, str );
	}


/* yyerror - eat up an error message from the parser;
 *	     currently, messages are ignore
 */

void yyerror( msg )
const char *msg;
	{
	}

#if YYDEBUG
#include <stdio.h>		/* needed for printf */
#endif

#include <stdlib.h>	/* needed for malloc, etc */
#include <string.h>	/* needed for memset */

/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data)
{
    int i;
    unsigned newsize;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = data->stacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;

    i = (int) (data->s_mark - data->s_base);
    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
    if (newss == 0)
        return -1;

    data->s_base = newss;
    data->s_mark = newss + i;

    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
    if (newvs == 0)
        return -1;

    data->l_base = newvs;
    data->l_mark = newvs + i;

    data->stacksize = newsize;
    data->s_last = data->s_base + newsize - 1;
    return 0;
}

#if YYPURE || defined(YY_NO_LEAKS)
static void yyfreestack(YYSTACKDATA *data)
{
    free(data->s_base);
    free(data->l_base);
    memset(data, 0, sizeof(*data));
}
#else
#define yyfreestack(data) /* nothing */
#endif

#define YYABORT  goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR  goto yyerrlab

int
YYPARSE_DECL()
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")) != 0)
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = YYEMPTY;
    yystate = 0;

#if YYPURE
    memset(&yystack, 0, sizeof(yystack));
#endif

    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
    yystack.s_mark = yystack.s_base;
    yystack.l_mark = yystack.l_base;
    yystate = 0;
    *yystack.s_mark = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
        {
            goto yyoverflow;
        }
        yystate = yytable[yyn];
        *++yystack.s_mark = yytable[yyn];
        *++yystack.l_mark = yylval;
        yychar = YYEMPTY;
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;

    yyerror("syntax error");

    goto yyerrlab;

yyerrlab:
    ++yynerrs;

yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
#endif
                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
                {
                    goto yyoverflow;
                }
                yystate = yytable[yyn];
                *++yystack.s_mark = yytable[yyn];
                *++yystack.l_mark = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yystack.s_mark);
#endif
                if (yystack.s_mark <= yystack.s_base) goto yyabort;
                --yystack.s_mark;
                --yystack.l_mark;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = YYEMPTY;
        goto yyloop;
    }

yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yystack.l_mark[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 1:
	{ /* add default rule */
			int def_rule;

			pat = cclinit();
			cclnegate( pat );

			def_rule = mkstate( -pat );

			/* Remember the number of the default rule so we
			 * don't generate "can't match" warnings for it.
			 */
			default_rule = num_rules;

			finish_rule( def_rule, false, 0, 0, 0);

			for ( i = 1; i <= lastsc; ++i )
				scset[i] = mkbranch( scset[i], def_rule );

			if ( spprdflt )
				add_action(
				"YY_FATAL_ERROR( \"flex scanner jammed\" )" );
			else
				add_action( "ECHO" );

			add_action( ";\n\tYY_BREAK\n" );
			}
break;
case 2:
	{ /* initialize for processing rules */

			/* Create default DFA start condition. */
			scinstal( "INITIAL", false );
			}
break;
case 6:
	{ synerr( _("unknown error processing section 1") ); }
break;
case 7:
	{
			check_options();
			scon_stk = allocate_integer_array( lastsc + 1 );
			scon_stk_ptr = 0;
			}
break;
case 8:
	{ xcluflg = false; }
break;
case 9:
	{ xcluflg = true; }
break;
case 10:
	{ scinstal( nmstr, xcluflg ); }
break;
case 11:
	{ scinstal( nmstr, xcluflg ); }
break;
case 12:
	{ synerr( _("bad start condition list") ); }
break;
case 16:
	{
			outfilename = copy_string( nmstr );
			did_outfilename = 1;
			}
break;
case 17:
	{ extra_type = copy_string( nmstr ); }
break;
case 18:
	{ prefix = copy_string( nmstr ); }
break;
case 19:
	{ yyclass = copy_string( nmstr ); }
break;
case 20:
	{ headerfilename = copy_string( nmstr ); }
break;
case 21:
	{ tablesext = true; tablesfilename = copy_string( nmstr ); }
break;
case 22:
	{ scon_stk_ptr = yystack.l_mark[-3]; }
break;
case 23:
	{ scon_stk_ptr = yystack.l_mark[-3]; }
break;
case 25:
	{
			/* Initialize for a parse of one rule. */
			trlcontxt = variable_trail_rule = varlength = false;
			trailcnt = headcnt = rulelen = 0;
			current_state_type = STATE_NORMAL;
			previous_continued_action = continued_action;
			in_rule = true;

			new_rule();
			}
break;
case 26:
	{
			pat = yystack.l_mark[0];
			finish_rule( pat, variable_trail_rule,
				headcnt, trailcnt , previous_continued_action);

			if ( scon_stk_ptr > 0 )
				{
				for ( i = 1; i <= scon_stk_ptr; ++i )
					scbol[scon_stk[i]] =
						mkbranch( scbol[scon_stk[i]],
								pat );
				}

			else
				{
				/* Add to all non-exclusive start conditions,
				 * including the default (0) start condition.
				 */

				for ( i = 1; i <= lastsc; ++i )
					if ( ! scxclu[i] )
						scbol[i] = mkbranch( scbol[i],
									pat );
				}

			if ( ! bol_needed )
				{
				bol_needed = true;

				if ( performance_report > 1 )
					pinpoint_message(
			"'^' operator results in sub-optimal performance" );
				}
			}
break;
case 27:
	{
			pat = yystack.l_mark[0];
			finish_rule( pat, variable_trail_rule,
				headcnt, trailcnt , previous_continued_action);

			if ( scon_stk_ptr > 0 )
				{
				for ( i = 1; i <= scon_stk_ptr; ++i )
					scset[scon_stk[i]] =
						mkbranch( scset[scon_stk[i]],
								pat );
				}

			else
				{
				for ( i = 1; i <= lastsc; ++i )
					if ( ! scxclu[i] )
						scset[i] =
							mkbranch( scset[i],
								pat );
				}
			}
break;
case 28:
	{
			if ( scon_stk_ptr > 0 )
				build_eof_action();

			else
				{
				/* This EOF applies to all start conditions
				 * which don't already have EOF actions.
				 */
				for ( i = 1; i <= lastsc; ++i )
					if ( ! sceof[i] )
						scon_stk[++scon_stk_ptr] = i;

				if ( scon_stk_ptr == 0 )
					lwarn(
			"all start conditions already have <<EOF>> rules" );

				else
					build_eof_action();
				}
			}
break;
case 29:
	{ synerr( _("unrecognized rule") ); }
break;
case 30:
	{ yyval = scon_stk_ptr; }
break;
case 31:
	{ yyval = yystack.l_mark[-2]; }
break;
case 32:
	{
			yyval = scon_stk_ptr;

			for ( i = 1; i <= lastsc; ++i )
				{
				int j;

				for ( j = 1; j <= scon_stk_ptr; ++j )
					if ( scon_stk[j] == i )
						break;

				if ( j > scon_stk_ptr )
					scon_stk[++scon_stk_ptr] = i;
				}
			}
break;
case 33:
	{ yyval = scon_stk_ptr; }
break;
case 36:
	{ synerr( _("bad start condition list") ); }
break;
case 37:
	{
			if ( (scnum = sclookup( nmstr )) == 0 )
				format_pinpoint_message(
					"undeclared start condition %s",
					nmstr );
			else
				{
				for ( i = 1; i <= scon_stk_ptr; ++i )
					if ( scon_stk[i] == scnum )
						{
						format_warn(
							"<%s> specified twice",
							scname[scnum] );
						break;
						}

				if ( i > scon_stk_ptr )
					scon_stk[++scon_stk_ptr] = scnum;
				}
			}
break;
case 38:
	{
			if ( transchar[lastst[yystack.l_mark[0]]] != SYM_EPSILON )
				/* Provide final transition \now/ so it
				 * will be marked as a trailing context
				 * state.
				 */
				yystack.l_mark[0] = link_machines( yystack.l_mark[0],
						mkstate( SYM_EPSILON ) );

			mark_beginning_as_normal( yystack.l_mark[0] );
			current_state_type = STATE_NORMAL;

			if ( previous_continued_action )
				{
				/* We need to treat this as variable trailing
				 * context so that the backup does not happen
				 * in the action but before the action switch
				 * statement.  If the backup happens in the
				 * action, then the rules "falling into" this
				 * one's action will *also* do the backup,
				 * erroneously.
				 */
				if ( ! varlength || headcnt != 0 )
					lwarn(
		"trailing context made variable due to preceding '|' action" );

				/* Mark as variable. */
				varlength = true;
				headcnt = 0;

				}

			if ( lex_compat || (varlength && headcnt == 0) )
				{ /* variable trailing context rule */
				/* Mark the first part of the rule as the
				 * accepting "head" part of a trailing
				 * context rule.
				 *
				 * By the way, we didn't do this at the
				 * beginning of this production because back
				 * then current_state_type was set up for a
				 * trail rule, and add_accept() can create
				 * a new state ...
				 */
				add_accept( yystack.l_mark[-1],
					num_rules | YY_TRAILING_HEAD_MASK );
				variable_trail_rule = true;
				}

			else
				trailcnt = rulelen;

			yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
			}
break;
case 39:
	{ synerr( _("trailing context used twice") ); }
break;
case 40:
	{
			headcnt = 0;
			trailcnt = 1;
			rulelen = 1;
			varlength = false;

			current_state_type = STATE_TRAILING_CONTEXT;

			if ( trlcontxt )
				{
				synerr( _("trailing context used twice") );
				yyval = mkstate( SYM_EPSILON );
				}

			else if ( previous_continued_action )
				{
				/* See the comment in the rule for "re2 re"
				 * above.
				 */
				lwarn(
		"trailing context made variable due to preceding '|' action" );

				varlength = true;
				}

			if ( lex_compat || varlength )
				{
				/* Again, see the comment in the rule for
				 * "re2 re" above.
				 */
				add_accept( yystack.l_mark[-1],
					num_rules | YY_TRAILING_HEAD_MASK );
				variable_trail_rule = true;
				}

			trlcontxt = true;

			eps = mkstate( SYM_EPSILON );
			yyval = link_machines( yystack.l_mark[-1],
				link_machines( eps, mkstate( '\n' ) ) );
			}
break;
case 41:
	{
			yyval = yystack.l_mark[0];

			if ( trlcontxt )
				{
				if ( lex_compat || (varlength && headcnt == 0) )
					/* Both head and trail are
					 * variable-length.
					 */
					variable_trail_rule = true;
				else
					trailcnt = rulelen;
				}
			}
break;
case 42:
	{
			varlength = true;
			yyval = mkor( yystack.l_mark[-2], yystack.l_mark[0] );
			}
break;
case 43:
	{ yyval = yystack.l_mark[0]; }
break;
case 44:
	{
			/* This rule is written separately so the
			 * reduction will occur before the trailing
			 * series is parsed.
			 */

			if ( trlcontxt )
				synerr( _("trailing context used twice") );
			else
				trlcontxt = true;

			if ( varlength )
				/* We hope the trailing context is
				 * fixed-length.
				 */
				varlength = false;
			else
				headcnt = rulelen;

			rulelen = 0;

			current_state_type = STATE_TRAILING_CONTEXT;
			yyval = yystack.l_mark[-1];
			}
break;
case 45:
	{
			/* This is where concatenation of adjacent patterns
			 * gets done.
			 */
			yyval = link_machines( yystack.l_mark[-1], yystack.l_mark[0] );
			}
break;
case 46:
	{ yyval = yystack.l_mark[0]; }
break;
case 47:
	{
			varlength = true;

			if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
				{
				synerr( _("bad iteration values") );
				yyval = yystack.l_mark[-5];
				}
			else
				{
				if ( yystack.l_mark[-3] == 0 )
					{
					if ( yystack.l_mark[-1] <= 0 )
						{
						synerr(
						_("bad iteration values") );
						yyval = yystack.l_mark[-5];
						}
					else
						yyval = mkopt(
							mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
					}
				else
					yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
				}
			}
break;
case 48:
	{
			varlength = true;

			if ( yystack.l_mark[-2] <= 0 )
				{
				synerr( _("iteration value must be positive") );
				yyval = yystack.l_mark[-4];
				}

			else
				yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
			}
break;
case 49:
	{
			/* The series could be something like "(foo)",
			 * in which case we have no idea what its length
			 * is, so we punt here.
			 */
			varlength = true;

			if ( yystack.l_mark[-1] <= 0 )
				{
				  synerr( _("iteration value must be positive")
					  );
				yyval = yystack.l_mark[-3];
				}

			else
				yyval = link_machines( yystack.l_mark[-3],
						copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
			}
break;
case 50:
	{
			varlength = true;

			yyval = mkclos( yystack.l_mark[-1] );
			}
break;
case 51:
	{
			varlength = true;
			yyval = mkposcl( yystack.l_mark[-1] );
			}
break;
case 52:
	{
			varlength = true;
			yyval = mkopt( yystack.l_mark[-1] );
			}
break;
case 53:
	{
			varlength = true;

			if ( yystack.l_mark[-3] > yystack.l_mark[-1] || yystack.l_mark[-3] < 0 )
				{
				synerr( _("bad iteration values") );
				yyval = yystack.l_mark[-5];
				}
			else
				{
				if ( yystack.l_mark[-3] == 0 )
					{
					if ( yystack.l_mark[-1] <= 0 )
						{
						synerr(
						_("bad iteration values") );
						yyval = yystack.l_mark[-5];
						}
					else
						yyval = mkopt(
							mkrep( yystack.l_mark[-5], 1, yystack.l_mark[-1] ) );
					}
				else
					yyval = mkrep( yystack.l_mark[-5], yystack.l_mark[-3], yystack.l_mark[-1] );
				}
			}
break;
case 54:
	{
			varlength = true;

			if ( yystack.l_mark[-2] <= 0 )
				{
				synerr( _("iteration value must be positive") );
				yyval = yystack.l_mark[-4];
				}

			else
				yyval = mkrep( yystack.l_mark[-4], yystack.l_mark[-2], INFINITE_REPEAT );
			}
break;
case 55:
	{
			/* The singleton could be something like "(foo)",
			 * in which case we have no idea what its length
			 * is, so we punt here.
			 */
			varlength = true;

			if ( yystack.l_mark[-1] <= 0 )
				{
				synerr( _("iteration value must be positive") );
				yyval = yystack.l_mark[-3];
				}

			else
				yyval = link_machines( yystack.l_mark[-3],
						copysingl( yystack.l_mark[-3], yystack.l_mark[-1] - 1 ) );
			}
break;
case 56:
	{
			if ( ! madeany )
				{
				/* Create the '.' character class. */
                    ccldot = cclinit();
                    ccladd( ccldot, '\n' );
                    cclnegate( ccldot );

                    if ( useecs )
                        mkeccl( ccltbl + cclmap[ccldot],
                            ccllen[ccldot], nextecm,
                            ecgroup, csize, csize );

				/* Create the (?s:'.') character class. */
                    cclany = cclinit();
                    cclnegate( cclany );

                    if ( useecs )
                        mkeccl( ccltbl + cclmap[cclany],
                            ccllen[cclany], nextecm,
                            ecgroup, csize, csize );

				madeany = true;
				}

			++rulelen;

            if (sf_dot_all())
                yyval = mkstate( -cclany );
            else
                yyval = mkstate( -ccldot );
			}
break;
case 57:
	{
				/* Sort characters for fast searching.
				 */
				qsort( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]], sizeof (*ccltbl), cclcmp );

			if ( useecs )
				mkeccl( ccltbl + cclmap[yystack.l_mark[0]], ccllen[yystack.l_mark[0]],
					nextecm, ecgroup, csize, csize );

			++rulelen;

			if (ccl_has_nl[yystack.l_mark[0]])
				rule_has_nl[num_rules] = true;

			yyval = mkstate( -yystack.l_mark[0] );
			}
break;
case 58:
	{
			++rulelen;

			if (ccl_has_nl[yystack.l_mark[0]])
				rule_has_nl[num_rules] = true;

			yyval = mkstate( -yystack.l_mark[0] );
			}
break;
case 59:
	{ yyval = yystack.l_mark[-1]; }
break;
case 60:
	{ yyval = yystack.l_mark[-1]; }
break;
case 61:
	{
			++rulelen;

			if (yystack.l_mark[0] == nlch)
				rule_has_nl[num_rules] = true;

            if (sf_case_ins() && has_case(yystack.l_mark[0]))
                /* create an alternation, as in (a|A) */
                yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
            else
                yyval = mkstate( yystack.l_mark[0] );
			}
break;
case 62:
	{ yyval = ccl_set_diff  (yystack.l_mark[-2], yystack.l_mark[0]); }
break;
case 63:
	{ yyval = ccl_set_union (yystack.l_mark[-2], yystack.l_mark[0]); }
break;
case 65:
	{ yyval = yystack.l_mark[-1]; }
break;
case 66:
	{
			cclnegate( yystack.l_mark[-1] );
			yyval = yystack.l_mark[-1];
			}
break;
case 67:
	{

			if (sf_case_ins())
			  {

			    /* If one end of the range has case and the other
			     * does not, or the cases are different, then we're not
			     * sure what range the user is trying to express.
			     * Examples: [@-z] or [S-t]
			     */
			    if (has_case (yystack.l_mark[-2]) != has_case (yystack.l_mark[0])
				     || (has_case (yystack.l_mark[-2]) && (b_islower (yystack.l_mark[-2]) != b_islower (yystack.l_mark[0])))
				     || (has_case (yystack.l_mark[-2]) && (b_isupper (yystack.l_mark[-2]) != b_isupper (yystack.l_mark[0]))))
			      format_warn3 (
			      _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
					    yystack.l_mark[-2], yystack.l_mark[0]);

			    /* If the range spans uppercase characters but not
			     * lowercase (or vice-versa), then should we automatically
			     * include lowercase characters in the range?
			     * Example: [@-_] spans [a-z] but not [A-Z]
			     */
			    else if (!has_case (yystack.l_mark[-2]) && !has_case (yystack.l_mark[0]) && !range_covers_case (yystack.l_mark[-2], yystack.l_mark[0]))
			      format_warn3 (
			      _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
					    yystack.l_mark[-2], yystack.l_mark[0]);
			  }

			if ( yystack.l_mark[-2] > yystack.l_mark[0] )
				synerr( _("negative range in character class") );

			else
				{
				for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
					ccladd( yystack.l_mark[-3], i );

				/* Keep track if this ccl is staying in
				 * alphabetical order.
				 */
				cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
				lastchar = yystack.l_mark[0];

                /* Do it again for upper/lowercase */
                if (sf_case_ins() && has_case(yystack.l_mark[-2]) && has_case(yystack.l_mark[0])){
                    yystack.l_mark[-2] = reverse_case (yystack.l_mark[-2]);
                    yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);

                    for ( i = yystack.l_mark[-2]; i <= yystack.l_mark[0]; ++i )
                        ccladd( yystack.l_mark[-3], i );

                    cclsorted = cclsorted && (yystack.l_mark[-2] > lastchar);
                    lastchar = yystack.l_mark[0];
                }

				}

			yyval = yystack.l_mark[-3];
			}
break;
case 68:
	{
			ccladd( yystack.l_mark[-1], yystack.l_mark[0] );
			cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
			lastchar = yystack.l_mark[0];

            /* Do it again for upper/lowercase */
            if (sf_case_ins() && has_case(yystack.l_mark[0])){
                yystack.l_mark[0] = reverse_case (yystack.l_mark[0]);
                ccladd (yystack.l_mark[-1], yystack.l_mark[0]);

                cclsorted = cclsorted && (yystack.l_mark[0] > lastchar);
                lastchar = yystack.l_mark[0];
            }

			yyval = yystack.l_mark[-1];
			}
break;
case 69:
	{
			/* Too hard to properly maintain cclsorted. */
			cclsorted = false;
			yyval = yystack.l_mark[-1];
			}
break;
case 70:
	{
			cclsorted = true;
			lastchar = 0;
			currccl = yyval = cclinit();
			}
break;
case 71:
	{ CCL_EXPR(isalnum); }
break;
case 72:
	{ CCL_EXPR(isalpha); }
break;
case 73:
	{ CCL_EXPR(IS_BLANK); }
break;
case 74:
	{ CCL_EXPR(iscntrl); }
break;
case 75:
	{ CCL_EXPR(isdigit); }
break;
case 76:
	{ CCL_EXPR(isgraph); }
break;
case 77:
	{
                          CCL_EXPR(islower);
                          if (sf_case_ins())
                              CCL_EXPR(isupper);
                        }
break;
case 78:
	{ CCL_EXPR(isprint); }
break;
case 79:
	{ CCL_EXPR(ispunct); }
break;
case 80:
	{ CCL_EXPR(isspace); }
break;
case 81:
	{ CCL_EXPR(isxdigit); }
break;
case 82:
	{
                    CCL_EXPR(isupper);
                    if (sf_case_ins())
                        CCL_EXPR(islower);
				}
break;
case 83:
	{ CCL_NEG_EXPR(isalnum); }
break;
case 84:
	{ CCL_NEG_EXPR(isalpha); }
break;
case 85:
	{ CCL_NEG_EXPR(IS_BLANK); }
break;
case 86:
	{ CCL_NEG_EXPR(iscntrl); }
break;
case 87:
	{ CCL_NEG_EXPR(isdigit); }
break;
case 88:
	{ CCL_NEG_EXPR(isgraph); }
break;
case 89:
	{ CCL_NEG_EXPR(isprint); }
break;
case 90:
	{ CCL_NEG_EXPR(ispunct); }
break;
case 91:
	{ CCL_NEG_EXPR(isspace); }
break;
case 92:
	{ CCL_NEG_EXPR(isxdigit); }
break;
case 93:
	{
				if ( sf_case_ins() )
					lwarn(_("[:^lower:] is ambiguous in case insensitive scanner"));
				else
					CCL_NEG_EXPR(islower);
				}
break;
case 94:
	{
				if ( sf_case_ins() )
					lwarn(_("[:^upper:] ambiguous in case insensitive scanner"));
				else
					CCL_NEG_EXPR(isupper);
				}
break;
case 95:
	{
			if ( yystack.l_mark[0] == nlch )
				rule_has_nl[num_rules] = true;

			++rulelen;

            if (sf_case_ins() && has_case(yystack.l_mark[0]))
                yyval = mkor (mkstate(yystack.l_mark[0]), mkstate(reverse_case(yystack.l_mark[0])));
            else
                yyval = mkstate (yystack.l_mark[0]);

			yyval = link_machines( yystack.l_mark[-1], yyval);
			}
break;
case 96:
	{ yyval = mkstate( SYM_EPSILON ); }
break;
    }
    yystack.s_mark -= yym;
    yystate = *yystack.s_mark;
    yystack.l_mark -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yystack.s_mark = YYFINAL;
        *++yystack.l_mark = yyval;
        if (yychar < 0)
        {
            if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
#endif
    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
    {
        goto yyoverflow;
    }
    *++yystack.s_mark = (short) yystate;
    *++yystack.l_mark = yyval;
    goto yyloop;

yyoverflow:
    yyerror("yacc stack overflow");

yyabort:
    yyfreestack(&yystack);
    return (1);

yyaccept:
    yyfreestack(&yystack);
    return (0);
}