src/common/cwy_tab.c

   1 #ifndef lint
   2 static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
   3 #endif
   4 #define YYBYACC 1
   5 #line 2 "parser.y"
   6 #include "string.h"
   7 #ifdef _MSC_VER
   8 #include <io.h>
   9 #endif
  10 #include "wx/expr.h"
  11
  12 #ifndef __EXTERN_C__
  13 #define __EXTERN_C__ 1
  14 #endif
  15
  16 #if defined(__cplusplus) || defined(__STDC__)
  17 #if defined(__cplusplus) && defined(__EXTERN_C__)
  18 extern "C" {
  19 #endif
  20 #endif
  21 int yylex(void);
  22 int yylook(void);
  23 int yywrap(void);
  24 int yyback(int *, int);
  25
  26 /* You may need to put /DLEX_SCANNER in your makefile
  27  * if you're using LEX!
  28         Last change:  JS   13 Jul 97    6:12 pm
  29  */
  30 #ifdef LEX_SCANNER
  31 /* int yyoutput(int); */
  32 void yyoutput(int);
  33 #else
  34 void yyoutput(int);
  35 #endif
  36
  37 #if defined(__cplusplus) || defined(__STDC__)
  38 #if defined(__cplusplus) && defined(__EXTERN_C__)
  39 }
  40 #endif
  41 #endif
  42 #line 36 "parser.y"
  43 typedef union {
  44     char *s;
  45 /*    struct pexpr *expr; */
  46 } YYSTYPE;
  47 #line 44 "y_tab.c"
  48 #define INTEGER 1
  49 #define WORD 2
  50 #define STRING 3
  51 #define PERIOD 13
  52 #define OPEN 4
  53 #define CLOSE 5
  54 #define COMMA 6
  55 #define NEWLINE 7
  56 #define ERROR 8
  57 #define OPEN_SQUARE 9
  58 #define CLOSE_SQUARE 10
  59 #define EQUALS 11
  60 #define EXP 14
  61 #define YYERRCODE 256
  62 short yylhs[] = {                                        -1,
  63     0,    0,    1,    1,    1,    2,    2,    2,    3,    3,
  64     3,    4,    4,    5,    5,    5,    5,    5,    5,    5,
  65 };
  66 short yylen[] = {                                         2,
  67     0,    2,    2,    2,    2,    4,    2,    3,    0,    1,
  68     3,    3,    1,    1,    1,    1,    3,    3,    5,    1,
  69 };
  70 short yydefred[] = {                                      1,
  71     0,    0,    0,    0,    2,    0,    5,    3,    0,    0,
  72     0,   15,    7,   20,    0,    0,   13,    4,    0,    0,
  73     0,    0,    8,    0,    6,    0,   18,    0,   12,   11,
  74     0,   19,
  75 };
  76 short yydgoto[] = {                                       1,
  77     5,   14,   15,   16,   17,
  78 };
  79 short yysindex[] = {                                      0,
  80    -2,    9,    2,    1,    0,   10,    0,    0,   11,   -5,
  81    17,    0,    0,    0,   14,   -1,    0,    0,   33,   38,
  82    41,   16,    0,   11,    0,   29,    0,   40,    0,    0,
  83    44,    0,
  84 };
  85 short yyrindex[] = {                                      0,
  86     0,    0,    0,    0,    0,    0,    0,    0,   42,   21,
  87    24,    0,    0,    0,    0,   30,    0,    0,    0,    0,
  88     0,    0,    0,   31,    0,   27,    0,   24,    0,    0,
  89     0,    0,
  90 };
  91 short yygindex[] = {                                      0,
  92     0,   45,   -8,    0,   26,
  93 };
  94 #define YYTABLESIZE 254
  95 short yytable[] = {                                       3,
  96    19,   10,   11,   12,   24,    9,    4,   20,   21,    4,
  97    13,   10,   11,   12,    8,   30,   10,   28,   12,    4,
  98     9,    7,   18,   23,    4,   16,   16,   22,   14,   14,
  99    16,   17,   17,   14,   10,    9,   17,   25,   26,   10,
 100     9,   27,   31,    9,   32,    6,    9,   29,    0,    0,
 101     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 102     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 103     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 104     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 105     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 106     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 107     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 108     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 109     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 110     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 111     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 112     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 113     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 114     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 115     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 116     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 117     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 118     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 119     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 120     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
 121     0,    0,    0,    2,
 122 };
 123 short yycheck[] = {                                       2,
 124     9,    1,    2,    3,    6,    4,    9,   13,   14,    9,
 125    10,    1,    2,    3,   13,   24,    1,    2,    3,    9,
 126     4,   13,   13,   10,    9,    5,    6,   11,    5,    6,
 127    10,    5,    6,   10,    5,    5,   10,    5,    1,   10,
 128    10,    1,   14,    4,    1,    1,    5,   22,   -1,   -1,
 129    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 130    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 131    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 132    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 133    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 134    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 135    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 136    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 137    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 138    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 139    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 140    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 141    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 142    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 143    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 144    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 145    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 146    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 147    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 148    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
 149    -1,   -1,   -1,  256,
 150 };
 151 #define YYFINAL 1
 152 #ifndef YYDEBUG
 153 #define YYDEBUG 0
 154 #endif
 155 #define YYMAXTOKEN 14
 156 #if YYDEBUG
 157 char *yyname[] = {
 158 "end-of-file","INTEGER","WORD","STRING","OPEN","CLOSE","COMMA","NEWLINE",
 159 "ERROR","OPEN_SQUARE","CLOSE_SQUARE","EQUALS",0,"PERIOD","EXP",
 160 };
 161 char *yyrule[] = {
 162 "$accept : commands",
 163 "commands :",
 164 "commands : commands command",
 165 "command : WORD PERIOD",
 166 "command : expr PERIOD",
 167 "command : error PERIOD",
 168 "expr : WORD OPEN arglist CLOSE",
 169 "expr : OPEN_SQUARE CLOSE_SQUARE",
 170 "expr : OPEN_SQUARE arglist CLOSE_SQUARE",
 171 "arglist :",
 172 "arglist : arg",
 173 "arglist : arg COMMA arglist",
 174 "arg : WORD EQUALS arg1",
 175 "arg : arg1",
 176 "arg1 : WORD",
 177 "arg1 : STRING",
 178 "arg1 : INTEGER",
 179 "arg1 : INTEGER PERIOD INTEGER",
 180 "arg1 : INTEGER EXP INTEGER",
 181 "arg1 : INTEGER PERIOD INTEGER EXP INTEGER",
 182 "arg1 : expr",
 183 };
 184 #endif
 185 #define yyclearin (yychar=(-1))
 186 #define yyerrok (yyerrflag=0)
 187 #ifdef YYSTACKSIZE
 188 #ifndef YYMAXDEPTH
 189 #define YYMAXDEPTH YYSTACKSIZE
 190 #endif
 191 #else
 192 #ifdef YYMAXDEPTH
 193 #define YYSTACKSIZE YYMAXDEPTH
 194 #else
 195 #define YYSTACKSIZE 600
 196 #define YYMAXDEPTH 600
 197 #endif
 198 #endif
 199 int yydebug;
 200 int yynerrs;
 201 int yyerrflag;
 202 int yychar;
 203 short *yyssp;
 204 YYSTYPE *yyvsp;
 205 YYSTYPE yyval;
 206 YYSTYPE yylval;
 207 short yyss[YYSTACKSIZE];
 208 YYSTYPE yyvs[YYSTACKSIZE];
 209 #define yystacksize YYSTACKSIZE
 210 #line 118 "parser.y"
 211
 212 #ifdef IDE_INVOKED
 213 #include "../common/doslex.c"
 214 #else
 215 #if (defined(__MWERKS__))
 216 #include "../common/cwlex_yy.c"
 217 #else
 218 #include "../common/lex_yy.c"
 219 #endif
 220 #endif
 221
 222 /*
 223 void yyerror(s)
 224 char *s;
 225 {
 226   syntax_error(s);
 227 }
 228 */
 229
 230 /* Ansi prototype. If this doesn't work for you... uncomment
 231    the above instead.
 232  */
 233
 234 void yyerror(char *s)
 235 {
 236   syntax_error(s);
 237 }
 238
 239 /*
 240  * Unfortunately, my DOS version of FLEX
 241  * requires yywrap to be #def'ed, whereas
 242  * the UNIX flex expects a proper function.
 243  */
 244
 245 /* Not sure if __SC__ is the appropriate thing
 246  * to test
 247  */
 248
 249 #ifndef __SC__
 250 #ifdef USE_DEFINE
 251 #ifndef yywrap
 252 #define yywrap() 1
 253 #endif
 254 #else
 255 int yywrap() { return 1; }
 256 #endif
 257 #endif
 258 #line 247 "y_tab.c"
 259 #define YYABORT goto yyabort
 260 #define YYACCEPT goto yyaccept
 261 #define YYERROR goto yyerrlab
 262 int
 263 yyparse()
 264 {
 265     register int yym, yyn, yystate;
 266 #if YYDEBUG
 267     register char *yys;
 268     extern char *getenv();
 269
 270     if (yys = getenv("YYDEBUG"))
 271     {
 272         yyn = *yys;
 273         if (yyn >= '0' && yyn <= '9')
 274             yydebug = yyn - '0';
 275     }
 276 #endif
 277
 278     yynerrs = 0;
 279     yyerrflag = 0;
 280     yychar = (-1);
 281
 282     yyssp = yyss;
 283     yyvsp = yyvs;
 284     *yyssp = yystate = 0;
 285
 286 yyloop:
 287     if (yyn = yydefred[yystate]) goto yyreduce;
 288     if (yychar < 0)
 289     {
 290         if ((yychar = yylex()) < 0) yychar = 0;
 291 #if YYDEBUG
 292         if (yydebug)
 293         {
 294             yys = 0;
 295             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 296             if (!yys) yys = "illegal-symbol";
 297             printf("yydebug: state %d, reading %d (%s)\n", yystate,
 298                     yychar, yys);
 299         }
 300 #endif
 301     }
 302     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 303             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 304     {
 305 #if YYDEBUG
 306         if (yydebug)
 307             printf("yydebug: state %d, shifting to state %d\n",
 308                     yystate, yytable[yyn]);
 309 #endif
 310         if (yyssp >= yyss + yystacksize - 1)
 311         {
 312             goto yyoverflow;
 313         }
 314         *++yyssp = yystate = yytable[yyn];
 315         *++yyvsp = yylval;
 316         yychar = (-1);
 317         if (yyerrflag > 0)  --yyerrflag;
 318         goto yyloop;
 319     }
 320     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 321             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 322     {
 323         yyn = yytable[yyn];
 324         goto yyreduce;
 325     }
 326     if (yyerrflag) goto yyinrecovery;
 327 #ifdef lint
 328     goto yynewerror;
 329 #endif
 330 yynewerror:
 331     yyerror("syntax error");
 332 #ifdef lint
 333     goto yyerrlab;
 334 #endif
 335 yyerrlab:
 336     ++yynerrs;
 337 yyinrecovery:
 338     if (yyerrflag < 3)
 339     {
 340         yyerrflag = 3;
 341         for (;;)
 342         {
 343             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 344                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 345             {
 346 #if YYDEBUG
 347                 if (yydebug)
 348                     printf("yydebug: state %d, error recovery shifting\
 349  to state %d\n", *yyssp, yytable[yyn]);
 350 #endif
 351                 if (yyssp >= yyss + yystacksize - 1)
 352                 {
 353                     goto yyoverflow;
 354                 }
 355                 *++yyssp = yystate = yytable[yyn];
 356                 *++yyvsp = yylval;
 357                 goto yyloop;
 358             }
 359             else
 360             {
 361 #if YYDEBUG
 362                 if (yydebug)
 363                     printf("yydebug: error recovery discarding state %d\n",
 364                             *yyssp);
 365 #endif
 366                 if (yyssp <= yyss) goto yyabort;
 367                 --yyssp;
 368                 --yyvsp;
 369             }
 370         }
 371     }
 372     else
 373     {
 374         if (yychar == 0) goto yyabort;
 375 #if YYDEBUG
 376         if (yydebug)
 377         {
 378             yys = 0;
 379             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 380             if (!yys) yys = "illegal-symbol";
 381             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
 382                     yystate, yychar, yys);
 383         }
 384 #endif
 385         yychar = (-1);
 386         goto yyloop;
 387     }
 388 yyreduce:
 389 #if YYDEBUG
 390     if (yydebug)
 391         printf("yydebug: state %d, reducing by rule %d (%s)\n",
 392                 yystate, yyn, yyrule[yyn]);
 393 #endif
 394     yym = yylen[yyn];
 395     yyval = yyvsp[1-yym];
 396     switch (yyn)
 397     {
 398 case 3:
 399 #line 68 "parser.y"
 400 {process_command(proio_cons(make_word(yyvsp[-1].s), NULL)); free(yyvsp[-1].s);}
 401 break;
 402 case 4:
 403 #line 70 "parser.y"
 404 {process_command(yyvsp[-1].s);}
 405 break;
 406 case 5:
 407 #line 72 "parser.y"
 408 {syntax_error("Unrecognized command.");}
 409 break;
 410 case 6:
 411 #line 76 "parser.y"
 412 {yyval.s = proio_cons(make_word(yyvsp[-3].s), yyvsp[-1].s); free(yyvsp[-3].s);}
 413 break;
 414 case 7:
 415 #line 78 "parser.y"
 416 {yyval.s = proio_cons(NULL, NULL);}
 417 break;
 418 case 8:
 419 #line 80 "parser.y"
 420 {yyval.s = yyvsp[-1].s; }
 421 break;
 422 case 9:
 423 #line 84 "parser.y"
 424 {yyval.s = NULL;}
 425 break;
 426 case 10:
 427 #line 86 "parser.y"
 428 {yyval.s = proio_cons(yyvsp[0].s, NULL);}
 429 break;
 430 case 11:
 431 #line 89 "parser.y"
 432 {yyval.s = proio_cons(yyvsp[-2].s, yyvsp[0].s);}
 433 break;
 434 case 12:
 435 #line 93 "parser.y"
 436 {yyval.s = proio_cons(make_word("="), proio_cons(make_word(yyvsp[-2].s), proio_cons(yyvsp[0].s, NULL)));
 437                          free(yyvsp[-2].s); }
 438 break;
 439 case 13:
 440 #line 96 "parser.y"
 441 {yyval.s = yyvsp[0].s; }
 442 break;
 443 case 14:
 444 #line 99 "parser.y"
 445 {yyval.s = make_word(yyvsp[0].s); free(yyvsp[0].s);}
 446 break;
 447 case 15:
 448 #line 101 "parser.y"
 449 {yyval.s = make_string(yyvsp[0].s); free(yyvsp[0].s);}
 450 break;
 451 case 16:
 452 #line 103 "parser.y"
 453 {yyval.s = make_integer(yyvsp[0].s); free(yyvsp[0].s);}
 454 break;
 455 case 17:
 456 #line 105 "parser.y"
 457 {yyval.s = make_real(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
 458 break;
 459 case 18:
 460 #line 107 "parser.y"
 461 {yyval.s = make_exp(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
 462 break;
 463 case 19:
 464 #line 110 "parser.y"
 465 {yyval.s = make_exp2(yyvsp[-4].s, yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-4].s); free(yyvsp[-2].s);
 466                                                                   free(yyvsp[0].s); }
 467 break;
 468 case 20:
 469 #line 114 "parser.y"
 470 {yyval.s = yyvsp[0].s;}
 471 break;
 472 #line 461 "y_tab.c"
 473     }
 474     yyssp -= yym;
 475     yystate = *yyssp;
 476     yyvsp -= yym;
 477     yym = yylhs[yyn];
 478     if (yystate == 0 && yym == 0)
 479     {
 480 #if YYDEBUG
 481         if (yydebug)
 482             printf("yydebug: after reduction, shifting from state 0 to\
 483  state %d\n", YYFINAL);
 484 #endif
 485         yystate = YYFINAL;
 486         *++yyssp = YYFINAL;
 487         *++yyvsp = yyval;
 488         if (yychar < 0)
 489         {
 490             if ((yychar = yylex()) < 0) yychar = 0;
 491 #if YYDEBUG
 492             if (yydebug)
 493             {
 494                 yys = 0;
 495                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 496                 if (!yys) yys = "illegal-symbol";
 497                 printf("yydebug: state %d, reading %d (%s)\n",
 498                         YYFINAL, yychar, yys);
 499             }
 500 #endif
 501         }
 502         if (yychar == 0) goto yyaccept;
 503         goto yyloop;
 504     }
 505     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 506             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 507         yystate = yytable[yyn];
 508     else
 509         yystate = yydgoto[yym];
 510 #if YYDEBUG
 511     if (yydebug)
 512         printf("yydebug: after reduction, shifting from state %d \
 513 to state %d\n", *yyssp, yystate);
 514 #endif
 515     if (yyssp >= yyss + yystacksize - 1)
 516     {
 517         goto yyoverflow;
 518     }
 519     *++yyssp = yystate;
 520     *++yyvsp = yyval;
 521     goto yyloop;
 522 yyoverflow:
 523     yyerror("yacc stack overflow");
 524 yyabort:
 525     return (1);
 526 yyaccept:
 527     return (0);
 528 }