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 #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 #include "../common/lex_yy.c"
 213
 214 /*
 215 void yyerror(s)
 216 char *s;
 217 {
 218   syntax_error(s);
 219 }
 220 */
 221
 222 /* Ansi prototype. If this doesn't work for you... uncomment
 223    the above instead.
 224  */
 225
 226 void yyerror(char *s)
 227 {
 228   syntax_error(s);
 229 }
 230
 231 /*
 232  * Unfortunately, my DOS version of FLEX
 233  * requires yywrap to be #def'ed, whereas
 234  * the UNIX flex expects a proper function.
 235  */
 236
 237 /* Not sure if __SC__ is the appropriate thing
 238  * to test
 239  */
 240
 241 #ifndef __SC__
 242 #ifdef USE_DEFINE
 243 #ifndef yywrap
 244 #define yywrap() 1
 245 #endif
 246 #else
 247 int yywrap() { return 1; }
 248 #endif
 249 #endif
 250 #line 247 "y_tab.c"
 251 #define YYABORT goto yyabort
 252 #define YYACCEPT goto yyaccept
 253 #define YYERROR goto yyerrlab
 254 int
 255 yyparse()
 256 {
 257     register int yym, yyn, yystate;
 258 #if YYDEBUG
 259     register char *yys;
 260     extern char *getenv();
 261
 262     if (yys = getenv("YYDEBUG"))
 263     {
 264         yyn = *yys;
 265         if (yyn >= '0' && yyn <= '9')
 266             yydebug = yyn - '0';
 267     }
 268 #endif
 269
 270     yynerrs = 0;
 271     yyerrflag = 0;
 272     yychar = (-1);
 273
 274     yyssp = yyss;
 275     yyvsp = yyvs;
 276     *yyssp = yystate = 0;
 277
 278 yyloop:
 279     if (yyn = yydefred[yystate]) goto yyreduce;
 280     if (yychar < 0)
 281     {
 282         if ((yychar = yylex()) < 0) yychar = 0;
 283 #if YYDEBUG
 284         if (yydebug)
 285         {
 286             yys = 0;
 287             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 288             if (!yys) yys = "illegal-symbol";
 289             printf("yydebug: state %d, reading %d (%s)\n", yystate,
 290                     yychar, yys);
 291         }
 292 #endif
 293     }
 294     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
 295             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 296     {
 297 #if YYDEBUG
 298         if (yydebug)
 299             printf("yydebug: state %d, shifting to state %d\n",
 300                     yystate, yytable[yyn]);
 301 #endif
 302         if (yyssp >= yyss + yystacksize - 1)
 303         {
 304             goto yyoverflow;
 305         }
 306         *++yyssp = yystate = yytable[yyn];
 307         *++yyvsp = yylval;
 308         yychar = (-1);
 309         if (yyerrflag > 0)  --yyerrflag;
 310         goto yyloop;
 311     }
 312     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
 313             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
 314     {
 315         yyn = yytable[yyn];
 316         goto yyreduce;
 317     }
 318     if (yyerrflag) goto yyinrecovery;
 319 #ifdef lint
 320     goto yynewerror;
 321 #endif
 322 yynewerror:
 323     yyerror("syntax error");
 324 #ifdef lint
 325     goto yyerrlab;
 326 #endif
 327 yyerrlab:
 328     ++yynerrs;
 329 yyinrecovery:
 330     if (yyerrflag < 3)
 331     {
 332         yyerrflag = 3;
 333         for (;;)
 334         {
 335             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
 336                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
 337             {
 338 #if YYDEBUG
 339                 if (yydebug)
 340                     printf("yydebug: state %d, error recovery shifting\
 341  to state %d\n", *yyssp, yytable[yyn]);
 342 #endif
 343                 if (yyssp >= yyss + yystacksize - 1)
 344                 {
 345                     goto yyoverflow;
 346                 }
 347                 *++yyssp = yystate = yytable[yyn];
 348                 *++yyvsp = yylval;
 349                 goto yyloop;
 350             }
 351             else
 352             {
 353 #if YYDEBUG
 354                 if (yydebug)
 355                     printf("yydebug: error recovery discarding state %d\n",
 356                             *yyssp);
 357 #endif
 358                 if (yyssp <= yyss) goto yyabort;
 359                 --yyssp;
 360                 --yyvsp;
 361             }
 362         }
 363     }
 364     else
 365     {
 366         if (yychar == 0) goto yyabort;
 367 #if YYDEBUG
 368         if (yydebug)
 369         {
 370             yys = 0;
 371             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 372             if (!yys) yys = "illegal-symbol";
 373             printf("yydebug: state %d, error recovery discards token %d (%s)\n",
 374                     yystate, yychar, yys);
 375         }
 376 #endif
 377         yychar = (-1);
 378         goto yyloop;
 379     }
 380 yyreduce:
 381 #if YYDEBUG
 382     if (yydebug)
 383         printf("yydebug: state %d, reducing by rule %d (%s)\n",
 384                 yystate, yyn, yyrule[yyn]);
 385 #endif
 386     yym = yylen[yyn];
 387     yyval = yyvsp[1-yym];
 388     switch (yyn)
 389     {
 390 case 3:
 391 #line 68 "parser.y"
 392 {process_command(proio_cons(make_word(yyvsp[-1].s), NULL)); free(yyvsp[-1].s);}
 393 break;
 394 case 4:
 395 #line 70 "parser.y"
 396 {process_command(yyvsp[-1].s);}
 397 break;
 398 case 5:
 399 #line 72 "parser.y"
 400 {syntax_error("Unrecognized command.");}
 401 break;
 402 case 6:
 403 #line 76 "parser.y"
 404 {yyval.s = proio_cons(make_word(yyvsp[-3].s), yyvsp[-1].s); free(yyvsp[-3].s);}
 405 break;
 406 case 7:
 407 #line 78 "parser.y"
 408 {yyval.s = proio_cons(NULL, NULL);}
 409 break;
 410 case 8:
 411 #line 80 "parser.y"
 412 {yyval.s = yyvsp[-1].s; }
 413 break;
 414 case 9:
 415 #line 84 "parser.y"
 416 {yyval.s = NULL;}
 417 break;
 418 case 10:
 419 #line 86 "parser.y"
 420 {yyval.s = proio_cons(yyvsp[0].s, NULL);}
 421 break;
 422 case 11:
 423 #line 89 "parser.y"
 424 {yyval.s = proio_cons(yyvsp[-2].s, yyvsp[0].s);}
 425 break;
 426 case 12:
 427 #line 93 "parser.y"
 428 {yyval.s = proio_cons(make_word("="), proio_cons(make_word(yyvsp[-2].s), proio_cons(yyvsp[0].s, NULL)));
 429                          free(yyvsp[-2].s); }
 430 break;
 431 case 13:
 432 #line 96 "parser.y"
 433 {yyval.s = yyvsp[0].s; }
 434 break;
 435 case 14:
 436 #line 99 "parser.y"
 437 {yyval.s = make_word(yyvsp[0].s); free(yyvsp[0].s);}
 438 break;
 439 case 15:
 440 #line 101 "parser.y"
 441 {yyval.s = make_string(yyvsp[0].s); free(yyvsp[0].s);}
 442 break;
 443 case 16:
 444 #line 103 "parser.y"
 445 {yyval.s = make_integer(yyvsp[0].s); free(yyvsp[0].s);}
 446 break;
 447 case 17:
 448 #line 105 "parser.y"
 449 {yyval.s = make_real(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
 450 break;
 451 case 18:
 452 #line 107 "parser.y"
 453 {yyval.s = make_exp(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
 454 break;
 455 case 19:
 456 #line 110 "parser.y"
 457 {yyval.s = make_exp2(yyvsp[-4].s, yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-4].s); free(yyvsp[-2].s);
 458                                                                   free(yyvsp[0].s); }
 459 break;
 460 case 20:
 461 #line 114 "parser.y"
 462 {yyval.s = yyvsp[0].s;}
 463 break;
 464 #line 461 "y_tab.c"
 465     }
 466     yyssp -= yym;
 467     yystate = *yyssp;
 468     yyvsp -= yym;
 469     yym = yylhs[yyn];
 470     if (yystate == 0 && yym == 0)
 471     {
 472 #if YYDEBUG
 473         if (yydebug)
 474             printf("yydebug: after reduction, shifting from state 0 to\
 475  state %d\n", YYFINAL);
 476 #endif
 477         yystate = YYFINAL;
 478         *++yyssp = YYFINAL;
 479         *++yyvsp = yyval;
 480         if (yychar < 0)
 481         {
 482             if ((yychar = yylex()) < 0) yychar = 0;
 483 #if YYDEBUG
 484             if (yydebug)
 485             {
 486                 yys = 0;
 487                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
 488                 if (!yys) yys = "illegal-symbol";
 489                 printf("yydebug: state %d, reading %d (%s)\n",
 490                         YYFINAL, yychar, yys);
 491             }
 492 #endif
 493         }
 494         if (yychar == 0) goto yyaccept;
 495         goto yyloop;
 496     }
 497     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
 498             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
 499         yystate = yytable[yyn];
 500     else
 501         yystate = yydgoto[yym];
 502 #if YYDEBUG
 503     if (yydebug)
 504         printf("yydebug: after reduction, shifting from state %d \
 505 to state %d\n", *yyssp, yystate);
 506 #endif
 507     if (yyssp >= yyss + yystacksize - 1)
 508     {
 509         goto yyoverflow;
 510     }
 511     *++yyssp = yystate;
 512     *++yyvsp = yyval;
 513     goto yyloop;
 514 yyoverflow:
 515     yyerror("yacc stack overflow");
 516 yyabort:
 517     return (1);
 518 yyaccept:
 519     return (0);
 520 }