src/common/cwy_tab.c

#ifndef lint
static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
#endif
#define YYBYACC 1
#line 2 "parser.y"
#include "string.h"
#ifdef _MSC_VER
#include <io.h>
#endif
#include "wx/expr.h"

#ifndef __EXTERN_C__
#define __EXTERN_C__ 1
#endif

#if defined(__cplusplus) || defined(__STDC__)
#if defined(__cplusplus) && defined(__EXTERN_C__)
extern "C" {
#endif
#endif
int yylex(void);
int yylook(void);
int yywrap(void);
int yyback(int *, int);
#ifdef __WXMAC__
int read( int , char * , int ) ;
int fileno( void* ) ;
#endif

/* You may need to put /DLEX_SCANNER in your makefile
 * if you're using LEX!
	Last change:  JS   13 Jul 97    6:12 pm
 */
#ifdef LEX_SCANNER
/* int yyoutput(int); */
void yyoutput(int);
#else
void yyoutput(int);
#endif

#if defined(__cplusplus) || defined(__STDC__)
#if defined(__cplusplus) && defined(__EXTERN_C__)
}
#endif
#endif
#line 36 "parser.y"
typedef union {
    char *s;
/*    struct pexpr *expr; */
} YYSTYPE;
#line 44 "y_tab.c"
#define INTEGER 1
#define WORD 2
#define STRING 3
#define PERIOD 13
#define OPEN 4
#define CLOSE 5
#define COMMA 6
#define NEWLINE 7
#define ERROR 8
#define OPEN_SQUARE 9
#define CLOSE_SQUARE 10
#define EQUALS 11
#define EXP 14
#define YYERRCODE 256
short yylhs[] = {                                        -1,
    0,    0,    1,    1,    1,    2,    2,    2,    3,    3,
    3,    4,    4,    5,    5,    5,    5,    5,    5,    5,
};
short yylen[] = {                                         2,
    0,    2,    2,    2,    2,    4,    2,    3,    0,    1,
    3,    3,    1,    1,    1,    1,    3,    3,    5,    1,
};
short yydefred[] = {                                      1,
    0,    0,    0,    0,    2,    0,    5,    3,    0,    0,
    0,   15,    7,   20,    0,    0,   13,    4,    0,    0,
    0,    0,    8,    0,    6,    0,   18,    0,   12,   11,
    0,   19,
};
short yydgoto[] = {                                       1,
    5,   14,   15,   16,   17,
};
short yysindex[] = {                                      0,
   -2,    9,    2,    1,    0,   10,    0,    0,   11,   -5,
   17,    0,    0,    0,   14,   -1,    0,    0,   33,   38,
   41,   16,    0,   11,    0,   29,    0,   40,    0,    0,
   44,    0,
};
short yyrindex[] = {                                      0,
    0,    0,    0,    0,    0,    0,    0,    0,   42,   21,
   24,    0,    0,    0,    0,   30,    0,    0,    0,    0,
    0,    0,    0,   31,    0,   27,    0,   24,    0,    0,
    0,    0,
};
short yygindex[] = {                                      0,
    0,   45,   -8,    0,   26,
};
#define YYTABLESIZE 254
short yytable[] = {                                       3,
   19,   10,   11,   12,   24,    9,    4,   20,   21,    4,
   13,   10,   11,   12,    8,   30,   10,   28,   12,    4,
    9,    7,   18,   23,    4,   16,   16,   22,   14,   14,
   16,   17,   17,   14,   10,    9,   17,   25,   26,   10,
    9,   27,   31,    9,   32,    6,    9,   29,    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,    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,    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,    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,    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,    0,    0,
    0,    0,    0,    2,
};
short yycheck[] = {                                       2,
    9,    1,    2,    3,    6,    4,    9,   13,   14,    9,
   10,    1,    2,    3,   13,   24,    1,    2,    3,    9,
    4,   13,   13,   10,    9,    5,    6,   11,    5,    6,
   10,    5,    6,   10,    5,    5,   10,    5,    1,   10,
   10,    1,   14,    4,    1,    1,    5,   22,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,  256,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 14
#if YYDEBUG
char *yyname[] = {
"end-of-file","INTEGER","WORD","STRING","OPEN","CLOSE","COMMA","NEWLINE",
"ERROR","OPEN_SQUARE","CLOSE_SQUARE","EQUALS",0,"PERIOD","EXP",
};
char *yyrule[] = {
"$accept : commands",
"commands :",
"commands : commands command",
"command : WORD PERIOD",
"command : expr PERIOD",
"command : error PERIOD",
"expr : WORD OPEN arglist CLOSE",
"expr : OPEN_SQUARE CLOSE_SQUARE",
"expr : OPEN_SQUARE arglist CLOSE_SQUARE",
"arglist :",
"arglist : arg",
"arglist : arg COMMA arglist",
"arg : WORD EQUALS arg1",
"arg : arg1",
"arg1 : WORD",
"arg1 : STRING",
"arg1 : INTEGER",
"arg1 : INTEGER PERIOD INTEGER",
"arg1 : INTEGER EXP INTEGER",
"arg1 : INTEGER PERIOD INTEGER EXP INTEGER",
"arg1 : expr",
};
#endif
#define yyclearin (yychar=(-1))
#define yyerrok (yyerrflag=0)
#ifdef YYSTACKSIZE
#ifndef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#endif
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 600
#define YYMAXDEPTH 600
#endif
#endif
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short yyss[YYSTACKSIZE];
YYSTYPE yyvs[YYSTACKSIZE];
#define yystacksize YYSTACKSIZE
#line 118 "parser.y"

#ifdef IDE_INVOKED
#include "../common/doslex.c"
#else
#if (defined(__MWERKS__))
#include "../common/cwlex_yy.c"
#else
#include "../common/lex_yy.c"
#endif
#endif

/*
void yyerror(s)
char *s;
{
  syntax_error(s);
}
*/

/* Ansi prototype. If this doesn't work for you... uncomment
   the above instead.
 */

void yyerror(char *s)
{
  syntax_error(s);
}

/*
 * Unfortunately, my DOS version of FLEX
 * requires yywrap to be #def'ed, whereas
 * the UNIX flex expects a proper function.
 */

/* Not sure if __SC__ is the appropriate thing
 * to test
 */

#ifndef __SC__
#ifdef USE_DEFINE
#ifndef yywrap
#define yywrap() 1
#endif
#else
int yywrap() { return 1; }
#endif
#endif
#line 247 "y_tab.c"
#define YYABORT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse()
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;
    extern char *getenv();

    if (yys = getenv("YYDEBUG"))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = (-1);

    yyssp = yyss;
    yyvsp = yyvs;
    *yyssp = yystate = 0;

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