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