Category : C Source Code
Archive   : CPPCOMBO.ZIP
Filename : COMGRAM.CPP

/* A Bison parser, made from com.y */

#define YDEBUG 258
#define NOYDEBUG 259
#define SHIFT_RIGHT 260
#define SHIFT_LEFT 261
#define LOGICAL_OR 262
#define LOGICAL_AND 263
#define NOT_EQ 264
#define EQ 265
#define GT_EQ 266
#define LT_EQ 267
#define BYTE_LITCONST 268
#define CONSTANT 269
#define LITCONST 270
#define STRING 271
#define SEND 272
#define WAIT 273
#define FOR 274
#define EOL 275
#define ANYTHING 276
#define ELSE 277
#define END 278
#define BELL 279
#define NOTIFY 280
#define ON 281
#define OFF 282
#define SLOW 283
#define CLOSE 284
#define WINDOW 285
#define DISPLAYCOMMENT 286
#define ERASECOMMENT 287


/* Make the generated module separately compilable */

#ifdef BORLAND
#pragma warn -sus /* No suspicious pointer messages */
#endif

#define YYDEBUG 1
#define CUSTOM_SIZE 200 /* Initial allocation for custom resources */

extern "C" {
#include
#include
#include
#include
#include
}

#include "pcodes.h" /* P-codes understood by the com engine */

extern short yystate;
extern FILE * comOut;

char *p; /* General purpose pointer */
char *pbase; /* Pointer to base of generic structure */
long psize; /* Size of data pointed to by p */
char *junk; /* Pointer to someting about to be trashed */
int *pi; /* Integer pointer */
short *ps; /* Short pointer */
int x; /* Work variable */

int yyerror(char *);
int yylex();


typedef union
{
int ival; /* Integer value */
long lval; /* Long value */
char * ptr; /* General pointer */
} YYSTYPE;

#ifndef YYLTYPE
typedef
struct yyltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
yyltype;

#define YYLTYPE yyltype
#endif

#include

#ifndef __STDC__
#define const
#endif



#define YYFINAL 91
#define YYFLAG -32768
#define YYNTBASE 50

#define YYTRANSLATE(x) ((unsigned)(x) <= 287 ? yytranslate[x] : 67)

static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 43, 2, 2, 2, 42, 35, 2, 48,
49, 40, 38, 45, 39, 2, 41, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 47, 36,
46, 37, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 34, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 33, 2, 44, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32
};

static const short yyrline[] = { 0,
107, 108, 109, 110, 113, 114, 115, 116, 117, 118,
119, 120, 121, 122, 125, 131, 141, 147, 154, 162,
168, 176, 187, 197, 201, 208, 214, 223, 230, 231,
235, 236, 240, 244, 248, 252, 256, 260, 264, 268,
272, 276, 280, 284, 288, 292, 296, 300, 304, 308,
312, 316, 327, 335, 338, 341
};

static const char * const yytname[] = { 0,
"error","$illegal.","YDEBUG","NOYDEBUG","SHIFT_RIGHT","SHIFT_LEFT","LOGICAL_OR","LOGICAL_AND","NOT_EQ","EQ",
"GT_EQ","LT_EQ","BYTE_LITCONST","CONSTANT","LITCONST","STRING","SEND","WAIT","FOR","EOL",
"ANYTHING","ELSE","END","BELL","NOTIFY","ON","OFF","SLOW","CLOSE","WINDOW",
"DISPLAYCOMMENT","ERASECOMMENT","'|'","'^'","'&'","'<'","'>'","'+'","'-'","'*'",
"'/'","'%'","'!'","'~'","','","'='","';'","'('","')'","com"
};

static const short yyr1[] = { 0,
50, 50, 50, 50, 51, 51, 51, 51, 51, 51,
51, 51, 51, 51, 52, 53, 54, 55, 56, 57,
58, 58, 59, 60, 60, 61, 62, 62, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 63, 63, 63, 63, 63, 63, 63,
63, 63, 63, 64, 65, 66
};

static const short yyr2[] = { 0,
0, 2, 2, 2, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 3, 2, 1, 2, 2, 1,
2, 3, 3, 2, 2, 1, 2, 2, 1, 1,
1, 2, 2, 2, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 1, 1, 1
};

static const short yydefact[] = { 1,
0, 4, 0, 0, 0, 20, 26, 0, 0, 0,
17, 0, 2, 3, 12, 13, 11, 10, 5, 6,
7, 14, 9, 8, 24, 25, 21, 0, 56, 54,
55, 0, 0, 0, 0, 0, 19, 29, 31, 30,
27, 28, 18, 16, 0, 22, 23, 32, 34, 33,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 15,
35, 36, 37, 39, 40, 43, 44, 45, 46, 41,
38, 42, 48, 47, 50, 49, 51, 52, 53, 0,
0
};

static const short yydefgoto[] = { 1,
13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 37, 38, 39, 40
};

static const short yypact[] = {-32768,
58,-32768, 0, -3, 224,-32768,-32768, -7, -11, 12,
-32768, 227,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768, 23,-32768,-32768,
-32768, 44, 227, 227, 227, 227, -4,-32768,-32768,-32768,
-32768,-32768,-32768,-32768, 104,-32768,-32768, -30,-32768,-32768,
59, 227, 227, 227, 227, 227, 227, 227, 227, 227,
227, 227, 227, 227, 227, 227, 227, 227, 227,-32768,
-32768, -24, -24, 119, 157, 220, 220, 79, 79, 166,
174, 212, 79, 79, -30, -30,-32768,-32768,-32768, 62,
-32768
};

static const short yypgoto[] = {-32768,
-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768, -12,-32768,-32768,-32768
};


#define YYLAST 275


static const short yytable[] = { 45,
52, 53, 54, 55, 56, 57, 58, 59, 41, 67,
68, 69, 27, 65, 66, 67, 68, 69, 43, 42,
48, 49, 50, 51, 28, 25, 26, 44, 60, 61,
62, 63, 64, 65, 66, 67, 68, 69, 46, 72,
73, 74, 75, 76, 77, 78, 79, 80, 81, 82,
83, 84, 85, 86, 87, 88, 89, 90, 2, 47,
3, 91, 0, 52, 53, 54, 55, 56, 57, 58,
59, 0, 0, 0, 4, 5, 0, 0, 0, 0,
6, 7, 8, 52, 53, 0, 9, 0, 10, 11,
0, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 0, 0, 12, 0, 0, 0, 71, 52, 53,
54, 55, 56, 57, 58, 59, 65, 66, 67, 68,
69, 0, 0, 52, 53, 0, 55, 56, 57, 58,
59, 0, 0, 0, 0, 0, 60, 61, 62, 63,
64, 65, 66, 67, 68, 69, 0, 0, 0, 0,
70, 60, 61, 62, 63, 64, 65, 66, 67, 68,
69, 52, 53, 0, 0, 56, 57, 58, 59, 0,
52, 53, 0, 0, 56, 57, 58, 59, 52, 53,
0, 0, 56, 57, 58, 59, 0, 0, 0, 60,
61, 62, 63, 64, 65, 66, 67, 68, 69, 61,
62, 63, 64, 65, 66, 67, 68, 69, 62, 63,
64, 65, 66, 67, 68, 69, 52, 53, 0, 0,
56, 57, 58, 59, 52, 53, 0, 0, 0, 0,
58, 59, 0, 0, 0, 0, 29, 30, 31, 29,
30, 31, 32, 0, 0, 0, 0, 63, 64, 65,
66, 67, 68, 69, 0, 63, 64, 65, 66, 67,
68, 69, 33, 0, 0, 33, 34, 35, 0, 34,
35, 36, 0, 0, 36
};

static const short yycheck[] = { 12,
5, 6, 7, 8, 9, 10, 11, 12, 16, 40,
41, 42, 16, 38, 39, 40, 41, 42, 30, 27,
33, 34, 35, 36, 28, 26, 27, 16, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42, 16, 52,
53, 54, 55, 56, 57, 58, 59, 60, 61, 62,
63, 64, 65, 66, 67, 68, 69, 0, 1, 16,
3, 0, -1, 5, 6, 7, 8, 9, 10, 11,
12, -1, -1, -1, 17, 18, -1, -1, -1, -1,
23, 24, 25, 5, 6, -1, 29, -1, 31, 32,
-1, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, -1, -1, 46, -1, -1, -1, 49, 5, 6,
7, 8, 9, 10, 11, 12, 38, 39, 40, 41,
42, -1, -1, 5, 6, -1, 8, 9, 10, 11,
12, -1, -1, -1, -1, -1, 33, 34, 35, 36,
37, 38, 39, 40, 41, 42, -1, -1, -1, -1,
47, 33, 34, 35, 36, 37, 38, 39, 40, 41,
42, 5, 6, -1, -1, 9, 10, 11, 12, -1,
5, 6, -1, -1, 9, 10, 11, 12, 5, 6,
-1, -1, 9, 10, 11, 12, -1, -1, -1, 33,
34, 35, 36, 37, 38, 39, 40, 41, 42, 34,
35, 36, 37, 38, 39, 40, 41, 42, 35, 36,
37, 38, 39, 40, 41, 42, 5, 6, -1, -1,
9, 10, 11, 12, 5, 6, -1, -1, -1, -1,
11, 12, -1, -1, -1, -1, 13, 14, 15, 13,
14, 15, 19, -1, -1, -1, -1, 36, 37, 38,
39, 40, 41, 42, -1, 36, 37, 38, 39, 40,
41, 42, 39, -1, -1, 39, 43, 44, -1, 43,
44, 48, -1, -1, 48
};
#define YYPURE 1

/* -*-C-*- Note some compilers choke on comments on `#line' lines. */


/* Skeleton output parser for bison,
Copyright (C) 1984 Bob Corbett and Richard Stallman

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */


#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
#include
#endif

/* TCC */
#ifdef MSDOS
#define bcopy(s, d, l) memcpy((d), (s), (l))
char * alloca (unsigned);
#endif

/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */

/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */

#define yyerrok (yyerrstatus = 0)
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
#define YYFAIL goto yyerrlab;
#define YYACCEPT return(0)
#define YYABORT return(1)
#define YYERROR goto yyerrlab

#define YYTERROR 1
#define YYERRCODE 256

#ifndef YYIMPURE
#define YYLEX yylex()
#endif

#ifndef YYPURE
#define YYLEX yylex(&yylval, &yylloc)
#endif

/* If nonreentrant, generate the variables here */

#ifndef YYIMPURE

int yychar; /* the lookahead symbol */
YYSTYPE yylval; /* the semantic value of the */
/* lookahead symbol */

YYLTYPE yylloc; /* location data for the lookahead */
/* symbol */

int yynerrs; /* number of parse errors so far */
#endif /* YYIMPURE */

#if YYDEBUG != 0
int yydebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */

#endif

/* YYMAXDEPTH indicates the initial size of the parser's stacks */

#ifndef YYMAXDEPTH
#define YYMAXDEPTH 200
#endif

/* YYMAXLIMIT is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */

#ifndef YYMAXLIMIT
#define YYMAXLIMIT 10000
#endif



int
yyparse()
{
register int yystate;
register int yyn;
register short *yyssp;
register YYSTYPE *yyvsp;
YYLTYPE *yylsp;
int yyerrstatus; /* number of tokens to shift before error messages enabled */
int yychar1; /* lookahead token as an internal (translated) token number */

short yyssa[YYMAXDEPTH]; /* the state stack */
YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */
YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */

short *yyss = yyssa; /* refer to the stacks thru separate pointers */
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
YYLTYPE *yyls = yylsa;

int yymaxdepth = YYMAXDEPTH;

#ifndef YYPURE
int yychar;
YYSTYPE yylval;
YYLTYPE yylloc;
int yynerrs;
#endif

YYSTYPE yyval; /* the variable used to return */
/* semantic values from the action */
/* routines */

int yylen;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Starting parse\n");
#endif

yystate = 0;
yyerrstatus = 0;
yynerrs = 0;
yychar = YYEMPTY; /* Cause a token to be read. */

/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack. */

yyssp = yyss - 1;
yyvsp = yyvs;
yylsp = yyls;

/* Push a new state, which is found in yystate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
yynewstate:

*++yyssp = yystate;

if (yyssp >= yyss + yymaxdepth - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
YYSTYPE *yyvs1 = yyvs;
YYLTYPE *yyls1 = yyls;
short *yyss1 = yyss;

/* Get the current used size of the three stacks, in elements. */
int size = yyssp - yyss + 1;

#ifdef yyoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
yyoverflow("parser stack overflow",
&yyss1, size * sizeof (*yyssp),
&yyvs1, size * sizeof (*yyvsp),
&yyls1, size * sizeof (*yylsp),
&yymaxdepth);

yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
#else /* no yyoverflow */
/* Extend the stack our own way. */
if (yymaxdepth >= YYMAXLIMIT)
yyerror("parser stack overflow");
yymaxdepth *= 2;
if (yymaxdepth > YYMAXLIMIT)
yymaxdepth = YYMAXLIMIT;
yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */

yyssp = yyss + size - 1;
yyvsp = yyvs + size - 1;
#ifdef YYLSP_NEEDED
yylsp = yyls + size - 1;
#endif

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
#endif

if (yyssp >= yyss + yymaxdepth - 1)
YYABORT;
}

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Entering state %d\n", yystate);
#endif

/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
yyresume:

/* First try to decide what to do without reference to lookahead token. */

yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yydefault;

/* Not known => get a lookahead token if don't already have one. */

/* yychar is either YYEMPTY or YYEOF
or a valid token in external form. */

if (yychar == YYEMPTY)
{
#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Reading a token: ");
#endif
yychar = YYLEX;
}

/* Convert token to internal form (in yychar1) for indexing tables with */

if (yychar <= 0) /* This means end of input. */
{
yychar1 = 0;
yychar = YYEOF; /* Don't call YYLEX any more */

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
#endif
}

yyn += yychar1;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
goto yydefault;

yyn = yytable[yyn];

/* yyn is what to do for this token type in this state.
Negative => reduce, -yyn is rule number.
Positive => shift, yyn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */

if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrlab;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrlab;

if (yyn == YYFINAL)
YYACCEPT;

/* Shift the lookahead token. */

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
#endif

/* Discard the token being shifted unless it is eof. */
if (yychar != YYEOF)
yychar = YYEMPTY;

*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif

/* count tokens shifted since error; after three, turn off error status. */
if (yyerrstatus) yyerrstatus--;

yystate = yyn;
goto yynewstate;

/* Do the default action for the current state. */
yydefault:

yyn = yydefact[yystate];
if (yyn == 0)
goto yyerrlab;

/* Do a reduction. yyn is the number of a rule to reduce with. */
yyreduce:
yylen = yyr2[yyn];
yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0
if (yydebug)
{
if (yylen == 1)
fprintf (stderr, "Reducing 1 value via line %d, ",
yyrline[yyn]);
else
fprintf (stderr, "Reducing %d values via line %d, ",
yylen, yyrline[yyn]);
}
#endif


switch (yyn) {

case 15:
{
printf ("Result=%i\n", yyvsp[-1].lval);
;
break;}
case 16:
{
fputc(PC_DISPCOM, comOut); // Display comment text
/* Length is +2 to include length byte + terminator */
fputc(strlen(yyvsp[0].ptr)+2, comOut);// Write the length
fputs(yyvsp[0].ptr, comOut); // Write string w/o null
fputc(0, comOut); // Termnate it
;
break;}
case 17:
{
fputc(PC_ERASECOM, comOut);
;
break;}
case 18:
{
fputc(PC_CLOSEWINDOW, comOut);
;
break;}
case 19:
{
fputc(PC_WAIT, comOut);
x=yyvsp[0].lval; // Make it into an INT
(void) fwrite(&x, sizeof(int), 1, comOut);
;
break;}
case 20:
{
fputc(PC_END, comOut); /* Write the end command */
;
break;}
case 21:
{
fputc(PC_SEND, comOut); // Start a send command
/* Length is +1 to include the length byte */
fputc(strlen(yyvsp[0].ptr)+1, comOut);// Write the length
fputs(yyvsp[0].ptr, comOut); // Write string w/o null
/* NOTE: WE DON'T TERMINATE THE STRING! */
;
break;}
case 22:
{
fputc(PC_SENDSLOW, comOut); // Start a send command
/* Length is +1 to include the length byte */
fputc(strlen(yyvsp[0].ptr)+1, comOut);// Write the length
fputs(yyvsp[0].ptr, comOut); // Write string w/o null
/* NOTE: WE DON'T TERMINATE THE STRING! */
;
break;}
case 23:
{
fputc(PC_WAITFOR, comOut); // Wait for a string
/* Length is +2 to include length byte + terminator */
fputc(strlen(yyvsp[0].ptr)+2, comOut);// Write the length
fputs(yyvsp[0].ptr, comOut); // Write string w/o null
fputc(0, comOut); // Termnate it
;
break;}
case 24:
{
yydebug=1;
;
break;}
case 25:
{
yydebug=0;
;
break;}
case 26:
{
fputc(PC_BELL, comOut); // Beep!
;
break;}
case 27:
{
fputc(PC_NOTIFY, comOut);
/* Length is +2 because we have a null terminator */
/* and we include the length byte. */
fputc(strlen(yyvsp[0].ptr)+2, comOut); // Write the length
fputs(yyvsp[0].ptr, comOut); // Write string w/o null
fputc(0, comOut); // Termnate it w/null
;
break;}
case 28:
{
fputc(PC_NOTIFYOFF, comOut); // Remove notify box
;
break;}
case 30:
{
yyval.lval=yyvsp[0].ival; /* Avoid type mismatch warning */
;
break;}
case 32:
{
yyval.lval=(-yyvsp[0].lval);
;
break;}
case 33:
{
yyval.lval=(~yyvsp[0].lval);
;
break;}
case 34:
{
yyval.lval=(!yyvsp[0].lval);
;
break;}
case 35:
{
yyval.lval=yyvsp[-1].lval;
;
break;}
case 36:
{
yyval.lval=(yyvsp[-2].lval >> yyvsp[0].lval);
;
break;}
case 37:
{
yyval.lval=(yyvsp[-2].lval << yyvsp[0].lval);
;
break;}
case 38:
{
yyval.lval=(yyvsp[-2].lval ^ yyvsp[0].lval);
;
break;}
case 39:
{
yyval.lval=(yyvsp[-2].lval || yyvsp[0].lval);
;
break;}
case 40:
{
yyval.lval=(yyvsp[-2].lval && yyvsp[0].lval);
;
break;}
case 41:
{
yyval.lval=(yyvsp[-2].lval | yyvsp[0].lval);
;
break;}
case 42:
{
yyval.lval=(yyvsp[-2].lval & yyvsp[0].lval);
;
break;}
case 43:
{
yyval.lval=(yyvsp[-2].lval != yyvsp[0].lval);
;
break;}
case 44:
{
yyval.lval=(yyvsp[-2].lval == yyvsp[0].lval);
;
break;}
case 45:
{
yyval.lval=(yyvsp[-2].lval >= yyvsp[0].lval);
;
break;}
case 46:
{
yyval.lval=(yyvsp[-2].lval <= yyvsp[0].lval);
;
break;}
case 47:
{
yyval.lval=(yyvsp[-2].lval > yyvsp[0].lval);
;
break;}
case 48:
{
yyval.lval=(yyvsp[-2].lval < yyvsp[0].lval);
;
break;}
case 49:
{
yyval.lval=(yyvsp[-2].lval - yyvsp[0].lval);
;
break;}
case 50:
{
yyval.lval=(yyvsp[-2].lval + yyvsp[0].lval);
;
break;}
case 51:
{
yyval.lval=(yyvsp[-2].lval * yyvsp[0].lval);
;
break;}
case 52:
{
if (yyvsp[0].lval!=0) {
yyval.lval=(yyvsp[-2].lval / yyvsp[0].lval);
} else {
/* This error should be handled properly! */
/* At the moment, I don't know how - sorry. */
yyerror("Attempt to divide by zero");
break;
}
;
break;}
case 53:
{
yyval.lval=(yyvsp[-2].lval % yyvsp[0].lval);
;
break;}
}
/* the action file gets copied in in place of this dollarsign */


yyvsp -= yylen;
yyssp -= yylen;
#ifdef YYLSP_NEEDED
yylsp -= yylen;
#endif

#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif

*++yyvsp = yyval;

#ifdef YYLSP_NEEDED
yylsp++;
if (yylen == 0)
{
yylsp->first_line = yylloc.first_line;
yylsp->first_column = yylloc.first_column;
yylsp->last_line = (yylsp-1)->last_line;
yylsp->last_column = (yylsp-1)->last_column;
yylsp->text = 0;
}
else
{
yylsp->last_line = (yylsp+yylen-1)->last_line;
yylsp->last_column = (yylsp+yylen-1)->last_column;
}
#endif

/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */

yyn = yyr1[yyn];

yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
yystate = yytable[yystate];
else
yystate = yydefgoto[yyn - YYNTBASE];

goto yynewstate;

yyerrlab: /* here on detecting error */

if (! yyerrstatus)
/* If not already recovering from an error, report this error. */
{
++yynerrs;
yyerror("parse error");
}

if (yyerrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */

/* return failure if at end of input */
if (yychar == YYEOF)
YYABORT;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
#endif

yychar = YYEMPTY;
}

/* Else will try to reuse lookahead token
after shifting the error token. */

yyerrstatus = 3; /* Each real token shifted decrements this */

goto yyerrhandle;

yyerrdefault: /* current state does not do anything special for the error token. */

#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */

yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (yyn) goto yydefault;
#endif

yyerrpop: /* pop the current state because it cannot handle the error token */

if (yyssp == yyss) YYABORT;
yyvsp--;
yystate = *--yyssp;
#ifdef YYLSP_NEEDED
yylsp--;
#endif

#if YYDEBUG != 0
if (yydebug)
{
short *ssp1 = yyss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != yyssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif

yyerrhandle:

yyn = yypact[yystate];
if (yyn == YYFLAG)
goto yyerrdefault;

yyn += YYTERROR;
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
goto yyerrdefault;

yyn = yytable[yyn];
if (yyn < 0)
{
if (yyn == YYFLAG)
goto yyerrpop;
yyn = -yyn;
goto yyreduce;
}
else if (yyn == 0)
goto yyerrpop;

if (yyn == YYFINAL)
YYACCEPT;

#if YYDEBUG != 0
if (yydebug)
fprintf(stderr, "Shifting error token, ");
#endif

*++yyvsp = yylval;
#ifdef YYLSP_NEEDED
*++yylsp = yylloc;
#endif

yystate = yyn;
goto yynewstate;
}