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