#include <sys/cdefs.h>
#ifndef lint
#if 0
static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
#else
__IDSTRING(yyrcsid, "$NetBSD: skeleton.c,v 1.14 1997/10/20 03:41:16 lukem Exp $");
#endif
#endif
#include <stdlib.h>
#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYLEX yylex()
#define YYEMPTY -1
#define yyclearin (yychar=(YYEMPTY))
#define yyerrok (yyerrflag=0)
#define YYRECOVERING (yyerrflag!=0)
#define YYPREFIX "yy"
#line 2 "moo.y"
/* $Id: moo.y,v 1.16 2007/01/11 19:03:07 ray Exp $ */
/*
* Written by Raymond Lai <ray@cyth.net>.
* Public domain.
*/
#include <sys/cdefs.h>
#include <sys/stdint.h>
#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <inttypes.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "extern.h"
extern FILE *yyin;
static int bflag;
static int nb_operands;
static int print_hex;
static int print_dec;
static int print_oct;
static int print_bin;
static int print_signed;
static int print_unsigned;
static int used_bin;
static int used_dec;
static int used_hex;
static int used_oct;
static void divbyzero(void);
static void printnum(int64_t);
__dead2 static void usage(void);
void yyerror(char *);
int yylex(void);
int yyparse(void);
#line 46 "moo.y"
typedef union {
int64_t number;
} YYSTYPE;
#line 67 "y.tab.c"
#define INTEGER 257
#define EQ 258
#define NEQ 259
#define LS 260
#define RS 261
#define LOR 262
#define LAND 263
#define BOR 264
#define XOR 265
#define BAND 266
#define LT 267
#define GT 268
#define LE 269
#define GE 270
#define PLUS 271
#define MINUS 272
#define TIMES 273
#define DIV 274
#define MOD 275
#define NOT 276
#define INVERSE 277
#define NL 278
#define LPAREN 279
#define RPAREN 280
#define YYERRCODE 256
short yylhs[] = { -1,
0, 0, 0, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
};
short yylen[] = { 2,
3, 0, 2, 1, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 2, 2, 2, 3,
};
short yydefred[] = { 0,
0, 0, 3, 4, 0, 0, 0, 0, 0, 25,
24, 23, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 26, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 7, 8,
9,
};
short yydgoto[] = { 2,
9,
};
short yysindex[] = { -256,
-228, 7, 0, 0, 7, 7, 7, 7, 29, 0,
0, 0, -229, 7, 7, 7, 7, 7, 7, 7,
7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
7, 0, 0, 166, 166, -265, -265, 78, 96, 114,
132, 150, 171, 171, 171, 171, -226, -226, 0, 0,
0,
};
short yyrindex[] = { 1,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, -21, -12, -160, -137, -166, 43, 55,
51, 46, -114, -91, -68, -45, -206, -183, 0, 0,
0,
};
short yygindex[] = { 0,
-3,
};
#define YYTABLESIZE 446
short yytable[] = { 1,
2, 10, 11, 12, 13, 27, 28, 29, 30, 31,
34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
44, 45, 46, 47, 48, 49, 50, 51, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 29, 30, 31, 3,
33, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 0, 0, 0, 0,
0, 5, 0, 5, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 0,
0, 0, 0, 0, 6, 14, 6, 21, 21, 21,
21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
0, 14, 0, 14, 0, 0, 0, 21, 0, 21,
22, 22, 22, 22, 22, 22, 22, 22, 22, 22,
22, 22, 22, 0, 0, 0, 0, 0, 0, 0,
22, 0, 22, 17, 17, 0, 0, 17, 17, 17,
17, 17, 17, 17, 17, 17, 0, 0, 0, 0,
0, 0, 0, 17, 0, 17, 18, 18, 0, 0,
18, 18, 18, 18, 18, 18, 18, 18, 18, 0,
0, 0, 0, 0, 0, 0, 18, 0, 18, 19,
19, 0, 0, 19, 19, 19, 19, 19, 19, 19,
19, 19, 0, 0, 0, 0, 0, 0, 0, 19,
0, 19, 20, 20, 0, 0, 20, 20, 20, 20,
20, 20, 20, 20, 20, 0, 0, 0, 0, 0,
0, 0, 20, 0, 20, 0, 15, 15, 0, 0,
15, 15, 15, 15, 15, 16, 16, 0, 0, 16,
16, 16, 16, 16, 0, 0, 15, 2, 15, 0,
0, 0, 0, 4, 0, 16, 0, 16, 0, 0,
0, 0, 2, 0, 0, 0, 2, 2, 5, 2,
0, 0, 6, 7, 0, 8, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 13, 13, 32, 10, 10, 10,
10, 10, 11, 11, 11, 11, 12, 12, 12, 0,
13, 0, 13, 10, 0, 10, 0, 0, 11, 0,
11, 0, 12, 0, 12, 14, 15, 16, 17, 0,
19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
29, 30, 31, 14, 15, 16, 17, 0, 0, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
31, 14, 15, 16, 17, 0, 0, 0, 21, 22,
23, 24, 25, 26, 27, 28, 29, 30, 31, 14,
15, 16, 17, 0, 0, 0, 0, 22, 23, 24,
25, 26, 27, 28, 29, 30, 31, 14, 15, 16,
17, 0, 0, 0, 0, 0, 23, 24, 25, 26,
27, 28, 29, 30, 31, 16, 17, 0, 0, 0,
16, 17, 23, 24, 25, 26, 27, 28, 29, 30,
31, 27, 28, 29, 30, 31,
};
short yycheck[] = { 256,
0, 5, 6, 7, 8, 271, 272, 273, 274, 275,
14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30, 31, 258, 259,
260, 261, 262, 263, 264, 265, 266, 267, 268, 269,
270, 271, 272, 273, 274, 275, 273, 274, 275, 278,
280, 258, 259, 260, 261, 262, 263, 264, 265, 266,
267, 268, 269, 270, 271, 272, -1, -1, -1, -1,
-1, 278, -1, 280, 258, 259, 260, 261, 262, 263,
264, 265, 266, 267, 268, 269, 270, 271, 272, -1,
-1, -1, -1, -1, 278, 262, 280, 258, 259, 260,
261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
-1, 278, -1, 280, -1, -1, -1, 278, -1, 280,
258, 259, 260, 261, 262, 263, 264, 265, 266, 267,
268, 269, 270, -1, -1, -1, -1, -1, -1, -1,
278, -1, 280, 258, 259, -1, -1, 262, 263, 264,
265, 266, 267, 268, 269, 270, -1, -1, -1, -1,
-1, -1, -1, 278, -1, 280, 258, 259, -1, -1,
262, 263, 264, 265, 266, 267, 268, 269, 270, -1,
-1, -1, -1, -1, -1, -1, 278, -1, 280, 258,
259, -1, -1, 262, 263, 264, 265, 266, 267, 268,
269, 270, -1, -1, -1, -1, -1, -1, -1, 278,
-1, 280, 258, 259, -1, -1, 262, 263, 264, 265,
266, 267, 268, 269, 270, -1, -1, -1, -1, -1,
-1, -1, 278, -1, 280, -1, 258, 259, -1, -1,
262, 263, 264, 265, 266, 258, 259, -1, -1, 262,
263, 264, 265, 266, -1, -1, 278, 257, 280, -1,
-1, -1, -1, 257, -1, 278, -1, 280, -1, -1,
-1, -1, 272, -1, -1, -1, 276, 277, 272, 279,
-1, -1, 276, 277, -1, 279, 258, 259, 260, 261,
262, 263, 264, 265, 266, 267, 268, 269, 270, 271,
272, 273, 274, 275, 262, 263, 278, 262, 263, 264,
265, 266, 262, 263, 264, 265, 262, 263, 264, -1,
278, -1, 280, 278, -1, 280, -1, -1, 278, -1,
280, -1, 278, -1, 280, 258, 259, 260, 261, -1,
263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
273, 274, 275, 258, 259, 260, 261, -1, -1, 264,
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
275, 258, 259, 260, 261, -1, -1, -1, 265, 266,
267, 268, 269, 270, 271, 272, 273, 274, 275, 258,
259, 260, 261, -1, -1, -1, -1, 266, 267, 268,
269, 270, 271, 272, 273, 274, 275, 258, 259, 260,
261, -1, -1, -1, -1, -1, 267, 268, 269, 270,
271, 272, 273, 274, 275, 260, 261, -1, -1, -1,
260, 261, 267, 268, 269, 270, 271, 272, 273, 274,
275, 271, 272, 273, 274, 275,
};
#define YYFINAL 2
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 280
#if YYDEBUG
char *yyname[] = {
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"INTEGER","EQ","NEQ","LS","RS",
"LOR","LAND","BOR","XOR","BAND","LT","GT","LE","GE","PLUS","MINUS","TIMES",
"DIV","MOD","NOT","INVERSE","NL","LPAREN","RPAREN",
};
char *yyrule[] = {
"$accept : program",
"program : program expr NL",
"program :",
"program : error NL",
"expr : INTEGER",
"expr : expr PLUS expr",
"expr : expr MINUS expr",
"expr : expr TIMES expr",
"expr : expr DIV expr",
"expr : expr MOD expr",
"expr : expr BAND expr",
"expr : expr XOR expr",
"expr : expr BOR expr",
"expr : expr LAND expr",
"expr : expr LOR expr",
"expr : expr EQ expr",
"expr : expr NEQ expr",
"expr : expr LT expr",
"expr : expr GT expr",
"expr : expr LE expr",
"expr : expr GE expr",
"expr : expr LS expr",
"expr : expr RS expr",
"expr : INVERSE expr",
"expr : NOT expr",
"expr : MINUS expr",
"expr : LPAREN expr RPAREN",
};
#endif
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 10000
#define YYMAXDEPTH 10000
#endif
#endif
#define YYINITSTACKSIZE 200
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
int yystacksize;
#line 114 "moo.y"
void
divbyzero(void)
{
warnx("divide by zero");
/* Don't print anything. */
used_hex = used_dec = used_oct = used_bin = 0;
}
void
yyerror(char *s)
{
fprintf(stderr, "%s\n", s);
}
/*
* Print numbers in bases that were input or in bases that were specified.
*/
static void
printnum(int64_t num)
{
int printed;
/* Print tabs between numbers as necessary. */
#define printspace() do { \
if (printed++) \
printf("\t"); \
} while (0)
printed = 0;
/* If no bases were specified, print the ones that were input. */
if (!bflag) {
/* If only one term was entered, print it in all bases */
if (nb_operands == 1)
print_hex = print_dec = print_oct = print_bin = 1;
else {
/* Reset print flags. */
print_hex = print_dec = print_oct = print_bin = 0;
if (used_hex)
print_hex = 1;
if (used_dec)
print_dec = 1;
if (used_oct)
print_oct = 1;
if (used_bin)
print_bin = 1;
/* Reset used flags. */
used_hex = used_dec = used_oct = used_bin = 0;
}
}
if (print_hex) {
printspace();
printf("0x%" PRIx64, num);
}
if (print_dec) {
if (print_unsigned) {
printspace();
printf("%" PRIu64, num);
}
if (print_signed) {
printspace();
printf("%" PRId64, num);
}
}
if (print_oct) {
printspace();
printf("0%" PRIo64, num);
}
if (print_bin) {
int bit, printed_bit;
printed_bit = 0;
printspace();
printf("0b");
for (bit = sizeof(num) * 8; bit > 0; --bit)
if (num & (1LL << (bit - 1))) {
printf("1");
++printed_bit;
/* Print leading zeroes if any bits were printed. */
} else {
if (printed_bit) {
printf("0");
++printed_bit;
}
}
/*
* If no bits were printed out (num == 0) then print a 0
* so we don't just print ``0b''.
*/
if (!printed_bit)
printf("0");
}
printf("\n");
return;
TOOLONG:
errx(1, "format string too long");
}
/*
* Read binary number string and convert to int.
*/
int64_t
getbin(const char *nptr)
{
int64_t num;
const char *p;
++nb_operands;
used_bin = 1;
if (strncmp("0b", nptr, 2) != 0)
errx(2, "not a binary number: %s", nptr);
/* XXX - buffer overflow */
for (p = nptr + 2, num = 0; *p != '\0'; ++p) {
num <<= 1;
switch (*p) {
case '1':
++num;
/* FALLTHROUGH */
case '0':
break;
default:
errx(2, "not a binary number: %s", nptr);
}
}
return (num);
}
/*
* Accept hex, decimal, and octal integers.
*/
int64_t
getnum(const char *nptr)
{
int64_t num;
char *ep;
int64_t lval;
errno = 0;
lval = strtoll(nptr, &ep, 0);
if (*nptr == '\0' || *ep != '\0')
errx(1, "invalid number: %s", nptr);
if ((errno == ERANGE && (lval == LLONG_MAX || lval == LLONG_MIN)) ||
(lval > INT64_MAX || lval < INT64_MIN))
errx(1, "out of range: %s", nptr);
num = lval;
++nb_operands;
if (strncmp(nptr, "0x", 2) == 0)
used_hex = 1;
else if (nptr[0] == '0' && nptr[1] != '\0')
used_oct = 1;
else
used_dec = 1;
return (num);
}
int
main(int argc, char *argv[])
{
int ch;
while ((ch = getopt(argc, argv, "0123456789b:suw:")) != -1)
switch (ch) {
/*
* If we get a numerical flag it may be a negative
* number, so pop the argument back in and let the
* argument parser handle it.
*/
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
--optind;
goto DONEPARSING;
case 'b':
bflag = 1;
if (optarg[0] == 'a') {
print_hex = print_dec = print_oct =
print_bin = 1;
break;
}
/* Only allow certain bases to be printed. */
switch (getnum(optarg)) {
case 16:
print_hex = 1;
break;
case 10:
print_dec = 1;
break;
case 8:
print_oct = 1;
break;
case 2:
print_bin = 1;
break;
default:
errx(1, "invalid base: %s", optarg);
}
break;
case 's':
print_signed = 1;
break;
case 'u':
print_unsigned = 1;
break;
default:
usage();
}
DONEPARSING:
argc -= optind;
argv += optind;
/* Print signed decimal numbers by default. */
if (!(print_signed || print_unsigned))
print_signed = 1;
/* If arguments were given calculate arguments instead of stdin. */
if (argc > 0) {
FILE *sfp;
int fd, i;
char *sfn;
if (asprintf(&sfn, "%s/moo.XXXXXXXXXX",
getenv("TMPDIR") ? getenv("TMPDIR") : "/tmp") == -1)
err(1, "asprintf");
if ((fd = mkstemp(sfn)) == -1 ||
(sfp = fdopen(fd, "w+")) == NULL) {
warn("%s", sfn);
if (fd != -1)
unlink(sfn);
exit(1);
}
if (unlink(sfn) == -1)
warn("%s", sfn);
/* Copy arguments to temp file. */
for (i = 0; i < argc; ++i)
if (fputs(argv[i], sfp))
err(1, "error writing %s", sfn);
/* Parser needs a newline at end. */
if (fputs("\n", sfp))
err(1, "error writing %s", sfn);
free(sfn);
rewind(sfp);
yyin = sfp;
}
yyparse();
return (0);
}
void
usage(void)
{
extern char *__progname;
fprintf(stderr, "usage: %s [-su] [-b base] expr\n",
__progname);
exit(1);
}
#line 569 "y.tab.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
int yyparse __P((void));
static int yygrowstack __P((void));
static int yygrowstack()
{
int newsize, i;
short *newss;
YYSTYPE *newvs;
if ((newsize = yystacksize) == 0)
newsize = YYINITSTACKSIZE;
else if (newsize >= YYMAXDEPTH)
return -1;
else if ((newsize *= 2) > YYMAXDEPTH)
newsize = YYMAXDEPTH;
i = yyssp - yyss;
if ((newss = (short *)realloc(yyss, newsize * sizeof *newss)) == NULL)
return -1;
yyss = newss;
yyssp = newss + i;
if ((newvs = (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs)) == NULL)
return -1;
yyvs = newvs;
yyvsp = newvs + i;
yystacksize = newsize;
yysslim = yyss + newsize - 1;
return 0;
}
#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse()
{
int yym, yyn, yystate;
#if YYDEBUG
char *yys;
if ((yys = getenv("YYDEBUG")) != NULL)
{
yyn = *yys;
if (yyn >= '0' && yyn <= '9')
yydebug = yyn - '0';
}
#endif
yynerrs = 0;
yyerrflag = 0;
yychar = (-1);
if (yyss == NULL && yygrowstack()) goto yyoverflow;
yyssp = yyss;
yyvsp = yyvs;
*yyssp = yystate = 0;
yyloop:
if ((yyn = yydefred[yystate]) != 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("%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 >= yysslim && yygrowstack())
{
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;
goto yynewerror;
yynewerror:
yyerror("syntax error");
goto yyerrlab;
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 >= yysslim && yygrowstack())
{
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 1:
#line 67 "moo.y"
{
if (used_hex || used_dec ||
used_oct || used_bin)
printnum(yyvsp[-1].number);
nb_operands = used_hex = used_dec =
used_oct = used_bin = 0;
}
break;
case 3:
#line 75 "moo.y"
{ yyerrok; }
break;
case 4:
#line 79 "moo.y"
{ yyval.number = yyvsp[0].number; }
break;
case 5:
#line 80 "moo.y"
{ yyval.number = yyvsp[-2].number + yyvsp[0].number; }
break;
case 6:
#line 81 "moo.y"
{ yyval.number = yyvsp[-2].number - yyvsp[0].number; }
break;
case 7:
#line 82 "moo.y"
{ yyval.number = yyvsp[-2].number * yyvsp[0].number; }
break;
case 8:
#line 83 "moo.y"
{
if (yyvsp[0].number == 0)
divbyzero();
else
yyval.number = yyvsp[-2].number / yyvsp[0].number;
}
break;
case 9:
#line 89 "moo.y"
{
if (yyvsp[0].number == 0)
divbyzero();
else
yyval.number = yyvsp[-2].number % yyvsp[0].number;
}
break;
case 10:
#line 95 "moo.y"
{ yyval.number = yyvsp[-2].number & yyvsp[0].number; }
break;
case 11:
#line 96 "moo.y"
{ yyval.number = yyvsp[-2].number ^ yyvsp[0].number; }
break;
case 12:
#line 97 "moo.y"
{ yyval.number = yyvsp[-2].number | yyvsp[0].number; }
break;
case 13:
#line 98 "moo.y"
{ yyval.number = yyvsp[-2].number && yyvsp[0].number; }
break;
case 14:
#line 99 "moo.y"
{ yyval.number = yyvsp[-2].number || yyvsp[0].number; }
break;
case 15:
#line 100 "moo.y"
{ yyval.number = yyvsp[-2].number == yyvsp[0].number; }
break;
case 16:
#line 101 "moo.y"
{ yyval.number = yyvsp[-2].number != yyvsp[0].number; }
break;
case 17:
#line 102 "moo.y"
{ yyval.number = yyvsp[-2].number < yyvsp[0].number; }
break;
case 18:
#line 103 "moo.y"
{ yyval.number = yyvsp[-2].number > yyvsp[0].number; }
break;
case 19:
#line 104 "moo.y"
{ yyval.number = yyvsp[-2].number <= yyvsp[0].number; }
break;
case 20:
#line 105 "moo.y"
{ yyval.number = yyvsp[-2].number >= yyvsp[0].number; }
break;
case 21:
#line 106 "moo.y"
{ yyval.number = yyvsp[-2].number << yyvsp[0].number; }
break;
case 22:
#line 107 "moo.y"
{ yyval.number = yyvsp[-2].number >> yyvsp[0].number; }
break;
case 23:
#line 108 "moo.y"
{ yyval.number = ~yyvsp[0].number; }
break;
case 24:
#line 109 "moo.y"
{ yyval.number = !yyvsp[0].number; }
break;
case 25:
#line 110 "moo.y"
{ yyval.number = -yyvsp[0].number; }
break;
case 26:
#line 111 "moo.y"
{ yyval.number = yyvsp[-1].number; }
break;
#line 851 "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 >= yysslim && yygrowstack())
{
goto yyoverflow;
}
*++yyssp = yystate;
*++yyvsp = yyval;
goto yyloop;
yyoverflow:
yyerror("yacc stack overflow");
yyabort:
return (1);
yyaccept:
return (0);
}
syntax highlighted by Code2HTML, v. 0.9.1