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