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