[wxWidgets.git] / src / common / dosyacc.c

#if defined(__WIN32__) || defined(__GNUWIN32__)
/* all Win32 compilers can handle C++ comments, and C++ comments
   is the only C++ in setup.h */
#include "wx/setup.h"
#endif

#if !defined(wxUSE_PROLOGIO) || wxUSE_PROLOGIO

#ifndef lint
static char yysccsid[] = "@(#)yaccpar     1.7 (Berkeley) 09/09/90";
#endif
#define YYBYACC 1
#line 2 "parser.y"
#include "string.h"
#if defined(_MSC_VER) || defined(__VISAGECPP__)
#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!
 */
#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
#include "../common/lex_yy.c"
#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
#  if !(defined(__VISAGECPP__) && __IBMC__ >= 400)
/* VA 4.0 thinks this is multiply defined (in lex_yy.c) */
   int yywrap() { return 1; }
#  endif
#endif
#endif
#line 247 "y_tab.c"
#define YYABORT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
PROIO_yyparse()
{
    register int yym, yyn, yystate;
#if YYDEBUG
    register char *yys;
    extern char *getenv();

    yys = getenv("YYDEBUG");
    if (yys)
    {
        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:
    yyn = yydefred[yystate];
    if (yyn != 0) 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);
}

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