src/msw/Y_TAB.C

#ifndef lint
static char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#endif
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define yyclearin (yychar=(-1))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
#define YYPREFIX "yy"
#line 2 "../common/parser.y"
#include <string.h>
#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);
void yyerror(char *);

/* You may need to put /DLEX_SCANNER in your makefile
 * if you're using LEX!
 */
#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 37 "../common/parser.y"
typedef union {
    char *s;
/*    struct pexpr *expr; */
} YYSTYPE;
#line 51 "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
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH 500
#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 119 "../common/parser.y"

#include "../common/lex_yy.c"

/*
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 if !defined(__alpha) && !defined(__ultrix)
int yywrap() { return 1; }
#endif
#endif
#line 251 "y_tab.c"
#define YYABORT goto yyabort
#define YYREJECT 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("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, 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("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *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("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *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("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = (-1);
        goto yyloop;
    }
yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    yyval = yyvsp[1-yym];
    switch (yyn)
    {
case 3:
#line 69 "../common/parser.y"
{process_command(proio_cons(make_word(yyvsp[-1].s), NULL)); free(yyvsp[-1].s);}
break;
case 4:
#line 71 "../common/parser.y"
{process_command(yyvsp[-1].s);}
break;
case 5:
#line 73 "../common/parser.y"
{syntax_error("Unrecognized command.");}
break;
case 6:
#line 77 "../common/parser.y"
{yyval.s = proio_cons(make_word(yyvsp[-3].s), yyvsp[-1].s); free(yyvsp[-3].s);}
break;
case 7:
#line 79 "../common/parser.y"
{yyval.s = proio_cons(NULL, NULL);}
break;
case 8:
#line 81 "../common/parser.y"
{yyval.s = yyvsp[-1].s; }
break;
case 9:
#line 85 "../common/parser.y"
{yyval.s = NULL;}
break;
case 10:
#line 87 "../common/parser.y"
{yyval.s = proio_cons(yyvsp[0].s, NULL);}
break;
case 11:
#line 90 "../common/parser.y"
{yyval.s = proio_cons(yyvsp[-2].s, yyvsp[0].s);}
break;
case 12:
#line 94 "../common/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 97 "../common/parser.y"
{yyval.s = yyvsp[0].s; }
break;
case 14:
#line 100 "../common/parser.y"
{yyval.s = make_word(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 15:
#line 102 "../common/parser.y"
{yyval.s = make_string(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 16:
#line 104 "../common/parser.y"
{yyval.s = make_integer(yyvsp[0].s); free(yyvsp[0].s);}
break;
case 17:
#line 106 "../common/parser.y"
{yyval.s = make_real(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
break;
case 18:
#line 108 "../common/parser.y"
{yyval.s = make_exp(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
break;
case 19:
#line 111 "../common/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 115 "../common/parser.y"
{yyval.s = yyvsp[0].s;}
break;
#line 466 "y_tab.c"
    }
    yyssp -= yym;
    yystate = *yyssp;
    yyvsp -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, 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("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, 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("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *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.9 (Berkeley) 02/21/93";
	3	#endif
	4	#define YYBYACC 1
	5	#define YYMAJOR 1
	6	#define YYMINOR 9
	7	#define yyclearin (yychar=(-1))
	8	#define yyerrok (yyerrflag=0)
	9	#define YYRECOVERING (yyerrflag!=0)
	10	#define YYPREFIX "yy"
	11	#line 2 "../common/parser.y"
	12	#include <string.h>
	13	#include "wx/expr.h"
	14
	15	#ifndef __EXTERN_C__
	16	#define __EXTERN_C__ 1
	17	#endif
	18
	19	#if defined(__cplusplus) \|\| defined(__STDC__)
	20	#if defined(__cplusplus) && defined(__EXTERN_C__)
	21	extern "C" {
	22	#endif
	23	#endif
	24	int yylex(void);
	25	int yylook(void);
	26	int yywrap(void);
	27	int yyback(int *, int);
	28	void yyerror(char *);
	29
	30	/* You may need to put /DLEX_SCANNER in your makefile
	31	* if you're using LEX!
	32	*/
	33	#ifdef LEX_SCANNER
	34	/* int yyoutput(int); */
	35	void yyoutput(int);
	36	#else
	37	void yyoutput(int);
	38	#endif
	39
	40	#if defined(__cplusplus) \|\| defined(__STDC__)
	41	#if defined(__cplusplus) && defined(__EXTERN_C__)
	42	}
	43	#endif
	44	#endif
	45	#line 37 "../common/parser.y"
	46	typedef union {
	47	char *s;
	48	/* struct pexpr expr; /
	49	} YYSTYPE;
	50	#line 51 "y_tab.c"
	51	#define INTEGER 1
	52	#define WORD 2
	53	#define STRING 3
	54	#define PERIOD 13
	55	#define OPEN 4
	56	#define CLOSE 5
	57	#define COMMA 6
	58	#define NEWLINE 7
	59	#define ERROR 8
	60	#define OPEN_SQUARE 9
	61	#define CLOSE_SQUARE 10
	62	#define EQUALS 11
	63	#define EXP 14
	64	#define YYERRCODE 256
	65	short yylhs[] = { -1,
	66	0, 0, 1, 1, 1, 2, 2, 2, 3, 3,
	67	3, 4, 4, 5, 5, 5, 5, 5, 5, 5,
	68	};
	69	short yylen[] = { 2,
	70	0, 2, 2, 2, 2, 4, 2, 3, 0, 1,
	71	3, 3, 1, 1, 1, 1, 3, 3, 5, 1,
	72	};
	73	short yydefred[] = { 1,
	74	0, 0, 0, 0, 2, 0, 5, 3, 0, 0,
	75	0, 15, 7, 20, 0, 0, 13, 4, 0, 0,
	76	0, 0, 8, 0, 6, 0, 18, 0, 12, 11,
	77	0, 19,
	78	};
	79	short yydgoto[] = { 1,
	80	5, 14, 15, 16, 17,
	81	};
	82	short yysindex[] = { 0,
	83	-2, 9, 2, 1, 0, 10, 0, 0, 11, -5,
	84	17, 0, 0, 0, 14, -1, 0, 0, 33, 38,
	85	41, 16, 0, 11, 0, 29, 0, 40, 0, 0,
	86	44, 0,
	87	};
	88	short yyrindex[] = { 0,
	89	0, 0, 0, 0, 0, 0, 0, 0, 42, 21,
	90	24, 0, 0, 0, 0, 30, 0, 0, 0, 0,
	91	0, 0, 0, 31, 0, 27, 0, 24, 0, 0,
	92	0, 0,
	93	};
	94	short yygindex[] = { 0,
	95	0, 45, -8, 0, 26,
	96	};
	97	#define YYTABLESIZE 254
	98	short yytable[] = { 3,
	99	19, 10, 11, 12, 24, 9, 4, 20, 21, 4,
	100	13, 10, 11, 12, 8, 30, 10, 28, 12, 4,
	101	9, 7, 18, 23, 4, 16, 16, 22, 14, 14,
	102	16, 17, 17, 14, 10, 9, 17, 25, 26, 10,
	103	9, 27, 31, 9, 32, 6, 9, 29, 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, 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, 2,
	125	};
	126	short yycheck[] = { 2,
	127	9, 1, 2, 3, 6, 4, 9, 13, 14, 9,
	128	10, 1, 2, 3, 13, 24, 1, 2, 3, 9,
	129	4, 13, 13, 10, 9, 5, 6, 11, 5, 6,
	130	10, 5, 6, 10, 5, 5, 10, 5, 1, 10,
	131	10, 1, 14, 4, 1, 1, 5, 22, -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, -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, 256,
	153	};
	154	#define YYFINAL 1
	155	#ifndef YYDEBUG
	156	#define YYDEBUG 0
	157	#endif
	158	#define YYMAXTOKEN 14
	159	#if YYDEBUG
	160	char *yyname[] = {
	161	"end-of-file","INTEGER","WORD","STRING","OPEN","CLOSE","COMMA","NEWLINE",
	162	"ERROR","OPEN_SQUARE","CLOSE_SQUARE","EQUALS",0,"PERIOD","EXP",
	163	};
	164	char *yyrule[] = {
	165	"$accept : commands",
	166	"commands :",
	167	"commands : commands command",
	168	"command : WORD PERIOD",
	169	"command : expr PERIOD",
	170	"command : error PERIOD",
	171	"expr : WORD OPEN arglist CLOSE",
	172	"expr : OPEN_SQUARE CLOSE_SQUARE",
	173	"expr : OPEN_SQUARE arglist CLOSE_SQUARE",
	174	"arglist :",
	175	"arglist : arg",
	176	"arglist : arg COMMA arglist",
	177	"arg : WORD EQUALS arg1",
	178	"arg : arg1",
	179	"arg1 : WORD",
	180	"arg1 : STRING",
	181	"arg1 : INTEGER",
	182	"arg1 : INTEGER PERIOD INTEGER",
	183	"arg1 : INTEGER EXP INTEGER",
	184	"arg1 : INTEGER PERIOD INTEGER EXP INTEGER",
	185	"arg1 : expr",
	186	};
	187	#endif
	188	#ifdef YYSTACKSIZE
	189	#undef YYMAXDEPTH
	190	#define YYMAXDEPTH YYSTACKSIZE
	191	#else
	192	#ifdef YYMAXDEPTH
	193	#define YYSTACKSIZE YYMAXDEPTH
	194	#else
	195	#define YYSTACKSIZE 500
	196	#define YYMAXDEPTH 500
	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 119 "../common/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 if !defined(__alpha) && !defined(__ultrix)
	247	int yywrap() { return 1; }
	248	#endif
	249	#endif
	250	#line 251 "y_tab.c"
	251	#define YYABORT goto yyabort
	252	#define YYREJECT goto yyabort
	253	#define YYACCEPT goto yyaccept
	254	#define YYERROR goto yyerrlab
	255	int
	256	yyparse()
	257	{
	258	register int yym, yyn, yystate;
	259	#if YYDEBUG
	260	register char *yys;
	261	extern char *getenv();
	262
	263	if (yys = getenv("YYDEBUG"))
	264	{
	265	yyn = *yys;
	266	if (yyn >= '0' && yyn <= '9')
	267	yydebug = yyn - '0';
	268	}
	269	#endif
	270
	271	yynerrs = 0;
	272	yyerrflag = 0;
	273	yychar = (-1);
	274
	275	yyssp = yyss;
	276	yyvsp = yyvs;
	277	*yyssp = yystate = 0;
	278
	279	yyloop:
	280	if (yyn = yydefred[yystate]) goto yyreduce;
	281	if (yychar < 0)
	282	{
	283	if ((yychar = yylex()) < 0) yychar = 0;
	284	#if YYDEBUG
	285	if (yydebug)
	286	{
	287	yys = 0;
	288	if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
	289	if (!yys) yys = "illegal-symbol";
	290	printf("%sdebug: state %d, reading %d (%s)\n",
	291	YYPREFIX, yystate, yychar, yys);
	292	}
	293	#endif
	294	}
	295	if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
	296	yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
	297	{
	298	#if YYDEBUG
	299	if (yydebug)
	300	printf("%sdebug: state %d, shifting to state %d\n",
	301	YYPREFIX, yystate, yytable[yyn]);
	302	#endif
	303	if (yyssp >= yyss + yystacksize - 1)
	304	{
	305	goto yyoverflow;
	306	}
	307	*++yyssp = yystate = yytable[yyn];
	308	*++yyvsp = yylval;
	309	yychar = (-1);
	310	if (yyerrflag > 0) --yyerrflag;
	311	goto yyloop;
	312	}
	313	if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
	314	yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
	315	{
	316	yyn = yytable[yyn];
	317	goto yyreduce;
	318	}
	319	if (yyerrflag) goto yyinrecovery;
	320	#ifdef lint
	321	goto yynewerror;
	322	#endif
	323	yynewerror:
	324	yyerror("syntax error");
	325	#ifdef lint
	326	goto yyerrlab;
	327	#endif
	328	yyerrlab:
	329	++yynerrs;
	330	yyinrecovery:
	331	if (yyerrflag < 3)
	332	{
	333	yyerrflag = 3;
	334	for (;;)
	335	{
	336	if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
	337	yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
	338	{
	339	#if YYDEBUG
	340	if (yydebug)
	341	printf("%sdebug: state %d, error recovery shifting\
	342	to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
	343	#endif
	344	if (yyssp >= yyss + yystacksize - 1)
	345	{
	346	goto yyoverflow;
	347	}
	348	*++yyssp = yystate = yytable[yyn];
	349	*++yyvsp = yylval;
	350	goto yyloop;
	351	}
	352	else
	353	{
	354	#if YYDEBUG
	355	if (yydebug)
	356	printf("%sdebug: error recovery discarding state %d\n",
	357	YYPREFIX, *yyssp);
	358	#endif
	359	if (yyssp <= yyss) goto yyabort;
	360	--yyssp;
	361	--yyvsp;
	362	}
	363	}
	364	}
	365	else
	366	{
	367	if (yychar == 0) goto yyabort;
	368	#if YYDEBUG
	369	if (yydebug)
	370	{
	371	yys = 0;
	372	if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
	373	if (!yys) yys = "illegal-symbol";
	374	printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
	375	YYPREFIX, yystate, yychar, yys);
	376	}
	377	#endif
	378	yychar = (-1);
	379	goto yyloop;
	380	}
	381	yyreduce:
	382	#if YYDEBUG
	383	if (yydebug)
	384	printf("%sdebug: state %d, reducing by rule %d (%s)\n",
	385	YYPREFIX, yystate, yyn, yyrule[yyn]);
	386	#endif
	387	yym = yylen[yyn];
	388	yyval = yyvsp[1-yym];
	389	switch (yyn)
	390	{
	391	case 3:
	392	#line 69 "../common/parser.y"
	393	{process_command(proio_cons(make_word(yyvsp[-1].s), NULL)); free(yyvsp[-1].s);}
	394	break;
	395	case 4:
	396	#line 71 "../common/parser.y"
	397	{process_command(yyvsp[-1].s);}
	398	break;
	399	case 5:
	400	#line 73 "../common/parser.y"
	401	{syntax_error("Unrecognized command.");}
	402	break;
	403	case 6:
	404	#line 77 "../common/parser.y"
	405	{yyval.s = proio_cons(make_word(yyvsp[-3].s), yyvsp[-1].s); free(yyvsp[-3].s);}
	406	break;
	407	case 7:
	408	#line 79 "../common/parser.y"
	409	{yyval.s = proio_cons(NULL, NULL);}
	410	break;
	411	case 8:
	412	#line 81 "../common/parser.y"
	413	{yyval.s = yyvsp[-1].s; }
	414	break;
	415	case 9:
	416	#line 85 "../common/parser.y"
	417	{yyval.s = NULL;}
	418	break;
	419	case 10:
	420	#line 87 "../common/parser.y"
	421	{yyval.s = proio_cons(yyvsp[0].s, NULL);}
	422	break;
	423	case 11:
	424	#line 90 "../common/parser.y"
	425	{yyval.s = proio_cons(yyvsp[-2].s, yyvsp[0].s);}
	426	break;
	427	case 12:
	428	#line 94 "../common/parser.y"
	429	{yyval.s = proio_cons(make_word("="), proio_cons(make_word(yyvsp[-2].s), proio_cons(yyvsp[0].s, NULL)));
	430	free(yyvsp[-2].s); }
	431	break;
	432	case 13:
	433	#line 97 "../common/parser.y"
	434	{yyval.s = yyvsp[0].s; }
	435	break;
	436	case 14:
	437	#line 100 "../common/parser.y"
	438	{yyval.s = make_word(yyvsp[0].s); free(yyvsp[0].s);}
	439	break;
	440	case 15:
	441	#line 102 "../common/parser.y"
	442	{yyval.s = make_string(yyvsp[0].s); free(yyvsp[0].s);}
	443	break;
	444	case 16:
	445	#line 104 "../common/parser.y"
	446	{yyval.s = make_integer(yyvsp[0].s); free(yyvsp[0].s);}
	447	break;
	448	case 17:
	449	#line 106 "../common/parser.y"
	450	{yyval.s = make_real(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
	451	break;
	452	case 18:
	453	#line 108 "../common/parser.y"
	454	{yyval.s = make_exp(yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-2].s); free(yyvsp[0].s); }
	455	break;
	456	case 19:
	457	#line 111 "../common/parser.y"
	458	{yyval.s = make_exp2(yyvsp[-4].s, yyvsp[-2].s, yyvsp[0].s); free(yyvsp[-4].s); free(yyvsp[-2].s);
	459	free(yyvsp[0].s); }
	460	break;
	461	case 20:
	462	#line 115 "../common/parser.y"
	463	{yyval.s = yyvsp[0].s;}
	464	break;
	465	#line 466 "y_tab.c"
	466	}
	467	yyssp -= yym;
	468	yystate = *yyssp;
	469	yyvsp -= yym;
	470	yym = yylhs[yyn];
	471	if (yystate == 0 && yym == 0)
	472	{
	473	#if YYDEBUG
	474	if (yydebug)
	475	printf("%sdebug: after reduction, shifting from state 0 to\
	476	state %d\n", YYPREFIX, YYFINAL);
	477	#endif
	478	yystate = YYFINAL;
	479	*++yyssp = YYFINAL;
	480	*++yyvsp = yyval;
	481	if (yychar < 0)
	482	{
	483	if ((yychar = yylex()) < 0) yychar = 0;
	484	#if YYDEBUG
	485	if (yydebug)
	486	{
	487	yys = 0;
	488	if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
	489	if (!yys) yys = "illegal-symbol";
	490	printf("%sdebug: state %d, reading %d (%s)\n",
	491	YYPREFIX, YYFINAL, yychar, yys);
	492	}
	493	#endif
	494	}
	495	if (yychar == 0) goto yyaccept;
	496	goto yyloop;
	497	}
	498	if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
	499	yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
	500	yystate = yytable[yyn];
	501	else
	502	yystate = yydgoto[yym];
	503	#if YYDEBUG
	504	if (yydebug)
	505	printf("%sdebug: after reduction, shifting from state %d \
	506	to state %d\n", YYPREFIX, *yyssp, yystate);
	507	#endif
	508	if (yyssp >= yyss + yystacksize - 1)
	509	{
	510	goto yyoverflow;
	511	}
	512	*++yyssp = yystate;
	513	*++yyvsp = yyval;
	514	goto yyloop;
	515	yyoverflow:
	516	yyerror("yacc stack overflow");
	517	yyabort:
	518	return (1);
	519	yyaccept:
	520	return (0);
	521	}