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