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);

/* 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(make_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(make_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(make_word("="), proio_cons(make_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 = make_word(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 15:
#line 101 "parser.y"
{yyval.s = make_string(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 16:
#line 103 "parser.y"
{yyval.s = make_integer(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 17:
#line 105 "parser.y"
{yyval.s = make_real(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
break;
case 18:
#line 107 "parser.y"
{yyval.s = make_exp(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
break;
case 19:
#line 110 "parser.y"
{yyval.s = make_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
	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	}