Module Name: src
Committed By: christos
Date: Thu Oct 29 17:17:12 UTC 2009
Added Files:
src/external/bsd/flex/dist: initparse.c initparse.h
Removed Files:
src/external/bsd/flex/dist: parse.c parse.h
Log Message:
we can regenerate yacc files now
To generate a diff of this commit:
cvs rdiff -u -r0 -r1.1 src/external/bsd/flex/dist/initparse.c \
src/external/bsd/flex/dist/initparse.h
cvs rdiff -u -r1.2 -r0 src/external/bsd/flex/dist/parse.c
cvs rdiff -u -r1.1.1.1 -r0 src/external/bsd/flex/dist/parse.h
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Added files:
Index: src/external/bsd/flex/dist/initparse.c
diff -u /dev/null src/external/bsd/flex/dist/initparse.c:1.1
--- /dev/null Thu Oct 29 13:17:12 2009
+++ src/external/bsd/flex/dist/initparse.c Thu Oct 29 13:17:12 2009
@@ -0,0 +1,1808 @@
+#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 YYLEX yylex()
+#define YYEMPTY (-1)
+#define yyclearin (yychar = YYEMPTY)
+#define yyerrok (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+/* 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 /* YYPARSE_PARAM */
+
+static int yygrowstack(void);
+#define YYPREFIX "yy"
+#line 37 "/usr/src/external/bsd/flex/dist/parse.y"
+/* Copyright (c) 1990 The Regents of the University of California. */
+/* All rights reserved. */
+
+/* This code is derived from software contributed to Berkeley by */
+/* Vern Paxson. */
+
+/* The United States Government has rights in this work pursuant */
+/* to contract no. DE-AC03-76SF00098 between the United States */
+/* Department of Energy and the University of California. */
+
+/* This file is part of flex. */
+
+/* Redistribution and use in source and binary forms, with or without */
+/* modification, are permitted provided that the following conditions */
+/* are met: */
+
+/* 1. Redistributions of source code must retain the above copyright */
+/* notice, this list of conditions and the following disclaimer. */
+/* 2. Redistributions in binary form must reproduce the above copyright */
+/* notice, this list of conditions and the following disclaimer in the */
+/* documentation and/or other materials provided with the distribution. */
+
+/* Neither the name of the University nor the names of its contributors */
+/* may be used to endorse or promote products derived from this software */
+/* without specific prior written permission. */
+
+/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
+/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
+/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
+/* PURPOSE. */
+
+#include "flexdef.h"
+#include "tables.h"
+
+int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen;
+int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule;
+
+int *scon_stk;
+int scon_stk_ptr;
+
+static int madeany = false; /* whether we've made the '.' character class */
+static int ccldot, cclany;
+int previous_continued_action; /* whether the previous rule's action was '|' */
+
+#define format_warn3(fmt, a1, a2) \
+ do{ \
+ char fw3_msg[MAXLINE];\
+ snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\
+ 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
+
+#line 116 "/usr/src/external/bsd/flex/dist/parse.c"
+#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
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+#if YYDEBUG
+#include <stdio.h>
+#endif
+
+extern int YYPARSE_DECL();
+
+/* 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
+
+int yydebug;
+int yynerrs;
+int yyerrflag;
+int yychar;
+short *yyssp;
+YYSTYPE *yyvsp;
+YYSTYPE yyval;
+YYSTYPE yylval;
+
+/* variables for the parser stack */
+static short *yyss;
+static short *yysslim;
+static YYSTYPE *yyvs;
+static unsigned yystacksize;
+#line 952 "/usr/src/external/bsd/flex/dist/parse.y"
+
+
+/* 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;
+ 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;
+ {
+ }
+#line 637 "/usr/src/external/bsd/flex/dist/parse.c"
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(void)
+{
+ int i;
+ unsigned newsize;
+ short *newss;
+ YYSTYPE *newvs;
+
+ if ((newsize = yystacksize) == 0)
+ newsize = YYINITSTACKSIZE;
+ else if (newsize >= YYMAXDEPTH)
+ return -1;
+ else if ((newsize *= 2) > YYMAXDEPTH)
+ newsize = YYMAXDEPTH;
+
+ i = yyssp - yyss;
+ newss = (yyss != 0)
+ ? (short *)realloc(yyss, newsize * sizeof(*newss))
+ : (short *)malloc(newsize * sizeof(*newss));
+ if (newss == 0)
+ return -1;
+
+ yyss = newss;
+ yyssp = newss + i;
+ newvs = (yyvs != 0)
+ ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
+ : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
+ if (newvs == 0)
+ return -1;
+
+ yyvs = newvs;
+ yyvsp = newvs + i;
+ yystacksize = newsize;
+ yysslim = yyss + newsize - 1;
+ return 0;
+}
+
+#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 (yyss == NULL && yygrowstack()) goto yyoverflow;
+ yyssp = yyss;
+ yyvsp = yyvs;
+ yystate = 0;
+ *yyssp = 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 (yyssp >= yysslim && yygrowstack())
+ {
+ goto yyoverflow;
+ }
+ yystate = yytable[yyn];
+ *++yyssp = yytable[yyn];
+ *++yyvsp = 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[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
+ yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+ {
+#if YYDEBUG
+ if (yydebug)
+ printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
+#endif
+ if (yyssp >= yysslim && yygrowstack())
+ {
+ goto yyoverflow;
+ }
+ yystate = yytable[yyn];
+ *++yyssp = yytable[yyn];
+ *++yyvsp = yylval;
+ goto yyloop;
+ }
+ else
+ {
+#if YYDEBUG
+ if (yydebug)
+ printf("%sdebug: error recovery discarding state %d\n",
+ YYPREFIX, *yyssp);
+#endif
+ if (yyssp <= yyss) goto yyabort;
+ --yyssp;
+ --yyvsp;
+ }
+ }
+ }
+ 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 = yyvsp[1-yym];
+ else
+ memset(&yyval, 0, sizeof yyval);
+ switch (yyn)
+ {
+case 1:
+#line 121 "/usr/src/external/bsd/flex/dist/parse.y"
+ { /* add default rule */
+ int def_rule;
+
+ pat = cclinit();
+ cclnegate( pat );
+
+ def_rule = mkstate( -pat );
+
+ /* Remember the number of the default rule so we
+ * don't generate "can't match" warnings for it.
+ */
+ default_rule = num_rules;
+
+ finish_rule( def_rule, false, 0, 0, 0);
+
+ for ( i = 1; i <= lastsc; ++i )
+ scset[i] = mkbranch( scset[i], def_rule );
+
+ if ( spprdflt )
+ add_action(
+ "YY_FATAL_ERROR( \"flex scanner jammed\" )" );
+ else
+ add_action( "ECHO" );
+
+ add_action( ";\n\tYY_BREAK\n" );
+ }
+break;
+case 2:
+#line 150 "/usr/src/external/bsd/flex/dist/parse.y"
+ { /* initialize for processing rules */
+
+ /* Create default DFA start condition. */
+ scinstal( "INITIAL", false );
+ }
+break;
+case 6:
+#line 161 "/usr/src/external/bsd/flex/dist/parse.y"
+ { synerr( _("unknown error processing section 1") ); }
+break;
+case 7:
+#line 165 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ check_options();
+ scon_stk = allocate_integer_array( lastsc + 1 );
+ scon_stk_ptr = 0;
+ }
+break;
+case 8:
+#line 173 "/usr/src/external/bsd/flex/dist/parse.y"
+ { xcluflg = false; }
+break;
+case 9:
+#line 176 "/usr/src/external/bsd/flex/dist/parse.y"
+ { xcluflg = true; }
+break;
+case 10:
+#line 180 "/usr/src/external/bsd/flex/dist/parse.y"
+ { scinstal( nmstr, xcluflg ); }
+break;
+case 11:
+#line 183 "/usr/src/external/bsd/flex/dist/parse.y"
+ { scinstal( nmstr, xcluflg ); }
+break;
+case 12:
+#line 186 "/usr/src/external/bsd/flex/dist/parse.y"
+ { synerr( _("bad start condition list") ); }
+break;
+case 16:
+#line 197 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ outfilename = copy_string( nmstr );
+ did_outfilename = 1;
+ }
+break;
+case 17:
+#line 202 "/usr/src/external/bsd/flex/dist/parse.y"
+ { extra_type = copy_string( nmstr ); }
+break;
+case 18:
+#line 204 "/usr/src/external/bsd/flex/dist/parse.y"
+ { prefix = copy_string( nmstr ); }
+break;
+case 19:
+#line 206 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyclass = copy_string( nmstr ); }
+break;
+case 20:
+#line 208 "/usr/src/external/bsd/flex/dist/parse.y"
+ { headerfilename = copy_string( nmstr ); }
+break;
+case 21:
+#line 210 "/usr/src/external/bsd/flex/dist/parse.y"
+ { tablesext = true; tablesfilename = copy_string( nmstr ); }
+break;
+case 22:
+#line 214 "/usr/src/external/bsd/flex/dist/parse.y"
+ { scon_stk_ptr = yyvsp[-3]; }
+break;
+case 23:
+#line 216 "/usr/src/external/bsd/flex/dist/parse.y"
+ { scon_stk_ptr = yyvsp[-3]; }
+break;
+case 25:
+#line 221 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* Initialize for a parse of one rule. */
+ trlcontxt = variable_trail_rule = varlength = false;
+ trailcnt = headcnt = rulelen = 0;
+ current_state_type = STATE_NORMAL;
+ previous_continued_action = continued_action;
+ in_rule = true;
+
+ new_rule();
+ }
+break;
+case 26:
+#line 234 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ pat = yyvsp[0];
+ finish_rule( pat, variable_trail_rule,
+ headcnt, trailcnt , previous_continued_action);
+
+ if ( scon_stk_ptr > 0 )
+ {
+ for ( i = 1; i <= scon_stk_ptr; ++i )
+ scbol[scon_stk[i]] =
+ mkbranch( scbol[scon_stk[i]],
+ pat );
+ }
+
+ else
+ {
+ /* Add to all non-exclusive start conditions,
+ * including the default (0) start condition.
+ */
+
+ for ( i = 1; i <= lastsc; ++i )
+ if ( ! scxclu[i] )
+ scbol[i] = mkbranch( scbol[i],
+ pat );
+ }
+
+ if ( ! bol_needed )
+ {
+ bol_needed = true;
+
+ if ( performance_report > 1 )
+ pinpoint_message(
+ "'^' operator results in sub-optimal performance" );
+ }
+ }
+break;
+case 27:
+#line 270 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ pat = yyvsp[0];
+ finish_rule( pat, variable_trail_rule,
+ headcnt, trailcnt , previous_continued_action);
+
+ if ( scon_stk_ptr > 0 )
+ {
+ for ( i = 1; i <= scon_stk_ptr; ++i )
+ scset[scon_stk[i]] =
+ mkbranch( scset[scon_stk[i]],
+ pat );
+ }
+
+ else
+ {
+ for ( i = 1; i <= lastsc; ++i )
+ if ( ! scxclu[i] )
+ scset[i] =
+ mkbranch( scset[i],
+ pat );
+ }
+ }
+break;
+case 28:
+#line 294 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( scon_stk_ptr > 0 )
+ build_eof_action();
+
+ else
+ {
+ /* This EOF applies to all start conditions
+ * which don't already have EOF actions.
+ */
+ for ( i = 1; i <= lastsc; ++i )
+ if ( ! sceof[i] )
+ scon_stk[++scon_stk_ptr] = i;
+
+ if ( scon_stk_ptr == 0 )
+ lwarn(
+ "all start conditions already have <<EOF>> rules" );
+
+ else
+ build_eof_action();
+ }
+ }
+break;
+case 29:
+#line 317 "/usr/src/external/bsd/flex/dist/parse.y"
+ { synerr( _("unrecognized rule") ); }
+break;
+case 30:
+#line 321 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = scon_stk_ptr; }
+break;
+case 31:
+#line 325 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[-2]; }
+break;
+case 32:
+#line 328 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ yyval = scon_stk_ptr;
+
+ for ( i = 1; i <= lastsc; ++i )
+ {
+ int j;
+
+ for ( j = 1; j <= scon_stk_ptr; ++j )
+ if ( scon_stk[j] == i )
+ break;
+
+ if ( j > scon_stk_ptr )
+ scon_stk[++scon_stk_ptr] = i;
+ }
+ }
+break;
+case 33:
+#line 345 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = scon_stk_ptr; }
+break;
+case 36:
+#line 353 "/usr/src/external/bsd/flex/dist/parse.y"
+ { synerr( _("bad start condition list") ); }
+break;
+case 37:
+#line 357 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( (scnum = sclookup( nmstr )) == 0 )
+ format_pinpoint_message(
+ "undeclared start condition %s",
+ nmstr );
+ else
+ {
+ for ( i = 1; i <= scon_stk_ptr; ++i )
+ if ( scon_stk[i] == scnum )
+ {
+ format_warn(
+ "<%s> specified twice",
+ scname[scnum] );
+ break;
+ }
+
+ if ( i > scon_stk_ptr )
+ scon_stk[++scon_stk_ptr] = scnum;
+ }
+ }
+break;
+case 38:
+#line 380 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON )
+ /* Provide final transition \now/ so it
+ * will be marked as a trailing context
+ * state.
+ */
+ yyvsp[0] = link_machines( yyvsp[0],
+ mkstate( SYM_EPSILON ) );
+
+ mark_beginning_as_normal( yyvsp[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( yyvsp[-1],
+ num_rules | YY_TRAILING_HEAD_MASK );
+ variable_trail_rule = true;
+ }
+
+ else
+ trailcnt = rulelen;
+
+ yyval = link_machines( yyvsp[-1], yyvsp[0] );
+ }
+break;
+case 39:
+#line 436 "/usr/src/external/bsd/flex/dist/parse.y"
+ { synerr( _("trailing context used twice") ); }
+break;
+case 40:
+#line 439 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ headcnt = 0;
+ trailcnt = 1;
+ rulelen = 1;
+ varlength = false;
+
+ current_state_type = STATE_TRAILING_CONTEXT;
+
+ if ( trlcontxt )
+ {
+ synerr( _("trailing context used twice") );
+ yyval = mkstate( SYM_EPSILON );
+ }
+
+ else if ( previous_continued_action )
+ {
+ /* See the comment in the rule for "re2 re"
+ * above.
+ */
+ 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( yyvsp[-1],
+ num_rules | YY_TRAILING_HEAD_MASK );
+ variable_trail_rule = true;
+ }
+
+ trlcontxt = true;
+
+ eps = mkstate( SYM_EPSILON );
+ yyval = link_machines( yyvsp[-1],
+ link_machines( eps, mkstate( '\n' ) ) );
+ }
+break;
+case 41:
+#line 482 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ yyval = yyvsp[0];
+
+ if ( trlcontxt )
+ {
+ if ( lex_compat || (varlength && headcnt == 0) )
+ /* Both head and trail are
+ * variable-length.
+ */
+ variable_trail_rule = true;
+ else
+ trailcnt = rulelen;
+ }
+ }
+break;
+case 42:
+#line 500 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+ yyval = mkor( yyvsp[-2], yyvsp[0] );
+ }
+break;
+case 43:
+#line 506 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[0]; }
+break;
+case 44:
+#line 511 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* This rule is written separately so the
+ * reduction will occur before the trailing
+ * series is parsed.
+ */
+
+ if ( trlcontxt )
+ synerr( _("trailing context used twice") );
+ else
+ trlcontxt = true;
+
+ if ( varlength )
+ /* We hope the trailing context is
+ * fixed-length.
+ */
+ varlength = false;
+ else
+ headcnt = rulelen;
+
+ rulelen = 0;
+
+ current_state_type = STATE_TRAILING_CONTEXT;
+ yyval = yyvsp[-1];
+ }
+break;
+case 45:
+#line 538 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* This is where concatenation of adjacent patterns
+ * gets done.
+ */
+ yyval = link_machines( yyvsp[-1], yyvsp[0] );
+ }
+break;
+case 46:
+#line 546 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[0]; }
+break;
+case 47:
+#line 549 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+
+ if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
+ {
+ synerr( _("bad iteration values") );
+ yyval = yyvsp[-5];
+ }
+ else
+ {
+ if ( yyvsp[-3] == 0 )
+ {
+ if ( yyvsp[-1] <= 0 )
+ {
+ synerr(
+ _("bad iteration values") );
+ yyval = yyvsp[-5];
+ }
+ else
+ yyval = mkopt(
+ mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
+ }
+ else
+ yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
+ }
+ }
+break;
+case 48:
+#line 577 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+
+ if ( yyvsp[-2] <= 0 )
+ {
+ synerr( _("iteration value must be positive") );
+ yyval = yyvsp[-4];
+ }
+
+ else
+ yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT );
+ }
+break;
+case 49:
+#line 591 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* The series could be something like "(foo)",
+ * in which case we have no idea what its length
+ * is, so we punt here.
+ */
+ varlength = true;
+
+ if ( yyvsp[-1] <= 0 )
+ {
+ synerr( _("iteration value must be positive")
+ );
+ yyval = yyvsp[-3];
+ }
+
+ else
+ yyval = link_machines( yyvsp[-3],
+ copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
+ }
+break;
+case 50:
+#line 613 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+
+ yyval = mkclos( yyvsp[-1] );
+ }
+break;
+case 51:
+#line 620 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+ yyval = mkposcl( yyvsp[-1] );
+ }
+break;
+case 52:
+#line 626 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+ yyval = mkopt( yyvsp[-1] );
+ }
+break;
+case 53:
+#line 632 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+
+ if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 )
+ {
+ synerr( _("bad iteration values") );
+ yyval = yyvsp[-5];
+ }
+ else
+ {
+ if ( yyvsp[-3] == 0 )
+ {
+ if ( yyvsp[-1] <= 0 )
+ {
+ synerr(
+ _("bad iteration values") );
+ yyval = yyvsp[-5];
+ }
+ else
+ yyval = mkopt(
+ mkrep( yyvsp[-5], 1, yyvsp[-1] ) );
+ }
+ else
+ yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] );
+ }
+ }
+break;
+case 54:
+#line 660 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ varlength = true;
+
+ if ( yyvsp[-2] <= 0 )
+ {
+ synerr( _("iteration value must be positive") );
+ yyval = yyvsp[-4];
+ }
+
+ else
+ yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT );
+ }
+break;
+case 55:
+#line 674 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* The singleton could be something like "(foo)",
+ * in which case we have no idea what its length
+ * is, so we punt here.
+ */
+ varlength = true;
+
+ if ( yyvsp[-1] <= 0 )
+ {
+ synerr( _("iteration value must be positive") );
+ yyval = yyvsp[-3];
+ }
+
+ else
+ yyval = link_machines( yyvsp[-3],
+ copysingl( yyvsp[-3], yyvsp[-1] - 1 ) );
+ }
+break;
+case 56:
+#line 693 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( ! madeany )
+ {
+ /* Create the '.' character class. */
+ ccldot = cclinit();
+ ccladd( ccldot, '\n' );
+ cclnegate( ccldot );
+
+ if ( useecs )
+ mkeccl( ccltbl + cclmap[ccldot],
+ ccllen[ccldot], nextecm,
+ ecgroup, csize, csize );
+
+ /* Create the (?s:'.') character class. */
+ cclany = cclinit();
+ cclnegate( cclany );
+
+ if ( useecs )
+ mkeccl( ccltbl + cclmap[cclany],
+ ccllen[cclany], nextecm,
+ ecgroup, csize, csize );
+
+ madeany = true;
+ }
+
+ ++rulelen;
+
+ if (sf_dot_all())
+ yyval = mkstate( -cclany );
+ else
+ yyval = mkstate( -ccldot );
+ }
+break;
+case 57:
+#line 727 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* Sort characters for fast searching. We
+ * use a shell sort since this list could
+ * be large.
+ */
+ cshell( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], true );
+
+ if ( useecs )
+ mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]],
+ nextecm, ecgroup, csize, csize );
+
+ ++rulelen;
+
+ if (ccl_has_nl[yyvsp[0]])
+ rule_has_nl[num_rules] = true;
+
+ yyval = mkstate( -yyvsp[0] );
+ }
+break;
+case 58:
+#line 747 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ ++rulelen;
+
+ if (ccl_has_nl[yyvsp[0]])
+ rule_has_nl[num_rules] = true;
+
+ yyval = mkstate( -yyvsp[0] );
+ }
+break;
+case 59:
+#line 757 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[-1]; }
+break;
+case 60:
+#line 760 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[-1]; }
+break;
+case 61:
+#line 763 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ ++rulelen;
+
+ if (yyvsp[0] == nlch)
+ rule_has_nl[num_rules] = true;
+
+ if (sf_case_ins() && has_case(yyvsp[0]))
+ /* create an alternation, as in (a|A) */
+ yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0])));
+ else
+ yyval = mkstate( yyvsp[0] );
+ }
+break;
+case 62:
+#line 777 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = ccl_set_diff (yyvsp[-2], yyvsp[0]); }
+break;
+case 63:
+#line 778 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = ccl_set_union (yyvsp[-2], yyvsp[0]); }
+break;
+case 65:
+#line 784 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = yyvsp[-1]; }
+break;
+case 66:
+#line 787 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ cclnegate( yyvsp[-1] );
+ yyval = yyvsp[-1];
+ }
+break;
+case 67:
+#line 794 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+
+ if (sf_case_ins())
+ {
+
+ /* If one end of the range has case and the other
+ * does not, or the cases are different, then we're not
+ * sure what range the user is trying to express.
+ * Examples: [...@-z] or [S-t]
+ */
+ if (has_case (yyvsp[-2]) != has_case (yyvsp[0])
+ || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0])))
+ || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0]))))
+ format_warn3 (
+ _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
+ yyvsp[-2], yyvsp[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 (yyvsp[-2]) && !has_case (yyvsp[0]) && !range_covers_case (yyvsp[-2], yyvsp[0]))
+ format_warn3 (
+ _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"),
+ yyvsp[-2], yyvsp[0]);
+ }
+
+ if ( yyvsp[-2] > yyvsp[0] )
+ synerr( _("negative range in character class") );
+
+ else
+ {
+ for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
+ ccladd( yyvsp[-3], i );
+
+ /* Keep track if this ccl is staying in
+ * alphabetical order.
+ */
+ cclsorted = cclsorted && (yyvsp[-2] > lastchar);
+ lastchar = yyvsp[0];
+
+ /* Do it again for upper/lowercase */
+ if (sf_case_ins() && has_case(yyvsp[-2]) && has_case(yyvsp[0])){
+ yyvsp[-2] = reverse_case (yyvsp[-2]);
+ yyvsp[0] = reverse_case (yyvsp[0]);
+
+ for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i )
+ ccladd( yyvsp[-3], i );
+
+ cclsorted = cclsorted && (yyvsp[-2] > lastchar);
+ lastchar = yyvsp[0];
+ }
+
+ }
+
+ yyval = yyvsp[-3];
+ }
+break;
+case 68:
+#line 854 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ ccladd( yyvsp[-1], yyvsp[0] );
+ cclsorted = cclsorted && (yyvsp[0] > lastchar);
+ lastchar = yyvsp[0];
+
+ /* Do it again for upper/lowercase */
+ if (sf_case_ins() && has_case(yyvsp[0])){
+ yyvsp[0] = reverse_case (yyvsp[0]);
+ ccladd (yyvsp[-1], yyvsp[0]);
+
+ cclsorted = cclsorted && (yyvsp[0] > lastchar);
+ lastchar = yyvsp[0];
+ }
+
+ yyval = yyvsp[-1];
+ }
+break;
+case 69:
+#line 872 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ /* Too hard to properly maintain cclsorted. */
+ cclsorted = false;
+ yyval = yyvsp[-1];
+ }
+break;
+case 70:
+#line 879 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ cclsorted = true;
+ lastchar = 0;
+ currccl = yyval = cclinit();
+ }
+break;
+case 71:
+#line 887 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isalnum); }
+break;
+case 72:
+#line 888 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isalpha); }
+break;
+case 73:
+#line 889 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(IS_BLANK); }
+break;
+case 74:
+#line 890 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(iscntrl); }
+break;
+case 75:
+#line 891 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isdigit); }
+break;
+case 76:
+#line 892 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isgraph); }
+break;
+case 77:
+#line 893 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ CCL_EXPR(islower);
+ if (sf_case_ins())
+ CCL_EXPR(isupper);
+ }
+break;
+case 78:
+#line 898 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isprint); }
+break;
+case 79:
+#line 899 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(ispunct); }
+break;
+case 80:
+#line 900 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isspace); }
+break;
+case 81:
+#line 901 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_EXPR(isxdigit); }
+break;
+case 82:
+#line 902 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ CCL_EXPR(isupper);
+ if (sf_case_ins())
+ CCL_EXPR(islower);
+ }
+break;
+case 83:
+#line 908 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isalnum); }
+break;
+case 84:
+#line 909 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isalpha); }
+break;
+case 85:
+#line 910 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(IS_BLANK); }
+break;
+case 86:
+#line 911 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(iscntrl); }
+break;
+case 87:
+#line 912 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isdigit); }
+break;
+case 88:
+#line 913 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isgraph); }
+break;
+case 89:
+#line 914 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isprint); }
+break;
+case 90:
+#line 915 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(ispunct); }
+break;
+case 91:
+#line 916 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isspace); }
+break;
+case 92:
+#line 917 "/usr/src/external/bsd/flex/dist/parse.y"
+ { CCL_NEG_EXPR(isxdigit); }
+break;
+case 93:
+#line 918 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( sf_case_ins() )
+ lwarn(_("[:^lower:] is ambiguous in case insensitive scanner"));
+ else
+ CCL_NEG_EXPR(islower);
+ }
+break;
+case 94:
+#line 924 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( sf_case_ins() )
+ lwarn(_("[:^upper:] ambiguous in case insensitive scanner"));
+ else
+ CCL_NEG_EXPR(isupper);
+ }
+break;
+case 95:
+#line 933 "/usr/src/external/bsd/flex/dist/parse.y"
+ {
+ if ( yyvsp[0] == nlch )
+ rule_has_nl[num_rules] = true;
+
+ ++rulelen;
+
+ if (sf_case_ins() && has_case(yyvsp[0]))
+ yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0])));
+ else
+ yyval = mkstate (yyvsp[0]);
+
+ yyval = link_machines( yyvsp[-1], yyval);
+ }
+break;
+case 96:
+#line 948 "/usr/src/external/bsd/flex/dist/parse.y"
+ { yyval = mkstate( SYM_EPSILON ); }
+break;
+#line 1749 "/usr/src/external/bsd/flex/dist/parse.c"
+ }
+ yyssp -= yym;
+ yystate = *yyssp;
+ yyvsp -= 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;
+ *++yyssp = YYFINAL;
+ *++yyvsp = 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, *yyssp, yystate);
+#endif
+ if (yyssp >= yysslim && yygrowstack())
+ {
+ goto yyoverflow;
+ }
+ *++yyssp = (short) yystate;
+ *++yyvsp = yyval;
+ goto yyloop;
+
+yyoverflow:
+ yyerror("yacc stack overflow");
+
+yyabort:
+ return (1);
+
+yyaccept:
+ return (0);
+}
Index: src/external/bsd/flex/dist/initparse.h
diff -u /dev/null src/external/bsd/flex/dist/initparse.h:1.1
--- /dev/null Thu Oct 29 13:17:12 2009
+++ src/external/bsd/flex/dist/initparse.h Thu Oct 29 13:17:12 2009
@@ -0,0 +1,45 @@
+#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
