jamgram.c

   1 #ifndef lint
   2 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
   3 #endif
   4
   5 #include <stdlib.h>
   6 #include <string.h>
   7
   8 #define YYBYACC 1
   9 #define YYMAJOR 1
  10 #define YYMINOR 9
  11 #define YYPATCH 20090221
  12
  13 #define YYEMPTY        (-1)
  14 #define yyclearin      (yychar = YYEMPTY)
  15 #define yyerrok        (yyerrflag = 0)
  16 #define YYRECOVERING() (yyerrflag != 0)
  17
  18 /* compatibility with bison */
  19 #ifdef YYPARSE_PARAM
  20 /* compatibility with FreeBSD */
  21 #ifdef YYPARSE_PARAM_TYPE
  22 #define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
  23 #else
  24 #define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
  25 #endif
  26 #else
  27 #define YYPARSE_DECL() yyparse(void)
  28 #endif /* YYPARSE_PARAM */
  29
  30 extern int YYPARSE_DECL();
  31
  32 static int yygrowstack(void);
  33 #define YYPREFIX "yy"
  34 #line 85 "jamgram.y"
  35 #include "jam.h"
  36
  37 #include "lists.h"
  38 #include "variable.h"
  39 #include "parse.h"
  40 #include "scan.h"
  41 #include "compile.h"
  42 #include "newstr.h"
  43 #include "rules.h"
  44
  45 # define YYMAXDEPTH 10000       /* for OSF and other less endowed yaccs */
  46
  47 # define F0 (LIST *(*)(PARSE *, LOL *, int *))0
  48 # define P0 (PARSE *)0
  49 # define S0 (char *)0
  50
  51 # define pappend( l,r )         parse_make( compile_append,l,r,P0,S0,S0,0 )
  52 # define pbreak( l,f )          parse_make( compile_break,l,P0,P0,S0,S0,f )
  53 # define peval( c,l,r )         parse_make( compile_eval,l,r,P0,S0,S0,c )
  54 # define pfor( s,l,r )          parse_make( compile_foreach,l,r,P0,s,S0,0 )
  55 # define pif( l,r,t )           parse_make( compile_if,l,r,t,S0,S0,0 )
  56 # define pincl( l )             parse_make( compile_include,l,P0,P0,S0,S0,0 )
  57 # define plist( s )             parse_make( compile_list,P0,P0,P0,s,S0,0 )
  58 # define plocal( l,r,t )        parse_make( compile_local,l,r,t,S0,S0,0 )
  59 # define pnull()                parse_make( compile_null,P0,P0,P0,S0,S0,0 )
  60 # define pon( l,r )             parse_make( compile_on,l,r,P0,S0,S0,0 )
  61 # define prule( a,p )           parse_make( compile_rule,a,p,P0,S0,S0,0 )
  62 # define prules( l,r )          parse_make( compile_rules,l,r,P0,S0,S0,0 )
  63 # define pset( l,r,a )          parse_make( compile_set,l,r,P0,S0,S0,a )
  64 # define pset1( l,r,t,a )       parse_make( compile_settings,l,r,t,S0,S0,a )
  65 # define psetc( s,l,r )         parse_make( compile_setcomp,l,r,P0,s,S0,0 )
  66 # define psete( s,l,s1,f )      parse_make( compile_setexec,l,P0,P0,s,s1,f )
  67 # define pswitch( l,r )         parse_make( compile_switch,l,r,P0,S0,S0,0 )
  68 # define pwhile( l,r )          parse_make( compile_while,l,r,P0,S0,S0,0 )
  69
  70 # define pnode( l,r )           parse_make( F0,l,r,P0,S0,S0,0 )
  71 # define psnode( s,l )          parse_make( F0,l,P0,P0,s,S0,0 )
  72
  73 #line 73 "y.tab.c"
  74 #define _LANGLE_t 257
  75 #define _LANGLE_EQUALS_t 258
  76 #define _EQUALS_t 259
  77 #define _RANGLE_t 260
  78 #define _RANGLE_EQUALS_t 261
  79 #define _BAR_t 262
  80 #define _BARBAR_t 263
  81 #define _SEMIC_t 264
  82 #define _COLON_t 265
  83 #define _BANG_t 266
  84 #define _BANG_EQUALS_t 267
  85 #define _QUESTION_EQUALS_t 268
  86 #define _LPAREN_t 269
  87 #define _RPAREN_t 270
  88 #define _LBRACKET_t 271
  89 #define _RBRACKET_t 272
  90 #define _LBRACE_t 273
  91 #define _RBRACE_t 274
  92 #define _AMPER_t 275
  93 #define _AMPERAMPER_t 276
  94 #define _PLUS_EQUALS_t 277
  95 #define ACTIONS_t 278
  96 #define BIND_t 279
  97 #define BREAK_t 280
  98 #define CASE_t 281
  99 #define CONTINUE_t 282
 100 #define DEFAULT_t 283
 101 #define ELSE_t 284
 102 #define EXISTING_t 285
 103 #define FOR_t 286
 104 #define IF_t 287
 105 #define IGNORE_t 288
 106 #define IN_t 289
 107 #define INCLUDE_t 290
 108 #define LOCAL_t 291
 109 #define MAXLINE_t 292
 110 #define ON_t 293
 111 #define PIECEMEAL_t 294
 112 #define QUIETLY_t 295
 113 #define RETURN_t 296
 114 #define RULE_t 297
 115 #define SWITCH_t 298
 116 #define TOGETHER_t 299
 117 #define UPDATED_t 300
 118 #define WHILE_t 301
 119 #define ARG 302
 120 #define STRING 303
 121 #define YYERRCODE 256
 122 static const short yylhs[] = {                           -1,
 123     0,    0,    2,    2,    1,    1,    1,    1,    3,    3,
 124     3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 125     3,    3,    3,   13,   14,    3,    7,    7,    7,    7,
 126     9,    9,    9,    9,    9,    9,    9,    9,    9,    9,
 127     9,    9,    9,    9,    8,    8,   15,   10,   10,   10,
 128     6,    6,    4,   16,   16,    5,   18,    5,   17,   17,
 129    17,   11,   11,   19,   19,   19,   19,   19,   19,   19,
 130    12,   12,
 131 };
 132 static const short yylen[] = {                            2,
 133     0,    1,    0,    1,    1,    2,    4,    6,    3,    3,
 134     3,    4,    6,    3,    3,    3,    7,    5,    5,    7,
 135     5,    6,    3,    0,    0,    9,    1,    1,    1,    2,
 136     1,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 137     3,    3,    2,    3,    0,    2,    4,    0,    3,    1,
 138     1,    3,    1,    0,    2,    1,    0,    4,    2,    4,
 139     4,    0,    2,    1,    1,    1,    1,    1,    1,    2,
 140     0,    2,
 141 };
 142 static const short yydefred[] = {                         0,
 143    57,    0,   62,   54,   54,    0,    0,   54,   54,    0,
 144    54,    0,   54,    0,   56,    0,    2,    0,    0,    0,
 145     4,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 146     0,    0,    0,    0,    0,    0,    0,    0,    6,   27,
 147    29,   28,    0,   54,    0,    0,   54,    0,   54,    0,
 148     9,   69,   66,    0,   68,   67,   65,   64,    0,   63,
 149    14,   55,   15,   54,   43,    0,   54,    0,    0,    0,
 150     0,    0,    0,    0,    0,    0,    0,    0,   10,   54,
 151     0,   23,   16,    0,    0,    0,    0,   30,    0,   54,
 152    11,    0,    0,   59,   58,   70,   54,    0,    0,   44,
 153    42,   34,   35,    0,   36,   37,    0,    0,    0,    0,
 154     0,    0,    0,    7,    0,    0,    0,    0,    0,    0,
 155    54,   52,   12,   54,   54,   72,   24,    0,    0,    0,
 156    49,    0,    0,   18,   46,   21,    0,   61,   60,    0,
 157     0,    0,    8,   22,    0,   13,   25,   17,   20,   47,
 158     0,   26,
 159 };
 160 static const short yydgoto[] = {                         16,
 161    21,   22,   18,   45,   30,   46,   47,  118,   31,   85,
 162    23,   98,  140,  151,  119,   25,   50,   20,   60,
 163 };
 164 static const short yysindex[] = {                      -134,
 165     0, -134,    0,    0,    0, -294, -260,    0,    0, -253,
 166     0, -288,    0, -260,    0,    0,    0, -134, -214, -261,
 167     0, -240, -198, -218, -253, -206, -239, -260, -260, -228,
 168    -9, -197, -199, -102, -191, -238, -193,   47,    0,    0,
 169     0,    0, -177,    0, -181, -179,    0, -253,    0, -183,
 170     0,    0,    0, -209,    0,    0,    0,    0, -184,    0,
 171     0,    0,    0,    0,    0,   67,    0, -260, -260, -260,
 172  -260, -260, -260, -260, -260, -134, -260, -260,    0,    0,
 173  -134,    0,    0, -166, -173, -178, -134,    0, -200,    0,
 174     0, -158, -245,    0,    0,    0,    0, -164, -155,    0,
 175     0,    0,    0,  -71,    0,    0, -133, -133,  -71, -167,
 176     2,    2, -142,    0, -238, -134, -162, -151, -178, -138,
 177     0,    0,    0,    0,    0,    0,    0, -134, -139, -134,
 178     0, -125, -114,    0,    0,    0, -110,    0,    0, -148,
 179  -116, -102,    0,    0, -134,    0,    0,    0,    0,    0,
 180  -113,    0,
 181 };
 182 static const short yyrindex[] = {                       160,
 183     0, -109,    0,    0,    0,    0,    0,    0,    0,    0,
 184     0,    0,    0,    0,    0,    0,    0,    3, -236,    0,
 185     0,    0,    0,    0,  -56,    0,    0,    0,    0,  -29,
 186     0,    0,    0,    0,    0, -107,    0,    0,    0,    0,
 187     0,    0,    0,    0, -224,    0,    0,    0,    0,    0,
 188     0,    0,    0,    0,    0,    0,    0,    0, -103,    0,
 189     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 190     0,    0,    0,    0,    0, -109,    0,    0,    0,    0,
 191     4,    0,    0, -101,    0, -100, -109,    0,    0,    0,
 192     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 193     0,    0,    0,   77,    0,    0, -226, -132,   92,    0,
 194   101,  110,    0,    0, -107, -109,    0,    0, -100,    0,
 195     0,    0,    0,    0,    0,    0,    0, -109,    1,    4,
 196     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 197     0,    0,    0,    0, -250,    0,    0,    0,    0,    0,
 198     0,    0,
 199 };
 200 static const short yygindex[] = {                         0,
 201    20,  -54,  -34,    8,    5,  -47,   84,   56,   42,   62,
 202     0,    0,    0,    0,    0,    0,    0,    0,    0,
 203 };
 204 #define YYTABLESIZE 386
 205 static const short yytable[] = {                         82,
 206    19,   94,    5,    3,   19,   28,   19,   27,   29,    1,
 207     1,   24,   26,   36,   34,   32,   33,    1,   35,   17,
 208    37,  110,   19,    3,   49,    1,  114,   54,   54,   62,
 209     3,   48,  120,   51,   54,   40,   40,   39,   19,   51,
 210    15,   15,  122,   40,   40,   61,   40,   51,   15,   64,
 211   124,   89,   93,   41,   92,   38,   15,   63,   40,   80,
 212    67,  132,   42,   84,   81,   54,   79,   41,   43,   65,
 213    66,   99,   83,  141,  101,  143,   42,  139,   44,   86,
 214    19,   88,   43,   90,   91,   19,   52,  113,   95,   53,
 215   150,   19,   96,   54,   97,   55,   56,  125,  115,  116,
 216    57,   58,  117,   59,  126,  123,  129,  149,  127,  102,
 217   103,  104,  105,  106,  107,  108,  109,  128,  111,  112,
 218    19,  130,  134,   68,   69,   70,   71,   72,  137,   41,
 219    41,  138,   19,   75,   19,  136,    1,   41,    2,  133,
 220    41,   77,   78,    3,  142,    4,   19,    5,  144,   19,
 221   145,    6,    7,  146,  147,    8,    9,  148,   10,    1,
 222   152,   11,   12,   13,    3,   48,   14,   15,    1,   71,
 223     2,   50,  121,   45,  135,    3,  131,    4,    0,    5,
 224     0,    0,    0,    6,    7,   68,   69,    8,   71,   72,
 225    10,    0,    0,   11,   12,   13,    0,    0,   14,   15,
 226    53,   53,   53,   53,   53,   53,   53,   53,   53,    0,
 227    53,   53,    0,   53,    0,   53,   53,    0,   53,   53,
 228    53,    0,    0,    0,    0,    0,   53,   31,   31,   31,
 229    31,   31,   31,   31,    0,    0,    0,   31,    0,    0,
 230    31,    0,    0,   31,    0,   31,   31,   68,   69,   70,
 231    71,   72,   73,   74,    0,    0,    0,   75,   68,   69,
 232    70,   71,   72,   76,    0,   77,   78,    0,   75,    0,
 233     0,   19,    0,   19,   19,    0,    5,    3,   19,    0,
 234    19,   19,   19,    5,    3,    0,   19,   19,    0,    0,
 235    19,   19,    0,   19,    0,    0,   19,   19,   19,    0,
 236     0,   19,   19,   68,   69,   70,   71,   72,   73,   74,
 237     0,    0,    0,   75,    0,    0,    0,    0,    0,   87,
 238     0,   77,   78,   68,   69,   70,   71,   72,   73,   74,
 239     0,    0,    0,   75,    0,   32,  100,    0,   32,   32,
 240     0,   77,   78,   32,    0,    0,   32,    0,    0,   32,
 241    33,   32,   32,   33,   33,    0,    0,    0,   33,    0,
 242     0,   33,   38,   38,   33,    0,   33,   33,    0,    0,
 243    38,   39,   39,   38,    0,   38,   38,    0,    0,   39,
 244     0,    0,   39,    0,   39,   39,
 245 };
 246 static const short yycheck[] = {                         34,
 247     0,   49,    0,    0,    0,  266,    2,  302,  269,  271,
 248   271,    4,    5,  302,   10,    8,    9,  271,   11,    0,
 249    13,   76,   18,  274,   20,  271,   81,  264,  265,   25,
 250   281,  293,   87,  274,  271,  262,  263,   18,   34,  264,
 251   302,  302,   90,  270,  259,  264,  273,  272,  302,  289,
 252   296,   44,   48,  268,   47,   14,  302,  264,  259,  259,
 253   289,  116,  277,  302,  264,  302,  264,  268,  283,   28,
 254    29,   64,  264,  128,   67,  130,  277,  125,  293,  273,
 255    76,  259,  283,  265,  264,   81,  285,   80,  272,  288,
 256   145,   87,  302,  292,  279,  294,  295,   93,  265,  273,
 257   299,  300,  281,  302,   97,  264,  274,  142,  273,   68,
 258    69,   70,   71,   72,   73,   74,   75,  273,   77,   78,
 259   116,  264,  274,  257,  258,  259,  260,  261,  121,  262,
 260   263,  124,  128,  267,  130,  274,  271,  270,  273,  302,
 261   273,  275,  276,  278,  284,  280,  142,  282,  274,  145,
 262   265,  286,  287,  264,  303,  290,  291,  274,  293,    0,
 263   274,  296,  297,  298,  274,  273,  301,  302,  271,  273,
 264   273,  273,   89,  274,  119,  278,  115,  280,   -1,  282,
 265    -1,   -1,   -1,  286,  287,  257,  258,  290,  260,  261,
 266   293,   -1,   -1,  296,  297,  298,   -1,   -1,  301,  302,
 267   257,  258,  259,  260,  261,  262,  263,  264,  265,   -1,
 268   267,  268,   -1,  270,   -1,  272,  273,   -1,  275,  276,
 269   277,   -1,   -1,   -1,   -1,   -1,  283,  257,  258,  259,
 270   260,  261,  262,  263,   -1,   -1,   -1,  267,   -1,   -1,
 271   270,   -1,   -1,  273,   -1,  275,  276,  257,  258,  259,
 272   260,  261,  262,  263,   -1,   -1,   -1,  267,  257,  258,
 273   259,  260,  261,  273,   -1,  275,  276,   -1,  267,   -1,
 274    -1,  271,   -1,  273,  274,   -1,  274,  274,  278,   -1,
 275   280,  281,  282,  281,  281,   -1,  286,  287,   -1,   -1,
 276   290,  291,   -1,  293,   -1,   -1,  296,  297,  298,   -1,
 277    -1,  301,  302,  257,  258,  259,  260,  261,  262,  263,
 278    -1,   -1,   -1,  267,   -1,   -1,   -1,   -1,   -1,  273,
 279    -1,  275,  276,  257,  258,  259,  260,  261,  262,  263,
 280    -1,   -1,   -1,  267,   -1,  259,  270,   -1,  262,  263,
 281    -1,  275,  276,  267,   -1,   -1,  270,   -1,   -1,  273,
 282   259,  275,  276,  262,  263,   -1,   -1,   -1,  267,   -1,
 283    -1,  270,  262,  263,  273,   -1,  275,  276,   -1,   -1,
 284   270,  262,  263,  273,   -1,  275,  276,   -1,   -1,  270,
 285    -1,   -1,  273,   -1,  275,  276,
 286 };
 287 #define YYFINAL 16
 288 #ifndef YYDEBUG
 289 #define YYDEBUG 0
 290 #endif
 291 #define YYMAXTOKEN 303
 292 #if YYDEBUG
 293 static const char *yyname[] = {
 294
 295 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 296 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 297 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 298 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 299 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 300 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 301 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"_LANGLE_t","_LANGLE_EQUALS_t",
 302 "_EQUALS_t","_RANGLE_t","_RANGLE_EQUALS_t","_BAR_t","_BARBAR_t","_SEMIC_t",
 303 "_COLON_t","_BANG_t","_BANG_EQUALS_t","_QUESTION_EQUALS_t","_LPAREN_t",
 304 "_RPAREN_t","_LBRACKET_t","_RBRACKET_t","_LBRACE_t","_RBRACE_t","_AMPER_t",
 305 "_AMPERAMPER_t","_PLUS_EQUALS_t","ACTIONS_t","BIND_t","BREAK_t","CASE_t",
 306 "CONTINUE_t","DEFAULT_t","ELSE_t","EXISTING_t","FOR_t","IF_t","IGNORE_t","IN_t",
 307 "INCLUDE_t","LOCAL_t","MAXLINE_t","ON_t","PIECEMEAL_t","QUIETLY_t","RETURN_t",
 308 "RULE_t","SWITCH_t","TOGETHER_t","UPDATED_t","WHILE_t","ARG","STRING",
 309 };
 310 static const char *yyrule[] = {
 311 "$accept : run",
 312 "run :",
 313 "run : rules",
 314 "block :",
 315 "block : rules",
 316 "rules : rule",
 317 "rules : rule rules",
 318 "rules : LOCAL_t list _SEMIC_t block",
 319 "rules : LOCAL_t list _EQUALS_t list _SEMIC_t block",
 320 "rule : _LBRACE_t block _RBRACE_t",
 321 "rule : INCLUDE_t list _SEMIC_t",
 322 "rule : arg lol _SEMIC_t",
 323 "rule : arg assign list _SEMIC_t",
 324 "rule : arg ON_t list assign list _SEMIC_t",
 325 "rule : BREAK_t list _SEMIC_t",
 326 "rule : CONTINUE_t list _SEMIC_t",
 327 "rule : RETURN_t list _SEMIC_t",
 328 "rule : FOR_t ARG IN_t list _LBRACE_t block _RBRACE_t",
 329 "rule : SWITCH_t list _LBRACE_t cases _RBRACE_t",
 330 "rule : IF_t expr _LBRACE_t block _RBRACE_t",
 331 "rule : IF_t expr _LBRACE_t block _RBRACE_t ELSE_t rule",
 332 "rule : WHILE_t expr _LBRACE_t block _RBRACE_t",
 333 "rule : RULE_t ARG params _LBRACE_t block _RBRACE_t",
 334 "rule : ON_t arg rule",
 335 "$$1 :",
 336 "$$2 :",
 337 "rule : ACTIONS_t eflags ARG bindlist _LBRACE_t $$1 STRING $$2 _RBRACE_t",
 338 "assign : _EQUALS_t",
 339 "assign : _PLUS_EQUALS_t",
 340 "assign : _QUESTION_EQUALS_t",
 341 "assign : DEFAULT_t _EQUALS_t",
 342 "expr : arg",
 343 "expr : expr _EQUALS_t expr",
 344 "expr : expr _BANG_EQUALS_t expr",
 345 "expr : expr _LANGLE_t expr",
 346 "expr : expr _LANGLE_EQUALS_t expr",
 347 "expr : expr _RANGLE_t expr",
 348 "expr : expr _RANGLE_EQUALS_t expr",
 349 "expr : expr _AMPER_t expr",
 350 "expr : expr _AMPERAMPER_t expr",
 351 "expr : expr _BAR_t expr",
 352 "expr : expr _BARBAR_t expr",
 353 "expr : arg IN_t list",
 354 "expr : _BANG_t expr",
 355 "expr : _LPAREN_t expr _RPAREN_t",
 356 "cases :",
 357 "cases : case cases",
 358 "case : CASE_t ARG _COLON_t block",
 359 "params :",
 360 "params : ARG _COLON_t params",
 361 "params : ARG",
 362 "lol : list",
 363 "lol : list _COLON_t lol",
 364 "list : listp",
 365 "listp :",
 366 "listp : listp arg",
 367 "arg : ARG",
 368 "$$3 :",
 369 "arg : _LBRACKET_t $$3 func _RBRACKET_t",
 370 "func : arg lol",
 371 "func : ON_t arg arg lol",
 372 "func : ON_t arg RETURN_t list",
 373 "eflags :",
 374 "eflags : eflags eflag",
 375 "eflag : UPDATED_t",
 376 "eflag : TOGETHER_t",
 377 "eflag : IGNORE_t",
 378 "eflag : QUIETLY_t",
 379 "eflag : PIECEMEAL_t",
 380 "eflag : EXISTING_t",
 381 "eflag : MAXLINE_t ARG",
 382 "bindlist :",
 383 "bindlist : BIND_t list",
 384
 385 };
 386 #endif
 387 #ifndef YYSTYPE
 388 typedef int YYSTYPE;
 389 #endif
 390 #if YYDEBUG
 391 #include <stdio.h>
 392 #endif
 393
 394 /* define the initial stack-sizes */
 395 #ifdef YYSTACKSIZE
 396 #undef YYMAXDEPTH
 397 #define YYMAXDEPTH  YYSTACKSIZE
 398 #else
 399 #ifdef YYMAXDEPTH
 400 #define YYSTACKSIZE YYMAXDEPTH
 401 #else
 402 #define YYSTACKSIZE 500
 403 #define YYMAXDEPTH  500
 404 #endif
 405 #endif
 406
 407 #define YYINITSTACKSIZE 500
 408
 409 int      yydebug;
 410 int      yynerrs;
 411 int      yyerrflag;
 412 int      yychar;
 413 short   *yyssp;
 414 YYSTYPE *yyvsp;
 415 YYSTYPE  yyval;
 416 YYSTYPE  yylval;
 417
 418 /* variables for the parser stack */
 419 static short   *yyss;
 420 static short   *yysslim;
 421 static YYSTYPE *yyvs;
 422 static unsigned yystacksize;
 423 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 424 static int yygrowstack(void)
 425 {
 426     int i;
 427     unsigned newsize;
 428     short *newss;
 429     YYSTYPE *newvs;
 430
 431     if ((newsize = yystacksize) == 0)
 432         newsize = YYINITSTACKSIZE;
 433     else if (newsize >= YYMAXDEPTH)
 434         return -1;
 435     else if ((newsize *= 2) > YYMAXDEPTH)
 436         newsize = YYMAXDEPTH;
 437
 438     i = yyssp - yyss;
 439     newss = (yyss != 0)
 440           ? (short *)realloc(yyss, newsize * sizeof(*newss))
 441           : (short *)malloc(newsize * sizeof(*newss));
 442     if (newss == 0)
 443         return -1;
 444
 445     yyss  = newss;
 446     yyssp = newss + i;
 447     newvs = (yyvs != 0)
 448           ? (YYSTYPE *)realloc(yyvs, newsize * sizeof(*newvs))
 449           : (YYSTYPE *)malloc(newsize * sizeof(*newvs));
 450     if (newvs == 0)
 451         return -1;
 452
 453     yyvs = newvs;
 454     yyvsp = newvs + i;
 455     yystacksize = newsize;
 456     yysslim = yyss + newsize - 1;
 457     return 0;
 458 }
 459
 460 #define YYABORT  goto yyabort
 461 #define YYREJECT goto yyabort
 462 #define YYACCEPT goto yyaccept
 463 #define YYERROR  goto yyerrlab
 464
 465 int
 466 YYPARSE_DECL()
 467 {
 468     int yym, yyn, yystate;
 469 #if YYDEBUG
 470     const char *yys;
 471
 472     if ((yys = getenv("YYDEBUG")) != 0)
 473     {
 474         yyn = *yys;
 475         if (yyn >= '0' && yyn <= '9')
 476             yydebug = yyn - '0';
 477     }
 478 #endif
 479
 480     yynerrs = 0;
 481     yyerrflag = 0;
 482     yychar = YYEMPTY;
 483     yystate = 0;
 484
 485     if (yyss == NULL && yygrowstack()) goto yyoverflow;
 486     yyssp = yyss;
 487     yyvsp = yyvs;
 488     yystate = 0;
 489     *yyssp = 0;
 490
 491 yyloop:
 492     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
 493     if (yychar < 0)
 494     {
 495         if ((yychar = yylex()) < 0) yychar = 0;
 496 #if YYDEBUG
 497         if (yydebug)
 498         {
 499             yys = 0;
 500             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 501             if (!yys) yys = "illegal-symbol";
 502             printf("%sdebug: state %d, reading %d (%s)\n",
 503                     YYPREFIX, yystate, yychar, yys);
 504         }
 505 #endif
 506     }
 507     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 508             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 509     {
 510 #if YYDEBUG
 511         if (yydebug)
 512             printf("%sdebug: state %d, shifting to state %d\n",
 513                     YYPREFIX, yystate, yytable[yyn]);
 514 #endif
 515         if (yyssp >= yysslim && yygrowstack())
 516         {
 517             goto yyoverflow;
 518         }
 519         yystate = yytable[yyn];
 520         *++yyssp = yytable[yyn];
 521         *++yyvsp = yylval;
 522         yychar = YYEMPTY;
 523         if (yyerrflag > 0)  --yyerrflag;
 524         goto yyloop;
 525     }
 526     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 527             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 528     {
 529         yyn = yytable[yyn];
 530         goto yyreduce;
 531     }
 532     if (yyerrflag) goto yyinrecovery;
 533
 534     yyerror("syntax error");
 535
 536     goto yyerrlab;
 537
 538 yyerrlab:
 539     ++yynerrs;
 540
 541 yyinrecovery:
 542     if (yyerrflag < 3)
 543     {
 544         yyerrflag = 3;
 545         for (;;)
 546         {
 547             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 548                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 549             {
 550 #if YYDEBUG
 551                 if (yydebug)
 552                     printf("%sdebug: state %d, error recovery shifting\
 553  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 554 #endif
 555                 if (yyssp >= yysslim && yygrowstack())
 556                 {
 557                     goto yyoverflow;
 558                 }
 559                 yystate = yytable[yyn];
 560                 *++yyssp = yytable[yyn];
 561                 *++yyvsp = yylval;
 562                 goto yyloop;
 563             }
 564             else
 565             {
 566 #if YYDEBUG
 567                 if (yydebug)
 568                     printf("%sdebug: error recovery discarding state %d\n",
 569                             YYPREFIX, *yyssp);
 570 #endif
 571                 if (yyssp <= yyss) goto yyabort;
 572                 --yyssp;
 573                 --yyvsp;
 574             }
 575         }
 576     }
 577     else
 578     {
 579         if (yychar == 0) goto yyabort;
 580 #if YYDEBUG
 581         if (yydebug)
 582         {
 583             yys = 0;
 584             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 585             if (!yys) yys = "illegal-symbol";
 586             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
 587                     YYPREFIX, yystate, yychar, yys);
 588         }
 589 #endif
 590         yychar = YYEMPTY;
 591         goto yyloop;
 592     }
 593
 594 yyreduce:
 595 #if YYDEBUG
 596     if (yydebug)
 597         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
 598                 YYPREFIX, yystate, yyn, yyrule[yyn]);
 599 #endif
 600     yym = yylen[yyn];
 601     if (yym)
 602         yyval = yyvsp[1-yym];
 603     else
 604         memset(&yyval, 0, sizeof yyval);
 605     switch (yyn)
 606     {
 607 case 2:
 608 #line 130 "jamgram.y"
 609         { parse_save( yyvsp[0].parse ); }
 610 break;
 611 case 3:
 612 #line 141 "jamgram.y"
 613         { yyval.parse = pnull(); }
 614 break;
 615 case 4:
 616 #line 143 "jamgram.y"
 617         { yyval.parse = yyvsp[0].parse; }
 618 break;
 619 case 5:
 620 #line 147 "jamgram.y"
 621         { yyval.parse = yyvsp[0].parse; }
 622 break;
 623 case 6:
 624 #line 149 "jamgram.y"
 625         { yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
 626 break;
 627 case 7:
 628 #line 151 "jamgram.y"
 629         { yyval.parse = plocal( yyvsp[-2].parse, pnull(), yyvsp[0].parse ); }
 630 break;
 631 case 8:
 632 #line 153 "jamgram.y"
 633         { yyval.parse = plocal( yyvsp[-4].parse, yyvsp[-2].parse, yyvsp[0].parse ); }
 634 break;
 635 case 9:
 636 #line 157 "jamgram.y"
 637         { yyval.parse = yyvsp[-1].parse; }
 638 break;
 639 case 10:
 640 #line 159 "jamgram.y"
 641         { yyval.parse = pincl( yyvsp[-1].parse ); }
 642 break;
 643 case 11:
 644 #line 161 "jamgram.y"
 645         { yyval.parse = prule( yyvsp[-2].parse, yyvsp[-1].parse ); }
 646 break;
 647 case 12:
 648 #line 163 "jamgram.y"
 649         { yyval.parse = pset( yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
 650 break;
 651 case 13:
 652 #line 165 "jamgram.y"
 653         { yyval.parse = pset1( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[-1].parse, yyvsp[-2].number ); }
 654 break;
 655 case 14:
 656 #line 167 "jamgram.y"
 657         { yyval.parse = pbreak( yyvsp[-1].parse, JMP_BREAK ); }
 658 break;
 659 case 15:
 660 #line 169 "jamgram.y"
 661         { yyval.parse = pbreak( yyvsp[-1].parse, JMP_CONTINUE ); }
 662 break;
 663 case 16:
 664 #line 171 "jamgram.y"
 665         { yyval.parse = pbreak( yyvsp[-1].parse, JMP_RETURN ); }
 666 break;
 667 case 17:
 668 #line 173 "jamgram.y"
 669         { yyval.parse = pfor( yyvsp[-5].string, yyvsp[-3].parse, yyvsp[-1].parse ); }
 670 break;
 671 case 18:
 672 #line 175 "jamgram.y"
 673         { yyval.parse = pswitch( yyvsp[-3].parse, yyvsp[-1].parse ); }
 674 break;
 675 case 19:
 676 #line 177 "jamgram.y"
 677         { yyval.parse = pif( yyvsp[-3].parse, yyvsp[-1].parse, pnull() ); }
 678 break;
 679 case 20:
 680 #line 179 "jamgram.y"
 681         { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
 682 break;
 683 case 21:
 684 #line 181 "jamgram.y"
 685         { yyval.parse = pwhile( yyvsp[-3].parse, yyvsp[-1].parse ); }
 686 break;
 687 case 22:
 688 #line 183 "jamgram.y"
 689         { yyval.parse = psetc( yyvsp[-4].string, yyvsp[-3].parse, yyvsp[-1].parse ); }
 690 break;
 691 case 23:
 692 #line 185 "jamgram.y"
 693         { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
 694 break;
 695 case 24:
 696 #line 187 "jamgram.y"
 697         { yymode( SCAN_STRING ); }
 698 break;
 699 case 25:
 700 #line 189 "jamgram.y"
 701         { yymode( SCAN_NORMAL ); }
 702 break;
 703 case 26:
 704 #line 191 "jamgram.y"
 705         { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
 706 break;
 707 case 27:
 708 #line 199 "jamgram.y"
 709         { yyval.number = VAR_SET; }
 710 break;
 711 case 28:
 712 #line 201 "jamgram.y"
 713         { yyval.number = VAR_APPEND; }
 714 break;
 715 case 29:
 716 #line 203 "jamgram.y"
 717         { yyval.number = VAR_DEFAULT; }
 718 break;
 719 case 30:
 720 #line 205 "jamgram.y"
 721         { yyval.number = VAR_DEFAULT; }
 722 break;
 723 case 31:
 724 #line 213 "jamgram.y"
 725         { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); }
 726 break;
 727 case 32:
 728 #line 215 "jamgram.y"
 729         { yyval.parse = peval( EXPR_EQUALS, yyvsp[-2].parse, yyvsp[0].parse ); }
 730 break;
 731 case 33:
 732 #line 217 "jamgram.y"
 733         { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
 734 break;
 735 case 34:
 736 #line 219 "jamgram.y"
 737         { yyval.parse = peval( EXPR_LESS, yyvsp[-2].parse, yyvsp[0].parse ); }
 738 break;
 739 case 35:
 740 #line 221 "jamgram.y"
 741         { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
 742 break;
 743 case 36:
 744 #line 223 "jamgram.y"
 745         { yyval.parse = peval( EXPR_MORE, yyvsp[-2].parse, yyvsp[0].parse ); }
 746 break;
 747 case 37:
 748 #line 225 "jamgram.y"
 749         { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-2].parse, yyvsp[0].parse ); }
 750 break;
 751 case 38:
 752 #line 227 "jamgram.y"
 753         { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
 754 break;
 755 case 39:
 756 #line 229 "jamgram.y"
 757         { yyval.parse = peval( EXPR_AND, yyvsp[-2].parse, yyvsp[0].parse ); }
 758 break;
 759 case 40:
 760 #line 231 "jamgram.y"
 761         { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
 762 break;
 763 case 41:
 764 #line 233 "jamgram.y"
 765         { yyval.parse = peval( EXPR_OR, yyvsp[-2].parse, yyvsp[0].parse ); }
 766 break;
 767 case 42:
 768 #line 235 "jamgram.y"
 769         { yyval.parse = peval( EXPR_IN, yyvsp[-2].parse, yyvsp[0].parse ); }
 770 break;
 771 case 43:
 772 #line 237 "jamgram.y"
 773         { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
 774 break;
 775 case 44:
 776 #line 239 "jamgram.y"
 777         { yyval.parse = yyvsp[-1].parse; }
 778 break;
 779 case 45:
 780 #line 249 "jamgram.y"
 781         { yyval.parse = P0; }
 782 break;
 783 case 46:
 784 #line 251 "jamgram.y"
 785         { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
 786 break;
 787 case 47:
 788 #line 255 "jamgram.y"
 789         { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
 790 break;
 791 case 48:
 792 #line 264 "jamgram.y"
 793         { yyval.parse = P0; }
 794 break;
 795 case 49:
 796 #line 266 "jamgram.y"
 797         { yyval.parse = psnode( yyvsp[-2].string, yyvsp[0].parse ); }
 798 break;
 799 case 50:
 800 #line 268 "jamgram.y"
 801         { yyval.parse = psnode( yyvsp[0].string, P0 ); }
 802 break;
 803 case 51:
 804 #line 277 "jamgram.y"
 805         { yyval.parse = pnode( P0, yyvsp[0].parse ); }
 806 break;
 807 case 52:
 808 #line 279 "jamgram.y"
 809         { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
 810 break;
 811 case 53:
 812 #line 289 "jamgram.y"
 813         { yyval.parse = yyvsp[0].parse; yymode( SCAN_NORMAL ); }
 814 break;
 815 case 54:
 816 #line 293 "jamgram.y"
 817         { yyval.parse = pnull(); yymode( SCAN_PUNCT ); }
 818 break;
 819 case 55:
 820 #line 295 "jamgram.y"
 821         { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
 822 break;
 823 case 56:
 824 #line 299 "jamgram.y"
 825         { yyval.parse = plist( yyvsp[0].string ); }
 826 break;
 827 case 57:
 828 #line 300 "jamgram.y"
 829         { yymode( SCAN_NORMAL ); }
 830 break;
 831 case 58:
 832 #line 301 "jamgram.y"
 833         { yyval.parse = yyvsp[-1].parse; }
 834 break;
 835 case 59:
 836 #line 310 "jamgram.y"
 837         { yyval.parse = prule( yyvsp[-1].parse, yyvsp[0].parse ); }
 838 break;
 839 case 60:
 840 #line 312 "jamgram.y"
 841         { yyval.parse = pon( yyvsp[-2].parse, prule( yyvsp[-1].parse, yyvsp[0].parse ) ); }
 842 break;
 843 case 61:
 844 #line 314 "jamgram.y"
 845         { yyval.parse = pon( yyvsp[-2].parse, yyvsp[0].parse ); }
 846 break;
 847 case 62:
 848 #line 323 "jamgram.y"
 849         { yyval.number = 0; }
 850 break;
 851 case 63:
 852 #line 325 "jamgram.y"
 853         { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
 854 break;
 855 case 64:
 856 #line 329 "jamgram.y"
 857         { yyval.number = RULE_UPDATED; }
 858 break;
 859 case 65:
 860 #line 331 "jamgram.y"
 861         { yyval.number = RULE_TOGETHER; }
 862 break;
 863 case 66:
 864 #line 333 "jamgram.y"
 865         { yyval.number = RULE_IGNORE; }
 866 break;
 867 case 67:
 868 #line 335 "jamgram.y"
 869         { yyval.number = RULE_QUIETLY; }
 870 break;
 871 case 68:
 872 #line 337 "jamgram.y"
 873         { yyval.number = RULE_PIECEMEAL; }
 874 break;
 875 case 69:
 876 #line 339 "jamgram.y"
 877         { yyval.number = RULE_EXISTING; }
 878 break;
 879 case 70:
 880 #line 341 "jamgram.y"
 881         { yyval.number = atoi( yyvsp[0].string ) * RULE_MAXLINE; }
 882 break;
 883 case 71:
 884 #line 350 "jamgram.y"
 885         { yyval.parse = pnull(); }
 886 break;
 887 case 72:
 888 #line 352 "jamgram.y"
 889         { yyval.parse = yyvsp[0].parse; }
 890 break;
 891 #line 891 "y.tab.c"
 892     }
 893     yyssp -= yym;
 894     yystate = *yyssp;
 895     yyvsp -= yym;
 896     yym = yylhs[yyn];
 897     if (yystate == 0 && yym == 0)
 898     {
 899 #if YYDEBUG
 900         if (yydebug)
 901             printf("%sdebug: after reduction, shifting from state 0 to\
 902  state %d\n", YYPREFIX, YYFINAL);
 903 #endif
 904         yystate = YYFINAL;
 905         *++yyssp = YYFINAL;
 906         *++yyvsp = yyval;
 907         if (yychar < 0)
 908         {
 909             if ((yychar = yylex()) < 0) yychar = 0;
 910 #if YYDEBUG
 911             if (yydebug)
 912             {
 913                 yys = 0;
 914                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 915                 if (!yys) yys = "illegal-symbol";
 916                 printf("%sdebug: state %d, reading %d (%s)\n",
 917                         YYPREFIX, YYFINAL, yychar, yys);
 918             }
 919 #endif
 920         }
 921         if (yychar == 0) goto yyaccept;
 922         goto yyloop;
 923     }
 924     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 925             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 926         yystate = yytable[yyn];
 927     else
 928         yystate = yydgoto[yym];
 929 #if YYDEBUG
 930     if (yydebug)
 931         printf("%sdebug: after reduction, shifting from state %d \
 932 to state %d\n", YYPREFIX, *yyssp, yystate);
 933 #endif
 934     if (yyssp >= yysslim && yygrowstack())
 935     {
 936         goto yyoverflow;
 937     }
 938     *++yyssp = (short) yystate;
 939     *++yyvsp = yyval;
 940     goto yyloop;
 941
 942 yyoverflow:
 943     yyerror("yacc stack overflow");
 944
 945 yyabort:
 946     return (1);
 947
 948 yyaccept:
 949     return (0);
 950 }