/*-*- mode:c;indent-tabs-mode:t;c-basic-offset:8;tab-width:8;coding:utf-8 -*-│ │vi: set et ft=c ts=8 sw=8 fenc=utf-8 :vi│ └─────────────────────────────────────────────────────────────────────────────*/ #include "libc/alg/alg.h" #include "libc/fmt/fmt.h" #include "libc/mem/mem.h" #include "libc/runtime/runtime.h" #include "libc/str/str.h" #include "third_party/lex/flexdef.h" #include "third_party/lex/tables.h" /* clang-format off */ #define YYBYACC 1 #define YYMAJOR 1 #define YYMINOR 9 #define YYLEX yylex() #define YYEMPTY -1 #define yyclearin (yychar=(YYEMPTY)) #define yyerrok (yyerrflag=0) #define YYRECOVERING() (yyerrflag!=0) #define YYPREFIX "yy" /* #line 37 "third_party/lex/parse.y" */ /* Copyright (c) 1990 The Regents of the University of California. */ /* All rights reserved. */ /* This code is derived from software contributed to Berkeley by */ /* Vern Paxson. */ /* The United States Government has rights in this work pursuant */ /* to contract no. DE-AC03-76SF00098 between the United States */ /* Department of Energy and the University of California. */ /* This file is part of flex. */ /* Redistribution and use in source and binary forms, with or without */ /* modification, are permitted provided that the following conditions */ /* are met: */ /* 1. Redistributions of source code must retain the above copyright */ /* notice, this list of conditions and the following disclaimer. */ /* 2. Redistributions in binary form must reproduce the above copyright */ /* notice, this list of conditions and the following disclaimer in the */ /* documentation and/or other materials provided with the distribution. */ /* Neither the name of the University nor the names of its contributors */ /* may be used to endorse or promote products derived from this software */ /* without specific prior written permission. */ /* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */ /* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */ /* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */ /* PURPOSE. */ int pat, scnum, eps, headcnt, trailcnt, lastchar, i, rulelen; int trlcontxt, xcluflg, currccl, cclsorted, varlength, variable_trail_rule; int *scon_stk; int scon_stk_ptr; static int madeany = false; /* whether we've made the '.' character class */ static int ccldot, cclany; int previous_continued_action; /* whether the previous rule's action was '|' */ #define format_warn3(fmt, a1, a2) \ do{ \ char fw3_msg[MAXLINE];\ snprintf( fw3_msg, MAXLINE,(fmt), (a1), (a2) );\ lexwarn( fw3_msg );\ }while(0) /* Expand a POSIX character class expression. */ #define CCL_EXPR(func) \ do{ \ int c; \ for ( c = 0; c < csize; ++c ) \ if ( isascii(c) && func(c) ) \ ccladd( currccl, c ); \ }while(0) /* negated class */ #define CCL_NEG_EXPR(func) \ do{ \ int c; \ for ( c = 0; c < csize; ++c ) \ if ( !func(c) ) \ ccladd( currccl, c ); \ }while(0) /* On some over-ambitious machines, such as DEC Alpha's, the default * token type is "long" instead of "int"; this leads to problems with * declaring yylval in flexdef.h. But so far, all the yacc's I've seen * wrap their definitions of YYSTYPE with "#ifndef YYSTYPE"'s, so the * following should ensure that the default token type is "int". */ #define YYSTYPE int /* #line 91 "third_party/lex/parse.c" */ #define CHAR 257 #define NUMBER 258 #define SECTEND 259 #define SCDECL 260 #define XSCDECL 261 #define NAME 262 #define PREVCCL 263 #define EOF_OP 264 #define OPTION_OP 265 #define OPT_OUTFILE 266 #define OPT_PREFIX 267 #define OPT_YYCLASS 268 #define OPT_HEADER 269 #define OPT_EXTRA_TYPE 270 #define OPT_TABLES 271 #define CCE_ALNUM 272 #define CCE_ALPHA 273 #define CCE_BLANK 274 #define CCE_CNTRL 275 #define CCE_DIGIT 276 #define CCE_GRAPH 277 #define CCE_LOWER 278 #define CCE_PRINT 279 #define CCE_PUNCT 280 #define CCE_SPACE 281 #define CCE_UPPER 282 #define CCE_XDIGIT 283 #define CCE_NEG_ALNUM 284 #define CCE_NEG_ALPHA 285 #define CCE_NEG_BLANK 286 #define CCE_NEG_CNTRL 287 #define CCE_NEG_DIGIT 288 #define CCE_NEG_GRAPH 289 #define CCE_NEG_LOWER 290 #define CCE_NEG_PRINT 291 #define CCE_NEG_PUNCT 292 #define CCE_NEG_SPACE 293 #define CCE_NEG_UPPER 294 #define CCE_NEG_XDIGIT 295 #define CCL_OP_DIFF 296 #define CCL_OP_UNION 297 #define BEGIN_REPEAT_POSIX 298 #define END_REPEAT_POSIX 299 #define BEGIN_REPEAT_FLEX 300 #define END_REPEAT_FLEX 301 #define YYERRCODE 256 const short yylhs[] = { -1, 0, 1, 2, 2, 2, 2, 3, 6, 6, 7, 7, 7, 8, 9, 9, 10, 10, 10, 10, 10, 10, 4, 4, 4, 5, 12, 12, 12, 12, 14, 11, 11, 11, 15, 15, 15, 16, 13, 13, 13, 13, 18, 18, 17, 19, 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21, 21, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 22, 22, }; const short yylen[] = { 2, 5, 0, 3, 2, 0, 1, 1, 1, 1, 2, 1, 1, 2, 2, 0, 3, 3, 3, 3, 3, 3, 5, 5, 0, 0, 2, 1, 1, 1, 0, 4, 3, 0, 3, 1, 1, 1, 2, 3, 2, 1, 3, 1, 2, 2, 1, 6, 5, 4, 2, 2, 2, 6, 5, 4, 1, 1, 1, 3, 3, 1, 3, 3, 1, 3, 4, 4, 2, 2, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 0, }; const short yydefred[] = { 2, 0, 0, 6, 0, 7, 8, 9, 15, 24, 0, 4, 0, 0, 12, 11, 0, 0, 0, 0, 0, 0, 0, 14, 0, 1, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 24, 0, 16, 18, 19, 20, 17, 21, 32, 36, 37, 0, 35, 0, 29, 61, 58, 28, 0, 56, 96, 0, 0, 0, 27, 0, 0, 0, 0, 0, 64, 31, 0, 23, 26, 0, 0, 70, 0, 22, 0, 40, 0, 44, 0, 0, 0, 50, 51, 52, 0, 0, 34, 95, 59, 60, 0, 0, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 82, 81, 83, 84, 85, 86, 87, 88, 93, 89, 90, 91, 94, 92, 65, 69, 39, 0, 0, 0, 62, 63, 66, 0, 49, 0, 55, 0, 67, 0, 48, 0, 54, 47, 53, }; const short yydgoto[] = { 1, 2, 4, 9, 13, 25, 10, 16, 11, 12, 23, 26, 59, 60, 35, 47, 48, 61, 62, 63, 64, 65, 71, 66, 74, 119, }; const short yysindex[] = { 0, 0, -222, 0, -155, 0, 0, 0, 0, 0, -215, 0, -123, 6, 0, 0, -193, 10, 21, 26, 31, 35, 37, 0, 59, 0, -44, 0, -147, -145, -140, -133, -132, -129, 75, -214, 0, -19, 0, 0, 0, 0, 0, 0, 0, 0, 0, 23, 0, -48, 0, 0, 0, 0, -17, 0, 0, -17, 27, 128, 0, -17, -1, -30, -41, -189, 0, 0, -121, 0, 0, -31, -34, 0, -87, 0, -25, 0, -17, 0, -109, -41, -108, 0, 0, 0, 60, 60, 0, 0, 0, 0, 46, 107, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -30, -36, -39, 0, 0, 0, -104, 0, -219, 0, -238, 0, -144, 0, -143, 0, 0, 0,}; const short yyrindex[] = { 0, 0, -141, 0, 0, 0, 0, 0, 0, 0, 0, 0, -134, 9, 0, 0, -125, 0, 0, 0, 0, 0, 0, 0, -178, 0, 22, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -21, 0, 0, 0, 0, 0, 0, 0, 0, 85, 0, 0, 0, 144, 47, 4, -10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 146, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,}; const short yygindex[] = { 0, 0, 0, 0, 121, 133, 0, 0, 0, 0, 0, 0, 0, 106, 0, 0, 93, 0, 32, 84, -45, 0, 0, 25, 90, 0, }; #define YYTABLESIZE 419 const short yytable[] = { 57, 83, 84, 90, 56, 131, 118, 91, 129, 25, 57, 120, 24, 33, 46, 56, 55, 56, 81, 33, 135, 57, 85, 57, 57, 33, 57, 55, 45, 55, 57, 57, 57, 57, 3, 77, 57, 57, 46, 133, 46, 14, 45, 33, 46, 46, 79, 15, 46, 33, 46, 46, 45, 57, 45, 33, 25, 43, 45, 45, 42, 58, 25, 136, 45, 45, 24, 68, 25, 27, 33, 28, 58, 33, 58, 54, 81, 69, 30, 36, 134, 57, 29, 43, 30, 67, 42, 30, 43, 72, 78, 42, 31, 76, 43, 46, 32, 42, 33, 78, 33, 34, 33, 33, 5, 6, 7, 86, 87, 45, 8, 124, 125, 25, 57, 38, 25, 39, 5, 5, 5, 73, 40, 78, 5, 13, 13, 13, 46, 41, 42, 13, 33, 43, 3, 3, 3, 44, 75, 126, 3, 46, 45, 17, 18, 19, 20, 21, 22, 122, 123, 58, 127, 132, 41, 137, 38, 49, 138, 37, 70, 88, 121, 92, 0, 0, 0, 0, 0, 0, 93, 43, 0, 0, 42, 0, 0, 0, 70, 0, 0, 0, 0, 0, 0, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 0, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 89, 51, 0, 0, 0, 0, 0, 52, 0, 33, 33, 50, 51, 0, 51, 0, 33, 33, 52, 53, 52, 57, 0, 0, 0, 0, 0, 57, 0, 0, 0, 0, 0, 82, 0, 46, 130, 128, 0, 33, 33, 46, 80, 0, 0, 0, 33, 33, 0, 45, 0, 0, 25, 25, 0, 45, 0, 0, 0, 25, 25, 0, 57, 0, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 93, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 45, 0, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 70, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 70, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, }; const short yycheck[] = { 10, 42, 43, 34, 34, 44, 93, 41, 44, 0, 40, 36, 60, 34, 10, 34, 46, 34, 63, 40, 258, 40, 63, 40, 34, 46, 36, 46, 10, 46, 40, 41, 42, 43, 256, 36, 46, 47, 34, 258, 36, 256, 256, 34, 40, 41, 47, 262, 262, 40, 46, 47, 34, 63, 36, 46, 34, 10, 40, 41, 10, 91, 40, 301, 46, 47, 60, 44, 46, 262, 91, 61, 91, 94, 91, 94, 121, 125, 256, 123, 299, 91, 61, 36, 262, 62, 36, 61, 41, 57, 124, 41, 61, 61, 47, 91, 61, 47, 61, 124, 91, 42, 123, 94, 259, 260, 261, 296, 297, 91, 265, 86, 87, 91, 124, 262, 94, 262, 259, 260, 261, 94, 262, 124, 265, 259, 260, 261, 124, 262, 262, 265, 123, 262, 259, 260, 261, 62, 10, 93, 265, 262, 124, 266, 267, 268, 269, 270, 271, 258, 258, 91, 45, 257, 10, 299, 10, 36, 301, 26, 54, 68, 78, 73, -1, -1, -1, -1, -1, -1, 257, 124, -1, -1, 124, -1, -1, -1, 93, -1, -1, -1, -1, -1, -1, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, -1, -1, -1, -1, -1, -1, -1, -1, 93, -1, -1, -1, -1, -1, -1, -1, -1, 257, 257, -1, -1, -1, -1, -1, 263, -1, 256, 257, 256, 257, -1, 257, -1, 263, 264, 263, 264, 263, 257, -1, -1, -1, -1, -1, 263, -1, -1, -1, -1, -1, 300, -1, 257, 301, 299, -1, 256, 257, 263, 298, -1, -1, -1, 263, 264, -1, 257, -1, -1, 256, 257, -1, 263, -1, -1, -1, 263, 264, -1, 298, -1, 300, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 298, 257, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 298, -1, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 257, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 257, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, }; #define YYFINAL 1 #ifndef YYDEBUG #define YYDEBUG 0 #endif #define YYMAXTOKEN 301 #if YYDEBUG const char * const yyname[] = { "end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,"'\"'",0,"'$'",0,0,0,"'('","')'","'*'","'+'","','","'-'","'.'","'/'",0,0, 0,0,0,0,0,0,0,0,0,0,"'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,"'{'","'|'","'}'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"CHAR","NUMBER","SECTEND", "SCDECL","XSCDECL","NAME","PREVCCL","EOF_OP","OPTION_OP","OPT_OUTFILE", "OPT_PREFIX","OPT_YYCLASS","OPT_HEADER","OPT_EXTRA_TYPE","OPT_TABLES", "CCE_ALNUM","CCE_ALPHA","CCE_BLANK","CCE_CNTRL","CCE_DIGIT","CCE_GRAPH", "CCE_LOWER","CCE_PRINT","CCE_PUNCT","CCE_SPACE","CCE_UPPER","CCE_XDIGIT", "CCE_NEG_ALNUM","CCE_NEG_ALPHA","CCE_NEG_BLANK","CCE_NEG_CNTRL","CCE_NEG_DIGIT", "CCE_NEG_GRAPH","CCE_NEG_LOWER","CCE_NEG_PRINT","CCE_NEG_PUNCT","CCE_NEG_SPACE", "CCE_NEG_UPPER","CCE_NEG_XDIGIT","CCL_OP_DIFF","CCL_OP_UNION", "BEGIN_REPEAT_POSIX","END_REPEAT_POSIX","BEGIN_REPEAT_FLEX","END_REPEAT_FLEX", }; const char * const yyrule[] = {"$accept : goal", "goal : initlex sect1 sect1end sect2 initforrule", "initlex :", "sect1 : sect1 startconddecl namelist1", "sect1 : sect1 options", "sect1 :", "sect1 : error", "sect1end : SECTEND", "startconddecl : SCDECL", "startconddecl : XSCDECL", "namelist1 : namelist1 NAME", "namelist1 : NAME", "namelist1 : error", "options : OPTION_OP optionlist", "optionlist : optionlist option", "optionlist :", "option : OPT_OUTFILE '=' NAME", "option : OPT_EXTRA_TYPE '=' NAME", "option : OPT_PREFIX '=' NAME", "option : OPT_YYCLASS '=' NAME", "option : OPT_HEADER '=' NAME", "option : OPT_TABLES '=' NAME", "sect2 : sect2 scon initforrule flexrule '\\n'", "sect2 : sect2 scon '{' sect2 '}'", "sect2 :", "initforrule :", "flexrule : '^' rule", "flexrule : rule", "flexrule : EOF_OP", "flexrule : error", "scon_stk_ptr :", "scon : '<' scon_stk_ptr namelist2 '>'", "scon : '<' '*' '>'", "scon :", "namelist2 : namelist2 ',' sconname", "namelist2 : sconname", "namelist2 : error", "sconname : NAME", "rule : re2 re", "rule : re2 re '$'", "rule : re '$'", "rule : re", "re : re '|' series", "re : series", "re2 : re '/'", "series : series singleton", "series : singleton", "series : series BEGIN_REPEAT_POSIX NUMBER ',' NUMBER END_REPEAT_POSIX", "series : series BEGIN_REPEAT_POSIX NUMBER ',' END_REPEAT_POSIX", "series : series BEGIN_REPEAT_POSIX NUMBER END_REPEAT_POSIX", "singleton : singleton '*'", "singleton : singleton '+'", "singleton : singleton '?'", "singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' NUMBER END_REPEAT_FLEX", "singleton : singleton BEGIN_REPEAT_FLEX NUMBER ',' END_REPEAT_FLEX", "singleton : singleton BEGIN_REPEAT_FLEX NUMBER END_REPEAT_FLEX", "singleton : '.'", "singleton : fullccl", "singleton : PREVCCL", "singleton : '\"' string '\"'", "singleton : '(' re ')'", "singleton : CHAR", "fullccl : fullccl CCL_OP_DIFF braceccl", "fullccl : fullccl CCL_OP_UNION braceccl", "fullccl : braceccl", "braceccl : '[' ccl ']'", "braceccl : '[' '^' ccl ']'", "ccl : ccl CHAR '-' CHAR", "ccl : ccl CHAR", "ccl : ccl ccl_expr", "ccl :", "ccl_expr : CCE_ALNUM", "ccl_expr : CCE_ALPHA", "ccl_expr : CCE_BLANK", "ccl_expr : CCE_CNTRL", "ccl_expr : CCE_DIGIT", "ccl_expr : CCE_GRAPH", "ccl_expr : CCE_LOWER", "ccl_expr : CCE_PRINT", "ccl_expr : CCE_PUNCT", "ccl_expr : CCE_SPACE", "ccl_expr : CCE_XDIGIT", "ccl_expr : CCE_UPPER", "ccl_expr : CCE_NEG_ALNUM", "ccl_expr : CCE_NEG_ALPHA", "ccl_expr : CCE_NEG_BLANK", "ccl_expr : CCE_NEG_CNTRL", "ccl_expr : CCE_NEG_DIGIT", "ccl_expr : CCE_NEG_GRAPH", "ccl_expr : CCE_NEG_PRINT", "ccl_expr : CCE_NEG_PUNCT", "ccl_expr : CCE_NEG_SPACE", "ccl_expr : CCE_NEG_XDIGIT", "ccl_expr : CCE_NEG_LOWER", "ccl_expr : CCE_NEG_UPPER", "string : string CHAR", "string :", }; #endif #ifndef YYSTYPE typedef int YYSTYPE; #endif #ifdef YYSTACKSIZE #undef YYMAXDEPTH #define YYMAXDEPTH YYSTACKSIZE #else #ifdef YYMAXDEPTH #define YYSTACKSIZE YYMAXDEPTH #else #define YYSTACKSIZE 10000 #define YYMAXDEPTH 10000 #endif #endif #define YYINITSTACKSIZE 200 /* LINTUSED */ int yydebug; int yynerrs; int yyerrflag; int yychar; short *yyssp; YYSTYPE *yyvsp; YYSTYPE yyval; YYSTYPE yylval; short *yyss; short *yysslim; YYSTYPE *yyvs; unsigned int yystacksize; /* int yyparse(void); */ /* #line 947 "third_party/lex/parse.y" */ /* build_eof_action - build the "<>" action for the active start * conditions */ void build_eof_action() { int i2; char action_text[MAXLINE]; for ( i2 = 1; i2 <= scon_stk_ptr; ++i2 ) { if ( sceof[scon_stk[i2]] ) format_pinpoint_message( "multiple <> rules for start condition %s", scname[scon_stk[i2]] ); else { sceof[scon_stk[i2]] = true; if (previous_continued_action /* && previous action was regular */) add_action("YY_RULE_SETUP\n"); snprintf( action_text, sizeof(action_text), "case YY_STATE_EOF(%s):\n", scname[scon_stk[i2]] ); add_action( action_text ); } } line_directive_out( (FILE *) 0, 1 ); /* This isn't a normal rule after all - don't count it as * such, so we don't have any holes in the rule numbering * (which make generating "rule can never match" warnings * more difficult. */ --num_rules; ++num_eof_rules; } /* format_synerr - write out formatted syntax error */ void format_synerr( msg, arg ) const char *msg, arg[]; { char errmsg[MAXLINE]; (void) snprintf( errmsg, sizeof(errmsg), msg, arg ); synerr( errmsg ); } /* synerr - report a syntax error */ void synerr( str ) const char *str; { syntaxerror = true; pinpoint_message( str ); } /* format_warn - write out formatted warning */ void format_warn( msg, arg ) const char *msg, arg[]; { char warn_msg[MAXLINE]; snprintf( warn_msg, sizeof(warn_msg), msg, arg ); lexwarn( warn_msg ); } /* warn - report a warning, unless -w was given */ void lexwarn( str ) const char *str; { line_warning( str, linenum ); } /* format_pinpoint_message - write out a message formatted with one string, * pinpointing its location */ void format_pinpoint_message( msg, arg ) const char *msg, arg[]; { char errmsg[MAXLINE]; snprintf( errmsg, sizeof(errmsg), msg, arg ); pinpoint_message( errmsg ); } /* pinpoint_message - write out a message, pinpointing its location */ void pinpoint_message( str ) const char *str; { line_pinpoint( str, linenum ); } /* line_warning - report a warning at a given line, unless -w was given */ void line_warning( str, line ) const char *str; int line; { char warning[MAXLINE]; if ( ! nowarn ) { snprintf( warning, sizeof(warning), "warning, %s", str ); line_pinpoint( warning, line ); } } /* line_pinpoint - write out a message, pinpointing it at the given line */ void line_pinpoint( str, line ) const char *str; int line; { fprintf( stderr, "%s:%d: %s\n", infilename, line, str ); } /* yyerror - eat up an error message from the parser; * currently, messages are ignore */ void yyerror( msg ) const char *msg; { } /* #line 605 "third_party/lex/parse.c" */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */ static int yygrowstack(void) { unsigned int newsize; long sslen; short *newss; YYSTYPE *newvs; if ((newsize = yystacksize) == 0) newsize = YYINITSTACKSIZE; else if (newsize >= YYMAXDEPTH) return -1; else if ((newsize *= 2) > YYMAXDEPTH) newsize = YYMAXDEPTH; sslen = yyssp - yyss; #ifdef SIZE_MAX #define YY_SIZE_MAX SIZE_MAX #else #define YY_SIZE_MAX 0xffffffffU #endif if (newsize && YY_SIZE_MAX / newsize < sizeof *newss) goto bail; newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) : (short *)malloc(newsize * sizeof *newss); /* overflow check above */ if (newss == NULL) goto bail; yyss = newss; yyssp = newss + sslen; if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs) goto bail; newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) : (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */ if (newvs == NULL) goto bail; yyvs = newvs; yyvsp = newvs + sslen; yystacksize = newsize; yysslim = yyss + newsize - 1; return 0; bail: if (yyss) free(yyss); if (yyvs) free(yyvs); yyss = yyssp = NULL; yyvs = yyvsp = NULL; yystacksize = 0; return -1; } #define YYABORT goto yyabort #define YYREJECT goto yyabort #define YYACCEPT goto yyaccept #define YYERROR goto yyerrlab int yyparse(void) { int yym, yyn, yystate; #if YYDEBUG const char *yys; if ((yys = getenv("YYDEBUG"))) { yyn = *yys; if (yyn >= '0' && yyn <= '9') yydebug = yyn - '0'; } #endif /* YYDEBUG */ yynerrs = 0; yyerrflag = 0; yychar = (-1); if (yyss == NULL && yygrowstack()) goto yyoverflow; yyssp = yyss; yyvsp = yyvs; *yyssp = yystate = 0; yyloop: if ((yyn = yydefred[yystate]) != 0) goto yyreduce; if (yychar < 0) { if ((yychar = yylex()) < 0) yychar = 0; #if YYDEBUG if (yydebug) { yys = 0; if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; if (!yys) yys = "illegal-symbol"; printf("%sdebug: state %d, reading %d (%s)\n", YYPREFIX, yystate, yychar, yys); } #endif } if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { #if YYDEBUG if (yydebug) printf("%sdebug: state %d, shifting to state %d\n", YYPREFIX, yystate, yytable[yyn]); #endif if (yyssp >= yysslim && yygrowstack()) { goto yyoverflow; } *++yyssp = yystate = yytable[yyn]; *++yyvsp = yylval; yychar = (-1); if (yyerrflag > 0) --yyerrflag; goto yyloop; } if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == yychar) { yyn = yytable[yyn]; goto yyreduce; } if (yyerrflag) goto yyinrecovery; #if defined(__GNUC__) goto yynewerror; #endif yynewerror: yyerror("syntax error"); #if defined(__GNUC__) goto yyerrlab; #endif yyerrlab: ++yynerrs; yyinrecovery: if (yyerrflag < 3) { yyerrflag = 3; for (;;) { if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) { #if YYDEBUG if (yydebug) printf("%sdebug: state %d, error recovery shifting\ to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); #endif if (yyssp >= yysslim && yygrowstack()) { goto yyoverflow; } *++yyssp = yystate = yytable[yyn]; *++yyvsp = yylval; goto yyloop; } else { #if YYDEBUG if (yydebug) printf("%sdebug: error recovery discarding state %d\n", YYPREFIX, *yyssp); #endif if (yyssp <= yyss) goto yyabort; --yyssp; --yyvsp; } } } else { if (yychar == 0) goto yyabort; #if YYDEBUG if (yydebug) { yys = 0; if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; if (!yys) yys = "illegal-symbol"; printf("%sdebug: state %d, error recovery discards token %d (%s)\n", YYPREFIX, yystate, yychar, yys); } #endif yychar = (-1); goto yyloop; } yyreduce: #if YYDEBUG if (yydebug) printf("%sdebug: state %d, reducing by rule %d (%s)\n", YYPREFIX, yystate, yyn, yyrule[yyn]); #endif yym = yylen[yyn]; if (yym) yyval = yyvsp[1-yym]; else memset(&yyval, 0, sizeof yyval); switch (yyn) { case 1: /* #line 118 "third_party/lex/parse.y" */ { /* add default rule */ int def_rule; pat = cclinit(); cclnegate( pat ); def_rule = mkstate( -pat ); /* Remember the number of the default rule so we * don't generate "can't match" warnings for it. */ default_rule = num_rules; finish_rule( def_rule, false, 0, 0, 0); for ( i = 1; i <= lastsc; ++i ) scset[i] = mkbranch( scset[i], def_rule ); if ( spprdflt ) add_action( "YY_FATAL_ERROR( \"flex scanner jammed\" )" ); else add_action( "ECHO" ); add_action( ";\n\tYY_BREAK\n" ); } break; case 2: /* #line 147 "third_party/lex/parse.y" */ { /* initialize for processing rules */ /* Create default DFA start condition. */ scinstal( "INITIAL", false ); } break; case 6: /* #line 158 "third_party/lex/parse.y" */ { synerr( _("unknown error processing section 1") ); } break; case 7: /* #line 162 "third_party/lex/parse.y" */ { check_options(); scon_stk = allocate_integer_array( lastsc + 1 ); scon_stk_ptr = 0; } break; case 8: /* #line 170 "third_party/lex/parse.y" */ { xcluflg = false; } break; case 9: /* #line 173 "third_party/lex/parse.y" */ { xcluflg = true; } break; case 10: /* #line 177 "third_party/lex/parse.y" */ { scinstal( nmstr, xcluflg ); } break; case 11: /* #line 180 "third_party/lex/parse.y" */ { scinstal( nmstr, xcluflg ); } break; case 12: /* #line 183 "third_party/lex/parse.y" */ { synerr( _("bad start condition list") ); } break; case 16: /* #line 194 "third_party/lex/parse.y" */ { outfilename = copy_string( nmstr ); did_outfilename = 1; } break; case 17: /* #line 199 "third_party/lex/parse.y" */ { extra_type = copy_string( nmstr ); } break; case 18: /* #line 201 "third_party/lex/parse.y" */ { prefix = copy_string( nmstr ); } break; case 19: /* #line 203 "third_party/lex/parse.y" */ { yyclass = copy_string( nmstr ); } break; case 20: /* #line 205 "third_party/lex/parse.y" */ { headerfilename = copy_string( nmstr ); } break; case 21: /* #line 207 "third_party/lex/parse.y" */ { tablesext = true; tablesfilename = copy_string( nmstr ); } break; case 22: /* #line 211 "third_party/lex/parse.y" */ { scon_stk_ptr = yyvsp[-3]; } break; case 23: /* #line 213 "third_party/lex/parse.y" */ { scon_stk_ptr = yyvsp[-3]; } break; case 25: /* #line 218 "third_party/lex/parse.y" */ { /* Initialize for a parse of one rule. */ trlcontxt = variable_trail_rule = varlength = false; trailcnt = headcnt = rulelen = 0; current_state_type = STATE_NORMAL; previous_continued_action = continued_action; in_rule = true; new_rule(); } break; case 26: /* #line 231 "third_party/lex/parse.y" */ { pat = yyvsp[0]; finish_rule( pat, variable_trail_rule, headcnt, trailcnt , previous_continued_action); if ( scon_stk_ptr > 0 ) { for ( i = 1; i <= scon_stk_ptr; ++i ) scbol[scon_stk[i]] = mkbranch( scbol[scon_stk[i]], pat ); } else { /* Add to all non-exclusive start conditions, * including the default (0) start condition. */ for ( i = 1; i <= lastsc; ++i ) if ( ! scxclu[i] ) scbol[i] = mkbranch( scbol[i], pat ); } if ( ! bol_needed ) { bol_needed = true; if ( performance_report > 1 ) pinpoint_message( "'^' operator results in sub-optimal performance" ); } } break; case 27: /* #line 267 "third_party/lex/parse.y" */ { pat = yyvsp[0]; finish_rule( pat, variable_trail_rule, headcnt, trailcnt , previous_continued_action); if ( scon_stk_ptr > 0 ) { for ( i = 1; i <= scon_stk_ptr; ++i ) scset[scon_stk[i]] = mkbranch( scset[scon_stk[i]], pat ); } else { for ( i = 1; i <= lastsc; ++i ) if ( ! scxclu[i] ) scset[i] = mkbranch( scset[i], pat ); } } break; case 28: /* #line 291 "third_party/lex/parse.y" */ { if ( scon_stk_ptr > 0 ) build_eof_action(); else { /* This EOF applies to all start conditions * which don't already have EOF actions. */ for ( i = 1; i <= lastsc; ++i ) if ( ! sceof[i] ) scon_stk[++scon_stk_ptr] = i; if ( scon_stk_ptr == 0 ) lexwarn( "all start conditions already have <> rules" ); else build_eof_action(); } } break; case 29: /* #line 314 "third_party/lex/parse.y" */ { synerr( _("unrecognized rule") ); } break; case 30: /* #line 318 "third_party/lex/parse.y" */ { yyval = scon_stk_ptr; } break; case 31: /* #line 322 "third_party/lex/parse.y" */ { yyval = yyvsp[-2]; } break; case 32: /* #line 325 "third_party/lex/parse.y" */ { yyval = scon_stk_ptr; for ( i = 1; i <= lastsc; ++i ) { int j; for ( j = 1; j <= scon_stk_ptr; ++j ) if ( scon_stk[j] == i ) break; if ( j > scon_stk_ptr ) scon_stk[++scon_stk_ptr] = i; } } break; case 33: /* #line 342 "third_party/lex/parse.y" */ { yyval = scon_stk_ptr; } break; case 36: /* #line 350 "third_party/lex/parse.y" */ { synerr( _("bad start condition list") ); } break; case 37: /* #line 354 "third_party/lex/parse.y" */ { if ( (scnum = sclookup( nmstr )) == 0 ) format_pinpoint_message( "undeclared start condition %s", nmstr ); else { for ( i = 1; i <= scon_stk_ptr; ++i ) if ( scon_stk[i] == scnum ) { format_warn( "<%s> specified twice", scname[scnum] ); break; } if ( i > scon_stk_ptr ) scon_stk[++scon_stk_ptr] = scnum; } } break; case 38: /* #line 377 "third_party/lex/parse.y" */ { if ( transchar[lastst[yyvsp[0]]] != SYM_EPSILON ) /* Provide final transition \now/ so it * will be marked as a trailing context * state. */ yyvsp[0] = link_machines( yyvsp[0], mkstate( SYM_EPSILON ) ); mark_beginning_as_normal( yyvsp[0] ); current_state_type = STATE_NORMAL; if ( previous_continued_action ) { /* We need to treat this as variable trailing * context so that the backup does not happen * in the action but before the action switch * statement. If the backup happens in the * action, then the rules "falling into" this * one's action will *also* do the backup, * erroneously. */ if ( ! varlength || headcnt != 0 ) lexwarn( "trailing context made variable due to preceding '|' action" ); /* Mark as variable. */ varlength = true; headcnt = 0; } if ( lex_compat || (varlength && headcnt == 0) ) { /* variable trailing context rule */ /* Mark the first part of the rule as the * accepting "head" part of a trailing * context rule. * * By the way, we didn't do this at the * beginning of this production because back * then current_state_type was set up for a * trail rule, and add_accept() can create * a new state ... */ add_accept( yyvsp[-1], num_rules | YY_TRAILING_HEAD_MASK ); variable_trail_rule = true; } else trailcnt = rulelen; yyval = link_machines( yyvsp[-1], yyvsp[0] ); } break; case 39: /* #line 433 "third_party/lex/parse.y" */ { synerr( _("trailing context used twice") ); } break; case 40: /* #line 436 "third_party/lex/parse.y" */ { headcnt = 0; trailcnt = 1; rulelen = 1; varlength = false; current_state_type = STATE_TRAILING_CONTEXT; if ( trlcontxt ) { synerr( _("trailing context used twice") ); yyval = mkstate( SYM_EPSILON ); } else if ( previous_continued_action ) { /* See the comment in the rule for "re2 re" * above. */ lexwarn( "trailing context made variable due to preceding '|' action" ); varlength = true; } if ( lex_compat || varlength ) { /* Again, see the comment in the rule for * "re2 re" above. */ add_accept( yyvsp[-1], num_rules | YY_TRAILING_HEAD_MASK ); variable_trail_rule = true; } trlcontxt = true; eps = mkstate( SYM_EPSILON ); yyval = link_machines( yyvsp[-1], link_machines( eps, mkstate( '\n' ) ) ); } break; case 41: /* #line 479 "third_party/lex/parse.y" */ { yyval = yyvsp[0]; if ( trlcontxt ) { if ( lex_compat || (varlength && headcnt == 0) ) /* Both head and trail are * variable-length. */ variable_trail_rule = true; else trailcnt = rulelen; } } break; case 42: /* #line 497 "third_party/lex/parse.y" */ { varlength = true; yyval = mkor( yyvsp[-2], yyvsp[0] ); } break; case 43: /* #line 503 "third_party/lex/parse.y" */ { yyval = yyvsp[0]; } break; case 44: /* #line 508 "third_party/lex/parse.y" */ { /* This rule is written separately so the * reduction will occur before the trailing * series is parsed. */ if ( trlcontxt ) synerr( _("trailing context used twice") ); else trlcontxt = true; if ( varlength ) /* We hope the trailing context is * fixed-length. */ varlength = false; else headcnt = rulelen; rulelen = 0; current_state_type = STATE_TRAILING_CONTEXT; yyval = yyvsp[-1]; } break; case 45: /* #line 535 "third_party/lex/parse.y" */ { /* This is where concatenation of adjacent patterns * gets done. */ yyval = link_machines( yyvsp[-1], yyvsp[0] ); } break; case 46: /* #line 543 "third_party/lex/parse.y" */ { yyval = yyvsp[0]; } break; case 47: /* #line 546 "third_party/lex/parse.y" */ { varlength = true; if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) { synerr( _("bad iteration values") ); yyval = yyvsp[-5]; } else { if ( yyvsp[-3] == 0 ) { if ( yyvsp[-1] <= 0 ) { synerr( _("bad iteration values") ); yyval = yyvsp[-5]; } else yyval = mkopt( mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); } else yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); } } break; case 48: /* #line 574 "third_party/lex/parse.y" */ { varlength = true; if ( yyvsp[-2] <= 0 ) { synerr( _("iteration value must be positive") ); yyval = yyvsp[-4]; } else yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); } break; case 49: /* #line 588 "third_party/lex/parse.y" */ { /* The series could be something like "(foo)", * in which case we have no idea what its length * is, so we punt here. */ varlength = true; if ( yyvsp[-1] <= 0 ) { synerr( _("iteration value must be positive") ); yyval = yyvsp[-3]; } else yyval = link_machines( yyvsp[-3], copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); } break; case 50: /* #line 610 "third_party/lex/parse.y" */ { varlength = true; yyval = mkclos( yyvsp[-1] ); } break; case 51: /* #line 617 "third_party/lex/parse.y" */ { varlength = true; yyval = mkposcl( yyvsp[-1] ); } break; case 52: /* #line 623 "third_party/lex/parse.y" */ { varlength = true; yyval = mkopt( yyvsp[-1] ); } break; case 53: /* #line 629 "third_party/lex/parse.y" */ { varlength = true; if ( yyvsp[-3] > yyvsp[-1] || yyvsp[-3] < 0 ) { synerr( _("bad iteration values") ); yyval = yyvsp[-5]; } else { if ( yyvsp[-3] == 0 ) { if ( yyvsp[-1] <= 0 ) { synerr( _("bad iteration values") ); yyval = yyvsp[-5]; } else yyval = mkopt( mkrep( yyvsp[-5], 1, yyvsp[-1] ) ); } else yyval = mkrep( yyvsp[-5], yyvsp[-3], yyvsp[-1] ); } } break; case 54: /* #line 657 "third_party/lex/parse.y" */ { varlength = true; if ( yyvsp[-2] <= 0 ) { synerr( _("iteration value must be positive") ); yyval = yyvsp[-4]; } else yyval = mkrep( yyvsp[-4], yyvsp[-2], INFINITE_REPEAT ); } break; case 55: /* #line 671 "third_party/lex/parse.y" */ { /* The singleton could be something like "(foo)", * in which case we have no idea what its length * is, so we punt here. */ varlength = true; if ( yyvsp[-1] <= 0 ) { synerr( _("iteration value must be positive") ); yyval = yyvsp[-3]; } else yyval = link_machines( yyvsp[-3], copysingl( yyvsp[-3], yyvsp[-1] - 1 ) ); } break; case 56: /* #line 690 "third_party/lex/parse.y" */ { if ( ! madeany ) { /* Create the '.' character class. */ ccldot = cclinit(); ccladd( ccldot, '\n' ); cclnegate( ccldot ); if ( useecs ) mkeccl( ccltbl + cclmap[ccldot], ccllen[ccldot], nextecm, ecgroup, csize, csize ); /* Create the (?s:'.') character class. */ cclany = cclinit(); cclnegate( cclany ); if ( useecs ) mkeccl( ccltbl + cclmap[cclany], ccllen[cclany], nextecm, ecgroup, csize, csize ); madeany = true; } ++rulelen; if (sf_dot_all()) yyval = mkstate( -cclany ); else yyval = mkstate( -ccldot ); } break; case 57: /* #line 724 "third_party/lex/parse.y" */ { /* Sort characters for fast searching. */ qsort( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], sizeof (*ccltbl), cclcmp ); if ( useecs ) mkeccl( ccltbl + cclmap[yyvsp[0]], ccllen[yyvsp[0]], nextecm, ecgroup, csize, csize ); ++rulelen; if (ccl_has_nl[yyvsp[0]]) rule_has_nl[num_rules] = true; yyval = mkstate( -yyvsp[0] ); } break; case 58: /* #line 742 "third_party/lex/parse.y" */ { ++rulelen; if (ccl_has_nl[yyvsp[0]]) rule_has_nl[num_rules] = true; yyval = mkstate( -yyvsp[0] ); } break; case 59: /* #line 752 "third_party/lex/parse.y" */ { yyval = yyvsp[-1]; } break; case 60: /* #line 755 "third_party/lex/parse.y" */ { yyval = yyvsp[-1]; } break; case 61: /* #line 758 "third_party/lex/parse.y" */ { ++rulelen; if (yyvsp[0] == nlch) rule_has_nl[num_rules] = true; if (sf_case_ins() && has_case(yyvsp[0])) /* create an alternation, as in (a|A) */ yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); else yyval = mkstate( yyvsp[0] ); } break; case 62: /* #line 772 "third_party/lex/parse.y" */ { yyval = ccl_set_diff (yyvsp[-2], yyvsp[0]); } break; case 63: /* #line 773 "third_party/lex/parse.y" */ { yyval = ccl_set_union (yyvsp[-2], yyvsp[0]); } break; case 65: /* #line 779 "third_party/lex/parse.y" */ { yyval = yyvsp[-1]; } break; case 66: /* #line 782 "third_party/lex/parse.y" */ { cclnegate( yyvsp[-1] ); yyval = yyvsp[-1]; } break; case 67: /* #line 789 "third_party/lex/parse.y" */ { if (sf_case_ins()) { /* If one end of the range has case and the other * does not, or the cases are different, then we're not * sure what range the user is trying to express. * Examples: [@-z] or [S-t] */ if (has_case (yyvsp[-2]) != has_case (yyvsp[0]) || (has_case (yyvsp[-2]) && (b_islower (yyvsp[-2]) != b_islower (yyvsp[0]))) || (has_case (yyvsp[-2]) && (b_isupper (yyvsp[-2]) != b_isupper (yyvsp[0])))) format_warn3 ( _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), yyvsp[-2], yyvsp[0]); /* If the range spans uppercase characters but not * lowercase (or vice-versa), then should we automatically * include lowercase characters in the range? * Example: [@-_] spans [a-z] but not [A-Z] */ else if (!has_case (yyvsp[-2]) && !has_case (yyvsp[0]) && !range_covers_case (yyvsp[-2], yyvsp[0])) format_warn3 ( _("the character range [%c-%c] is ambiguous in a case-insensitive scanner"), yyvsp[-2], yyvsp[0]); } if ( yyvsp[-2] > yyvsp[0] ) synerr( _("negative range in character class") ); else { for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ccladd( yyvsp[-3], i ); /* Keep track if this ccl is staying in * alphabetical order. */ cclsorted = cclsorted && (yyvsp[-2] > lastchar); lastchar = yyvsp[0]; /* Do it again for upper/lowercase */ if (sf_case_ins() && has_case(yyvsp[-2]) && has_case(yyvsp[0])){ yyvsp[-2] = reverse_case (yyvsp[-2]); yyvsp[0] = reverse_case (yyvsp[0]); for ( i = yyvsp[-2]; i <= yyvsp[0]; ++i ) ccladd( yyvsp[-3], i ); cclsorted = cclsorted && (yyvsp[-2] > lastchar); lastchar = yyvsp[0]; } } yyval = yyvsp[-3]; } break; case 68: /* #line 849 "third_party/lex/parse.y" */ { ccladd( yyvsp[-1], yyvsp[0] ); cclsorted = cclsorted && (yyvsp[0] > lastchar); lastchar = yyvsp[0]; /* Do it again for upper/lowercase */ if (sf_case_ins() && has_case(yyvsp[0])){ yyvsp[0] = reverse_case (yyvsp[0]); ccladd (yyvsp[-1], yyvsp[0]); cclsorted = cclsorted && (yyvsp[0] > lastchar); lastchar = yyvsp[0]; } yyval = yyvsp[-1]; } break; case 69: /* #line 867 "third_party/lex/parse.y" */ { /* Too hard to properly maintain cclsorted. */ cclsorted = false; yyval = yyvsp[-1]; } break; case 70: /* #line 874 "third_party/lex/parse.y" */ { cclsorted = true; lastchar = 0; currccl = yyval = cclinit(); } break; case 71: /* #line 882 "third_party/lex/parse.y" */ { CCL_EXPR(isalnum); } break; case 72: /* #line 883 "third_party/lex/parse.y" */ { CCL_EXPR(isalpha); } break; case 73: /* #line 884 "third_party/lex/parse.y" */ { CCL_EXPR(isblank); } break; case 74: /* #line 885 "third_party/lex/parse.y" */ { CCL_EXPR(iscntrl); } break; case 75: /* #line 886 "third_party/lex/parse.y" */ { CCL_EXPR(isdigit); } break; case 76: /* #line 887 "third_party/lex/parse.y" */ { CCL_EXPR(isgraph); } break; case 77: /* #line 888 "third_party/lex/parse.y" */ { CCL_EXPR(islower); if (sf_case_ins()) CCL_EXPR(isupper); } break; case 78: /* #line 893 "third_party/lex/parse.y" */ { CCL_EXPR(isprint); } break; case 79: /* #line 894 "third_party/lex/parse.y" */ { CCL_EXPR(ispunct); } break; case 80: /* #line 895 "third_party/lex/parse.y" */ { CCL_EXPR(isspace); } break; case 81: /* #line 896 "third_party/lex/parse.y" */ { CCL_EXPR(isxdigit); } break; case 82: /* #line 897 "third_party/lex/parse.y" */ { CCL_EXPR(isupper); if (sf_case_ins()) CCL_EXPR(islower); } break; case 83: /* #line 903 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isalnum); } break; case 84: /* #line 904 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isalpha); } break; case 85: /* #line 905 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isblank); } break; case 86: /* #line 906 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(iscntrl); } break; case 87: /* #line 907 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isdigit); } break; case 88: /* #line 908 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isgraph); } break; case 89: /* #line 909 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isprint); } break; case 90: /* #line 910 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(ispunct); } break; case 91: /* #line 911 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isspace); } break; case 92: /* #line 912 "third_party/lex/parse.y" */ { CCL_NEG_EXPR(isxdigit); } break; case 93: /* #line 913 "third_party/lex/parse.y" */ { if ( sf_case_ins() ) lexwarn(_("[:^lower:] is ambiguous in case insensitive scanner")); else CCL_NEG_EXPR(islower); } break; case 94: /* #line 919 "third_party/lex/parse.y" */ { if ( sf_case_ins() ) lexwarn(_("[:^upper:] ambiguous in case insensitive scanner")); else CCL_NEG_EXPR(isupper); } break; case 95: /* #line 928 "third_party/lex/parse.y" */ { if ( yyvsp[0] == nlch ) rule_has_nl[num_rules] = true; ++rulelen; if (sf_case_ins() && has_case(yyvsp[0])) yyval = mkor (mkstate(yyvsp[0]), mkstate(reverse_case(yyvsp[0]))); else yyval = mkstate (yyvsp[0]); yyval = link_machines( yyvsp[-1], yyval); } break; case 96: /* #line 943 "third_party/lex/parse.y" */ { yyval = mkstate( SYM_EPSILON ); } break; /* #line 1724 "third_party/lex/parse.c" */ } yyssp -= yym; yystate = *yyssp; yyvsp -= yym; yym = yylhs[yyn]; if (yystate == 0 && yym == 0) { #if YYDEBUG if (yydebug) printf("%sdebug: after reduction, shifting from state 0 to\ state %d\n", YYPREFIX, YYFINAL); #endif yystate = YYFINAL; *++yyssp = YYFINAL; *++yyvsp = yyval; if (yychar < 0) { if ((yychar = yylex()) < 0) yychar = 0; #if YYDEBUG if (yydebug) { yys = 0; if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; if (!yys) yys = "illegal-symbol"; printf("%sdebug: state %d, reading %d (%s)\n", YYPREFIX, YYFINAL, yychar, yys); } #endif } if (yychar == 0) goto yyaccept; goto yyloop; } if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && yyn <= YYTABLESIZE && yycheck[yyn] == yystate) yystate = yytable[yyn]; else yystate = yydgoto[yym]; #if YYDEBUG if (yydebug) printf("%sdebug: after reduction, shifting from state %d \ to state %d\n", YYPREFIX, *yyssp, yystate); #endif if (yyssp >= yysslim && yygrowstack()) { goto yyoverflow; } *++yyssp = yystate; *++yyvsp = yyval; goto yyloop; yyoverflow: yyerror("yacc stack overflow"); yyabort: if (yyss) free(yyss); if (yyvs) free(yyvs); yyss = yyssp = NULL; yyvs = yyvsp = NULL; yystacksize = 0; return (1); yyaccept: if (yyss) free(yyss); if (yyvs) free(yyvs); yyss = yyssp = NULL; yyvs = yyvsp = NULL; yystacksize = 0; return (0); }