src/common/dosyacc.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 #if defined(_MSC_VER) || defined(__VISAGECPP__)
   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  */
  29 #ifdef LEX_SCANNER
  30 /* int yyoutput(int); */
  31 void yyoutput(int);
  32 #else
  33 void yyoutput(int);
  34 #endif
  35
  36 #if defined(__cplusplus) || defined(__STDC__)
  37 #if defined(__cplusplus) && defined(__EXTERN_C__)
  38 }
  39 #endif
  40 #endif
  41 #line 36 "parser.y"
  42 typedef union {
  43     char *s;
  44 /*    struct pexpr *expr; */
  45 } YYSTYPE;
  46 #line 44 "y_tab.c"
  47 #define INTEGER 1
  48 #define WORD 2
  49 #define STRING 3
  50 #define PERIOD 13
  51 #define OPEN 4
  52 #define CLOSE 5
  53 #define COMMA 6
  54 #define NEWLINE 7
  55 #define ERROR 8
  56 #define OPEN_SQUARE 9
  57 #define CLOSE_SQUARE 10
  58 #define EQUALS 11
  59 #define EXP 14
  60 #define YYERRCODE 256
  61 short yylhs[] = {                                        -1,
  62     0,    0,    1,    1,    1,    2,    2,    2,    3,    3,
  63     3,    4,    4,    5,    5,    5,    5,    5,    5,    5,
  64 };
  65 short yylen[] = {                                         2,
  66     0,    2,    2,    2,    2,    4,    2,    3,    0,    1,
  67     3,    3,    1,    1,    1,    1,    3,    3,    5,    1,
  68 };
  69 short yydefred[] = {                                      1,
  70     0,    0,    0,    0,    2,    0,    5,    3,    0,    0,
  71     0,   15,    7,   20,    0,    0,   13,    4,    0,    0,
  72     0,    0,    8,    0,    6,    0,   18,    0,   12,   11,
  73     0,   19,
  74 };
  75 short yydgoto[] = {                                       1,
  76     5,   14,   15,   16,   17,
  77 };
  78 short yysindex[] = {                                      0,
  79    -2,    9,    2,    1,    0,   10,    0,    0,   11,   -5,
  80    17,    0,    0,    0,   14,   -1,    0,    0,   33,   38,
  81    41,   16,    0,   11,    0,   29,    0,   40,    0,    0,
  82    44,    0,
  83 };
  84 short yyrindex[] = {                                      0,
  85     0,    0,    0,    0,    0,    0,    0,    0,   42,   21,
  86    24,    0,    0,    0,    0,   30,    0,    0,    0,    0,
  87     0,    0,    0,   31,    0,   27,    0,   24,    0,    0,
  88     0,    0,
  89 };
  90 short yygindex[] = {                                      0,
  91     0,   45,   -8,    0,   26,
  92 };
  93 #define YYTABLESIZE 254
  94 short yytable[] = {                                       3,
  95    19,   10,   11,   12,   24,    9,    4,   20,   21,    4,
  96    13,   10,   11,   12,    8,   30,   10,   28,   12,    4,
  97     9,    7,   18,   23,    4,   16,   16,   22,   14,   14,
  98    16,   17,   17,   14,   10,    9,   17,   25,   26,   10,
  99     9,   27,   31,    9,   32,    6,    9,   29,    0,    0,
 100     0,    0,    0,    0,    0,    0,    0,    0,    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,    2,
 121 };
 122 short yycheck[] = {                                       2,
 123     9,    1,    2,    3,    6,    4,    9,   13,   14,    9,
 124    10,    1,    2,    3,   13,   24,    1,    2,    3,    9,
 125     4,   13,   13,   10,    9,    5,    6,   11,    5,    6,
 126    10,    5,    6,   10,    5,    5,   10,    5,    1,   10,
 127    10,    1,   14,    4,    1,    1,    5,   22,   -1,   -1,
 128    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -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,  256,
 149 };
 150 #define YYFINAL 1
 151 #ifndef YYDEBUG
 152 #define YYDEBUG 0
 153 #endif
 154 #define YYMAXTOKEN 14
 155 #if YYDEBUG
 156 char *yyname[] = {
 157 "end-of-file","INTEGER","WORD","STRING","OPEN","CLOSE","COMMA","NEWLINE",
 158 "ERROR","OPEN_SQUARE","CLOSE_SQUARE","EQUALS",0,"PERIOD","EXP",
 159 };
 160 char *yyrule[] = {
 161 "$accept : commands",
 162 "commands :",
 163 "commands : commands command",
 164 "command : WORD PERIOD",
 165 "command : expr PERIOD",
 166 "command : error PERIOD",
 167 "expr : WORD OPEN arglist CLOSE",
 168 "expr : OPEN_SQUARE CLOSE_SQUARE",
 169 "expr : OPEN_SQUARE arglist CLOSE_SQUARE",
 170 "arglist :",
 171 "arglist : arg",
 172 "arglist : arg COMMA arglist",
 173 "arg : WORD EQUALS arg1",
 174 "arg : arg1",
 175 "arg1 : WORD",
 176 "arg1 : STRING",
 177 "arg1 : INTEGER",
 178 "arg1 : INTEGER PERIOD INTEGER",
 179 "arg1 : INTEGER EXP INTEGER",
 180 "arg1 : INTEGER PERIOD INTEGER EXP INTEGER",
 181 "arg1 : expr",
 182 };
 183 #endif
 184 #define yyclearin (yychar=(-1))
 185 #define yyerrok (yyerrflag=0)
 186 #ifdef YYSTACKSIZE
 187 #ifndef YYMAXDEPTH
 188 #define YYMAXDEPTH YYSTACKSIZE
 189 #endif
 190 #else
 191 #ifdef YYMAXDEPTH
 192 #define YYSTACKSIZE YYMAXDEPTH
 193 #else
 194 #define YYSTACKSIZE 600
 195 #define YYMAXDEPTH 600
 196 #endif
 197 #endif
 198 int yydebug;
 199 int yynerrs;
 200 int yyerrflag;
 201 int yychar;
 202 short *yyssp;
 203 YYSTYPE *yyvsp;
 204 YYSTYPE yyval;
 205 YYSTYPE yylval;
 206 short yyss[YYSTACKSIZE];
 207 YYSTYPE yyvs[YYSTACKSIZE];
 208 #define yystacksize YYSTACKSIZE
 209 #line 118 "parser.y"
 210
 211 #ifdef IDE_INVOKED
 212 #include "../common/doslex.c"
 213 #else
 214 #include "../common/lex_yy.c"
 215 #endif
 216
 217 /*
 218 void yyerror(s)
 219 char *s;
 220 {
 221   syntax_error(s);
 222 }
 223 */
 224
 225 /* Ansi prototype. If this doesn't work for you... uncomment
 226    the above instead.
 227  */
 228
 229 void yyerror(char *s)
 230 {
 231   syntax_error(s);
 232 }
 233
 234 /*
 235  * Unfortunately, my DOS version of FLEX
 236  * requires yywrap to be #def'ed, whereas
 237  * the UNIX flex expects a proper function.
 238  */
 239
 240 /* Not sure if __SC__ is the appropriate thing
 241  * to test
 242  */
 243
 244 #ifndef __SC__
 245 #ifdef USE_DEFINE
 246 #ifndef yywrap
 247 #define yywrap() 1
 248 #endif
 249 #else
 250 #  if !(defined(__VISAGECPP__) && __IBMC__ >= 400)
 251 /* VA 4.0 thinks this is multiply defined (in lex_yy.c) */
 252    int yywrap() { return 1; }
 253 #  endif
 254 #endif
 255 #endif
 256 #line 247 "y_tab.c"
 257 #define YYABORT goto yyabort
 258 #define YYACCEPT goto yyaccept
 259 #define YYERROR goto yyerrlab
 260 int
 261 yyparse()
 262 {
 263     register int yym, yyn, yystate;
 264 #if YYDEBUG
 265     register char *yys;
 266     extern char *getenv();
 267
 268     yys = getenv("YYDEBUG");
 269     if (yys)
 270     {
 271         yyn = *yys;
 272         if (yyn >= '0' && yyn <= '9')
 273             yydebug = yyn - '0';
 274     }
 275 #endif
 276
 277     yynerrs = 0;
 278     yyerrflag = 0;
 279     yychar = (-1);
 280
 281     yyssp = yyss;
 282     yyvsp = yyvs;
 283     *yyssp = yystate = 0;
 284
 285 yyloop:
 286     yyn = yydefred[yystate];
 287     if (yyn != 0) 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(wxmake_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(wxmake_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(wxmake_word("="), proio_cons(wxmake_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 = wxmake_word(yyvsp[0].s); free(yyvsp[0].s);}
 446 break;
 447 case 15:
 448 #line 101 "parser.y"
 449 {yyval.s = wxmake_string(yyvsp[0].s); free(yyvsp[0].s);}
 450 break;
 451 case 16:
 452 #line 103 "parser.y"
 453 {yyval.s = wxmake_integer(yyvsp[0].s); free(yyvsp[0].s);}
 454 break;
 455 case 17:
 456 #line 105 "parser.y"
 457 {yyval.s = wxmake_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 = wxmake_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 = wxmake_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 }