Head

GCC Code Coverage Report
Directory:	./		Exec	Total	Coverage
File:	usr.bin/bc/bc.c	Lines:	297	380	78.2 %
Date:	2017-11-07	Branches:	135	214	63.1 %

#include <stdlib.h>
#include <string.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 "/usr/src/usr.bin/bc/bc.y"
/*	$OpenBSD: bc.y,v 1.51 2017/07/02 23:19:07 deraadt Exp $	*/

/*
 * Copyright (c) 2003, Otto Moerbeek <otto@drijf.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This implementation of bc(1) uses concepts from the original 4.4
 * BSD bc(1). The code itself is a complete rewrite, based on the
 * Posix defined bc(1) grammar. Other differences include type safe
 * usage of pointers to build the tree of emitted code, typed yacc
 * rule values, dynamic allocation of all data structures and a
 * completely rewritten lexical analyzer using lex(1).
 *
 * Some effort has been made to make sure that the generated code is
 * the same as the code generated by the older version, to provide
 * easy regression testing.
 */

#include <sys/types.h>
#include <sys/wait.h>

#include <ctype.h>
#include <err.h>
#include <errno.h>
#include <histedit.h>
#include <limits.h>
#include <search.h>
#include <signal.h>
#include <stdarg.h>
#include <string.h>
#include <unistd.h>

#include "extern.h"
#include "pathnames.h"

#define END_NODE	((ssize_t) -1)
#define CONST_STRING	((ssize_t) -2)
#define ALLOC_STRING	((ssize_t) -3)

struct tree {
	ssize_t			index;
	union {
		char		*astr;
		const char	*cstr;
	} u;
};

int			yyparse(void);
int			yywrap(void);

int			fileindex;
int			sargc;
char			**sargv;
char			*filename;
char			*cmdexpr;

static void		grow(void);
static ssize_t		cs(const char *);
static ssize_t		as(const char *);
static ssize_t		node(ssize_t, ...);
static void		emit(ssize_t, int);
static void		emit_macro(int, ssize_t);
static void		free_tree(void);
static ssize_t		numnode(int);
static ssize_t		lookup(char *, size_t, char);
static ssize_t		letter_node(char *);
static ssize_t		array_node(char *);
static ssize_t		function_node(char *);

static void		add_par(ssize_t);
static void		add_local(ssize_t);
static void		warning(const char *);
static void		init(void);
static __dead void	usage(void);
static char		*escape(const char *);

static ssize_t		instr_sz = 0;
static struct tree	*instructions = NULL;
static ssize_t		current = 0;
static int		macro_char = '0';
static int		reset_macro_char = '0';
static int		nesting = 0;
static int		breakstack[16];
static int		breaksp = 0;
static ssize_t		prologue;
static ssize_t		epilogue;
static bool		st_has_continue;
static char		str_table[UCHAR_MAX][2];
static bool		do_fork = true;
static u_short		var_count;
static pid_t		dc;

extern char *__progname;

#define BREAKSTACK_SZ	(sizeof(breakstack)/sizeof(breakstack[0]))

/* These values are 4.4BSD bc compatible */
#define FUNC_CHAR	0x01
#define ARRAY_CHAR	0xa1

/* Skip '\0', [, \ and ] */
#define ENCODE(c)	((c) < '[' ? (c) : (c) + 3);
#define VAR_BASE	(256-4)
#define MAX_VARIABLES	(VAR_BASE * VAR_BASE)

#line 124 "/usr/src/usr.bin/bc/bc.y"
#ifndef YYSTYPE_DEFINED
#define YYSTYPE_DEFINED
typedef union {
	ssize_t		node;
	struct lvalue	lvalue;
	const char	*str;
	char		*astr;
} YYSTYPE;
#endif /* YYSTYPE_DEFINED */
#line 142 "bc.c"
#define COMMA 257
#define SEMICOLON 258
#define LPAR 259
#define RPAR 260
#define LBRACE 261
#define RBRACE 262
#define LBRACKET 263
#define RBRACKET 264
#define DOT 265
#define NEWLINE 266
#define LETTER 267
#define NUMBER 268
#define STRING 269
#define DEFINE 270
#define BREAK 271
#define QUIT 272
#define LENGTH 273
#define RETURN 274
#define FOR 275
#define IF 276
#define WHILE 277
#define SQRT 278
#define SCALE 279
#define IBASE 280
#define OBASE 281
#define AUTO 282
#define CONTINUE 283
#define ELSE 284
#define PRINT 285
#define BOOL_OR 286
#define BOOL_AND 287
#define BOOL_NOT 288
#define EQUALS 289
#define LESS_EQ 290
#define GREATER_EQ 291
#define UNEQUALS 292
#define LESS 293
#define GREATER 294
#define ASSIGN_OP 295
#define PLUS 296
#define MINUS 297
#define MULTIPLY 298
#define DIVIDE 299
#define REMAINDER 300
#define EXPONENT 301
#define UMINUS 302
#define INCR 303
#define DECR 304
#define YYERRCODE 256
const short yylhs[] =
	{                                        -1,
    0,    0,    7,    7,    7,    7,   16,   16,   16,   16,
   18,   18,   18,   18,   18,   18,   11,   11,   17,   17,
   17,   17,   17,   17,   17,   17,   17,   17,   17,   17,
   17,    3,   19,    5,    6,   21,   21,   20,   20,   23,
   23,   23,   23,   22,   22,   22,   24,   24,   24,   24,
    8,    8,    2,    2,    2,   10,   10,   14,   14,   14,
   14,   14,   14,   14,   15,   15,   15,    9,    9,    4,
    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
    4,    4,    4,    4,    4,    4,    4,    4,    1,    1,
    1,    1,    1,   13,   13,   12,   12,
};
const short yylen[] =
	{                                         2,
    0,    2,    2,    1,    2,    2,    0,    1,    3,    2,
    0,    1,    2,    3,    2,    3,    0,    1,    1,    3,
    1,    1,    1,    1,    2,   11,    7,   11,    7,    3,
    2,    0,    0,    9,    3,    0,    1,    0,    1,    1,
    3,    3,    5,    0,    3,    3,    1,    3,    3,    5,
    0,    1,    1,    3,    5,    0,    1,    3,    3,    3,
    3,    3,    3,    1,    0,    1,    2,    0,    1,    1,
    1,    1,    3,    4,    2,    3,    3,    3,    3,    3,
    3,    2,    2,    2,    2,    3,    4,    4,    4,    2,
    5,    5,    3,    3,    3,    3,    3,    3,    1,    4,
    1,    1,    1,    1,    3,    1,    1,
};
const short yydefred[] =
	{                                      1,
    0,    0,    0,    0,   71,    0,   72,   21,    0,   22,
   24,    0,    0,    0,    0,    0,    0,    0,  102,  103,
   23,    0,    0,    0,    0,    0,    0,    0,    4,    0,
    2,    0,    8,    5,    6,    0,    0,   12,    0,    0,
    0,    0,    0,    0,    0,   25,   32,   32,   32,    0,
    0,  107,    0,  104,    0,    0,   75,    0,  101,   82,
   83,    0,   84,   85,   32,   32,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    3,    0,   73,    0,   30,    0,    0,    0,
    0,    0,   35,    0,   67,    0,   33,    0,    0,    0,
    0,    0,   33,   33,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    9,
    0,   16,   14,    0,   74,  100,   87,    0,    0,    0,
    0,    0,   88,   89,  105,    0,    0,   41,   37,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   57,    0,
    0,    0,    0,    0,    0,    0,   33,   18,    0,   43,
   55,    0,    0,   29,    0,    0,    0,   32,    0,    0,
    0,    0,   33,    0,    0,   46,   45,   34,   33,    0,
   48,    0,   26,   28,    0,   50,
};
const short yydgoto[] =
	{                                       1,
   36,   89,   96,   28,   29,   30,   31,   91,  129,  158,
  167,   54,   55,  132,   46,   32,  168,   39,  130,   80,
  140,  176,   81,  180,
};
const short yysindex[] =
	{                                      0,
  -77, -188,  196,   88,    0, -257,    0,    0, -260,    0,
    0, -236,  223, -225, -109, -107, -103, -102,    0,    0,
    0,  115,  196,  196, -227, -227, -291,  -17,    0, -237,
    0, -202,    0,    0,    0, -166,  479,    0,  -89,  196,
  196,  -87,  196,  142,  -17,    0,    0,    0,    0,  196,
  196,    0,  -17,    0, -195,  815,    0, -170,    0,    0,
    0,  196,    0,    0,    0,    0,  196,  196,  196,  196,
  196,  196,  196,  196,  196,  196,  196,  196,  -85, -157,
  -81,   88,    0,  196,    0,   88,    0,   88,  -72,  -17,
  -73,  607,    0,  496,    0,  196,    0,  196,  514,  531,
  115,  291,    0,    0,  291,  291,  291,  291,  291,  291,
  126,  126,  -71,  -71,  -71,  -71,  -33,  -37,  -32,    0,
  291,    0,    0,  250,    0,    0,    0,  -17,  -21,  196,
  787,  -20,    0,    0,    0,  196,  196,    0,    0,   -7,
   -6, -216,  -17,  196,    6,  196,  196,  196,  196,  196,
  196,   88,  802,  815,   -4,    7,  169,   20,    0,   88,
  291,  291,  291,  291,  291,  291,    0,    0,   21,    0,
    0,  196,    5,    0,   41,   88,   51,    0,   49, -207,
  -45,   88,    0,   54,   65,    0,    0,    0,    0,   88,
    0,   74,    0,    0,   76,    0,};
const short yyrindex[] =
	{                                      0,
 -175,    0,    0,  -43,    0,  -48,    0,    0,    0,    0,
    0,    0,    2,    0,    0,    0,    0,    1,    0,    0,
    0,    0,    0,    0,    0,    0,  461,  221,    0,   81,
    0,    0,    0,    0,    0,  275,    0,    0,    0,   82,
    0,    0,    0,    0,  384,    0,    0,    0,    0,    0,
    0,    0,  286,    0,  445, -229,    0,  320,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0, -152,    0,
   84, -133,    0,    0,    0,  -34,    0,   72,   86,  -86,
    0,    0,    0,    0,    0,   90,    0,    0,    0,    0,
    0, -126,    0,    0,  194,  663,  694,  704,  735,  745,
  576,  590,  339,  383,  400,  444,    0,   89,    0,    0,
  652,    0,    0,    0,    0,    0,    0, -197,    0,    0,
 -117,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  -74, -180,  -35,   96,    0,    0,    0,    0,    0,    0,
    0,  577,  786,  776,    0,    0,    0,    0,    0,  577,
 -241, -160, -156,  -53,  112,  119,    0,    0,   48,    0,
    0,   98,   77,    0,    0,  -43,    0,    0, -169,    0,
    0,  577,    0,    0,    0,    0,    0,    0,    0,  577,
    0, -104,    0,    0,    0,    0,};
const short yygindex[] =
	{                                      0,
   -1,    0,  -39,   -2,    0,    0,    0,    0,  203,    0,
 -146,  277,    0, -112,    0,    0,    4,  205,  -88,    0,
    0,    0,    0,    0,
};
#define YYTABLESIZE 1116
const short yytable[] =
	{                                      27,
   37,   40,   27,   62,   33,   41,   42,   38,   97,   98,
   45,   63,   64,  173,  136,  137,   58,  145,   58,   53,
   56,   57,   43,   60,   61,  103,  104,   90,   90,   79,
   90,  159,   90,   47,   90,  189,   90,   90,   92,   58,
   94,   37,   40,  194,   93,   93,  157,   99,  100,  185,
  186,   59,   19,   20,   90,   82,   90,   90,  187,  102,
   69,  101,   69,   83,  105,  106,  107,  108,  109,  110,
  111,  112,  113,  114,  115,  116,   99,   34,  174,   99,
   27,  121,    7,   35,   27,  120,   27,   47,   47,  122,
    7,  123,   41,  128,  190,  131,   47,   61,   53,   61,
  193,   63,  118,   63,   40,   99,   99,   40,   99,   99,
   99,   99,   99,   99,   99,   99,   99,   99,   99,   99,
   99,  143,   99,   99,   10,   96,   96,  131,   84,   98,
   98,   20,   10,  153,  154,   20,   63,   64,  183,   20,
   64,  131,   64,  161,  162,  163,  164,  165,  166,   48,
   27,   49,   49,   49,   92,   50,   51,   20,   27,   86,
   86,   49,   86,   86,   86,   86,   86,   86,   86,  128,
   53,   93,   87,   53,   27,  119,   88,  117,    2,   38,
   27,    3,   42,    4,  124,   42,  125,    5,   27,    6,
    7,    8,    9,   10,   11,   12,   13,   14,   15,   16,
   17,   18,   19,   20,   59,   21,   59,   22,   99,   99,
   23,   99,   86,   99,   11,   99,  188,   99,   11,   24,
   88,   54,   11,   15,   54,   25,   26,   15,  139,   78,
  138,   15,   94,   94,  141,   99,  144,   99,   99,  152,
   99,   99,   99,   99,   99,   99,   99,   99,   99,   99,
   99,   99,   99,  155,   99,   99,  156,  101,  101,   65,
  101,  169,  101,   65,  101,  160,  101,   65,   65,   66,
  170,   67,   68,   69,   70,   71,   72,  172,   73,   74,
   75,   76,   77,   78,  101,   65,  101,  101,  178,  101,
  101,  101,  101,  101,  101,  101,  101,  101,  101,  101,
  101,  101,  175,  101,  101,   44,   44,  179,   44,   44,
  182,  184,   44,   44,   44,   44,   44,  191,   44,   44,
   44,   44,   44,   44,   44,   44,   44,   44,   44,   13,
   44,  192,   44,   13,   27,   44,  195,   13,   27,  196,
   38,   51,   27,   39,   44,   52,    3,   68,    4,   36,
   44,   44,    5,   56,    6,    7,    8,   68,   10,   11,
   12,   13,   14,   15,   16,   17,   18,   19,   20,   60,
   21,   60,   22,    3,  177,   23,   62,  135,   62,    5,
  181,    6,    7,   52,   24,    0,    0,   12,    0,    0,
   25,   26,   17,   18,   19,   20,    0,   95,   95,    0,
    3,   95,   23,    0,   97,   97,    5,    0,    6,    7,
    0,   24,    0,    0,   12,    0,    0,   25,   26,   17,
   18,   19,   20,   75,   76,   77,   78,    3,    0,   23,
    0,    0,  171,    5,    0,    6,    7,    0,   24,    0,
    0,   12,    0,    0,   25,   26,   17,   18,   19,   20,
   93,   93,    0,   93,    3,   93,   23,   93,    0,   93,
    5,    0,    6,    7,    0,   24,    0,    0,   12,    0,
    0,   25,   26,   17,   18,   19,   20,   93,   19,   93,
   93,   44,   19,   23,    0,    0,   19,    5,    0,    6,
    7,    0,   24,    0,    0,   12,    0,    0,   25,   26,
   17,   18,   19,   20,   19,    0,    0,    0,    3,    0,
   23,    0,    0,    0,    5,    0,  142,    7,    0,   24,
    0,    0,   12,    0,    0,   25,   26,   17,   18,   19,
   20,   70,   70,    0,   70,    0,   70,   23,   70,    0,
   70,    0,  106,  106,    0,    0,   24,  106,    0,    0,
    0,  106,   25,   26,    0,    0,    0,    0,   70,    0,
   70,   70,    0,   70,   70,   70,   70,   70,   70,  106,
   70,   70,   70,   70,   70,   70,   99,   99,    0,   99,
    0,   99,    0,   99,    0,   99,   73,   74,   75,   76,
   77,   78,    0,    0,    0,   78,   78,    0,   78,    0,
   78,    0,   78,   99,   78,   99,   99,    0,   99,   99,
   99,   99,   99,   99,    0,   99,   99,   99,   99,   99,
   99,    0,   78,    0,   78,   78,    0,   78,   78,   78,
   78,   78,   78,    0,   78,   78,   78,   78,   78,   79,
   79,   66,   79,    0,   79,   66,   79,    0,   79,   66,
    0,    0,    0,    0,    0,    0,   80,   80,    0,   80,
    0,   80,    0,   80,    0,   80,   79,   66,   79,   79,
    0,   79,   79,   79,   79,   79,   79,    0,   79,   79,
   79,   79,   79,   80,    0,   80,   80,    0,   80,   80,
   80,   80,   80,   80,    0,   80,   80,   80,   80,   80,
   81,   81,   31,   81,    0,   81,   31,   81,    0,   81,
   31,    0,    0,    0,    0,    0,    0,    0,   70,    0,
    0,    0,   70,    0,    0,    0,   70,   81,   31,   81,
   81,    0,   81,   81,   81,   81,   81,   81,   85,   81,
   81,   81,   81,   81,   70,    0,   70,   70,    0,   70,
   70,   70,   70,   70,   70,  127,   70,   70,   70,   70,
   70,   70,    0,    0,   65,   66,    0,   67,   68,   69,
   70,   71,   72,  133,   73,   74,   75,   76,   77,   78,
    0,   65,   66,    0,   67,   68,   69,   70,   71,   72,
  134,   73,   74,   75,   76,   77,   78,    0,    0,   65,
   66,    0,   67,   68,   69,   70,   71,   72,    0,   73,
   74,   75,   76,   77,   78,    0,   65,   66,    0,   67,
   68,   69,   70,   71,   72,    0,   73,   74,   75,   76,
   77,   78,   76,   76,   17,   76,    0,   76,   17,   76,
    0,   76,   17,    0,    0,    0,   77,   77,    0,   77,
    0,   77,    0,   77,    0,   77,    0,    0,    0,   76,
   17,   76,   76,    0,   76,   76,   76,   76,   76,   76,
  126,   76,   76,   77,    0,   77,   77,    0,   77,   77,
   77,   77,   77,   77,    0,   77,   77,    0,    0,    0,
    0,    0,   65,   66,    0,   67,   68,   69,   70,   71,
   72,    0,   73,   74,   75,   76,   77,   78,   86,   86,
    0,   86,    0,   86,    0,   86,    0,   86,    0,   96,
   96,    0,   96,    0,   96,    0,   96,    0,   96,    0,
    0,    0,    0,    0,    0,   86,    0,   86,   86,    0,
   86,   86,   86,   86,   86,   86,   96,    0,   96,   96,
   98,   98,    0,   98,    0,   98,    0,   98,    0,   98,
   94,   94,    0,   94,    0,   94,    0,   94,    0,   94,
    0,    0,    0,    0,    0,    0,    0,   98,    0,   98,
   98,    0,    0,    0,    0,    0,    0,   94,    0,   94,
   94,   95,   95,    0,   95,    0,   95,    0,   95,    0,
   95,   97,   97,    0,   97,    0,   97,    0,   97,    0,
   97,    0,    0,    0,    0,    0,    0,    0,   95,    0,
   95,   95,    0,    0,    0,    0,    0,    0,   97,    0,
   97,   97,   91,   91,    0,   91,    0,   91,    0,   91,
    0,   91,   92,   92,    0,   92,    0,   92,    0,   92,
    0,   92,    0,    0,    0,    0,    0,    0,    0,   91,
    0,   91,   91,    0,    0,    0,    0,    0,    0,   92,
    0,   92,   65,   66,    0,  146,  147,  148,  149,  150,
  151,    0,   73,   74,   75,   76,   77,   78,   66,    0,
   67,   68,   69,   70,   71,   72,    0,   73,   74,   75,
   76,   77,   78,   67,   68,   69,   70,   71,   72,    0,
   73,   74,   75,   76,   77,   78,
};
const short yycheck[] =
	{                                       1,
    3,  259,    4,  295,    1,  263,  267,    4,   48,   49,
   13,  303,  304,  160,  103,  104,  258,  130,  260,   22,
   23,   24,  259,   25,   26,   65,   66,  257,  258,  267,
  260,  144,  262,  259,  264,  182,  266,   40,   41,  267,
   43,   44,  259,  190,  286,  287,  263,   50,   51,  257,
  258,  279,  280,  281,  284,  258,  286,  287,  266,   62,
  258,  257,  260,  266,   67,   68,   69,   70,   71,   72,
   73,   74,   75,   76,   77,   78,  257,  266,  167,  260,
   82,   84,  258,  272,   86,   82,   88,  257,  258,   86,
  266,   88,  263,   96,  183,   98,  266,  258,  101,  260,
  189,  258,  260,  260,  257,  286,  287,  260,  289,  290,
  291,  292,  293,  294,  295,  296,  297,  298,  299,  300,
  301,  124,  303,  304,  258,  286,  287,  130,  295,  286,
  287,  258,  266,  136,  137,  262,  303,  304,  178,  266,
  258,  144,  260,  146,  147,  148,  149,  150,  151,  259,
  152,  259,  257,  258,  157,  259,  259,  284,  160,  286,
  287,  266,  289,  290,  291,  292,  293,  294,  258,  172,
  257,  259,  262,  260,  176,  257,  266,  263,  256,  176,
  182,  259,  257,  261,  257,  260,  260,  265,  190,  267,
  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,
  278,  279,  280,  281,  258,  283,  260,  285,  257,  258,
  288,  260,  258,  262,  258,  264,  262,  266,  262,  297,
  266,  257,  266,  258,  260,  303,  304,  262,  266,  301,
  264,  266,  286,  287,  267,  284,  258,  286,  287,  260,
  289,  290,  291,  292,  293,  294,  295,  296,  297,  298,
  299,  300,  301,  261,  303,  304,  263,  257,  258,  258,
  260,  266,  262,  262,  264,  260,  266,  266,  286,  287,
  264,  289,  290,  291,  292,  293,  294,  258,  296,  297,
  298,  299,  300,  301,  284,  284,  286,  287,  284,  289,
  290,  291,  292,  293,  294,  295,  296,  297,  298,  299,
  300,  301,  282,  303,  304,  258,  259,  267,  261,  262,
  260,  263,  265,  266,  267,  268,  269,  264,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  258,
  283,  267,  285,  262,  258,  288,  263,  266,  262,  264,
  260,  260,  266,  260,  297,  260,  259,  258,  261,  261,
  303,  304,  265,  258,  267,  268,  269,  260,  271,  272,
  273,  274,  275,  276,  277,  278,  279,  280,  281,  258,
  283,  260,  285,  259,  172,  288,  258,  101,  260,  265,
  176,  267,  268,  269,  297,   -1,   -1,  273,   -1,   -1,
  303,  304,  278,  279,  280,  281,   -1,  286,  287,   -1,
  259,  260,  288,   -1,  286,  287,  265,   -1,  267,  268,
   -1,  297,   -1,   -1,  273,   -1,   -1,  303,  304,  278,
  279,  280,  281,  298,  299,  300,  301,  259,   -1,  288,
   -1,   -1,  264,  265,   -1,  267,  268,   -1,  297,   -1,
   -1,  273,   -1,   -1,  303,  304,  278,  279,  280,  281,
  257,  258,   -1,  260,  259,  262,  288,  264,   -1,  266,
  265,   -1,  267,  268,   -1,  297,   -1,   -1,  273,   -1,
   -1,  303,  304,  278,  279,  280,  281,  284,  258,  286,
  287,  259,  262,  288,   -1,   -1,  266,  265,   -1,  267,
  268,   -1,  297,   -1,   -1,  273,   -1,   -1,  303,  304,
  278,  279,  280,  281,  284,   -1,   -1,   -1,  259,   -1,
  288,   -1,   -1,   -1,  265,   -1,  267,  268,   -1,  297,
   -1,   -1,  273,   -1,   -1,  303,  304,  278,  279,  280,
  281,  257,  258,   -1,  260,   -1,  262,  288,  264,   -1,
  266,   -1,  257,  258,   -1,   -1,  297,  262,   -1,   -1,
   -1,  266,  303,  304,   -1,   -1,   -1,   -1,  284,   -1,
  286,  287,   -1,  289,  290,  291,  292,  293,  294,  284,
  296,  297,  298,  299,  300,  301,  257,  258,   -1,  260,
   -1,  262,   -1,  264,   -1,  266,  296,  297,  298,  299,
  300,  301,   -1,   -1,   -1,  257,  258,   -1,  260,   -1,
  262,   -1,  264,  284,  266,  286,  287,   -1,  289,  290,
  291,  292,  293,  294,   -1,  296,  297,  298,  299,  300,
  301,   -1,  284,   -1,  286,  287,   -1,  289,  290,  291,
  292,  293,  294,   -1,  296,  297,  298,  299,  300,  257,
  258,  258,  260,   -1,  262,  262,  264,   -1,  266,  266,
   -1,   -1,   -1,   -1,   -1,   -1,  257,  258,   -1,  260,
   -1,  262,   -1,  264,   -1,  266,  284,  284,  286,  287,
   -1,  289,  290,  291,  292,  293,  294,   -1,  296,  297,
  298,  299,  300,  284,   -1,  286,  287,   -1,  289,  290,
  291,  292,  293,  294,   -1,  296,  297,  298,  299,  300,
  257,  258,  258,  260,   -1,  262,  262,  264,   -1,  266,
  266,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,
   -1,   -1,  262,   -1,   -1,   -1,  266,  284,  284,  286,
  287,   -1,  289,  290,  291,  292,  293,  294,  260,  296,
  297,  298,  299,  300,  284,   -1,  286,  287,   -1,  289,
  290,  291,  292,  293,  294,  260,  296,  297,  298,  299,
  300,  301,   -1,   -1,  286,  287,   -1,  289,  290,  291,
  292,  293,  294,  260,  296,  297,  298,  299,  300,  301,
   -1,  286,  287,   -1,  289,  290,  291,  292,  293,  294,
  260,  296,  297,  298,  299,  300,  301,   -1,   -1,  286,
  287,   -1,  289,  290,  291,  292,  293,  294,   -1,  296,
  297,  298,  299,  300,  301,   -1,  286,  287,   -1,  289,
  290,  291,  292,  293,  294,   -1,  296,  297,  298,  299,
  300,  301,  257,  258,  258,  260,   -1,  262,  262,  264,
   -1,  266,  266,   -1,   -1,   -1,  257,  258,   -1,  260,
   -1,  262,   -1,  264,   -1,  266,   -1,   -1,   -1,  284,
  284,  286,  287,   -1,  289,  290,  291,  292,  293,  294,
  264,  296,  297,  284,   -1,  286,  287,   -1,  289,  290,
  291,  292,  293,  294,   -1,  296,  297,   -1,   -1,   -1,
   -1,   -1,  286,  287,   -1,  289,  290,  291,  292,  293,
  294,   -1,  296,  297,  298,  299,  300,  301,  257,  258,
   -1,  260,   -1,  262,   -1,  264,   -1,  266,   -1,  257,
  258,   -1,  260,   -1,  262,   -1,  264,   -1,  266,   -1,
   -1,   -1,   -1,   -1,   -1,  284,   -1,  286,  287,   -1,
  289,  290,  291,  292,  293,  294,  284,   -1,  286,  287,
  257,  258,   -1,  260,   -1,  262,   -1,  264,   -1,  266,
  257,  258,   -1,  260,   -1,  262,   -1,  264,   -1,  266,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  284,   -1,  286,
  287,   -1,   -1,   -1,   -1,   -1,   -1,  284,   -1,  286,
  287,  257,  258,   -1,  260,   -1,  262,   -1,  264,   -1,
  266,  257,  258,   -1,  260,   -1,  262,   -1,  264,   -1,
  266,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  284,   -1,
  286,  287,   -1,   -1,   -1,   -1,   -1,   -1,  284,   -1,
  286,  287,  257,  258,   -1,  260,   -1,  262,   -1,  264,
   -1,  266,  257,  258,   -1,  260,   -1,  262,   -1,  264,
   -1,  266,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  284,
   -1,  286,  287,   -1,   -1,   -1,   -1,   -1,   -1,  284,
   -1,  286,  286,  287,   -1,  289,  290,  291,  292,  293,
  294,   -1,  296,  297,  298,  299,  300,  301,  287,   -1,
  289,  290,  291,  292,  293,  294,   -1,  296,  297,  298,
  299,  300,  301,  289,  290,  291,  292,  293,  294,   -1,
  296,  297,  298,  299,  300,  301,
};
#define YYFINAL 1
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 304
#if YYDEBUG
const char * const 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,"COMMA","SEMICOLON","LPAR","RPAR",
"LBRACE","RBRACE","LBRACKET","RBRACKET","DOT","NEWLINE","LETTER","NUMBER",
"STRING","DEFINE","BREAK","QUIT","LENGTH","RETURN","FOR","IF","WHILE","SQRT",
"SCALE","IBASE","OBASE","AUTO","CONTINUE","ELSE","PRINT","BOOL_OR","BOOL_AND",
"BOOL_NOT","EQUALS","LESS_EQ","GREATER_EQ","UNEQUALS","LESS","GREATER",
"ASSIGN_OP","PLUS","MINUS","MULTIPLY","DIVIDE","REMAINDER","EXPONENT","UMINUS",
"INCR","DECR",
};
const char * const yyrule[] =
	{"$accept : program",
"program :",
"program : program input_item",
"input_item : semicolon_list NEWLINE",
"input_item : function",
"input_item : error NEWLINE",
"input_item : error QUIT",
"semicolon_list :",
"semicolon_list : statement",
"semicolon_list : semicolon_list SEMICOLON statement",
"semicolon_list : semicolon_list SEMICOLON",
"statement_list :",
"statement_list : statement",
"statement_list : statement_list NEWLINE",
"statement_list : statement_list NEWLINE statement",
"statement_list : statement_list SEMICOLON",
"statement_list : statement_list SEMICOLON statement",
"opt_statement :",
"opt_statement : statement",
"statement : expression",
"statement : named_expression ASSIGN_OP expression",
"statement : STRING",
"statement : BREAK",
"statement : CONTINUE",
"statement : QUIT",
"statement : RETURN return_expression",
"statement : FOR LPAR alloc_macro opt_expression SEMICOLON opt_relational_expression SEMICOLON opt_expression RPAR opt_statement pop_nesting",
"statement : IF LPAR alloc_macro pop_nesting relational_expression RPAR opt_statement",
"statement : IF LPAR alloc_macro pop_nesting relational_expression RPAR opt_statement ELSE alloc_macro pop_nesting opt_statement",
"statement : WHILE LPAR alloc_macro relational_expression RPAR opt_statement pop_nesting",
"statement : LBRACE statement_list RBRACE",
"statement : PRINT print_expression_list",
"alloc_macro :",
"pop_nesting :",
"function : function_header opt_parameter_list RPAR opt_newline LBRACE NEWLINE opt_auto_define_list statement_list RBRACE",
"function_header : DEFINE LETTER LPAR",
"opt_newline :",
"opt_newline : NEWLINE",
"opt_parameter_list :",
"opt_parameter_list : parameter_list",
"parameter_list : LETTER",
"parameter_list : LETTER LBRACKET RBRACKET",
"parameter_list : parameter_list COMMA LETTER",
"parameter_list : parameter_list COMMA LETTER LBRACKET RBRACKET",
"opt_auto_define_list :",
"opt_auto_define_list : AUTO define_list NEWLINE",
"opt_auto_define_list : AUTO define_list SEMICOLON",
"define_list : LETTER",
"define_list : LETTER LBRACKET RBRACKET",
"define_list : define_list COMMA LETTER",
"define_list : define_list COMMA LETTER LBRACKET RBRACKET",
"opt_argument_list :",
"opt_argument_list : argument_list",
"argument_list : expression",
"argument_list : argument_list COMMA expression",
"argument_list : argument_list COMMA LETTER LBRACKET RBRACKET",
"opt_relational_expression :",
"opt_relational_expression : relational_expression",
"relational_expression : expression EQUALS expression",
"relational_expression : expression UNEQUALS expression",
"relational_expression : expression LESS expression",
"relational_expression : expression LESS_EQ expression",
"relational_expression : expression GREATER expression",
"relational_expression : expression GREATER_EQ expression",
"relational_expression : expression",
"return_expression :",
"return_expression : expression",
"return_expression : LPAR RPAR",
"opt_expression :",
"opt_expression : expression",
"expression : named_expression",
"expression : DOT",
"expression : NUMBER",
"expression : LPAR expression RPAR",
"expression : LETTER LPAR opt_argument_list RPAR",
"expression : MINUS expression",
"expression : expression PLUS expression",
"expression : expression MINUS expression",
"expression : expression MULTIPLY expression",
"expression : expression DIVIDE expression",
"expression : expression REMAINDER expression",
"expression : expression EXPONENT expression",
"expression : INCR named_expression",
"expression : DECR named_expression",
"expression : named_expression INCR",
"expression : named_expression DECR",
"expression : named_expression ASSIGN_OP expression",
"expression : LENGTH LPAR expression RPAR",
"expression : SQRT LPAR expression RPAR",
"expression : SCALE LPAR expression RPAR",
"expression : BOOL_NOT expression",
"expression : expression BOOL_AND alloc_macro pop_nesting expression",
"expression : expression BOOL_OR alloc_macro pop_nesting expression",
"expression : expression EQUALS expression",
"expression : expression UNEQUALS expression",
"expression : expression LESS expression",
"expression : expression LESS_EQ expression",
"expression : expression GREATER expression",
"expression : expression GREATER_EQ expression",
"named_expression : LETTER",
"named_expression : LETTER LBRACKET expression RBRACKET",
"named_expression : SCALE",
"named_expression : IBASE",
"named_expression : OBASE",
"print_expression_list : print_expression",
"print_expression_list : print_expression_list COMMA print_expression",
"print_expression : expression",
"print_expression : STRING",
};
#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
/* LINTUSED */
int yydebug;
int yynerrs;
int yyerrflag;
int yychar;
short *yyssp;
YYSTYPE *yyvsp;
YYSTYPE yyval;
YYSTYPE yylval;
short *yyss;
short *yysslim;
YYSTYPE *yyvs;
unsigned int yystacksize;
int yyparse(void);
#line 743 "/usr/src/usr.bin/bc/bc.y"


static void
grow(void)
{
	struct tree	*p;
	size_t		newsize;

	if (current == instr_sz) {
		newsize = instr_sz * 2 + 1;
		p = reallocarray(instructions, newsize, sizeof(*p));
		if (p == NULL) {
			free(instructions);
			err(1, NULL);
		}
		instructions = p;
		instr_sz = newsize;
	}
}

static ssize_t
cs(const char *str)
{
	grow();
	instructions[current].index = CONST_STRING;
	instructions[current].u.cstr = str;
	return current++;
}

static ssize_t
as(const char *str)
{
	grow();
	instructions[current].index = ALLOC_STRING;
	instructions[current].u.astr = strdup(str);
	if (instructions[current].u.astr == NULL)
		err(1, NULL);
	return current++;
}

static ssize_t
node(ssize_t arg, ...)
{
	va_list		ap;
	ssize_t		ret;

	va_start(ap, arg);

	ret = current;
	grow();
	instructions[current++].index = arg;

	do {
		arg = va_arg(ap, ssize_t);
		grow();
		instructions[current++].index = arg;
	} while (arg != END_NODE);

	va_end(ap);
	return ret;
}

static void
emit(ssize_t i, int level)
{
	if (level > 1000)
		errx(1, "internal error: tree level > 1000");
	if (instructions[i].index >= 0) {
		while (instructions[i].index != END_NODE &&
		    instructions[i].index != i)  {
			emit(instructions[i].index, level + 1);
			i++;
		}
	} else if (instructions[i].index != END_NODE)
		fputs(instructions[i].u.cstr, stdout);
}

static void
emit_macro(int node, ssize_t code)
{
	putchar('[');
	emit(code, 0);
	printf("]s%s\n", instructions[node].u.cstr);
	nesting--;
}

static void
free_tree(void)
{
	ssize_t i;

	for (i = 0; i < current; i++)
		if (instructions[i].index == ALLOC_STRING)
			free(instructions[i].u.astr);
	current = 0;
}

static ssize_t
numnode(int num)
{
	const char *p;

	if (num < 10)
		p = str_table['0' + num];
	else if (num < 16)
		p = str_table['A' - 10 + num];
	else
		errx(1, "internal error: break num > 15");
	return node(cs(" "), cs(p), END_NODE);
}


static ssize_t
lookup(char * str, size_t len, char type)
{
	ENTRY	entry, *found;
	u_short	num;
	u_char	*p;

	/* The scanner allocated an extra byte already */
	if (str[len-1] != type) {
		str[len] = type;
		str[len+1] = '\0';
	}
	entry.key = str;
	found = hsearch(entry, FIND);
	if (found == NULL) {
		if (var_count == MAX_VARIABLES)
			errx(1, "too many variables");
		p = malloc(4);
		if (p == NULL)
			err(1, NULL);
		num = var_count++;
		p[0] = 255;
		p[1] = ENCODE(num / VAR_BASE + 1);
		p[2] = ENCODE(num % VAR_BASE + 1);
		p[3] = '\0';

		entry.data = (char *)p;
		entry.key = strdup(str);
		if (entry.key == NULL)
			err(1, NULL);
		found = hsearch(entry, ENTER);
		if (found == NULL)
			err(1, NULL);
	}
	return cs(found->data);
}

static ssize_t
letter_node(char *str)
{
	size_t len;

	len = strlen(str);
	if (len == 1 && str[0] != '_')
		return cs(str_table[(int)str[0]]);
	else
		return lookup(str, len, 'L');
}

static ssize_t
array_node(char *str)
{
	size_t len;

	len = strlen(str);
	if (len == 1 && str[0] != '_')
		return cs(str_table[(int)str[0] - 'a' + ARRAY_CHAR]);
	else
		return lookup(str, len, 'A');
}

static ssize_t
function_node(char *str)
{
	size_t len;

	len = strlen(str);
	if (len == 1 && str[0] != '_')
		return cs(str_table[(int)str[0] - 'a' + FUNC_CHAR]);
	else
		return lookup(str, len, 'F');
}

static void
add_par(ssize_t n)
{
	prologue = node(cs("S"), n, prologue, END_NODE);
	epilogue = node(epilogue, cs("L"), n, cs("s."), END_NODE);
}

static void
add_local(ssize_t n)
{
	prologue = node(cs("0S"), n, prologue, END_NODE);
	epilogue = node(epilogue, cs("L"), n, cs("s."), END_NODE);
}

void
yyerror(char *s)
{
	char	*str, *p;
	int	n;

	if (yyin != NULL && feof(yyin))
		n = asprintf(&str, "%s: %s:%d: %s: unexpected EOF",
		    __progname, filename, lineno, s);
	else if (yytext[0] == '\n')
		n = asprintf(&str,
		    "%s: %s:%d: %s: newline unexpected",
		    __progname, filename, lineno, s);
	else if (isspace((unsigned char)yytext[0]) ||
	    !isprint((unsigned char)yytext[0]))
		n = asprintf(&str,
		    "%s: %s:%d: %s: ascii char 0x%02x unexpected",
		    __progname, filename, lineno, s, yytext[0] & 0xff);
	else
		n = asprintf(&str, "%s: %s:%d: %s: %s unexpected",
		    __progname, filename, lineno, s, yytext);
	if (n == -1)
		err(1, NULL);

	fputs("c[", stdout);
	for (p = str; *p != '\0'; p++) {
		if (*p == '[' || *p == ']' || *p =='\\')
			putchar('\\');
		putchar(*p);
	}
	fputs("]ec\n", stdout);
	free(str);
}

void
fatal(const char *s)
{
	errx(1, "%s:%d: %s", filename, lineno, s);
}

static void
warning(const char *s)
{
	warnx("%s:%d: %s", filename, lineno, s);
}

static void
init(void)
{
	int i;

	for (i = 0; i < UCHAR_MAX; i++) {
		str_table[i][0] = i;
		str_table[i][1] = '\0';
	}
	if (hcreate(1 << 16) == 0)
		err(1, NULL);
}


static __dead void
usage(void)
{
	fprintf(stderr, "usage: %s [-cl] [-e expression] [file ...]\n",
	    __progname);
	exit(1);
}

static char *
escape(const char *str)
{
	char *ret, *p;

	ret = malloc(strlen(str) + 1);
	if (ret == NULL)
		err(1, NULL);

	p = ret;
	while (*str != '\0') {
		/*
		 * We get _escaped_ strings here. Single backslashes are
		 * already converted to double backslashes
		 */
		if (*str == '\\') {
			if (*++str == '\\') {
				switch (*++str) {
				case 'a':
					*p++ = '\a';
					break;
				case 'b':
					*p++ = '\b';
					break;
				case 'f':
					*p++ = '\f';
					break;
				case 'n':
					*p++ = '\n';
					break;
				case 'q':
					*p++ = '"';
					break;
				case 'r':
					*p++ = '\r';
					break;
				case 't':
					*p++ = '\t';
					break;
				case '\\':
					*p++ = '\\';
					break;
				}
				str++;
			} else {
				*p++ = '\\';
				*p++ = *str++;
			}
		} else
			*p++ = *str++;
	}
	*p = '\0';
	return ret;
}

/* ARGSUSED */
static void
sigchld(int signo)
{
	pid_t pid;
	int status, save_errno = errno;

	for (;;) {
		pid = waitpid(dc, &status, WCONTINUED | WNOHANG);
		if (pid == -1) {
			if (errno == EINTR)
				continue;
			_exit(0);
		} else if (pid == 0)
			break;
		if (WIFEXITED(status) || WIFSIGNALED(status))
			_exit(0);
		else
			break;
	}
	errno = save_errno;
}

static const char *
dummy_prompt(void)
{

        return ("");
}

int
main(int argc, char *argv[])
{
	int	i, ch;
	int	p[2];
	char	*q;

	if (pledge("stdio rpath wpath cpath flock rpath proc tty", NULL) == -1)
		err(1, "pledge");

	init();
	setvbuf(stdout, NULL, _IOLBF, 0);

	sargv = reallocarray(NULL, argc, sizeof(char *));
	if (sargv == NULL)
		err(1, NULL);

	if ((cmdexpr = strdup("")) == NULL)
		err(1, NULL);
	/* The d debug option is 4.4 BSD bc(1) compatible */
	while ((ch = getopt(argc, argv, "cde:l")) != -1) {
		switch (ch) {
		case 'c':
		case 'd':
			do_fork = false;
			break;
		case 'e':
			q = cmdexpr;
			if (asprintf(&cmdexpr, "%s%s\n", cmdexpr, optarg) == -1)
				err(1, NULL);
			free(q);
			break;
		case 'l':
			sargv[sargc++] = _PATH_LIBB;
			break;
		default:
			usage();
		}
	}

	argc -= optind;
	argv += optind;

	interactive = isatty(STDIN_FILENO) && isatty(STDOUT_FILENO) &&
	    isatty(STDERR_FILENO);
	for (i = 0; i < argc; i++)
		sargv[sargc++] = argv[i];

	if (do_fork) {
		if (pipe(p) == -1)
			err(1, "cannot create pipe");
		dc = fork();
		if (dc == -1)
			err(1, "cannot fork");
		else if (dc != 0) {
			signal(SIGCHLD, sigchld);
			close(STDOUT_FILENO);
			dup(p[1]);
			close(p[0]);
			close(p[1]);
		} else {
			char *dc_argv[] = { "dc", "-x", NULL };
			extern int dc_main(int, char **);

			if (pledge("flock rpath cpath wpath stdio", NULL) == -1)
				err(1, "pledge");

			close(STDIN_FILENO);
			dup(p[0]);
			close(p[0]);
			close(p[1]);

			exit (dc_main(2, dc_argv));
		}
	}
	if (interactive) {
		gettty(&ttysaved);
		el = el_init("bc", stdin, stderr, stderr);
		hist = history_init();
		history(hist, &he, H_SETSIZE, 100);
		el_set(el, EL_HIST, history, hist);
		el_set(el, EL_EDITOR, "emacs");
		el_set(el, EL_SIGNAL, 0);
		el_set(el, EL_PROMPT, dummy_prompt);
		el_set(el, EL_ADDFN, "bc_eof", "", bc_eof);
		el_set(el, EL_BIND, "^D", "bc_eof", NULL);
		el_source(el, NULL);
	}

	if (pledge("stdio rpath cpath wpath flock rpath tty", NULL) == -1)
		err(1, "pledge");

	yywrap();
	return yyparse();
}
#line 1129 "bc.c"
/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(void)
{
    unsigned int newsize;
    long sslen;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = yystacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;
    sslen = yyssp - yyss;
#ifdef SIZE_MAX
#define YY_SIZE_MAX SIZE_MAX
#else
#define YY_SIZE_MAX 0xffffffffU
#endif
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newss)
        goto bail;
    newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :
      (short *)malloc(newsize * sizeof *newss); /* overflow check above */
    if (newss == NULL)
        goto bail;
    yyss = newss;
    yyssp = newss + sslen;
    if (newsize && YY_SIZE_MAX / newsize < sizeof *newvs)
        goto bail;
    newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :
      (YYSTYPE *)malloc(newsize * sizeof *newvs); /* overflow check above */
    if (newvs == NULL)
        goto bail;
    yyvs = newvs;
    yyvsp = newvs + sslen;
    yystacksize = newsize;
    yysslim = yyss + newsize - 1;
    return 0;
bail:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return -1;
}

#define YYABORT goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR goto yyerrlab
int
yyparse(void)
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")))
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif /* YYDEBUG */

    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;
#if defined(__GNUC__)
    goto yynewerror;
#endif
yynewerror:
    yyerror("syntax error");
#if defined(__GNUC__)
    goto yyerrlab;
#endif
yyerrlab:
    ++yynerrs;
yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
#endif
                if (yyssp >= 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];
    if (yym)
        yyval = yyvsp[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 3:
#line 177 "/usr/src/usr.bin/bc/bc.y"
{
				emit(yyvsp[-1].node, 0);
				macro_char = reset_macro_char;
				putchar('\n');
				free_tree();
				st_has_continue = false;
			}
break;
case 4:
#line 185 "/usr/src/usr.bin/bc/bc.y"
{
				putchar('\n');
				free_tree();
				st_has_continue = false;
			}
break;
case 5:
#line 191 "/usr/src/usr.bin/bc/bc.y"
{
				yyerrok;
			}
break;
case 6:
#line 195 "/usr/src/usr.bin/bc/bc.y"
{
				yyerrok;
			}
break;
case 7:
#line 201 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs("");
			}
break;
case 9:
#line 206 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, END_NODE);
			}
break;
case 11:
#line 213 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs("");
			}
break;
case 14:
#line 219 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, END_NODE);
			}
break;
case 16:
#line 224 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, END_NODE);
			}
break;
case 17:
#line 231 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs("");
			}
break;
case 19:
#line 238 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, cs("ps."), END_NODE);
			}
break;
case 20:
#line 242 "/usr/src/usr.bin/bc/bc.y"
{
				if (yyvsp[-1].str[0] == '\0')
					yyval.node = node(yyvsp[0].node, cs(yyvsp[-1].str), yyvsp[-2].lvalue.store,
					    END_NODE);
				else
					yyval.node = node(yyvsp[-2].lvalue.load, yyvsp[0].node, cs(yyvsp[-1].str), yyvsp[-2].lvalue.store,
					    END_NODE);
			}
break;
case 21:
#line 251 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs("["), as(yyvsp[0].str),
				    cs("]P"), END_NODE);
			}
break;
case 22:
#line 256 "/usr/src/usr.bin/bc/bc.y"
{
				if (breaksp == 0) {
					warning("break not in for or while");
					YYERROR;
				} else {
					yyval.node = node(
					    numnode(nesting -
						breakstack[breaksp-1]),
					    cs("Q"), END_NODE);
				}
			}
break;
case 23:
#line 268 "/usr/src/usr.bin/bc/bc.y"
{
				if (breaksp == 0) {
					warning("continue not in for or while");
					YYERROR;
				} else {
					st_has_continue = true;
					yyval.node = node(numnode(nesting -
					    breakstack[breaksp-1] - 1),
					    cs("J"), END_NODE);
				}
			}
break;
case 24:
#line 280 "/usr/src/usr.bin/bc/bc.y"
{
				sigset_t mask;

				putchar('q');
				fflush(stdout);
				if (dc) {
					sigprocmask(SIG_BLOCK, NULL, &mask);
					sigsuspend(&mask);
				} else
					exit(0);
			}
break;
case 25:
#line 292 "/usr/src/usr.bin/bc/bc.y"
{
				if (nesting == 0) {
					warning("return must be in a function");
					YYERROR;
				}
				yyval.node = yyvsp[0].node;
			}
break;
case 26:
#line 302 "/usr/src/usr.bin/bc/bc.y"
{
				ssize_t n;

				if (st_has_continue)
					n = node(yyvsp[-1].node, cs("M"), yyvsp[-3].node, cs("s."),
					    yyvsp[-5].node, yyvsp[-8].node, END_NODE);
				else
					n = node(yyvsp[-1].node, yyvsp[-3].node, cs("s."), yyvsp[-5].node, yyvsp[-8].node,
					    END_NODE);

				emit_macro(yyvsp[-8].node, n);
				yyval.node = node(yyvsp[-7].node, cs("s."), yyvsp[-5].node, yyvsp[-8].node, cs(" "),
				    END_NODE);
			}
break;
case 27:
#line 318 "/usr/src/usr.bin/bc/bc.y"
{
				emit_macro(yyvsp[-4].node, yyvsp[0].node);
				yyval.node = node(yyvsp[-2].node, yyvsp[-4].node, cs(" "), END_NODE);
			}
break;
case 28:
#line 324 "/usr/src/usr.bin/bc/bc.y"
{
				emit_macro(yyvsp[-8].node, yyvsp[-4].node);
				emit_macro(yyvsp[-2].node, yyvsp[0].node);
				yyval.node = node(yyvsp[-6].node, yyvsp[-8].node, cs("e"), yyvsp[-2].node, cs(" "),
				    END_NODE);
			}
break;
case 29:
#line 332 "/usr/src/usr.bin/bc/bc.y"
{
				ssize_t n;

				if (st_has_continue)
					n = node(yyvsp[-1].node, cs("M"), yyvsp[-3].node, yyvsp[-4].node, END_NODE);
				else
					n = node(yyvsp[-1].node, yyvsp[-3].node, yyvsp[-4].node, END_NODE);
				emit_macro(yyvsp[-4].node, n);
				yyval.node = node(yyvsp[-3].node, yyvsp[-4].node, cs(" "), END_NODE);
			}
break;
case 30:
#line 343 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = yyvsp[-1].node;
			}
break;
case 31:
#line 347 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = yyvsp[0].node;
			}
break;
case 32:
#line 353 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs(str_table[macro_char]);
				macro_char++;
				/* Do not use [, \ and ] */
				if (macro_char == '[')
					macro_char += 3;
				/* skip letters */
				else if (macro_char == 'a')
					macro_char = '{';
				else if (macro_char == ARRAY_CHAR)
					macro_char += 26;
				else if (macro_char == 255)
					fatal("program too big");
				if (breaksp == BREAKSTACK_SZ)
					fatal("nesting too deep");
				breakstack[breaksp++] = nesting++;
			}
break;
case 33:
#line 373 "/usr/src/usr.bin/bc/bc.y"
{
				breaksp--;
			}
break;
case 34:
#line 381 "/usr/src/usr.bin/bc/bc.y"
{
				int n = node(prologue, yyvsp[-1].node, epilogue,
				    cs("0"), numnode(nesting),
				    cs("Q"), END_NODE);
				emit_macro(yyvsp[-8].node, n);
				reset_macro_char = macro_char;
				nesting = 0;
				breaksp = 0;
			}
break;
case 35:
#line 393 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = function_node(yyvsp[-1].astr);
				free(yyvsp[-1].astr);
				prologue = cs("");
				epilogue = cs("");
				nesting = 1;
				breaksp = 0;
				breakstack[breaksp] = 0;
			}
break;
case 40:
#line 415 "/usr/src/usr.bin/bc/bc.y"
{
				add_par(letter_node(yyvsp[0].astr));
				free(yyvsp[0].astr);
			}
break;
case 41:
#line 420 "/usr/src/usr.bin/bc/bc.y"
{
				add_par(array_node(yyvsp[-2].astr));
				free(yyvsp[-2].astr);
			}
break;
case 42:
#line 425 "/usr/src/usr.bin/bc/bc.y"
{
				add_par(letter_node(yyvsp[0].astr));
				free(yyvsp[0].astr);
			}
break;
case 43:
#line 430 "/usr/src/usr.bin/bc/bc.y"
{
				add_par(array_node(yyvsp[-2].astr));
				free(yyvsp[-2].astr);
			}
break;
case 47:
#line 446 "/usr/src/usr.bin/bc/bc.y"
{
				add_local(letter_node(yyvsp[0].astr));
				free(yyvsp[0].astr);
			}
break;
case 48:
#line 451 "/usr/src/usr.bin/bc/bc.y"
{
				add_local(array_node(yyvsp[-2].astr));
				free(yyvsp[-2].astr);
			}
break;
case 49:
#line 456 "/usr/src/usr.bin/bc/bc.y"
{
				add_local(letter_node(yyvsp[0].astr));
				free(yyvsp[0].astr);
			}
break;
case 50:
#line 461 "/usr/src/usr.bin/bc/bc.y"
{
				add_local(array_node(yyvsp[-2].astr));
				free(yyvsp[-2].astr);
			}
break;
case 51:
#line 470 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs("");
			}
break;
case 54:
#line 479 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, END_NODE);
			}
break;
case 55:
#line 483 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-4].node, cs("l"), array_node(yyvsp[-2].astr),
				    END_NODE);
				free(yyvsp[-2].astr);
			}
break;
case 56:
#line 492 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs(" 0 0=");
			}
break;
case 58:
#line 500 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("="), END_NODE);
			}
break;
case 59:
#line 504 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("!="), END_NODE);
			}
break;
case 60:
#line 508 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs(">"), END_NODE);
			}
break;
case 61:
#line 512 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("!<"), END_NODE);
			}
break;
case 62:
#line 516 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("<"), END_NODE);
			}
break;
case 63:
#line 520 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("!>"), END_NODE);
			}
break;
case 64:
#line 524 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, cs(" 0!="), END_NODE);
			}
break;
case 65:
#line 532 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs("0"), epilogue,
				    numnode(nesting), cs("Q"), END_NODE);
			}
break;
case 66:
#line 537 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, epilogue,
				    numnode(nesting), cs("Q"), END_NODE);
			}
break;
case 67:
#line 542 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs("0"), epilogue,
				    numnode(nesting), cs("Q"), END_NODE);
			}
break;
case 68:
#line 550 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = cs(" 0");
			}
break;
case 70:
#line 557 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].lvalue.load, END_NODE);
			}
break;
case 71:
#line 560 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs("l."), END_NODE);
			}
break;
case 72:
#line 564 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs(" "), as(yyvsp[0].str), END_NODE);
			}
break;
case 73:
#line 568 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = yyvsp[-1].node;
			}
break;
case 74:
#line 572 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].node, cs("l"),
				    function_node(yyvsp[-3].astr), cs("x"),
				    END_NODE);
				free(yyvsp[-3].astr);
			}
break;
case 75:
#line 579 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(cs(" 0"), yyvsp[0].node, cs("-"),
				    END_NODE);
			}
break;
case 76:
#line 584 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("+"), END_NODE);
			}
break;
case 77:
#line 588 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("-"), END_NODE);
			}
break;
case 78:
#line 592 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("*"), END_NODE);
			}
break;
case 79:
#line 596 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("/"), END_NODE);
			}
break;
case 80:
#line 600 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("%"), END_NODE);
			}
break;
case 81:
#line 604 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("^"), END_NODE);
			}
break;
case 82:
#line 608 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].lvalue.load, cs("1+d"), yyvsp[0].lvalue.store,
				    END_NODE);
			}
break;
case 83:
#line 613 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].lvalue.load, cs("1-d"),
				    yyvsp[0].lvalue.store, END_NODE);
			}
break;
case 84:
#line 618 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].lvalue.load, cs("d1+"),
				    yyvsp[-1].lvalue.store, END_NODE);
			}
break;
case 85:
#line 623 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].lvalue.load, cs("d1-"),
				    yyvsp[-1].lvalue.store, END_NODE);
			}
break;
case 86:
#line 628 "/usr/src/usr.bin/bc/bc.y"
{
				if (yyvsp[-1].str[0] == '\0')
					yyval.node = node(yyvsp[0].node, cs(yyvsp[-1].str), cs("d"), yyvsp[-2].lvalue.store,
					    END_NODE);
				else
					yyval.node = node(yyvsp[-2].lvalue.load, yyvsp[0].node, cs(yyvsp[-1].str), cs("d"),
					    yyvsp[-2].lvalue.store, END_NODE);
			}
break;
case 87:
#line 637 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].node, cs("Z"), END_NODE);
			}
break;
case 88:
#line 641 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].node, cs("v"), END_NODE);
			}
break;
case 89:
#line 645 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-1].node, cs("X"), END_NODE);
			}
break;
case 90:
#line 649 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, cs("N"), END_NODE);
			}
break;
case 91:
#line 653 "/usr/src/usr.bin/bc/bc.y"
{
				ssize_t n = node(cs("R"), yyvsp[0].node, END_NODE);
				emit_macro(yyvsp[-2].node, n);
				yyval.node = node(yyvsp[-4].node, cs("d0!="), yyvsp[-2].node, END_NODE);
			}
break;
case 92:
#line 659 "/usr/src/usr.bin/bc/bc.y"
{
				ssize_t n = node(cs("R"), yyvsp[0].node, END_NODE);
				emit_macro(yyvsp[-2].node, n);
				yyval.node = node(yyvsp[-4].node, cs("d0="), yyvsp[-2].node, END_NODE);
			}
break;
case 93:
#line 665 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("G"), END_NODE);
			}
break;
case 94:
#line 669 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("GN"), END_NODE);
			}
break;
case 95:
#line 673 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, yyvsp[-2].node, cs("("), END_NODE);
			}
break;
case 96:
#line 677 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, yyvsp[-2].node, cs("{"), END_NODE);
			}
break;
case 97:
#line 681 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("("), END_NODE);
			}
break;
case 98:
#line 685 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, cs("{"), END_NODE);
			}
break;
case 99:
#line 692 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.lvalue.load = node(cs("l"), letter_node(yyvsp[0].astr),
				    END_NODE);
				yyval.lvalue.store = node(cs("s"), letter_node(yyvsp[0].astr),
				    END_NODE);
				free(yyvsp[0].astr);
			}
break;
case 100:
#line 700 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.lvalue.load = node(yyvsp[-1].node, cs(";"),
				    array_node(yyvsp[-3].astr), END_NODE);
				yyval.lvalue.store = node(yyvsp[-1].node, cs(":"),
				    array_node(yyvsp[-3].astr), END_NODE);
				free(yyvsp[-3].astr);
			}
break;
case 101:
#line 708 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.lvalue.load = cs("K");
				yyval.lvalue.store = cs("k");
			}
break;
case 102:
#line 713 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.lvalue.load = cs("I");
				yyval.lvalue.store = cs("i");
			}
break;
case 103:
#line 718 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.lvalue.load = cs("O");
				yyval.lvalue.store = cs("o");
			}
break;
case 105:
#line 727 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[-2].node, yyvsp[0].node, END_NODE);
			}
break;
case 106:
#line 733 "/usr/src/usr.bin/bc/bc.y"
{
				yyval.node = node(yyvsp[0].node, cs("ds.n"), END_NODE);
			}
break;
case 107:
#line 737 "/usr/src/usr.bin/bc/bc.y"
{
				char *p = escape(yyvsp[0].str);
				yyval.node = node(cs("["), as(p), cs("]n"), END_NODE);
				free(p);
			}
break;
#line 1976 "bc.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:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (1);
yyaccept:
    if (yyss)
            free(yyss);
    if (yyvs)
            free(yyvs);
    yyss = yyssp = NULL;
    yyvs = yyvsp = NULL;
    yystacksize = 0;
    return (0);
}

Generated by: GCOVR (Version 3.3)