Migrate most of tools/regression/usr.bin/ to the new tests layout.

I'm starting with the easy cases.  The leftovers need to be looked at a
bit more closely.

Note that this change _does_ modify the code of the old tests.  This is
required in order to allow the code to locate the data files in the
source directory instead of the current directory, because Kyua
automatically changes the latter to a temporary directory.

Also note that at least one test is known to be broken here.  Actually,
the test is not really broken: it's marked as a TODO but unfortunately
Kyua's TAP parser currently does not understand that.  Will have to be
fixed separately.

34 files changed, 15082 insertions, 0 deletions

diff --git a/usr.bin/yacc/tests/Makefile b/usr.bin/yacc/tests/Makefile
new file mode 100644
index 000000000000..f8b7d85249c9
--- /dev/null
+++ b/usr.bin/yacc/tests/Makefile
@@ -0,0 +1,41 @@
+# $FreeBSD$
+
+TESTSDIR=	${TESTSBASE}/usr.bin/yacc
+
+TAP_TESTS_SH=	legacy_test
+
+FILESDIR=	${TESTSDIR}
+FILES=		calc.y
+FILES+=		calc1.y
+FILES+=		calc2.y
+FILES+=		calc3.y
+FILES+=		code_calc.y
+FILES+=		code_error.y
+FILES+=		error.y
+FILES+=		ftp.y
+FILES+=		grammar.y
+FILES+=		pure_calc.y
+FILES+=		pure_error.y
+FILES+=		quote_calc.y
+FILES+=		quote_calc2.y
+FILES+=		quote_calc3.y
+FILES+=		quote_calc4.y
+FILES+=		regress.00.out
+FILES+=		regress.01.out
+FILES+=		regress.02.out
+FILES+=		regress.03.out
+FILES+=		regress.04.out
+FILES+=		regress.05.out
+FILES+=		regress.06.out
+FILES+=		regress.07.out
+FILES+=		regress.08.out
+FILES+=		regress.09.out
+FILES+=		regress.10.out
+FILES+=		regress.11.out
+FILES+=		regress.12.out
+FILES+=		regress.13.out
+FILES+=		regress.14.out
+FILES+=		regress.sh
+FILES+=		undefined.y
+
+.include <bsd.test.mk>
diff --git a/usr.bin/yacc/tests/calc.y b/usr.bin/yacc/tests/calc.y
new file mode 100644
index 000000000000..c2e5a898c93d
--- /dev/null
+++ b/usr.bin/yacc/tests/calc.y
@@ -0,0 +1,106 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+extern int yylex(void);
+static void yyerror(const char *s);
+
+%}
+
+%start list
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr '+' expr
+            {  $$ = $1 + $3; }
+      |  expr '-' expr
+            {  $$ = $1 - $3; }
+      |  expr '*' expr
+            {  $$ = $1 * $3; }
+      |  expr '/' expr
+            {  $$ = $1 / $3; }
+      |  expr '%' expr
+            {  $$ = $1 % $3; }
+      |  expr '&' expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  '-' expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/calc1.y b/usr.bin/yacc/tests/calc1.y
new file mode 100644
index 000000000000..ec89736f47a5
--- /dev/null
+++ b/usr.bin/yacc/tests/calc1.y
@@ -0,0 +1,305 @@
+%{
+
+/* http://dinosaur.compilertools.net/yacc/index.html */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+
+typedef struct interval
+{
+    double lo, hi;
+}
+INTERVAL;
+
+INTERVAL vmul(double, double, INTERVAL);
+INTERVAL vdiv(double, double, INTERVAL);
+
+extern int yylex(void);
+static void yyerror(const char *s);
+
+int dcheck(INTERVAL);
+
+double dreg[26];
+INTERVAL vreg[26];
+
+%}
+%expect 18
+
+%start line
+%union
+{
+	int ival;
+	double dval;
+	INTERVAL vval;
+}
+
+%token <ival> DREG VREG		/* indices into dreg, vreg arrays */
+%token <dval> CONST		/* floating point constant */
+
+%type <dval> dexp		/* expression */
+%type <vval> vexp		/* interval expression */
+
+	/* precedence information about the operators */
+
+%left '+' '-'
+%left '*' '/'
+%left UMINUS			/* precedence for unary minus */
+
+%%	/* beginning of rules section */
+
+lines   : /* empty */
+	| lines line
+	;
+
+line	: dexp '\n'
+	{
+		(void) printf("%15.8f\n", $1);
+	}
+	| vexp '\n'
+	{
+		(void) printf("(%15.8f, %15.8f)\n", $1.lo, $1.hi);
+	}
+	| DREG '=' dexp '\n'
+	{
+		dreg[$1] = $3;
+	}
+	| VREG '=' vexp '\n'
+	{
+		vreg[$1] = $3;
+	}
+	| error '\n'
+	{
+		yyerrok;
+	}
+	;
+
+dexp	: CONST
+	| DREG
+	{
+		$$ = dreg[$1];
+	}
+	| dexp '+' dexp
+	{
+		$$ = $1 + $3;
+	}
+	| dexp '-' dexp
+	{
+		$$ = $1 - $3;
+	}
+	| dexp '*' dexp
+	{
+		$$ = $1 * $3;
+	}
+	| dexp '/' dexp
+	{
+		$$ = $1 / $3;
+	}
+	| '-' dexp %prec UMINUS
+	{
+		$$ = -$2;
+	}
+	| '(' dexp ')'
+	{
+		$$ = $2;
+	}
+	;
+
+vexp	: dexp
+	{
+		$$.hi = $$.lo = $1;
+	}
+	| '(' dexp ',' dexp ')'
+	{
+		$$.lo = $2;
+		$$.hi = $4;
+		if ( $$.lo > $$.hi ) 
+		{
+			(void) printf("interval out of order\n");
+			YYERROR;
+		}
+	}
+	| VREG
+	{
+		$$ = vreg[$1];
+	}
+	| vexp '+' vexp
+	{
+		$$.hi = $1.hi + $3.hi;
+		$$.lo = $1.lo + $3.lo;
+	}
+	| dexp '+' vexp
+	{
+		$$.hi = $1 + $3.hi;
+		$$.lo = $1 + $3.lo;
+	}
+	| vexp '-' vexp
+	{
+		$$.hi = $1.hi - $3.lo;
+		$$.lo = $1.lo - $3.hi;
+	}
+	| dexp '-' vexp
+	{
+		$$.hi = $1 - $3.lo;
+		$$.lo = $1 - $3.hi;
+	}
+	| vexp '*' vexp
+	{
+		$$ = vmul( $1.lo, $1.hi, $3 );
+	}
+	| dexp '*' vexp
+	{
+		$$ = vmul ($1, $1, $3 );
+	}
+	| vexp '/' vexp
+	{
+		if (dcheck($3)) YYERROR;
+		$$ = vdiv ( $1.lo, $1.hi, $3 );
+	}
+	| dexp '/' vexp
+	{
+		if (dcheck ( $3 )) YYERROR;
+		$$ = vdiv ($1, $1, $3 );
+	}
+	| '-' vexp %prec UMINUS
+	{
+		$$.hi = -$2.lo;
+		$$.lo = -$2.hi;
+	}
+	| '(' vexp ')'
+	{
+		$$ = $2;
+	}
+	;
+
+%%	/* beginning of subroutines section */
+
+#define BSZ 50			/* buffer size for floating point numbers */
+
+	/* lexical analysis */
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+    int c;
+
+    while ((c = getchar()) == ' ')
+    {				/* skip over blanks */
+    }
+
+    if (isupper(c))
+    {
+	yylval.ival = c - 'A';
+	return (VREG);
+    }
+    if (islower(c))
+    {
+	yylval.ival = c - 'a';
+	return (DREG);
+    }
+
+    if (isdigit(c) || c == '.')
+    {
+	/* gobble up digits, points, exponents */
+	char buf[BSZ + 1], *cp = buf;
+	int dot = 0, expr = 0;
+
+	for (; (cp - buf) < BSZ; ++cp, c = getchar())
+	{
+
+	    *cp = c;
+	    if (isdigit(c))
+		continue;
+	    if (c == '.')
+	    {
+		if (dot++ || expr)
+		    return ('.');	/* will cause syntax error */
+		continue;
+	    }
+
+	    if (c == 'e')
+	    {
+		if (expr++)
+		    return ('e');	/*  will  cause  syntax  error  */
+		continue;
+	    }
+
+	    /*  end  of  number  */
+	    break;
+	}
+	*cp = '\0';
+
+	if ((cp - buf) >= BSZ)
+	    printf("constant  too  long:  truncated\n");
+	else
+	    ungetc(c, stdin);	/*  push  back  last  char  read  */
+	yylval.dval = atof(buf);
+	return (CONST);
+    }
+    return (c);
+}
+
+static INTERVAL
+hilo(double a, double b, double c, double d)
+{
+    /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
+    /*  used  by  *,  /  routines  */
+    INTERVAL v;
+
+    if (a > b)
+    {
+	v.hi = a;
+	v.lo = b;
+    }
+    else
+    {
+	v.hi = b;
+	v.lo = a;
+    }
+
+    if (c > d)
+    {
+	if (c > v.hi)
+	    v.hi = c;
+	if (d < v.lo)
+	    v.lo = d;
+    }
+    else
+    {
+	if (d > v.hi)
+	    v.hi = d;
+	if (c < v.lo)
+	    v.lo = c;
+    }
+    return (v);
+}
+
+INTERVAL
+vmul(double a, double b, INTERVAL v)
+{
+    return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
+}
+
+int
+dcheck(INTERVAL v)
+{
+    if (v.hi >= 0. && v.lo <= 0.)
+    {
+	printf("divisor  interval  contains  0.\n");
+	return (1);
+    }
+    return (0);
+}
+
+INTERVAL
+vdiv(double a, double b, INTERVAL v)
+{
+    return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
+}
diff --git a/usr.bin/yacc/tests/calc2.y b/usr.bin/yacc/tests/calc2.y
new file mode 100644
index 000000000000..e742ff34c215
--- /dev/null
+++ b/usr.bin/yacc/tests/calc2.y
@@ -0,0 +1,120 @@
+%parse-param { int regs[26] }
+%parse-param { int *base }
+
+%lex-param { int *base }
+
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+#ifdef YYBISON
+#define YYLEX_PARAM base
+#define YYLEX_DECL() yylex(int *YYLEX_PARAM)
+#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+%}
+
+%start list
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr '+' expr
+            {  $$ = $1 + $3; }
+      |  expr '-' expr
+            {  $$ = $1 - $3; }
+      |  expr '*' expr
+            {  $$ = $1 * $3; }
+      |  expr '/' expr
+            {  $$ = $1 / $3; }
+      |  expr '%' expr
+            {  $$ = $1 % $3; }
+      |  expr '&' expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  '-' expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; (*base) = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = (*base) * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    int regs[26];
+    int base = 10;
+
+    while(!feof(stdin)) {
+	yyparse(regs, &base);
+    }
+    return 0;
+}
+
+static void
+YYERROR_DECL()
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+YYLEX_DECL()
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = (c - '0') % (*base);
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/calc3.y b/usr.bin/yacc/tests/calc3.y
new file mode 100644
index 000000000000..252faa961f4b
--- /dev/null
+++ b/usr.bin/yacc/tests/calc3.y
@@ -0,0 +1,123 @@
+%pure-parser
+
+%parse-param { int regs[26] }
+%parse-param { int *base }
+
+%lex-param { int *base }
+
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM base
+#define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
+#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+%}
+
+%start list
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr '+' expr
+            {  $$ = $1 + $3; }
+      |  expr '-' expr
+            {  $$ = $1 - $3; }
+      |  expr '*' expr
+            {  $$ = $1 * $3; }
+      |  expr '/' expr
+            {  $$ = $1 / $3; }
+      |  expr '%' expr
+            {  $$ = $1 % $3; }
+      |  expr '&' expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  '-' expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; (*base) = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = (*base) * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    int regs[26];
+    int base = 10;
+
+    while(!feof(stdin)) {
+	yyparse(regs, &base);
+    }
+    return 0;
+}
+
+static void
+YYERROR_DECL()
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+YYLEX_DECL()
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	*yylval = (c - 'a');
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	*yylval = (c - '0') % (*base);
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/code_calc.y b/usr.bin/yacc/tests/code_calc.y
new file mode 100644
index 000000000000..0a99456e7f89
--- /dev/null
+++ b/usr.bin/yacc/tests/code_calc.y
@@ -0,0 +1,112 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *s);
+#endif
+
+%}
+
+%start list
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr '+' expr
+            {  $$ = $1 + $3; }
+      |  expr '-' expr
+            {  $$ = $1 - $3; }
+      |  expr '*' expr
+            {  $$ = $1 * $3; }
+      |  expr '/' expr
+            {  $$ = $1 / $3; }
+      |  expr '%' expr
+            {  $$ = $1 % $3; }
+      |  expr '&' expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  '-' expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/code_error.y b/usr.bin/yacc/tests/code_error.y
new file mode 100644
index 000000000000..bb771567606a
--- /dev/null
+++ b/usr.bin/yacc/tests/code_error.y
@@ -0,0 +1,36 @@
+%{
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *);
+#endif
+
+%}
+%%
+S: error
+%%
+
+#include <stdio.h>
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(void)
+{
+    return -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
diff --git a/usr.bin/yacc/tests/error.y b/usr.bin/yacc/tests/error.y
new file mode 100644
index 000000000000..673c68d68e92
--- /dev/null
+++ b/usr.bin/yacc/tests/error.y
@@ -0,0 +1,28 @@
+%{
+int yylex(void);
+static void yyerror(const char *);
+%}
+%%
+S: error
+%%
+
+#include <stdio.h>
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(void)
+{
+    return -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
diff --git a/usr.bin/yacc/tests/ftp.y b/usr.bin/yacc/tests/ftp.y
new file mode 100644
index 000000000000..42c210bf4ef6
--- /dev/null
+++ b/usr.bin/yacc/tests/ftp.y
@@ -0,0 +1,1228 @@
+/*
+ * Copyright (c) 1985, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *	@(#)ftpcmd.y	5.20.1.1 (Berkeley) 3/2/89
+ */
+
+/*
+ * Grammar for FTP commands.
+ * See RFC 959.
+ */
+
+%{
+
+/* sccsid[] = "@(#)ftpcmd.y	5.20.1.1 (Berkeley) 3/2/89"; */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+
+#include <arpa/ftp.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <signal.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <setjmp.h>
+#include <syslog.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *);
+#endif
+
+extern	struct sockaddr_in data_dest;
+extern	int logged_in;
+extern	struct passwd *pw;
+extern	int guest;
+extern	int logging;
+extern	int type;
+extern	int form;
+extern	int debug;
+extern	int timeout;
+extern	int maxtimeout;
+extern  int pdata;
+extern	char hostname[], remotehost[];
+extern	char proctitle[];
+extern	char *globerr;
+extern	int usedefault;
+extern  int transflag;
+extern  char tmpline[];
+
+extern char **glob(char *);
+extern char *renamefrom(char *);
+extern void cwd(const char *);
+
+extern void dologout(int);
+extern void fatal(const char *);
+extern void makedir(const char *);
+extern void nack(const char *);
+extern void pass(const char *);
+extern void passive(void);
+extern void pwd(void);
+extern void removedir(char *);
+extern void renamecmd(char *, char *);
+extern void retrieve(const char *, const char *);
+extern void send_file_list(const char *);
+extern void statcmd(void);
+extern void statfilecmd(const char *);
+extern void store(char *, const char *, int);
+extern void user(const char *);
+
+extern void perror_reply(int, const char *, ...);
+extern void reply(int, const char *, ...);
+extern void lreply(int, const char *, ...);
+
+static	int cmd_type;
+static	int cmd_form;
+static	int cmd_bytesz;
+char	cbuf[512];
+char	*fromname;
+
+struct tab {
+	const char *name;
+	short	token;
+	short	state;
+	short	implemented;	/* 1 if command is implemented */
+	const char *help;
+};
+
+static char * copy(const char *);
+
+#ifdef YYBISON
+static void sizecmd(char *filename);
+static void help(struct tab *ctab, char *s);
+struct tab cmdtab[];
+struct tab sitetab[];
+#endif
+
+static void
+yyerror(const char *msg)
+{
+	perror(msg);
+}
+%}
+
+%token
+	A	B	C	E	F	I
+	L	N	P	R	S	T
+
+	SP	CRLF	COMMA	STRING	NUMBER
+
+	USER	PASS	ACCT	REIN	QUIT	PORT
+	PASV	TYPE	STRU	MODE	RETR	STOR
+	APPE	MLFL	MAIL	MSND	MSOM	MSAM
+	MRSQ	MRCP	ALLO	REST	RNFR	RNTO
+	ABOR	DELE	CWD	LIST	NLST	SITE
+	STAT	HELP	NOOP	MKD	RMD	PWD
+	CDUP	STOU	SMNT	SYST	SIZE	MDTM
+
+	UMASK	IDLE	CHMOD
+
+	LEXERR
+
+%start	cmd_list
+
+%%
+
+cmd_list:	/* empty */
+	|	cmd_list cmd
+		{
+			fromname = (char *) 0;
+		}
+	|	cmd_list rcmd
+	;
+
+cmd:		USER SP username CRLF
+		{
+			user((char *) $3);
+			free((char *) $3);
+		}
+	|	PASS SP password CRLF
+		{
+			pass((char *) $3);
+			free((char *) $3);
+		}
+	|	PORT SP host_port CRLF
+		{
+			usedefault = 0;
+			if (pdata >= 0) {
+				(void) close(pdata);
+				pdata = -1;
+			}
+			reply(200, "PORT command successful.");
+		}
+	|	PASV CRLF
+		{
+			passive();
+		}
+	|	TYPE SP type_code CRLF
+		{
+			switch (cmd_type) {
+
+			case TYPE_A:
+				if (cmd_form == FORM_N) {
+					reply(200, "Type set to A.");
+					type = cmd_type;
+					form = cmd_form;
+				} else
+					reply(504, "Form must be N.");
+				break;
+
+			case TYPE_E:
+				reply(504, "Type E not implemented.");
+				break;
+
+			case TYPE_I:
+				reply(200, "Type set to I.");
+				type = cmd_type;
+				break;
+
+			case TYPE_L:
+#if NBBY == 8
+				if (cmd_bytesz == 8) {
+					reply(200,
+					    "Type set to L (byte size 8).");
+					type = cmd_type;
+				} else
+					reply(504, "Byte size must be 8.");
+#else /* NBBY == 8 */
+				UNIMPLEMENTED for NBBY != 8
+#endif /* NBBY == 8 */
+			}
+		}
+	|	STRU SP struct_code CRLF
+		{
+			switch ($3) {
+
+			case STRU_F:
+				reply(200, "STRU F ok.");
+				break;
+
+			default:
+				reply(504, "Unimplemented STRU type.");
+			}
+		}
+	|	MODE SP mode_code CRLF
+		{
+			switch ($3) {
+
+			case MODE_S:
+				reply(200, "MODE S ok.");
+				break;
+
+			default:
+				reply(502, "Unimplemented MODE type.");
+			}
+		}
+	|	ALLO SP NUMBER CRLF
+		{
+			reply(202, "ALLO command ignored.");
+		}
+	|	ALLO SP NUMBER SP R SP NUMBER CRLF
+		{
+			reply(202, "ALLO command ignored.");
+		}
+	|	RETR check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				retrieve((char *) 0, (char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	STOR check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				store((char *) $4, "w", 0);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	APPE check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				store((char *) $4, "a", 0);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	NLST check_login CRLF
+		{
+			if ($2)
+				send_file_list(".");
+		}
+	|	NLST check_login SP STRING CRLF
+		{
+			if ($2 && $4 != 0)
+				send_file_list((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	LIST check_login CRLF
+		{
+			if ($2)
+				retrieve("/bin/ls -lgA", "");
+		}
+	|	LIST check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				retrieve("/bin/ls -lgA %s", (char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	STAT check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				statfilecmd((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	STAT CRLF
+		{
+			statcmd();
+		}
+	|	DELE check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				remove((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	RNTO SP pathname CRLF
+		{
+			if (fromname) {
+				renamecmd(fromname, (char *) $3);
+				free(fromname);
+				fromname = (char *) 0;
+			} else {
+				reply(503, "Bad sequence of commands.");
+			}
+			free((char *) $3);
+		}
+	|	ABOR CRLF
+		{
+			reply(225, "ABOR command successful.");
+		}
+	|	CWD check_login CRLF
+		{
+			if ($2)
+				cwd(pw->pw_dir);
+		}
+	|	CWD check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				cwd((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	HELP CRLF
+		{
+			help(cmdtab, (char *) 0);
+		}
+	|	HELP SP STRING CRLF
+		{
+			register char *cp = (char *)$3;
+
+			if (strncasecmp(cp, "SITE", 4) == 0) {
+				cp = (char *)$3 + 4;
+				if (*cp == ' ')
+					cp++;
+				if (*cp)
+					help(sitetab, cp);
+				else
+					help(sitetab, (char *) 0);
+			} else
+				help(cmdtab, (char *) $3);
+		}
+	|	NOOP CRLF
+		{
+			reply(200, "NOOP command successful.");
+		}
+	|	MKD check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				makedir((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	RMD check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				removedir((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	PWD check_login CRLF
+		{
+			if ($2)
+				pwd();
+		}
+	|	CDUP check_login CRLF
+		{
+			if ($2)
+				cwd("..");
+		}
+	|	SITE SP HELP CRLF
+		{
+			help(sitetab, (char *) 0);
+		}
+	|	SITE SP HELP SP STRING CRLF
+		{
+			help(sitetab, (char *) $5);
+		}
+	|	SITE SP UMASK check_login CRLF
+		{
+			int oldmask;
+
+			if ($4) {
+				oldmask = umask(0);
+				(void) umask(oldmask);
+				reply(200, "Current UMASK is %03o", oldmask);
+			}
+		}
+	|	SITE SP UMASK check_login SP octal_number CRLF
+		{
+			int oldmask;
+
+			if ($4) {
+				if (($6 == -1) || ($6 > 0777)) {
+					reply(501, "Bad UMASK value");
+				} else {
+					oldmask = umask($6);
+					reply(200,
+					    "UMASK set to %03o (was %03o)",
+					    $6, oldmask);
+				}
+			}
+		}
+	|	SITE SP CHMOD check_login SP octal_number SP pathname CRLF
+		{
+			if ($4 && ($8 != 0)) {
+				if ($6 > 0777)
+					reply(501,
+				"CHMOD: Mode value must be between 0 and 0777");
+				else if (chmod((char *) $8, $6) < 0)
+					perror_reply(550, (char *) $8);
+				else
+					reply(200, "CHMOD command successful.");
+			}
+			if ($8 != 0)
+				free((char *) $8);
+		}
+	|	SITE SP IDLE CRLF
+		{
+			reply(200,
+			    "Current IDLE time limit is %d seconds; max %d",
+				timeout, maxtimeout);
+		}
+	|	SITE SP IDLE SP NUMBER CRLF
+		{
+			if ($5 < 30 || $5 > maxtimeout) {
+				reply(501,
+			"Maximum IDLE time must be between 30 and %d seconds",
+				    maxtimeout);
+			} else {
+				timeout = $5;
+				(void) alarm((unsigned) timeout);
+				reply(200,
+				    "Maximum IDLE time set to %d seconds",
+				    timeout);
+			}
+		}
+	|	STOU check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				store((char *) $4, "w", 1);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	SYST CRLF
+		{
+#ifdef unix
+#ifdef BSD
+			reply(215, "UNIX Type: L%d Version: BSD-%d",
+				NBBY, BSD);
+#else /* BSD */
+			reply(215, "UNIX Type: L%d", NBBY);
+#endif /* BSD */
+#else /* unix */
+			reply(215, "UNKNOWN Type: L%d", NBBY);
+#endif /* unix */
+		}
+
+		/*
+		 * SIZE is not in RFC959, but Postel has blessed it and
+		 * it will be in the updated RFC.
+		 *
+		 * Return size of file in a format suitable for
+		 * using with RESTART (we just count bytes).
+		 */
+	|	SIZE check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0)
+				sizecmd((char *) $4);
+			if ($4 != 0)
+				free((char *) $4);
+		}
+
+		/*
+		 * MDTM is not in RFC959, but Postel has blessed it and
+		 * it will be in the updated RFC.
+		 *
+		 * Return modification time of file as an ISO 3307
+		 * style time. E.g. YYYYMMDDHHMMSS or YYYYMMDDHHMMSS.xxx
+		 * where xxx is the fractional second (of any precision,
+		 * not necessarily 3 digits)
+		 */
+	|	MDTM check_login SP pathname CRLF
+		{
+			if ($2 && $4 != 0) {
+				struct stat stbuf;
+				if (stat((char *) $4, &stbuf) < 0)
+					perror_reply(550, "%s", (char *) $4);
+				else if ((stbuf.st_mode&S_IFMT) != S_IFREG) {
+					reply(550, "%s: not a plain file.",
+						(char *) $4);
+				} else {
+					register struct tm *t;
+					t = gmtime(&stbuf.st_mtime);
+					reply(213,
+					    "%04d%02d%02d%02d%02d%02d",
+					    1900 + t->tm_year,
+					    t->tm_mon+1, t->tm_mday,
+					    t->tm_hour, t->tm_min, t->tm_sec);
+				}
+			}
+			if ($4 != 0)
+				free((char *) $4);
+		}
+	|	QUIT CRLF
+		{
+			reply(221, "Goodbye.");
+			dologout(0);
+		}
+	|	error CRLF
+		{
+			yyerrok;
+		}
+	;
+rcmd:		RNFR check_login SP pathname CRLF
+		{
+			if ($2 && $4) {
+				fromname = renamefrom((char *) $4);
+				if (fromname == (char *) 0 && $4) {
+					free((char *) $4);
+				}
+			}
+		}
+	;
+
+username:	STRING
+	;
+
+password:	/* empty */
+		{
+			*(const char **)(&($$)) = "";
+		}
+	|	STRING
+	;
+
+byte_size:	NUMBER
+	;
+
+host_port:	NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA
+		NUMBER COMMA NUMBER
+		{
+			register char *a, *p;
+
+			a = (char *)&data_dest.sin_addr;
+			a[0] = $1; a[1] = $3; a[2] = $5; a[3] = $7;
+			p = (char *)&data_dest.sin_port;
+			p[0] = $9; p[1] = $11;
+			data_dest.sin_family = AF_INET;
+		}
+	;
+
+form_code:	N
+	{
+		$$ = FORM_N;
+	}
+	|	T
+	{
+		$$ = FORM_T;
+	}
+	|	C
+	{
+		$$ = FORM_C;
+	}
+	;
+
+type_code:	A
+	{
+		cmd_type = TYPE_A;
+		cmd_form = FORM_N;
+	}
+	|	A SP form_code
+	{
+		cmd_type = TYPE_A;
+		cmd_form = $3;
+	}
+	|	E
+	{
+		cmd_type = TYPE_E;
+		cmd_form = FORM_N;
+	}
+	|	E SP form_code
+	{
+		cmd_type = TYPE_E;
+		cmd_form = $3;
+	}
+	|	I
+	{
+		cmd_type = TYPE_I;
+	}
+	|	L
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = NBBY;
+	}
+	|	L SP byte_size
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = $3;
+	}
+	/* this is for a bug in the BBN ftp */
+	|	L byte_size
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = $2;
+	}
+	;
+
+struct_code:	F
+	{
+		$$ = STRU_F;
+	}
+	|	R
+	{
+		$$ = STRU_R;
+	}
+	|	P
+	{
+		$$ = STRU_P;
+	}
+	;
+
+mode_code:	S
+	{
+		$$ = MODE_S;
+	}
+	|	B
+	{
+		$$ = MODE_B;
+	}
+	|	C
+	{
+		$$ = MODE_C;
+	}
+	;
+
+pathname:	pathstring
+	{
+		/*
+		 * Problem: this production is used for all pathname
+		 * processing, but only gives a 550 error reply.
+		 * This is a valid reply in some cases but not in others.
+		 */
+		if (logged_in && $1 && strncmp((char *) $1, "~", 1) == 0) {
+			*(char **)&($$) = *glob((char *) $1);
+			if (globerr != 0) {
+				reply(550, globerr);
+				$$ = 0;
+			}
+			free((char *) $1);
+		} else
+			$$ = $1;
+	}
+	;
+
+pathstring:	STRING
+	;
+
+octal_number:	NUMBER
+	{
+		register int ret, dec, multby, digit;
+
+		/*
+		 * Convert a number that was read as decimal number
+		 * to what it would be if it had been read as octal.
+		 */
+		dec = $1;
+		multby = 1;
+		ret = 0;
+		while (dec) {
+			digit = dec%10;
+			if (digit > 7) {
+				ret = -1;
+				break;
+			}
+			ret += digit * multby;
+			multby *= 8;
+			dec /= 10;
+		}
+		$$ = ret;
+	}
+	;
+
+check_login:	/* empty */
+	{
+		if (logged_in)
+			$$ = 1;
+		else {
+			reply(530, "Please login with USER and PASS.");
+			$$ = 0;
+		}
+	}
+	;
+
+%%
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+extern jmp_buf errcatch;
+
+static void upper(char *);
+
+#define	CMD	0	/* beginning of command */
+#define	ARGS	1	/* expect miscellaneous arguments */
+#define	STR1	2	/* expect SP followed by STRING */
+#define	STR2	3	/* expect STRING */
+#define	OSTR	4	/* optional SP then STRING */
+#define	ZSTR1	5	/* SP then optional STRING */
+#define	ZSTR2	6	/* optional STRING after SP */
+#define	SITECMD	7	/* SITE command */
+#define	NSTR	8	/* Number followed by a string */
+
+struct tab cmdtab[] = {		/* In order defined in RFC 765 */
+	{ "USER", USER, STR1, 1,	"<sp> username" },
+	{ "PASS", PASS, ZSTR1, 1,	"<sp> password" },
+	{ "ACCT", ACCT, STR1, 0,	"(specify account)" },
+	{ "SMNT", SMNT, ARGS, 0,	"(structure mount)" },
+	{ "REIN", REIN, ARGS, 0,	"(reinitialize server state)" },
+	{ "QUIT", QUIT, ARGS, 1,	"(terminate service)", },
+	{ "PORT", PORT, ARGS, 1,	"<sp> b0, b1, b2, b3, b4" },
+	{ "PASV", PASV, ARGS, 1,	"(set server in passive mode)" },
+	{ "TYPE", TYPE, ARGS, 1,	"<sp> [ A | E | I | L ]" },
+	{ "STRU", STRU, ARGS, 1,	"(specify file structure)" },
+	{ "MODE", MODE, ARGS, 1,	"(specify transfer mode)" },
+	{ "RETR", RETR, STR1, 1,	"<sp> file-name" },
+	{ "STOR", STOR, STR1, 1,	"<sp> file-name" },
+	{ "APPE", APPE, STR1, 1,	"<sp> file-name" },
+	{ "MLFL", MLFL, OSTR, 0,	"(mail file)" },
+	{ "MAIL", MAIL, OSTR, 0,	"(mail to user)" },
+	{ "MSND", MSND, OSTR, 0,	"(mail send to terminal)" },
+	{ "MSOM", MSOM, OSTR, 0,	"(mail send to terminal or mailbox)" },
+	{ "MSAM", MSAM, OSTR, 0,	"(mail send to terminal and mailbox)" },
+	{ "MRSQ", MRSQ, OSTR, 0,	"(mail recipient scheme question)" },
+	{ "MRCP", MRCP, STR1, 0,	"(mail recipient)" },
+	{ "ALLO", ALLO, ARGS, 1,	"allocate storage (vacuously)" },
+	{ "REST", REST, ARGS, 0,	"(restart command)" },
+	{ "RNFR", RNFR, STR1, 1,	"<sp> file-name" },
+	{ "RNTO", RNTO, STR1, 1,	"<sp> file-name" },
+	{ "ABOR", ABOR, ARGS, 1,	"(abort operation)" },
+	{ "DELE", DELE, STR1, 1,	"<sp> file-name" },
+	{ "CWD",  CWD,  OSTR, 1,	"[ <sp> directory-name ]" },
+	{ "XCWD", CWD,	OSTR, 1,	"[ <sp> directory-name ]" },
+	{ "LIST", LIST, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "NLST", NLST, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "SITE", SITE, SITECMD, 1,	"site-cmd [ <sp> arguments ]" },
+	{ "SYST", SYST, ARGS, 1,	"(get type of operating system)" },
+	{ "STAT", STAT, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "HELP", HELP, OSTR, 1,	"[ <sp> <string> ]" },
+	{ "NOOP", NOOP, ARGS, 1,	"" },
+	{ "MKD",  MKD,  STR1, 1,	"<sp> path-name" },
+	{ "XMKD", MKD,  STR1, 1,	"<sp> path-name" },
+	{ "RMD",  RMD,  STR1, 1,	"<sp> path-name" },
+	{ "XRMD", RMD,  STR1, 1,	"<sp> path-name" },
+	{ "PWD",  PWD,  ARGS, 1,	"(return current directory)" },
+	{ "XPWD", PWD,  ARGS, 1,	"(return current directory)" },
+	{ "CDUP", CDUP, ARGS, 1,	"(change to parent directory)" },
+	{ "XCUP", CDUP, ARGS, 1,	"(change to parent directory)" },
+	{ "STOU", STOU, STR1, 1,	"<sp> file-name" },
+	{ "SIZE", SIZE, OSTR, 1,	"<sp> path-name" },
+	{ "MDTM", MDTM, OSTR, 1,	"<sp> path-name" },
+	{ 0,   0,    0,    0,	0 }
+};
+
+struct tab sitetab[] = {
+	{ "UMASK", UMASK, ARGS, 1,	"[ <sp> umask ]" },
+	{ "IDLE", IDLE, ARGS, 1,	"[ <sp> maximum-idle-time ]" },
+	{ "CHMOD", CHMOD, NSTR, 1,	"<sp> mode <sp> file-name" },
+	{ "HELP", HELP, OSTR, 1,	"[ <sp> <string> ]" },
+	{ 0,   0,    0,    0,	0 }
+};
+
+static struct tab *
+lookup(struct tab *p, char *cmd)
+{
+
+	for (; p->name != 0; p++)
+		if (strcmp(cmd, p->name) == 0)
+			return (p);
+	return (0);
+}
+
+#include <arpa/telnet.h>
+
+/*
+ * get_line - a hacked up version of fgets to ignore TELNET escape codes.
+ */
+static char *
+get_line(char *s, int n, FILE *iop)
+{
+	register int c;
+	register char *cs;
+
+	cs = s;
+/* tmpline may contain saved command from urgent mode interruption */
+	for (c = 0; tmpline[c] != '\0' && --n > 0; ++c) {
+		*cs++ = tmpline[c];
+		if (tmpline[c] == '\n') {
+			*cs = '\0';
+			if (debug)
+				syslog(LOG_DEBUG, "command: %s", s);
+			tmpline[0] = '\0';
+			return(s);
+		}
+		if (c == 0)
+			tmpline[0] = '\0';
+	}
+	while ((c = getc(iop)) != EOF) {
+		c &= 0377;
+		if (c == IAC) {
+		    if ((c = getc(iop)) != EOF) {
+			c &= 0377;
+			switch (c) {
+			case WILL:
+			case WONT:
+				c = getc(iop);
+				printf("%c%c%c", IAC, DONT, 0377&c);
+				(void) fflush(stdout);
+				continue;
+			case DO:
+			case DONT:
+				c = getc(iop);
+				printf("%c%c%c", IAC, WONT, 0377&c);
+				(void) fflush(stdout);
+				continue;
+			case IAC:
+				break;
+			default:
+				continue;	/* ignore command */
+			}
+		    }
+		}
+		*cs++ = c;
+		if (--n <= 0 || c == '\n')
+			break;
+	}
+	if (c == EOF && cs == s)
+		return (0);
+	*cs = '\0';
+	if (debug)
+		syslog(LOG_DEBUG, "command: %s", s);
+	return (s);
+}
+
+static void
+toolong(int sig)
+{
+	time_t now;
+
+	(void) sig;
+	reply(421,
+	  "Timeout (%d seconds): closing control connection.", timeout);
+	(void) time(&now);
+	if (logging) {
+		syslog(LOG_INFO,
+			"User %s timed out after %d seconds at %s",
+			(pw ? pw -> pw_name : "unknown"), timeout, ctime(&now));
+	}
+	dologout(1);
+}
+
+int
+yylex(void)
+{
+	static int cpos, state;
+	register char *cp, *cp2;
+	register struct tab *p;
+	int n;
+	char c;
+
+	for (;;) {
+		switch (state) {
+
+		case CMD:
+			(void) signal(SIGALRM, toolong);
+			(void) alarm((unsigned) timeout);
+			if (get_line(cbuf, sizeof(cbuf)-1, stdin) == 0) {
+				reply(221, "You could at least say goodbye.");
+				dologout(0);
+			}
+			(void) alarm(0);
+#ifdef SETPROCTITLE
+			if (strncasecmp(cbuf, "PASS", 4) != 0)
+				setproctitle("%s: %s", proctitle, cbuf);
+#endif /* SETPROCTITLE */
+			if ((cp = strchr(cbuf, '\r'))) {
+				*cp++ = '\n';
+				*cp = '\0';
+			}
+			if ((cp = strpbrk(cbuf, " \n")))
+				cpos = cp - cbuf;
+			if (cpos == 0)
+				cpos = 4;
+			c = cbuf[cpos];
+			cbuf[cpos] = '\0';
+			upper(cbuf);
+			p = lookup(cmdtab, cbuf);
+			cbuf[cpos] = c;
+			if (p != 0) {
+				if (p->implemented == 0) {
+					nack(p->name);
+					longjmp(errcatch,0);
+					/* NOTREACHED */
+				}
+				state = p->state;
+				*(const char **)(&yylval) = p->name;
+				return (p->token);
+			}
+			break;
+
+		case SITECMD:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				return (SP);
+			}
+			cp = &cbuf[cpos];
+			if ((cp2 = strpbrk(cp, " \n")))
+				cpos = cp2 - cbuf;
+			c = cbuf[cpos];
+			cbuf[cpos] = '\0';
+			upper(cp);
+			p = lookup(sitetab, cp);
+			cbuf[cpos] = c;
+			if (p != 0) {
+				if (p->implemented == 0) {
+					state = CMD;
+					nack(p->name);
+					longjmp(errcatch,0);
+					/* NOTREACHED */
+				}
+				state = p->state;
+				*(const char **)(&yylval) = p->name;
+				return (p->token);
+			}
+			state = CMD;
+			break;
+
+		case OSTR:
+			if (cbuf[cpos] == '\n') {
+				state = CMD;
+				return (CRLF);
+			}
+			/* FALLTHROUGH */
+
+		case STR1:
+		case ZSTR1:
+		dostr1:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				if (state == OSTR)
+					state = STR2;
+				else
+					++state;
+				return (SP);
+			}
+			break;
+
+		case ZSTR2:
+			if (cbuf[cpos] == '\n') {
+				state = CMD;
+				return (CRLF);
+			}
+			/* FALLTHROUGH */
+
+		case STR2:
+			cp = &cbuf[cpos];
+			n = strlen(cp);
+			cpos += n - 1;
+			/*
+			 * Make sure the string is nonempty and \n terminated.
+			 */
+			if (n > 1 && cbuf[cpos] == '\n') {
+				cbuf[cpos] = '\0';
+				*(char **)&yylval = copy(cp);
+				cbuf[cpos] = '\n';
+				state = ARGS;
+				return (STRING);
+			}
+			break;
+
+		case NSTR:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				return (SP);
+			}
+			if (isdigit(cbuf[cpos])) {
+				cp = &cbuf[cpos];
+				while (isdigit(cbuf[++cpos]))
+					;
+				c = cbuf[cpos];
+				cbuf[cpos] = '\0';
+				yylval = atoi(cp);
+				cbuf[cpos] = c;
+				state = STR1;
+				return (NUMBER);
+			}
+			state = STR1;
+			goto dostr1;
+
+		case ARGS:
+			if (isdigit(cbuf[cpos])) {
+				cp = &cbuf[cpos];
+				while (isdigit(cbuf[++cpos]))
+					;
+				c = cbuf[cpos];
+				cbuf[cpos] = '\0';
+				yylval = atoi(cp);
+				cbuf[cpos] = c;
+				return (NUMBER);
+			}
+			switch (cbuf[cpos++]) {
+
+			case '\n':
+				state = CMD;
+				return (CRLF);
+
+			case ' ':
+				return (SP);
+
+			case ',':
+				return (COMMA);
+
+			case 'A':
+			case 'a':
+				return (A);
+
+			case 'B':
+			case 'b':
+				return (B);
+
+			case 'C':
+			case 'c':
+				return (C);
+
+			case 'E':
+			case 'e':
+				return (E);
+
+			case 'F':
+			case 'f':
+				return (F);
+
+			case 'I':
+			case 'i':
+				return (I);
+
+			case 'L':
+			case 'l':
+				return (L);
+
+			case 'N':
+			case 'n':
+				return (N);
+
+			case 'P':
+			case 'p':
+				return (P);
+
+			case 'R':
+			case 'r':
+				return (R);
+
+			case 'S':
+			case 's':
+				return (S);
+
+			case 'T':
+			case 't':
+				return (T);
+
+			}
+			break;
+
+		default:
+			fatal("Unknown state in scanner.");
+		}
+		yyerror((char *) 0);
+		state = CMD;
+		longjmp(errcatch,0);
+	}
+}
+
+static void
+upper(char *s)
+{
+	while (*s != '\0') {
+		if (islower(*s))
+			*s = toupper(*s);
+		s++;
+	}
+}
+
+static char *
+copy(const char *s)
+{
+	char *p;
+
+	p = (char * )malloc(strlen(s) + 1);
+	if (p == 0)
+		fatal("Ran out of memory.");
+	else
+		(void) strcpy(p, s);
+	return (p);
+}
+
+static void
+help(struct tab *ctab, char *s)
+{
+	register struct tab *c;
+	register int width, NCMDS;
+	const char *help_type;
+
+	if (ctab == sitetab)
+		help_type = "SITE ";
+	else
+		help_type = "";
+	width = 0, NCMDS = 0;
+	for (c = ctab; c->name != 0; c++) {
+		int len = strlen(c->name);
+
+		if (len > width)
+			width = len;
+		NCMDS++;
+	}
+	width = (width + 8) &~ 7;
+	if (s == 0) {
+		register int i, j, w;
+		int columns, lines;
+
+		lreply(214, "The following %scommands are recognized %s.",
+		    help_type, "(* =>'s unimplemented)");
+		columns = 76 / width;
+		if (columns == 0)
+			columns = 1;
+		lines = (NCMDS + columns - 1) / columns;
+		for (i = 0; i < lines; i++) {
+			printf("   ");
+			for (j = 0; j < columns; j++) {
+				c = ctab + j * lines + i;
+				assert(c->name != 0);
+				printf("%s%c", c->name,
+					c->implemented ? ' ' : '*');
+				if (c + lines >= &ctab[NCMDS])
+					break;
+				w = strlen(c->name) + 1;
+				while (w < width) {
+					putchar(' ');
+					w++;
+				}
+			}
+			printf("\r\n");
+		}
+		(void) fflush(stdout);
+		reply(214, "Direct comments to ftp-bugs@%s.", hostname);
+		return;
+	}
+	upper(s);
+	c = lookup(ctab, s);
+	if (c == (struct tab *)0) {
+		reply(502, "Unknown command %s.", s);
+		return;
+	}
+	if (c->implemented)
+		reply(214, "Syntax: %s%s %s", help_type, c->name, c->help);
+	else
+		reply(214, "%s%-*s\t%s; unimplemented.", help_type, width,
+		    c->name, c->help);
+}
+
+static void
+sizecmd(char *filename)
+{
+	switch (type) {
+	case TYPE_L:
+	case TYPE_I: {
+		struct stat stbuf;
+		if (stat(filename, &stbuf) < 0 ||
+		    (stbuf.st_mode&S_IFMT) != S_IFREG)
+			reply(550, "%s: not a plain file.", filename);
+		else
+#ifdef HAVE_LONG_LONG
+			reply(213, "%llu", (long long) stbuf.st_size);
+#else
+			reply(213, "%lu", stbuf.st_size);
+#endif
+		break;}
+	case TYPE_A: {
+		FILE *fin;
+		register int c, count;
+		struct stat stbuf;
+		fin = fopen(filename, "r");
+		if (fin == 0) {
+			perror_reply(550, filename);
+			return;
+		}
+		if (fstat(fileno(fin), &stbuf) < 0 ||
+		    (stbuf.st_mode&S_IFMT) != S_IFREG) {
+			reply(550, "%s: not a plain file.", filename);
+			(void) fclose(fin);
+			return;
+		}
+
+		count = 0;
+		while((c=getc(fin)) != EOF) {
+			if (c == '\n')	/* will get expanded to \r\n */
+				count++;
+			count++;
+		}
+		(void) fclose(fin);
+
+		reply(213, "%ld", count);
+		break;}
+	default:
+		reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
+	}
+}
diff --git a/usr.bin/yacc/tests/grammar.y b/usr.bin/yacc/tests/grammar.y
new file mode 100644
index 000000000000..a2f188397c17
--- /dev/null
+++ b/usr.bin/yacc/tests/grammar.y
@@ -0,0 +1,1183 @@
+/* $Id: grammar.y,v 1.5 2012/01/15 20:00:59 tom Exp $
+ *
+ * yacc grammar for C function prototype generator
+ * This was derived from the grammar in Appendix A of
+ * "The C Programming Language" by Kernighan and Ritchie.
+ */
+%expect 1
+%{
+#ifdef YYBISON
+#include <stdlib.h>
+#define YYSTYPE_IS_DECLARED
+#define yyerror yaccError
+#endif
+
+#if defined(YYBISON) || !defined(YYBYACC)
+static void yyerror(const char *s);
+#endif
+%}
+
+%token <text> '(' '*' '&'
+	/* identifiers that are not reserved words */
+	T_IDENTIFIER T_TYPEDEF_NAME T_DEFINE_NAME
+
+	/* storage class */
+	T_AUTO T_EXTERN T_REGISTER T_STATIC T_TYPEDEF
+	/* This keyword included for compatibility with C++. */
+	T_INLINE
+	/* This keyword included for compatibility with GCC */
+	T_EXTENSION
+
+	/* type specifiers */
+	T_CHAR T_DOUBLE T_FLOAT T_INT T_VOID
+	T_LONG T_SHORT T_SIGNED T_UNSIGNED
+	T_ENUM T_STRUCT T_UNION
+	/* C9X new types */
+	T_Bool T_Complex T_Imaginary
+
+	/* type qualifiers */
+	T_TYPE_QUALIFIER
+
+	/* paired square brackets and everything between them: [ ... ] */
+	T_BRACKETS
+
+%token
+	/* left brace */
+	T_LBRACE
+	/* all input to the matching right brace */
+	T_MATCHRBRACE
+
+	/* three periods */
+	T_ELLIPSIS
+
+	/* constant expression or paired braces following an equal sign */
+	T_INITIALIZER
+
+	/* string literal */
+	T_STRING_LITERAL
+
+	/* asm */
+	T_ASM
+	/* ( "string literal" ) following asm keyword */
+	T_ASMARG
+
+	/* va_dcl from <varargs.h> */
+	T_VA_DCL
+
+%type <decl_spec> decl_specifiers decl_specifier
+%type <decl_spec> storage_class type_specifier type_qualifier
+%type <decl_spec> struct_or_union_specifier enum_specifier
+%type <decl_list> init_declarator_list
+%type <declarator> init_declarator declarator direct_declarator
+%type <declarator> abs_declarator direct_abs_declarator
+%type <param_list> parameter_type_list parameter_list
+%type <parameter> parameter_declaration
+%type <param_list> opt_identifier_list identifier_list
+%type <text> struct_or_union pointer opt_type_qualifiers type_qualifier_list
+	any_id identifier_or_ref
+%type <text> enumeration
+
+%{
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#define OPT_LINTLIBRARY 1
+
+#ifndef TRUE
+#define	TRUE	(1)
+#endif
+
+#ifndef FALSE
+#define	FALSE	(0)
+#endif
+
+/* #include "cproto.h" */
+#define MAX_TEXT_SIZE 1024
+
+/* Prototype styles */
+#if OPT_LINTLIBRARY
+#define PROTO_ANSI_LLIB		-2	/* form ANSI lint-library source */
+#define PROTO_LINTLIBRARY	-1	/* form lint-library source */
+#endif
+#define PROTO_NONE		0	/* do not output any prototypes */
+#define PROTO_TRADITIONAL	1	/* comment out parameters */
+#define PROTO_ABSTRACT		2	/* comment out parameter names */
+#define PROTO_ANSI		3	/* ANSI C prototype */
+
+typedef int PrototypeStyle;
+
+typedef char boolean;
+
+extern boolean types_out;
+extern PrototypeStyle proto_style;
+
+#define ansiLintLibrary() (proto_style == PROTO_ANSI_LLIB)
+#define knrLintLibrary()  (proto_style == PROTO_LINTLIBRARY)
+#define lintLibrary()     (knrLintLibrary() || ansiLintLibrary())
+
+#if OPT_LINTLIBRARY
+#define FUNC_UNKNOWN		-1	/* unspecified */
+#else
+#define FUNC_UNKNOWN		0	/* unspecified (same as FUNC_NONE) */
+#endif
+#define FUNC_NONE		0	/* not a function definition */
+#define FUNC_TRADITIONAL	1	/* traditional style */
+#define FUNC_ANSI		2	/* ANSI style */
+#define FUNC_BOTH		3	/* both styles */
+
+typedef int FuncDefStyle;
+
+/* Source file text */
+typedef struct text {
+    char text[MAX_TEXT_SIZE];	/* source text */
+    long begin; 		/* offset in temporary file */
+} Text;
+
+/* Declaration specifier flags */
+#define DS_NONE 	0	/* default */
+#define DS_EXTERN	1	/* contains "extern" specifier */
+#define DS_STATIC	2	/* contains "static" specifier */
+#define DS_CHAR 	4	/* contains "char" type specifier */
+#define DS_SHORT	8	/* contains "short" type specifier */
+#define DS_FLOAT	16	/* contains "float" type specifier */
+#define DS_INLINE	32	/* contains "inline" specifier */
+#define DS_JUNK 	64	/* we're not interested in this declaration */
+
+/* This structure stores information about a declaration specifier. */
+typedef struct decl_spec {
+    unsigned short flags;	/* flags defined above */
+    char *text; 		/* source text */
+    long begin; 		/* offset in temporary file */
+} DeclSpec;
+
+/* This is a list of function parameters. */
+typedef struct _ParameterList {
+    struct parameter *first;	/* pointer to first parameter in list */
+    struct parameter *last;	/* pointer to last parameter in list */  
+    long begin_comment; 	/* begin offset of comment */
+    long end_comment;		/* end offset of comment */
+    char *comment;		/* comment at start of parameter list */
+} ParameterList;
+
+/* This structure stores information about a declarator. */
+typedef struct _Declarator {
+    char *name; 			/* name of variable or function */
+    char *text; 			/* source text */
+    long begin; 			/* offset in temporary file */
+    long begin_comment; 		/* begin offset of comment */
+    long end_comment;			/* end offset of comment */
+    FuncDefStyle func_def;		/* style of function definition */
+    ParameterList params;		/* function parameters */
+    boolean pointer;			/* TRUE if it declares a pointer */
+    struct _Declarator *head;		/* head function declarator */
+    struct _Declarator *func_stack;	/* stack of function declarators */
+    struct _Declarator *next;		/* next declarator in list */
+} Declarator;
+
+/* This structure stores information about a function parameter. */
+typedef struct parameter {
+    struct parameter *next;	/* next parameter in list */
+    DeclSpec decl_spec;
+    Declarator *declarator;
+    char *comment;		/* comment following the parameter */
+} Parameter;
+
+/* This is a list of declarators. */
+typedef struct declarator_list {
+    Declarator *first;		/* pointer to first declarator in list */
+    Declarator *last;		/* pointer to last declarator in list */  
+} DeclaratorList;
+
+/* #include "symbol.h" */
+typedef struct symbol {
+    struct symbol *next;	/* next symbol in list */
+    char *name; 		/* name of symbol */
+    char *value;		/* value of symbol (for defines) */
+    short flags;		/* symbol attributes */
+} Symbol;
+
+/* parser stack entry type */
+typedef union {
+    Text text;
+    DeclSpec decl_spec;
+    Parameter *parameter;
+    ParameterList param_list;
+    Declarator *declarator;
+    DeclaratorList decl_list;
+} YYSTYPE;
+
+/* The hash table length should be a prime number. */
+#define SYM_MAX_HASH 251
+
+typedef struct symbol_table {
+    Symbol *bucket[SYM_MAX_HASH];	/* hash buckets */
+} SymbolTable;
+
+extern SymbolTable *new_symbol_table	/* Create symbol table */
+	(void);
+extern void free_symbol_table		/* Destroy symbol table */
+	(SymbolTable *s);
+extern Symbol *find_symbol		/* Lookup symbol name */
+	(SymbolTable *s, const char *n);
+extern Symbol *new_symbol		/* Define new symbol */
+	(SymbolTable *s, const char *n, const char *v, int f);
+
+/* #include "semantic.h" */
+extern void new_decl_spec (DeclSpec *, const char *, long, int);
+extern void free_decl_spec (DeclSpec *);
+extern void join_decl_specs (DeclSpec *, DeclSpec *, DeclSpec *);
+extern void check_untagged (DeclSpec *);
+extern Declarator *new_declarator (const char *, const char *, long);
+extern void free_declarator (Declarator *);
+extern void new_decl_list (DeclaratorList *, Declarator *);
+extern void free_decl_list (DeclaratorList *);
+extern void add_decl_list (DeclaratorList *, DeclaratorList *, Declarator *);
+extern Parameter *new_parameter (DeclSpec *, Declarator *);
+extern void free_parameter (Parameter *);
+extern void new_param_list (ParameterList *, Parameter *);
+extern void free_param_list (ParameterList *);
+extern void add_param_list (ParameterList *, ParameterList *, Parameter *);
+extern void new_ident_list (ParameterList *);
+extern void add_ident_list (ParameterList *, ParameterList *, const char *);
+extern void set_param_types (ParameterList *, DeclSpec *, DeclaratorList *);
+extern void gen_declarations (DeclSpec *, DeclaratorList *);
+extern void gen_prototype (DeclSpec *, Declarator *);
+extern void gen_func_declarator (Declarator *);
+extern void gen_func_definition (DeclSpec *, Declarator *);
+
+extern void init_parser     (void);
+extern void process_file    (FILE *infile, char *name);
+extern char *cur_text       (void);
+extern char *cur_file_name  (void);
+extern char *implied_typedef (void);
+extern void include_file    (char *name, int convert);
+extern char *supply_parm    (int count);
+extern char *xstrdup        (const char *);
+extern int already_declared (char *name);
+extern int is_actual_func   (Declarator *d);
+extern int lint_ellipsis    (Parameter *p);
+extern int want_typedef     (void);
+extern void begin_tracking  (void);
+extern void begin_typedef   (void);
+extern void copy_typedef    (char *s);
+extern void ellipsis_varargs (Declarator *d);
+extern void end_typedef     (void);
+extern void flush_varargs   (void);
+extern void fmt_library     (int code);
+extern void imply_typedef   (const char *s);
+extern void indent          (FILE *outf);
+extern void put_blankline   (FILE *outf);
+extern void put_body        (FILE *outf, DeclSpec *decl_spec, Declarator *declarator);
+extern void put_char        (FILE *outf, int c);
+extern void put_error       (void);
+extern void put_newline     (FILE *outf);
+extern void put_padded      (FILE *outf, const char *s);
+extern void put_string      (FILE *outf, const char *s);
+extern void track_in        (void);
+
+extern boolean file_comments;
+extern FuncDefStyle func_style;
+extern char base_file[];
+
+extern	int	yylex (void);
+
+/* declaration specifier attributes for the typedef statement currently being
+ * scanned
+ */
+static int cur_decl_spec_flags;
+
+/* pointer to parameter list for the current function definition */
+static ParameterList *func_params;
+
+/* A parser semantic action sets this pointer to the current declarator in
+ * a function parameter declaration in order to catch any comments following
+ * the parameter declaration on the same line.  If the lexer scans a comment
+ * and <cur_declarator> is not NULL, then the comment is attached to the
+ * declarator.  To ignore subsequent comments, the lexer sets this to NULL
+ * after scanning a comment or end of line.
+ */
+static Declarator *cur_declarator;
+
+/* temporary string buffer */
+static char buf[MAX_TEXT_SIZE];
+
+/* table of typedef names */
+static SymbolTable *typedef_names;
+
+/* table of define names */
+static SymbolTable *define_names;
+
+/* table of type qualifiers */
+static SymbolTable *type_qualifiers;
+
+/* information about the current input file */
+typedef struct {
+    char *base_name;		/* base input file name */
+    char *file_name;		/* current file name */
+    FILE *file; 		/* input file */
+    unsigned line_num;		/* current line number in input file */
+    FILE *tmp_file;		/* temporary file */
+    long begin_comment; 	/* tmp file offset after last written ) or ; */
+    long end_comment;		/* tmp file offset after last comment */
+    boolean convert;		/* if TRUE, convert function definitions */
+    boolean changed;		/* TRUE if conversion done in this file */
+} IncludeStack;
+
+static IncludeStack *cur_file;	/* current input file */
+
+/* #include "yyerror.c" */
+
+static int haveAnsiParam (void);
+
+
+/* Flags to enable us to find if a procedure returns a value.
+ */
+static int return_val;	/* nonzero on BRACES iff return-expression found */
+
+static const char *
+dft_decl_spec (void)
+{
+    return (lintLibrary() && !return_val) ? "void" : "int";
+}
+
+static int
+haveAnsiParam (void)
+{
+    Parameter *p;
+    if (func_params != 0) {
+	for (p = func_params->first; p != 0; p = p->next) {
+	    if (p->declarator->func_def == FUNC_ANSI) {
+		return TRUE;
+	    }
+	}
+    }
+    return FALSE;
+}
+%}
+%%
+
+program
+	: /* empty */
+	| translation_unit
+	;
+
+translation_unit
+	: external_declaration
+	| translation_unit external_declaration
+	;
+
+external_declaration
+	: declaration
+	| function_definition
+	| ';'
+	| linkage_specification
+	| T_ASM T_ASMARG ';'
+	| error T_MATCHRBRACE
+	{
+	    yyerrok;
+	}
+	| error ';'
+	{
+	    yyerrok;
+	}
+	;
+
+braces
+	: T_LBRACE T_MATCHRBRACE
+	;
+
+linkage_specification
+	: T_EXTERN T_STRING_LITERAL braces
+	{
+	    /* Provide an empty action here so bison will not complain about
+	     * incompatible types in the default action it normally would
+	     * have generated.
+	     */
+	}
+	| T_EXTERN T_STRING_LITERAL declaration
+	{
+	    /* empty */
+	}
+	;
+
+declaration
+	: decl_specifiers ';'
+	{
+#if OPT_LINTLIBRARY
+	    if (types_out && want_typedef()) {
+		gen_declarations(&$1, (DeclaratorList *)0);
+		flush_varargs();
+	    }
+#endif
+	    free_decl_spec(&$1);
+	    end_typedef();
+	}
+	| decl_specifiers init_declarator_list ';'
+	{
+	    if (func_params != NULL) {
+		set_param_types(func_params, &$1, &$2);
+	    } else {
+		gen_declarations(&$1, &$2);
+#if OPT_LINTLIBRARY
+		flush_varargs();
+#endif
+		free_decl_list(&$2);
+	    }
+	    free_decl_spec(&$1);
+	    end_typedef();
+	}
+	| any_typedef decl_specifiers
+	{
+	    cur_decl_spec_flags = $2.flags;
+	    free_decl_spec(&$2);
+	}
+	  opt_declarator_list ';'
+	{
+	    end_typedef();
+	}
+	;
+
+any_typedef
+	: T_EXTENSION T_TYPEDEF
+	{
+	    begin_typedef();
+	}
+	| T_TYPEDEF
+	{
+	    begin_typedef();
+	}
+	;
+
+opt_declarator_list
+	: /* empty */
+	| declarator_list
+	;
+
+declarator_list
+	: declarator
+	{
+	    int flags = cur_decl_spec_flags;
+
+	    /* If the typedef is a pointer type, then reset the short type
+	     * flags so it does not get promoted.
+	     */
+	    if (strcmp($1->text, $1->name) != 0)
+		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
+	    new_symbol(typedef_names, $1->name, NULL, flags);
+	    free_declarator($1);
+	}
+	| declarator_list ',' declarator
+	{
+	    int flags = cur_decl_spec_flags;
+
+	    if (strcmp($3->text, $3->name) != 0)
+		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
+	    new_symbol(typedef_names, $3->name, NULL, flags);
+	    free_declarator($3);
+	}
+	;
+
+function_definition
+	: decl_specifiers declarator
+	{
+	    check_untagged(&$1);
+	    if ($2->func_def == FUNC_NONE) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &($2->head->params);
+	    func_params->begin_comment = cur_file->begin_comment;
+	    func_params->end_comment = cur_file->end_comment;
+	}
+	  opt_declaration_list T_LBRACE
+	{
+	    /* If we're converting to K&R and we've got a nominally K&R
+	     * function which has a parameter which is ANSI (i.e., a prototyped
+	     * function pointer), then we must override the deciphered value of
+	     * 'func_def' so that the parameter will be converted.
+	     */
+	    if (func_style == FUNC_TRADITIONAL
+	     && haveAnsiParam()
+	     && $2->head->func_def == func_style) {
+		$2->head->func_def = FUNC_BOTH;
+	    }
+
+	    func_params = NULL;
+
+	    if (cur_file->convert)
+		gen_func_definition(&$1, $2);
+	    gen_prototype(&$1, $2);
+#if OPT_LINTLIBRARY
+	    flush_varargs();
+#endif
+	    free_decl_spec(&$1);
+	    free_declarator($2);
+	}
+	  T_MATCHRBRACE
+	| declarator
+	{
+	    if ($1->func_def == FUNC_NONE) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &($1->head->params);
+	    func_params->begin_comment = cur_file->begin_comment;
+	    func_params->end_comment = cur_file->end_comment;
+	}
+	  opt_declaration_list T_LBRACE T_MATCHRBRACE
+	{
+	    DeclSpec decl_spec;
+
+	    func_params = NULL;
+
+	    new_decl_spec(&decl_spec, dft_decl_spec(), $1->begin, DS_NONE);
+	    if (cur_file->convert)
+		gen_func_definition(&decl_spec, $1);
+	    gen_prototype(&decl_spec, $1);
+#if OPT_LINTLIBRARY
+	    flush_varargs();
+#endif
+	    free_decl_spec(&decl_spec);
+	    free_declarator($1);
+	}
+	;
+
+opt_declaration_list
+	: /* empty */
+	| T_VA_DCL
+	| declaration_list
+	;
+
+declaration_list
+	: declaration
+	| declaration_list declaration
+	;
+
+decl_specifiers
+	: decl_specifier
+	| decl_specifiers decl_specifier
+	{
+	    join_decl_specs(&$$, &$1, &$2);
+	    free($1.text);
+	    free($2.text);
+	}
+	;
+
+decl_specifier
+	: storage_class
+	| type_specifier
+	| type_qualifier
+	;
+
+storage_class
+	: T_AUTO
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_EXTERN
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_EXTERN);
+	}
+	| T_REGISTER
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_STATIC
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_STATIC);
+	}
+	| T_INLINE
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_INLINE);
+	}
+	| T_EXTENSION
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_JUNK);
+	}
+	;
+
+type_specifier
+	: T_CHAR
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_CHAR);
+	}
+	| T_DOUBLE
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_FLOAT
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_FLOAT);
+	}
+	| T_INT
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_LONG
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_SHORT
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_SHORT);
+	}
+	| T_SIGNED
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_UNSIGNED
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_VOID
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_Bool
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_CHAR);
+	}
+	| T_Complex
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_Imaginary
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_TYPEDEF_NAME
+	{
+	    Symbol *s;
+	    s = find_symbol(typedef_names, $1.text);
+	    if (s != NULL)
+		new_decl_spec(&$$, $1.text, $1.begin, s->flags);
+	}
+	| struct_or_union_specifier
+	| enum_specifier
+	;
+
+type_qualifier
+	: T_TYPE_QUALIFIER
+	{
+	    new_decl_spec(&$$, $1.text, $1.begin, DS_NONE);
+	}
+	| T_DEFINE_NAME
+	{
+	    /* This rule allows the <pointer> nonterminal to scan #define
+	     * names as if they were type modifiers.
+	     */
+	    Symbol *s;
+	    s = find_symbol(define_names, $1.text);
+	    if (s != NULL)
+		new_decl_spec(&$$, $1.text, $1.begin, s->flags);
+	}
+	;
+
+struct_or_union_specifier
+	: struct_or_union any_id braces
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+	        (void)sprintf(s = buf, "%s %s", $1.text, $2.text);
+	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
+	}
+	| struct_or_union braces
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "%s {}", $1.text);
+	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
+	}
+	| struct_or_union any_id
+	{
+	    (void)sprintf(buf, "%s %s", $1.text, $2.text);
+	    new_decl_spec(&$$, buf, $1.begin, DS_NONE);
+	}
+	;
+
+struct_or_union
+	: T_STRUCT
+	{
+	    imply_typedef($$.text);
+	}
+	| T_UNION
+	{
+	    imply_typedef($$.text);
+	}
+	;
+
+init_declarator_list
+	: init_declarator
+	{
+	    new_decl_list(&$$, $1);
+	}
+	| init_declarator_list ',' init_declarator
+	{
+	    add_decl_list(&$$, &$1, $3);
+	}
+	;
+
+init_declarator
+	: declarator
+	{
+	    if ($1->func_def != FUNC_NONE && func_params == NULL &&
+		func_style == FUNC_TRADITIONAL && cur_file->convert) {
+		gen_func_declarator($1);
+		fputs(cur_text(), cur_file->tmp_file);
+	    }
+	    cur_declarator = $$;
+	}
+	| declarator '='
+	{
+	    if ($1->func_def != FUNC_NONE && func_params == NULL &&
+		func_style == FUNC_TRADITIONAL && cur_file->convert) {
+		gen_func_declarator($1);
+		fputs(" =", cur_file->tmp_file);
+	    }
+	}
+	  T_INITIALIZER
+	;
+
+enum_specifier
+	: enumeration any_id braces
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "enum %s", $2.text);
+	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
+	}
+	| enumeration braces
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "%s {}", $1.text);
+	    new_decl_spec(&$$, s, $1.begin, DS_NONE);
+	}
+	| enumeration any_id
+	{
+	    (void)sprintf(buf, "enum %s", $2.text);
+	    new_decl_spec(&$$, buf, $1.begin, DS_NONE);
+	}
+	;
+
+enumeration
+	: T_ENUM
+	{
+	    imply_typedef("enum");
+	    $$ = $1;
+	}
+	;
+
+any_id
+	: T_IDENTIFIER
+	| T_TYPEDEF_NAME
+	;
+
+declarator
+	: pointer direct_declarator
+	{
+	    $$ = $2;
+	    (void)sprintf(buf, "%s%s", $1.text, $$->text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	    $$->begin = $1.begin;
+	    $$->pointer = TRUE;
+	}
+	| direct_declarator
+	;
+
+direct_declarator
+	: identifier_or_ref
+	{
+	    $$ = new_declarator($1.text, $1.text, $1.begin);
+	}
+	| '(' declarator ')'
+	{
+	    $$ = $2;
+	    (void)sprintf(buf, "(%s)", $$->text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	    $$->begin = $1.begin;
+	}
+	| direct_declarator T_BRACKETS
+	{
+	    $$ = $1;
+	    (void)sprintf(buf, "%s%s", $$->text, $2.text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	}
+	| direct_declarator '(' parameter_type_list ')'
+	{
+	    $$ = new_declarator("%s()", $1->name, $1->begin);
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->func_def = FUNC_ANSI;
+	}
+	| direct_declarator '(' opt_identifier_list ')'
+	{
+	    $$ = new_declarator("%s()", $1->name, $1->begin);
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->func_def = FUNC_TRADITIONAL;
+	}
+	;
+
+pointer
+	: '*' opt_type_qualifiers
+	{
+	    (void)sprintf($$.text, "*%s", $2.text);
+	    $$.begin = $1.begin;
+	}
+	| '*' opt_type_qualifiers pointer
+	{
+	    (void)sprintf($$.text, "*%s%s", $2.text, $3.text);
+	    $$.begin = $1.begin;
+	}
+	;
+
+opt_type_qualifiers
+	: /* empty */
+	{
+	    strcpy($$.text, "");
+	    $$.begin = 0L;
+	}
+	| type_qualifier_list
+	;
+
+type_qualifier_list
+	: type_qualifier
+	{
+	    (void)sprintf($$.text, "%s ", $1.text);
+	    $$.begin = $1.begin;
+	    free($1.text);
+	}
+	| type_qualifier_list type_qualifier
+	{
+	    (void)sprintf($$.text, "%s%s ", $1.text, $2.text);
+	    $$.begin = $1.begin;
+	    free($2.text);
+	}
+	;
+
+parameter_type_list
+	: parameter_list
+	| parameter_list ',' T_ELLIPSIS
+	{
+	    add_ident_list(&$$, &$1, "...");
+	}
+	;
+
+parameter_list
+	: parameter_declaration
+	{
+	    new_param_list(&$$, $1);
+	}
+	| parameter_list ',' parameter_declaration
+	{
+	    add_param_list(&$$, &$1, $3);
+	}
+	;
+
+parameter_declaration
+	: decl_specifiers declarator
+	{
+	    check_untagged(&$1);
+	    $$ = new_parameter(&$1, $2);
+	}
+	| decl_specifiers abs_declarator
+	{
+	    check_untagged(&$1);
+	    $$ = new_parameter(&$1, $2);
+	}
+	| decl_specifiers
+	{
+	    check_untagged(&$1);
+	    $$ = new_parameter(&$1, (Declarator *)0);
+	}
+	;
+
+opt_identifier_list
+	: /* empty */
+	{
+	    new_ident_list(&$$);
+	}
+	| identifier_list
+	;
+
+identifier_list
+	: any_id
+	{
+	    new_ident_list(&$$);
+	    add_ident_list(&$$, &$$, $1.text);
+	}
+	| identifier_list ',' any_id
+	{
+	    add_ident_list(&$$, &$1, $3.text);
+	}
+	;
+
+identifier_or_ref
+	: any_id
+	{
+	    $$ = $1;
+	}
+	| '&' any_id
+	{
+#if OPT_LINTLIBRARY
+	    if (lintLibrary()) { /* Lint doesn't grok C++ ref variables */
+		$$ = $2;
+	    } else
+#endif
+		(void)sprintf($$.text, "&%s", $2.text);
+	    $$.begin = $1.begin;
+	}
+	;
+
+abs_declarator
+	: pointer
+	{
+	    $$ = new_declarator($1.text, "", $1.begin);
+	}
+	| pointer direct_abs_declarator
+	{
+	    $$ = $2;
+	    (void)sprintf(buf, "%s%s", $1.text, $$->text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	    $$->begin = $1.begin;
+	}
+	| direct_abs_declarator
+	;
+
+direct_abs_declarator
+	: '(' abs_declarator ')'
+	{
+	    $$ = $2;
+	    (void)sprintf(buf, "(%s)", $$->text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	    $$->begin = $1.begin;
+	}
+	| direct_abs_declarator T_BRACKETS
+	{
+	    $$ = $1;
+	    (void)sprintf(buf, "%s%s", $$->text, $2.text);
+	    free($$->text);
+	    $$->text = xstrdup(buf);
+	}
+	| T_BRACKETS
+	{
+	    $$ = new_declarator($1.text, "", $1.begin);
+	}
+	| direct_abs_declarator '(' parameter_type_list ')'
+	{
+	    $$ = new_declarator("%s()", "", $1->begin);
+	    $$->params = $3;
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->func_def = FUNC_ANSI;
+	}
+	| direct_abs_declarator '(' ')'
+	{
+	    $$ = new_declarator("%s()", "", $1->begin);
+	    $$->func_stack = $1;
+	    $$->head = ($1->func_stack == NULL) ? $$ : $1->head;
+	    $$->func_def = FUNC_ANSI;
+	}
+	| '(' parameter_type_list ')'
+	{
+	    Declarator *d;
+
+	    d = new_declarator("", "", $1.begin);
+	    $$ = new_declarator("%s()", "", $1.begin);
+	    $$->params = $2;
+	    $$->func_stack = d;
+	    $$->head = $$;
+	    $$->func_def = FUNC_ANSI;
+	}
+	| '(' ')'
+	{
+	    Declarator *d;
+
+	    d = new_declarator("", "", $1.begin);
+	    $$ = new_declarator("%s()", "", $1.begin);
+	    $$->func_stack = d;
+	    $$->head = $$;
+	    $$->func_def = FUNC_ANSI;
+	}
+	;
+
+%%
+
+/* lex.yy.c */
+#define BEGIN yy_start = 1 + 2 *
+
+#define CPP1 1
+#define INIT1 2
+#define INIT2 3
+#define CURLY 4
+#define LEXYACC 5
+#define ASM 6
+#define CPP_INLINE 7
+
+extern char *yytext;
+extern FILE *yyin, *yyout;
+
+static int curly;			/* number of curly brace nesting levels */
+static int ly_count;			/* number of occurrences of %% */
+static int inc_depth;			/* include nesting level */
+static SymbolTable *included_files;	/* files already included */
+static int yy_start = 0;		/* start state number */
+
+#define grammar_error(s) yaccError(s)
+
+static void
+yaccError (const char *msg)
+{
+    func_params = NULL;
+    put_error();		/* tell what line we're on, and what file */
+    fprintf(stderr, "%s at token '%s'\n", msg, yytext);
+}
+
+/* Initialize the table of type qualifier keywords recognized by the lexical
+ * analyzer.
+ */
+void
+init_parser (void)
+{
+    static const char *keywords[] = {
+	"const",
+	"restrict",
+	"volatile",
+	"interrupt",
+#ifdef vms
+	"noshare",
+	"readonly",
+#endif
+#if defined(MSDOS) || defined(OS2)
+	"__cdecl",
+	"__export",
+	"__far",
+	"__fastcall",
+	"__fortran",
+	"__huge",
+	"__inline",
+	"__interrupt",
+	"__loadds",
+	"__near",
+	"__pascal",
+	"__saveregs",
+	"__segment",
+	"__stdcall",
+	"__syscall",
+	"_cdecl",
+	"_cs",
+	"_ds",
+	"_es",
+	"_export",
+	"_far",
+	"_fastcall",
+	"_fortran",
+	"_huge",
+	"_interrupt",
+	"_loadds",
+	"_near",
+	"_pascal",
+	"_saveregs",
+	"_seg",
+	"_segment",
+	"_ss",
+	"cdecl",
+	"far",
+	"huge",
+	"near",
+	"pascal",
+#ifdef OS2
+	"__far16",
+#endif
+#endif
+#ifdef __GNUC__
+	/* gcc aliases */
+	"__builtin_va_arg",
+	"__builtin_va_list",
+	"__const",
+	"__const__",
+	"__inline",
+	"__inline__",
+	"__restrict",
+	"__restrict__",
+	"__volatile",
+	"__volatile__",
+#endif
+    };
+    unsigned i;
+
+    /* Initialize type qualifier table. */
+    type_qualifiers = new_symbol_table();
+    for (i = 0; i < sizeof(keywords)/sizeof(keywords[0]); ++i) {
+	new_symbol(type_qualifiers, keywords[i], NULL, DS_NONE);
+    }
+}
+
+/* Process the C source file.  Write function prototypes to the standard
+ * output.  Convert function definitions and write the converted source
+ * code to a temporary file.
+ */
+void
+process_file (FILE *infile, char *name)
+{
+    char *s;
+
+    if (strlen(name) > 2) {
+	s = name + strlen(name) - 2;
+	if (*s == '.') {
+	    ++s;
+	    if (*s == 'l' || *s == 'y')
+		BEGIN LEXYACC;
+#if defined(MSDOS) || defined(OS2)
+	    if (*s == 'L' || *s == 'Y')
+		BEGIN LEXYACC;
+#endif
+	}
+    }
+
+    included_files = new_symbol_table();
+    typedef_names = new_symbol_table();
+    define_names = new_symbol_table();
+    inc_depth = -1;
+    curly = 0;
+    ly_count = 0;
+    func_params = NULL;
+    yyin = infile;
+    include_file(strcpy(base_file, name), func_style != FUNC_NONE);
+    if (file_comments) {
+#if OPT_LINTLIBRARY
+    	if (lintLibrary()) {
+	    put_blankline(stdout);
+	    begin_tracking();
+	}
+#endif
+	put_string(stdout, "/* ");
+	put_string(stdout, cur_file_name());
+	put_string(stdout, " */\n");
+    }
+    yyparse();
+    free_symbol_table(define_names);
+    free_symbol_table(typedef_names);
+    free_symbol_table(included_files);
+}
+
+#ifdef NO_LEAKS
+void
+free_parser(void)
+{
+    free_symbol_table (type_qualifiers);
+#ifdef FLEX_SCANNER
+    if (yy_current_buffer != 0)
+	yy_delete_buffer(yy_current_buffer);
+#endif
+}
+#endif
diff --git a/usr.bin/yacc/tests/legacy_test.sh b/usr.bin/yacc/tests/legacy_test.sh
new file mode 100644
index 000000000000..1b6b806c5980
--- /dev/null
+++ b/usr.bin/yacc/tests/legacy_test.sh
@@ -0,0 +1,6 @@
+#!/bin/sh
+# $FreeBSD$
+
+SRCDIR="$(dirname "${0}")"; export SRCDIR
+
+m4 "${SRCDIR}/../regress.m4" "${SRCDIR}/regress.sh" | sh
diff --git a/usr.bin/yacc/tests/pure_calc.y b/usr.bin/yacc/tests/pure_calc.y
new file mode 100644
index 000000000000..3cd04332dcdd
--- /dev/null
+++ b/usr.bin/yacc/tests/pure_calc.y
@@ -0,0 +1,116 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM &yylval
+#define YYLEX_DECL() yylex(YYSTYPE *yylval)
+#define YYERROR_DECL() yyerror(const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+%}
+
+%start list
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr '+' expr
+            {  $$ = $1 + $3; }
+      |  expr '-' expr
+            {  $$ = $1 - $3; }
+      |  expr '*' expr
+            {  $$ = $1 * $3; }
+      |  expr '/' expr
+            {  $$ = $1 / $3; }
+      |  expr '%' expr
+            {  $$ = $1 % $3; }
+      |  expr '&' expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  '-' expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+#ifdef YYBYACC
+static int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+YYERROR_DECL()
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+YYLEX_DECL()
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	*yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	*yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/pure_error.y b/usr.bin/yacc/tests/pure_error.y
new file mode 100644
index 000000000000..fe7a3c3094f2
--- /dev/null
+++ b/usr.bin/yacc/tests/pure_error.y
@@ -0,0 +1,41 @@
+%{
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM &yylval
+#define YYLEX_DECL() yylex(YYSTYPE *yylval)
+#define YYERROR_DECL() yyerror(const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+%}
+
+%%
+S: error
+%%
+
+#include <stdio.h>
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(YYSTYPE *value)
+{
+    return value ? 0 : -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
diff --git a/usr.bin/yacc/tests/quote_calc.y b/usr.bin/yacc/tests/quote_calc.y
new file mode 100644
index 000000000000..9304dd8a7006
--- /dev/null
+++ b/usr.bin/yacc/tests/quote_calc.y
@@ -0,0 +1,112 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+%}
+
+%start list
+
+%token OP_ADD "ADD"
+%token OP_SUB "SUB"
+%token OP_MUL "MUL"
+%token OP_DIV "DIV"
+%token OP_MOD "MOD"
+%token OP_AND "AND"
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr OP_ADD expr
+            {  $$ = $1 + $3; }
+      |  expr OP_SUB expr
+            {  $$ = $1 - $3; }
+      |  expr OP_MUL expr
+            {  $$ = $1 * $3; }
+      |  expr OP_DIV expr
+            {  $$ = $1 / $3; }
+      |  expr OP_MOD expr
+            {  $$ = $1 % $3; }
+      |  expr OP_AND expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  OP_SUB expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/quote_calc2.y b/usr.bin/yacc/tests/quote_calc2.y
new file mode 100644
index 000000000000..ab72a285fcb5
--- /dev/null
+++ b/usr.bin/yacc/tests/quote_calc2.y
@@ -0,0 +1,112 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+%}
+
+%start list
+
+%token OP_ADD "ADD"
+%token OP_SUB "SUB"
+%token OP_MUL "MUL"
+%token OP_DIV "DIV"
+%token OP_MOD "MOD"
+%token OP_AND "AND"
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr "ADD" expr
+            {  $$ = $1 + $3; }
+      |  expr "SUB" expr
+            {  $$ = $1 - $3; }
+      |  expr "MUL" expr
+            {  $$ = $1 * $3; }
+      |  expr "DIV" expr
+            {  $$ = $1 / $3; }
+      |  expr "MOD" expr
+            {  $$ = $1 % $3; }
+      |  expr "AND" expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  "SUB" expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/quote_calc3.y b/usr.bin/yacc/tests/quote_calc3.y
new file mode 100644
index 000000000000..5feeb4a03ed6
--- /dev/null
+++ b/usr.bin/yacc/tests/quote_calc3.y
@@ -0,0 +1,112 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+%}
+
+%start list
+
+%token OP_ADD "ADD-operator"
+%token OP_SUB "SUB-operator"
+%token OP_MUL "MUL-operator"
+%token OP_DIV "DIV-operator"
+%token OP_MOD "MOD-operator"
+%token OP_AND "AND-operator"
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr OP_ADD expr
+            {  $$ = $1 + $3; }
+      |  expr OP_SUB expr
+            {  $$ = $1 - $3; }
+      |  expr OP_MUL expr
+            {  $$ = $1 * $3; }
+      |  expr OP_DIV expr
+            {  $$ = $1 / $3; }
+      |  expr OP_MOD expr
+            {  $$ = $1 % $3; }
+      |  expr OP_AND expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  OP_SUB expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/quote_calc4.y b/usr.bin/yacc/tests/quote_calc4.y
new file mode 100644
index 000000000000..34b790e67f12
--- /dev/null
+++ b/usr.bin/yacc/tests/quote_calc4.y
@@ -0,0 +1,112 @@
+%{
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+%}
+
+%start list
+
+%token OP_ADD "ADD-operator"
+%token OP_SUB "SUB-operator"
+%token OP_MUL "MUL-operator"
+%token OP_DIV "DIV-operator"
+%token OP_MOD "MOD-operator"
+%token OP_AND "AND-operator"
+
+%token DIGIT LETTER
+
+%left '|'
+%left '&'
+%left '+' '-'
+%left '*' '/' '%'
+%left UMINUS   /* supplies precedence for unary minus */
+
+%% /* beginning of rules section */
+
+list  :  /* empty */
+      |  list stat '\n'
+      |  list error '\n'
+            {  yyerrok ; }
+      ;
+
+stat  :  expr
+            {  printf("%d\n",$1);}
+      |  LETTER '=' expr
+            {  regs[$1] = $3; }
+      ;
+
+expr  :  '(' expr ')'
+            {  $$ = $2; }
+      |  expr "ADD-operator" expr
+            {  $$ = $1 + $3; }
+      |  expr "SUB-operator" expr
+            {  $$ = $1 - $3; }
+      |  expr "MUL-operator" expr
+            {  $$ = $1 * $3; }
+      |  expr "DIV-operator" expr
+            {  $$ = $1 / $3; }
+      |  expr "MOD-operator" expr
+            {  $$ = $1 % $3; }
+      |  expr "AND-operator" expr
+            {  $$ = $1 & $3; }
+      |  expr '|' expr
+            {  $$ = $1 | $3; }
+      |  "SUB-operator" expr %prec UMINUS
+            {  $$ = - $2; }
+      |  LETTER
+            {  $$ = regs[$1]; }
+      |  number
+      ;
+
+number:  DIGIT
+         {  $$ = $1; base = ($1==0) ? 8 : 10; }
+      |  number DIGIT
+         {  $$ = base * $1 + $2; }
+      ;
+
+%% /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
diff --git a/usr.bin/yacc/tests/regress.00.out b/usr.bin/yacc/tests/regress.00.out
new file mode 100644
index 000000000000..39a8ca28a5f3
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.00.out
@@ -0,0 +1,386 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,
+};
+static const short yylen[] = {                            2,
+    0,
+};
+static const short yydefred[] = {                         1,
+    0,
+};
+static const short yydgoto[] = {                          1,
+};
+static const short yysindex[] = {                         0,
+    0,
+};
+static const short yyrindex[] = {                         0,
+    0,
+};
+static const short yygindex[] = {                         0,
+};
+#define YYTABLESIZE 0
+static const short yytable[] = {                          0,
+};
+static const short yycheck[] = {                         -1,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 0
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : rule",
+"rule :",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.01.out b/usr.bin/yacc/tests/regress.01.out
new file mode 100644
index 000000000000..8187502fa21a
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.01.out
@@ -0,0 +1,589 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "calc.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+extern int yylex(void);
+static void yyerror(const char *s);
+
+#line 29 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define DIGIT 257
+#define LETTER 258
+#define UMINUS 259
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
+    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
+   10,   11,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
+  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
+  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,   65,    0,
+};
+#define YYTABLESIZE 220
+static const short yytable[] = {                          6,
+   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
+   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
+    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
+    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
+    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
+    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
+    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
+   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
+   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
+    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
+    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
+    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
+    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
+};
+static const short yycheck[] = {                         40,
+   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
+   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
+   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
+   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
+   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
+   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
+   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
+    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
+   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
+   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
+   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 259
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr '+' expr",
+"expr : expr '-' expr",
+"expr : expr '*' expr",
+"expr : expr '/' expr",
+"expr : expr '%' expr",
+"expr : expr '&' expr",
+"expr : expr '|' expr",
+"expr : '-' expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 66 "calc.y"
+ /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 267 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 28 "calc.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 32 "calc.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 34 "calc.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 38 "calc.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 40 "calc.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 42 "calc.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 44 "calc.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 46 "calc.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 48 "calc.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 50 "calc.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 52 "calc.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 54 "calc.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 56 "calc.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 61 "calc.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 63 "calc.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 529 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.02.out b/usr.bin/yacc/tests/regress.02.out
new file mode 100644
index 000000000000..30de536da40e
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.02.out
@@ -0,0 +1,831 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "calc1.y"
+
+/* http://dinosaur.compilertools.net/yacc/index.html */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <math.h>
+
+typedef struct interval
+{
+    double lo, hi;
+}
+INTERVAL;
+
+INTERVAL vmul(double, double, INTERVAL);
+INTERVAL vdiv(double, double, INTERVAL);
+
+extern int yylex(void);
+static void yyerror(const char *s);
+
+int dcheck(INTERVAL);
+
+double dreg[26];
+INTERVAL vreg[26];
+
+#line 31 "calc1.y"
+#ifdef YYSTYPE
+#undef  YYSTYPE_IS_DECLARED
+#define YYSTYPE_IS_DECLARED 1
+#endif
+#ifndef YYSTYPE_IS_DECLARED
+#define YYSTYPE_IS_DECLARED 1
+typedef union
+{
+	int ival;
+	double dval;
+	INTERVAL vval;
+} YYSTYPE;
+#endif /* !YYSTYPE_IS_DECLARED */
+#line 59 "/dev/stdout"
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define DREG 257
+#define VREG 258
+#define CONST 259
+#define UMINUS 260
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    3,    3,    0,    0,    0,    0,    0,    1,    1,    1,
+    1,    1,    1,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    2,    2,
+};
+static const short yylen[] = {                            2,
+    0,    2,    2,    2,    4,    4,    2,    1,    1,    3,
+    3,    3,    3,    2,    3,    1,    5,    1,    3,    3,
+    3,    3,    3,    3,    3,    3,    2,    3,
+};
+static const short yydefred[] = {                         0,
+    0,    0,    0,    8,    0,    0,    0,    0,    0,    7,
+    0,    0,    9,   18,   14,   27,    0,    0,    0,    0,
+    0,    0,    3,    0,    0,    0,    0,    4,    0,    0,
+    0,    0,    0,   15,    0,   28,    0,    0,    0,    0,
+   12,   24,   13,   26,    0,    0,   23,   25,   14,    0,
+    0,    0,    0,    0,    5,    6,    0,    0,    0,   12,
+   13,   17,
+};
+static const short yydgoto[] = {                          7,
+   32,    9,    0,
+};
+static const short yysindex[] = {                       -40,
+   -8,  -48,  -47,    0,  -37,  -37,    0,    2,   17,    0,
+  -34,  -37,    0,    0,    0,    0,  -25,   90,  -37,  -37,
+  -37,  -37,    0,  -37,  -37,  -37,  -37,    0,  -34,  -34,
+   25,  125,   31,    0,  -34,    0,  -11,   37,  -11,   37,
+    0,    0,    0,    0,   37,   37,    0,    0,    0,  111,
+  -34,  -34,  -34,  -34,    0,    0,  118,   69,   69,    0,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,   38,   44,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   -9,    0,    0,    0,    0,   51,   -3,   56,   61,
+    0,    0,    0,    0,   67,   72,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   78,   83,    0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+    4,  124,    0,
+};
+#define YYTABLESIZE 225
+static const short yytable[] = {                          6,
+   16,   10,    6,    8,    5,   30,   20,    5,   15,   17,
+   29,   23,   11,   12,   31,   34,   21,   19,   35,   20,
+    0,   22,   37,   39,   41,   43,   28,    0,    0,    0,
+   21,   16,   49,   50,   55,   22,    0,   20,   57,   20,
+   56,   20,    0,   21,   19,    0,   20,    9,   22,    0,
+    0,    0,    0,   18,   58,   59,   60,   61,   26,   24,
+   10,   25,    0,   27,    0,   11,   53,   51,    0,   52,
+   22,   54,   26,   24,    0,   25,   19,   27,   26,    9,
+    9,   21,    9,   27,    9,   18,   18,   10,   18,    0,
+   18,   10,   11,   10,   10,   10,   11,    0,   11,   11,
+   11,   22,    0,   22,    0,   22,    0,   19,    0,   19,
+   53,   19,   21,    0,   21,   54,   21,    0,   10,    0,
+   10,    0,   10,   11,    0,   11,    0,   11,   16,   18,
+   36,   26,   24,    0,   25,   33,   27,    0,    0,    0,
+    0,    0,   38,   40,   42,   44,    0,   45,   46,   47,
+   48,   34,   53,   51,    0,   52,    0,   54,   62,   53,
+   51,    0,   52,    0,   54,    0,   21,   19,    0,   20,
+    0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    1,    2,    3,    4,   13,
+   14,    4,   13,    0,    4,
+};
+static const short yycheck[] = {                         40,
+   10,   10,   40,    0,   45,   40,   10,   45,    5,    6,
+   45,   10,   61,   61,   11,   41,   42,   43,   44,   45,
+   -1,   47,   19,   20,   21,   22,   10,   -1,   -1,   -1,
+   42,   41,   29,   30,   10,   47,   -1,   41,   35,   43,
+   10,   45,   -1,   42,   43,   -1,   45,   10,   47,   -1,
+   -1,   -1,   -1,   10,   51,   52,   53,   54,   42,   43,
+   10,   45,   -1,   47,   -1,   10,   42,   43,   -1,   45,
+   10,   47,   42,   43,   -1,   45,   10,   47,   42,   42,
+   43,   10,   45,   47,   47,   42,   43,   10,   45,   -1,
+   47,   41,   10,   43,   44,   45,   41,   -1,   43,   44,
+   45,   41,   -1,   43,   -1,   45,   -1,   41,   -1,   43,
+   42,   45,   41,   -1,   43,   47,   45,   -1,   41,   -1,
+   43,   -1,   45,   41,   -1,   43,   -1,   45,    5,    6,
+   41,   42,   43,   -1,   45,   12,   47,   -1,   -1,   -1,
+   -1,   -1,   19,   20,   21,   22,   -1,   24,   25,   26,
+   27,   41,   42,   43,   -1,   45,   -1,   47,   41,   42,
+   43,   -1,   45,   -1,   47,   -1,   42,   43,   -1,   45,
+   -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  259,  257,
+  258,  259,  257,   -1,  259,
+};
+#define YYFINAL 7
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 260
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,
+0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,"DREG","VREG","CONST","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : line",
+"lines :",
+"lines : lines line",
+"line : dexp '\\n'",
+"line : vexp '\\n'",
+"line : DREG '=' dexp '\\n'",
+"line : VREG '=' vexp '\\n'",
+"line : error '\\n'",
+"dexp : CONST",
+"dexp : DREG",
+"dexp : dexp '+' dexp",
+"dexp : dexp '-' dexp",
+"dexp : dexp '*' dexp",
+"dexp : dexp '/' dexp",
+"dexp : '-' dexp",
+"dexp : '(' dexp ')'",
+"vexp : dexp",
+"vexp : '(' dexp ',' dexp ')'",
+"vexp : VREG",
+"vexp : vexp '+' vexp",
+"vexp : dexp '+' vexp",
+"vexp : vexp '-' vexp",
+"vexp : dexp '-' vexp",
+"vexp : vexp '*' vexp",
+"vexp : dexp '*' vexp",
+"vexp : vexp '/' vexp",
+"vexp : dexp '/' vexp",
+"vexp : '-' vexp",
+"vexp : '(' vexp ')'",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 176 "calc1.y"
+	/* beginning of subroutines section */
+
+#define BSZ 50			/* buffer size for floating point numbers */
+
+	/* lexical analysis */
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+    int c;
+
+    while ((c = getchar()) == ' ')
+    {				/* skip over blanks */
+    }
+
+    if (isupper(c))
+    {
+	yylval.ival = c - 'A';
+	return (VREG);
+    }
+    if (islower(c))
+    {
+	yylval.ival = c - 'a';
+	return (DREG);
+    }
+
+    if (isdigit(c) || c == '.')
+    {
+	/* gobble up digits, points, exponents */
+	char buf[BSZ + 1], *cp = buf;
+	int dot = 0, expr = 0;
+
+	for (; (cp - buf) < BSZ; ++cp, c = getchar())
+	{
+
+	    *cp = c;
+	    if (isdigit(c))
+		continue;
+	    if (c == '.')
+	    {
+		if (dot++ || expr)
+		    return ('.');	/* will cause syntax error */
+		continue;
+	    }
+
+	    if (c == 'e')
+	    {
+		if (expr++)
+		    return ('e');	/*  will  cause  syntax  error  */
+		continue;
+	    }
+
+	    /*  end  of  number  */
+	    break;
+	}
+	*cp = '\0';
+
+	if ((cp - buf) >= BSZ)
+	    printf("constant  too  long:  truncated\n");
+	else
+	    ungetc(c, stdin);	/*  push  back  last  char  read  */
+	yylval.dval = atof(buf);
+	return (CONST);
+    }
+    return (c);
+}
+
+static INTERVAL
+hilo(double a, double b, double c, double d)
+{
+    /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
+    /*  used  by  *,  /  routines  */
+    INTERVAL v;
+
+    if (a > b)
+    {
+	v.hi = a;
+	v.lo = b;
+    }
+    else
+    {
+	v.hi = b;
+	v.lo = a;
+    }
+
+    if (c > d)
+    {
+	if (c > v.hi)
+	    v.hi = c;
+	if (d < v.lo)
+	    v.lo = d;
+    }
+    else
+    {
+	if (d > v.hi)
+	    v.hi = d;
+	if (c < v.lo)
+	    v.lo = c;
+    }
+    return (v);
+}
+
+INTERVAL
+vmul(double a, double b, INTERVAL v)
+{
+    return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
+}
+
+int
+dcheck(INTERVAL v)
+{
+    if (v.hi >= 0. && v.lo <= 0.)
+    {
+	printf("divisor  interval  contains  0.\n");
+	return (1);
+    }
+    return (0);
+}
+
+INTERVAL
+vdiv(double a, double b, INTERVAL v)
+{
+    return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
+}
+#line 406 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 57 "calc1.y"
+	{
+		(void) printf("%15.8f\n", yystack.l_mark[-1].dval);
+	}
+break;
+case 4:
+#line 61 "calc1.y"
+	{
+		(void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
+	}
+break;
+case 5:
+#line 65 "calc1.y"
+	{
+		dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
+	}
+break;
+case 6:
+#line 69 "calc1.y"
+	{
+		vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
+	}
+break;
+case 7:
+#line 73 "calc1.y"
+	{
+		yyerrok;
+	}
+break;
+case 9:
+#line 80 "calc1.y"
+	{
+		yyval.dval = dreg[yystack.l_mark[0].ival];
+	}
+break;
+case 10:
+#line 84 "calc1.y"
+	{
+		yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
+	}
+break;
+case 11:
+#line 88 "calc1.y"
+	{
+		yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
+	}
+break;
+case 12:
+#line 92 "calc1.y"
+	{
+		yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
+	}
+break;
+case 13:
+#line 96 "calc1.y"
+	{
+		yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
+	}
+break;
+case 14:
+#line 100 "calc1.y"
+	{
+		yyval.dval = -yystack.l_mark[0].dval;
+	}
+break;
+case 15:
+#line 104 "calc1.y"
+	{
+		yyval.dval = yystack.l_mark[-1].dval;
+	}
+break;
+case 16:
+#line 110 "calc1.y"
+	{
+		yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
+	}
+break;
+case 17:
+#line 114 "calc1.y"
+	{
+		yyval.vval.lo = yystack.l_mark[-3].dval;
+		yyval.vval.hi = yystack.l_mark[-1].dval;
+		if ( yyval.vval.lo > yyval.vval.hi ) 
+		{
+			(void) printf("interval out of order\n");
+			YYERROR;
+		}
+	}
+break;
+case 18:
+#line 124 "calc1.y"
+	{
+		yyval.vval = vreg[yystack.l_mark[0].ival];
+	}
+break;
+case 19:
+#line 128 "calc1.y"
+	{
+		yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
+		yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
+	}
+break;
+case 20:
+#line 133 "calc1.y"
+	{
+		yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
+		yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
+	}
+break;
+case 21:
+#line 138 "calc1.y"
+	{
+		yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
+		yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
+	}
+break;
+case 22:
+#line 143 "calc1.y"
+	{
+		yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
+		yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
+	}
+break;
+case 23:
+#line 148 "calc1.y"
+	{
+		yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
+	}
+break;
+case 24:
+#line 152 "calc1.y"
+	{
+		yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
+	}
+break;
+case 25:
+#line 156 "calc1.y"
+	{
+		if (dcheck(yystack.l_mark[0].vval)) YYERROR;
+		yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
+	}
+break;
+case 26:
+#line 161 "calc1.y"
+	{
+		if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
+		yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
+	}
+break;
+case 27:
+#line 166 "calc1.y"
+	{
+		yyval.vval.hi = -yystack.l_mark[0].vval.lo;
+		yyval.vval.lo = -yystack.l_mark[0].vval.hi;
+	}
+break;
+case 28:
+#line 171 "calc1.y"
+	{
+		yyval.vval = yystack.l_mark[-1].vval;
+	}
+break;
+#line 771 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.03.out b/usr.bin/yacc/tests/regress.03.out
new file mode 100644
index 000000000000..a8c9f8c924eb
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.03.out
@@ -0,0 +1,603 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 1
+
+#line 9 "calc3.y"
+# include <stdio.h>
+# include <ctype.h>
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM base
+#define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
+#define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+#line 32 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(int  regs[26], int * base)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# ifdef YYLEX_PARAM_TYPE
+#  define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
+# else
+#  define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
+# endif
+# define YYLEX yylex(&yylval, YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(YYSTYPE *yylval, int * base)
+# define YYLEX yylex(&yylval, base)
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(int  regs[26], int * base, const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(regs, base, msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define DIGIT 257
+#define LETTER 258
+#define UMINUS 259
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
+    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
+   10,   11,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
+  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
+  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,   65,    0,
+};
+#define YYTABLESIZE 220
+static const short yytable[] = {                          6,
+   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
+   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
+    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
+    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
+    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
+    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
+    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
+   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
+   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
+    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
+    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
+    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
+    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
+};
+static const short yycheck[] = {                         40,
+   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
+   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
+   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
+   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
+   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
+   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
+   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
+    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
+   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
+   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
+   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 259
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr '+' expr",
+"expr : expr '-' expr",
+"expr : expr '*' expr",
+"expr : expr '/' expr",
+"expr : expr '%' expr",
+"expr : expr '&' expr",
+"expr : expr '|' expr",
+"expr : '-' expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+#line 76 "calc3.y"
+ /* start of programs */
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    int regs[26];
+    int base = 10;
+
+    while(!feof(stdin)) {
+	yyparse(regs, &base);
+    }
+    return 0;
+}
+
+static void
+YYERROR_DECL()
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+YYLEX_DECL()
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	*yylval = (c - 'a');
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	*yylval = (c - '0') % (*base);
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 274 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int      yyerrflag;
+    int      yychar;
+    YYSTYPE  yyval;
+    YYSTYPE  yylval;
+
+    /* variables for the parser stack */
+    YYSTACKDATA yystack;
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror(regs, base, "syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 38 "calc3.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 42 "calc3.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 44 "calc3.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 48 "calc3.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 50 "calc3.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 52 "calc3.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 54 "calc3.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 56 "calc3.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 58 "calc3.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 60 "calc3.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 62 "calc3.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 64 "calc3.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 66 "calc3.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 71 "calc3.y"
+	{  yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 73 "calc3.y"
+	{  yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 543 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror(regs, base, "yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.04.out b/usr.bin/yacc/tests/regress.04.out
new file mode 100644
index 000000000000..cd93e8652c2c
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.04.out
@@ -0,0 +1,595 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "code_calc.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *s);
+#endif
+
+#line 31 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define DIGIT 257
+#define LETTER 258
+#define UMINUS 259
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
+    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
+   10,   11,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
+  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
+  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,   65,    0,
+};
+#define YYTABLESIZE 220
+static const short yytable[] = {                          6,
+   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
+   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
+    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
+    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
+    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
+    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
+    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
+   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
+   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
+    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
+    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
+    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
+    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
+};
+static const short yycheck[] = {                         40,
+   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
+   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
+   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
+   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
+   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
+   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
+   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
+    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
+   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
+   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
+   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 259
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr '+' expr",
+"expr : expr '-' expr",
+"expr : expr '*' expr",
+"expr : expr '/' expr",
+"expr : expr '%' expr",
+"expr : expr '&' expr",
+"expr : expr '|' expr",
+"expr : '-' expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 68 "code_calc.y"
+ /* start of programs */
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void)
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 273 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 30 "code_calc.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 34 "code_calc.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 36 "code_calc.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 40 "code_calc.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 42 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 44 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 46 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 48 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 50 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 52 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 54 "code_calc.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 56 "code_calc.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 58 "code_calc.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 63 "code_calc.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 65 "code_calc.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 535 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.05.out b/usr.bin/yacc/tests/regress.05.out
new file mode 100644
index 000000000000..2fbf0d93b211
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.05.out
@@ -0,0 +1,425 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "code_error.y"
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *);
+#endif
+
+#line 26 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,
+};
+static const short yylen[] = {                            2,
+    1,
+};
+static const short yydefred[] = {                         0,
+    1,    0,
+};
+static const short yydgoto[] = {                          2,
+};
+static const short yysindex[] = {                      -256,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+};
+#define YYTABLESIZE 0
+static const short yytable[] = {                          1,
+};
+static const short yycheck[] = {                        256,
+};
+#define YYFINAL 2
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 0
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : S",
+"S : error",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 12 "code_error.y"
+
+#include <stdio.h>
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(void)
+{
+    return -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
+#line 164 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.06.out b/usr.bin/yacc/tests/regress.06.out
new file mode 100644
index 000000000000..d2305e197152
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.06.out
@@ -0,0 +1,417 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "error.y"
+int yylex(void);
+static void yyerror(const char *);
+#line 22 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,
+};
+static const short yylen[] = {                            2,
+    1,
+};
+static const short yydefred[] = {                         0,
+    1,    0,
+};
+static const short yydgoto[] = {                          2,
+};
+static const short yysindex[] = {                      -256,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+};
+#define YYTABLESIZE 0
+static const short yytable[] = {                          1,
+};
+static const short yycheck[] = {                        256,
+};
+#define YYFINAL 2
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 0
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : S",
+"S : error",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 8 "error.y"
+
+#include <stdio.h>
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(void)
+{
+    return -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
+#line 156 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.07.out b/usr.bin/yacc/tests/regress.07.out
new file mode 100644
index 000000000000..ae185a01ea6c
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.07.out
@@ -0,0 +1,1912 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 26 "ftp.y"
+
+/* sccsid[] = "@(#)ftpcmd.y	5.20.1.1 (Berkeley) 3/2/89"; */
+
+#include <sys/param.h>
+#include <sys/socket.h>
+
+#include <netinet/in.h>
+
+#include <arpa/ftp.h>
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <signal.h>
+#include <ctype.h>
+#include <pwd.h>
+#include <setjmp.h>
+#include <syslog.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <time.h>
+#include <assert.h>
+
+#ifdef YYBISON
+int yylex(void);
+static void yyerror(const char *);
+#endif
+
+extern	struct sockaddr_in data_dest;
+extern	int logged_in;
+extern	struct passwd *pw;
+extern	int guest;
+extern	int logging;
+extern	int type;
+extern	int form;
+extern	int debug;
+extern	int timeout;
+extern	int maxtimeout;
+extern  int pdata;
+extern	char hostname[], remotehost[];
+extern	char proctitle[];
+extern	char *globerr;
+extern	int usedefault;
+extern  int transflag;
+extern  char tmpline[];
+
+extern char **glob(char *);
+extern char *renamefrom(char *);
+extern void cwd(const char *);
+
+extern void dologout(int);
+extern void fatal(const char *);
+extern void makedir(const char *);
+extern void nack(const char *);
+extern void pass(const char *);
+extern void passive(void);
+extern void pwd(void);
+extern void removedir(char *);
+extern void renamecmd(char *, char *);
+extern void retrieve(const char *, const char *);
+extern void send_file_list(const char *);
+extern void statcmd(void);
+extern void statfilecmd(const char *);
+extern void store(char *, const char *, int);
+extern void user(const char *);
+
+extern void perror_reply(int, const char *, ...);
+extern void reply(int, const char *, ...);
+extern void lreply(int, const char *, ...);
+
+static	int cmd_type;
+static	int cmd_form;
+static	int cmd_bytesz;
+char	cbuf[512];
+char	*fromname;
+
+struct tab {
+	const char *name;
+	short	token;
+	short	state;
+	short	implemented;	/* 1 if command is implemented */
+	const char *help;
+};
+
+static char * copy(const char *);
+
+#ifdef YYBISON
+static void sizecmd(char *filename);
+static void help(struct tab *ctab, char *s);
+struct tab cmdtab[];
+struct tab sitetab[];
+#endif
+
+static void
+yyerror(const char *msg)
+{
+	perror(msg);
+}
+#line 118 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define A 257
+#define B 258
+#define C 259
+#define E 260
+#define F 261
+#define I 262
+#define L 263
+#define N 264
+#define P 265
+#define R 266
+#define S 267
+#define T 268
+#define SP 269
+#define CRLF 270
+#define COMMA 271
+#define STRING 272
+#define NUMBER 273
+#define USER 274
+#define PASS 275
+#define ACCT 276
+#define REIN 277
+#define QUIT 278
+#define PORT 279
+#define PASV 280
+#define TYPE 281
+#define STRU 282
+#define MODE 283
+#define RETR 284
+#define STOR 285
+#define APPE 286
+#define MLFL 287
+#define MAIL 288
+#define MSND 289
+#define MSOM 290
+#define MSAM 291
+#define MRSQ 292
+#define MRCP 293
+#define ALLO 294
+#define REST 295
+#define RNFR 296
+#define RNTO 297
+#define ABOR 298
+#define DELE 299
+#define CWD 300
+#define LIST 301
+#define NLST 302
+#define SITE 303
+#define STAT 304
+#define HELP 305
+#define NOOP 306
+#define MKD 307
+#define RMD 308
+#define PWD 309
+#define CDUP 310
+#define STOU 311
+#define SMNT 312
+#define SYST 313
+#define SIZE 314
+#define MDTM 315
+#define UMASK 316
+#define IDLE 317
+#define CHMOD 318
+#define LEXERR 319
+#define YYERRCODE 256
+static const 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,    1,    1,    1,    1,
+    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+    1,    1,    1,    1,    1,    1,    2,    3,    4,    4,
+   12,    5,   13,   13,   13,    6,    6,    6,    6,    6,
+    6,    6,    6,    7,    7,    7,    8,    8,    8,   10,
+   14,   11,    9,
+};
+static const short yylen[] = {                            2,
+    0,    2,    2,    4,    4,    4,    2,    4,    4,    4,
+    4,    8,    5,    5,    5,    3,    5,    3,    5,    5,
+    2,    5,    4,    2,    3,    5,    2,    4,    2,    5,
+    5,    3,    3,    4,    6,    5,    7,    9,    4,    6,
+    5,    2,    5,    5,    2,    2,    5,    1,    0,    1,
+    1,   11,    1,    1,    1,    1,    3,    1,    3,    1,
+    1,    3,    2,    1,    1,    1,    1,    1,    1,    1,
+    1,    1,    0,
+};
+static const short yydefred[] = {                         1,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   73,   73,   73,    0,   73,    0,    0,   73,   73,   73,
+   73,    0,    0,    0,    0,   73,   73,   73,   73,   73,
+    0,   73,   73,    2,    3,   46,    0,    0,   45,    0,
+    7,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   24,    0,    0,    0,    0,    0,   21,    0,    0,   27,
+   29,    0,    0,    0,    0,    0,   42,    0,    0,   48,
+    0,   50,    0,    0,    0,    0,    0,   60,    0,    0,
+   64,   66,   65,    0,   68,   69,   67,    0,    0,    0,
+    0,    0,    0,   71,    0,   70,    0,    0,   25,    0,
+   18,    0,   16,    0,   73,    0,   73,    0,    0,    0,
+    0,   32,   33,    0,    0,    0,    4,    5,    0,    6,
+    0,    0,    0,   51,   63,    8,    9,   10,    0,    0,
+    0,    0,   11,    0,   23,    0,    0,    0,    0,    0,
+   34,    0,    0,   39,    0,    0,   28,    0,    0,    0,
+    0,    0,    0,   55,   53,   54,   57,   59,   62,   13,
+   14,   15,    0,   47,   22,   26,   19,   17,    0,    0,
+   36,    0,    0,   20,   30,   31,   41,   43,   44,    0,
+    0,   35,   72,    0,   40,    0,    0,    0,   37,    0,
+    0,   12,    0,    0,   38,    0,    0,    0,   52,
+};
+static const short yydgoto[] = {                          1,
+   34,   35,   71,   73,   75,   80,   84,   88,   45,   95,
+  184,  125,  157,   96,
+};
+static const short yysindex[] = {                         0,
+ -224, -247, -239, -236, -232, -222, -204, -200, -181, -177,
+    0,    0,    0, -166,    0, -161, -199,    0,    0,    0,
+    0, -160, -159, -264, -158,    0,    0,    0,    0,    0,
+ -157,    0,    0,    0,    0,    0, -167, -162,    0, -156,
+    0, -250, -198, -165, -155, -154, -153, -151, -150, -152,
+    0, -145, -252, -229, -217, -302,    0, -144, -146,    0,
+    0, -142, -141, -140, -139, -137,    0, -136, -135,    0,
+ -134,    0, -133, -132, -130, -131, -128,    0, -249, -127,
+    0,    0,    0, -126,    0,    0,    0, -125, -152, -152,
+ -152, -205, -152,    0, -124,    0, -152, -152,    0, -152,
+    0, -143,    0, -173,    0, -171,    0, -152, -123, -152,
+ -152,    0,    0, -152, -152, -152,    0,    0, -138,    0,
+ -164, -164, -122,    0,    0,    0,    0,    0, -121, -120,
+ -118, -148,    0, -117,    0, -116, -115, -114, -113, -112,
+    0, -163, -111,    0, -110, -109,    0, -107, -106, -105,
+ -104, -103, -129,    0,    0,    0,    0,    0,    0,    0,
+    0,    0, -101,    0,    0,    0,    0,    0, -100, -102,
+    0,  -98, -102,    0,    0,    0,    0,    0,    0,  -99,
+  -97,    0,    0,  -95,    0,  -96,  -94,  -92,    0, -152,
+  -93,    0,  -91,  -90,    0,  -88,  -87,  -86,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  -83,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  -82,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  -81,  -80,    0, -158,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,    0,    0,    0,    0,    0,    0,    0,   16,  -89,
+  -25,   35,   47,    0,
+};
+#define YYTABLESIZE 190
+static const short yytable[] = {                        129,
+  130,  131,  104,  134,   59,   60,   76,  136,  137,   77,
+  138,   78,   79,  105,  106,  107,   98,   99,  146,  123,
+  148,  149,   36,  124,  150,  151,  152,   46,   47,   37,
+   49,    2,   38,   52,   53,   54,   55,   39,   58,  100,
+  101,   62,   63,   64,   65,   66,   40,   68,   69,    3,
+    4,  102,  103,    5,    6,    7,    8,    9,   10,   11,
+   12,   13,   81,  132,  133,   41,   82,   83,   42,   14,
+   51,   15,   16,   17,   18,   19,   20,   21,   22,   23,
+   24,   25,   26,   27,   28,   29,   30,   43,   31,   32,
+   33,   44,   85,   86,  154,  140,  141,  143,  144,  155,
+  193,   87,   48,  156,   70,  170,  171,   50,   56,   72,
+   57,   61,   67,   89,   90,   91,   74,  163,   93,   94,
+  142,   92,  145,   97,  108,  109,  110,  111,  139,  112,
+  113,  114,  115,  116,  153,  117,  118,  121,  119,  120,
+  122,  180,  126,  127,  128,  135,  147,  186,  160,  161,
+  124,  162,  164,  165,  166,  167,  168,  159,  173,  169,
+  174,  172,  175,  176,  177,  178,  179,  181,  158,  182,
+  183,  185,  190,  187,  189,  188,  191,  192,  195,  194,
+  196,    0,    0,  198,  197,   73,  199,   49,   56,   58,
+};
+static const short yycheck[] = {                         89,
+   90,   91,  305,   93,  269,  270,  257,   97,   98,  260,
+  100,  262,  263,  316,  317,  318,  269,  270,  108,  269,
+  110,  111,  270,  273,  114,  115,  116,   12,   13,  269,
+   15,  256,  269,   18,   19,   20,   21,  270,   23,  269,
+  270,   26,   27,   28,   29,   30,  269,   32,   33,  274,
+  275,  269,  270,  278,  279,  280,  281,  282,  283,  284,
+  285,  286,  261,  269,  270,  270,  265,  266,  269,  294,
+  270,  296,  297,  298,  299,  300,  301,  302,  303,  304,
+  305,  306,  307,  308,  309,  310,  311,  269,  313,  314,
+  315,  269,  258,  259,  259,  269,  270,  269,  270,  264,
+  190,  267,  269,  268,  272,  269,  270,  269,  269,  272,
+  270,  270,  270,  269,  269,  269,  273,  266,  269,  272,
+  105,  273,  107,  269,  269,  272,  269,  269,  272,  270,
+  270,  269,  269,  269,  273,  270,  270,  269,  271,  270,
+  269,  271,  270,  270,  270,  270,  270,  173,  270,  270,
+  273,  270,  270,  270,  270,  270,  270,  123,  269,  272,
+  270,  273,  270,  270,  270,  270,  270,  269,  122,  270,
+  273,  270,  269,  273,  270,  273,  271,  270,  270,  273,
+  271,   -1,   -1,  271,  273,  269,  273,  270,  270,  270,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 319
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const 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,"A","B","C","E","F","I","L","N",
+"P","R","S","T","SP","CRLF","COMMA","STRING","NUMBER","USER","PASS","ACCT",
+"REIN","QUIT","PORT","PASV","TYPE","STRU","MODE","RETR","STOR","APPE","MLFL",
+"MAIL","MSND","MSOM","MSAM","MRSQ","MRCP","ALLO","REST","RNFR","RNTO","ABOR",
+"DELE","CWD","LIST","NLST","SITE","STAT","HELP","NOOP","MKD","RMD","PWD","CDUP",
+"STOU","SMNT","SYST","SIZE","MDTM","UMASK","IDLE","CHMOD","LEXERR",
+"illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : cmd_list",
+"cmd_list :",
+"cmd_list : cmd_list cmd",
+"cmd_list : cmd_list rcmd",
+"cmd : USER SP username CRLF",
+"cmd : PASS SP password CRLF",
+"cmd : PORT SP host_port CRLF",
+"cmd : PASV CRLF",
+"cmd : TYPE SP type_code CRLF",
+"cmd : STRU SP struct_code CRLF",
+"cmd : MODE SP mode_code CRLF",
+"cmd : ALLO SP NUMBER CRLF",
+"cmd : ALLO SP NUMBER SP R SP NUMBER CRLF",
+"cmd : RETR check_login SP pathname CRLF",
+"cmd : STOR check_login SP pathname CRLF",
+"cmd : APPE check_login SP pathname CRLF",
+"cmd : NLST check_login CRLF",
+"cmd : NLST check_login SP STRING CRLF",
+"cmd : LIST check_login CRLF",
+"cmd : LIST check_login SP pathname CRLF",
+"cmd : STAT check_login SP pathname CRLF",
+"cmd : STAT CRLF",
+"cmd : DELE check_login SP pathname CRLF",
+"cmd : RNTO SP pathname CRLF",
+"cmd : ABOR CRLF",
+"cmd : CWD check_login CRLF",
+"cmd : CWD check_login SP pathname CRLF",
+"cmd : HELP CRLF",
+"cmd : HELP SP STRING CRLF",
+"cmd : NOOP CRLF",
+"cmd : MKD check_login SP pathname CRLF",
+"cmd : RMD check_login SP pathname CRLF",
+"cmd : PWD check_login CRLF",
+"cmd : CDUP check_login CRLF",
+"cmd : SITE SP HELP CRLF",
+"cmd : SITE SP HELP SP STRING CRLF",
+"cmd : SITE SP UMASK check_login CRLF",
+"cmd : SITE SP UMASK check_login SP octal_number CRLF",
+"cmd : SITE SP CHMOD check_login SP octal_number SP pathname CRLF",
+"cmd : SITE SP IDLE CRLF",
+"cmd : SITE SP IDLE SP NUMBER CRLF",
+"cmd : STOU check_login SP pathname CRLF",
+"cmd : SYST CRLF",
+"cmd : SIZE check_login SP pathname CRLF",
+"cmd : MDTM check_login SP pathname CRLF",
+"cmd : QUIT CRLF",
+"cmd : error CRLF",
+"rcmd : RNFR check_login SP pathname CRLF",
+"username : STRING",
+"password :",
+"password : STRING",
+"byte_size : NUMBER",
+"host_port : NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER COMMA NUMBER",
+"form_code : N",
+"form_code : T",
+"form_code : C",
+"type_code : A",
+"type_code : A SP form_code",
+"type_code : E",
+"type_code : E SP form_code",
+"type_code : I",
+"type_code : L",
+"type_code : L SP byte_size",
+"type_code : L byte_size",
+"struct_code : F",
+"struct_code : R",
+"struct_code : P",
+"mode_code : S",
+"mode_code : B",
+"mode_code : C",
+"pathname : pathstring",
+"pathstring : STRING",
+"octal_number : NUMBER",
+"check_login :",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 707 "ftp.y"
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+extern jmp_buf errcatch;
+
+static void upper(char *);
+
+#define	CMD	0	/* beginning of command */
+#define	ARGS	1	/* expect miscellaneous arguments */
+#define	STR1	2	/* expect SP followed by STRING */
+#define	STR2	3	/* expect STRING */
+#define	OSTR	4	/* optional SP then STRING */
+#define	ZSTR1	5	/* SP then optional STRING */
+#define	ZSTR2	6	/* optional STRING after SP */
+#define	SITECMD	7	/* SITE command */
+#define	NSTR	8	/* Number followed by a string */
+
+struct tab cmdtab[] = {		/* In order defined in RFC 765 */
+	{ "USER", USER, STR1, 1,	"<sp> username" },
+	{ "PASS", PASS, ZSTR1, 1,	"<sp> password" },
+	{ "ACCT", ACCT, STR1, 0,	"(specify account)" },
+	{ "SMNT", SMNT, ARGS, 0,	"(structure mount)" },
+	{ "REIN", REIN, ARGS, 0,	"(reinitialize server state)" },
+	{ "QUIT", QUIT, ARGS, 1,	"(terminate service)", },
+	{ "PORT", PORT, ARGS, 1,	"<sp> b0, b1, b2, b3, b4" },
+	{ "PASV", PASV, ARGS, 1,	"(set server in passive mode)" },
+	{ "TYPE", TYPE, ARGS, 1,	"<sp> [ A | E | I | L ]" },
+	{ "STRU", STRU, ARGS, 1,	"(specify file structure)" },
+	{ "MODE", MODE, ARGS, 1,	"(specify transfer mode)" },
+	{ "RETR", RETR, STR1, 1,	"<sp> file-name" },
+	{ "STOR", STOR, STR1, 1,	"<sp> file-name" },
+	{ "APPE", APPE, STR1, 1,	"<sp> file-name" },
+	{ "MLFL", MLFL, OSTR, 0,	"(mail file)" },
+	{ "MAIL", MAIL, OSTR, 0,	"(mail to user)" },
+	{ "MSND", MSND, OSTR, 0,	"(mail send to terminal)" },
+	{ "MSOM", MSOM, OSTR, 0,	"(mail send to terminal or mailbox)" },
+	{ "MSAM", MSAM, OSTR, 0,	"(mail send to terminal and mailbox)" },
+	{ "MRSQ", MRSQ, OSTR, 0,	"(mail recipient scheme question)" },
+	{ "MRCP", MRCP, STR1, 0,	"(mail recipient)" },
+	{ "ALLO", ALLO, ARGS, 1,	"allocate storage (vacuously)" },
+	{ "REST", REST, ARGS, 0,	"(restart command)" },
+	{ "RNFR", RNFR, STR1, 1,	"<sp> file-name" },
+	{ "RNTO", RNTO, STR1, 1,	"<sp> file-name" },
+	{ "ABOR", ABOR, ARGS, 1,	"(abort operation)" },
+	{ "DELE", DELE, STR1, 1,	"<sp> file-name" },
+	{ "CWD",  CWD,  OSTR, 1,	"[ <sp> directory-name ]" },
+	{ "XCWD", CWD,	OSTR, 1,	"[ <sp> directory-name ]" },
+	{ "LIST", LIST, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "NLST", NLST, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "SITE", SITE, SITECMD, 1,	"site-cmd [ <sp> arguments ]" },
+	{ "SYST", SYST, ARGS, 1,	"(get type of operating system)" },
+	{ "STAT", STAT, OSTR, 1,	"[ <sp> path-name ]" },
+	{ "HELP", HELP, OSTR, 1,	"[ <sp> <string> ]" },
+	{ "NOOP", NOOP, ARGS, 1,	"" },
+	{ "MKD",  MKD,  STR1, 1,	"<sp> path-name" },
+	{ "XMKD", MKD,  STR1, 1,	"<sp> path-name" },
+	{ "RMD",  RMD,  STR1, 1,	"<sp> path-name" },
+	{ "XRMD", RMD,  STR1, 1,	"<sp> path-name" },
+	{ "PWD",  PWD,  ARGS, 1,	"(return current directory)" },
+	{ "XPWD", PWD,  ARGS, 1,	"(return current directory)" },
+	{ "CDUP", CDUP, ARGS, 1,	"(change to parent directory)" },
+	{ "XCUP", CDUP, ARGS, 1,	"(change to parent directory)" },
+	{ "STOU", STOU, STR1, 1,	"<sp> file-name" },
+	{ "SIZE", SIZE, OSTR, 1,	"<sp> path-name" },
+	{ "MDTM", MDTM, OSTR, 1,	"<sp> path-name" },
+	{ 0,   0,    0,    0,	0 }
+};
+
+struct tab sitetab[] = {
+	{ "UMASK", UMASK, ARGS, 1,	"[ <sp> umask ]" },
+	{ "IDLE", IDLE, ARGS, 1,	"[ <sp> maximum-idle-time ]" },
+	{ "CHMOD", CHMOD, NSTR, 1,	"<sp> mode <sp> file-name" },
+	{ "HELP", HELP, OSTR, 1,	"[ <sp> <string> ]" },
+	{ 0,   0,    0,    0,	0 }
+};
+
+static struct tab *
+lookup(struct tab *p, char *cmd)
+{
+
+	for (; p->name != 0; p++)
+		if (strcmp(cmd, p->name) == 0)
+			return (p);
+	return (0);
+}
+
+#include <arpa/telnet.h>
+
+/*
+ * get_line - a hacked up version of fgets to ignore TELNET escape codes.
+ */
+static char *
+get_line(char *s, int n, FILE *iop)
+{
+	register int c;
+	register char *cs;
+
+	cs = s;
+/* tmpline may contain saved command from urgent mode interruption */
+	for (c = 0; tmpline[c] != '\0' && --n > 0; ++c) {
+		*cs++ = tmpline[c];
+		if (tmpline[c] == '\n') {
+			*cs = '\0';
+			if (debug)
+				syslog(LOG_DEBUG, "command: %s", s);
+			tmpline[0] = '\0';
+			return(s);
+		}
+		if (c == 0)
+			tmpline[0] = '\0';
+	}
+	while ((c = getc(iop)) != EOF) {
+		c &= 0377;
+		if (c == IAC) {
+		    if ((c = getc(iop)) != EOF) {
+			c &= 0377;
+			switch (c) {
+			case WILL:
+			case WONT:
+				c = getc(iop);
+				printf("%c%c%c", IAC, DONT, 0377&c);
+				(void) fflush(stdout);
+				continue;
+			case DO:
+			case DONT:
+				c = getc(iop);
+				printf("%c%c%c", IAC, WONT, 0377&c);
+				(void) fflush(stdout);
+				continue;
+			case IAC:
+				break;
+			default:
+				continue;	/* ignore command */
+			}
+		    }
+		}
+		*cs++ = c;
+		if (--n <= 0 || c == '\n')
+			break;
+	}
+	if (c == EOF && cs == s)
+		return (0);
+	*cs = '\0';
+	if (debug)
+		syslog(LOG_DEBUG, "command: %s", s);
+	return (s);
+}
+
+static void
+toolong(int sig)
+{
+	time_t now;
+
+	(void) sig;
+	reply(421,
+	  "Timeout (%d seconds): closing control connection.", timeout);
+	(void) time(&now);
+	if (logging) {
+		syslog(LOG_INFO,
+			"User %s timed out after %d seconds at %s",
+			(pw ? pw -> pw_name : "unknown"), timeout, ctime(&now));
+	}
+	dologout(1);
+}
+
+int
+yylex(void)
+{
+	static int cpos, state;
+	register char *cp, *cp2;
+	register struct tab *p;
+	int n;
+	char c;
+
+	for (;;) {
+		switch (state) {
+
+		case CMD:
+			(void) signal(SIGALRM, toolong);
+			(void) alarm((unsigned) timeout);
+			if (get_line(cbuf, sizeof(cbuf)-1, stdin) == 0) {
+				reply(221, "You could at least say goodbye.");
+				dologout(0);
+			}
+			(void) alarm(0);
+#ifdef SETPROCTITLE
+			if (strncasecmp(cbuf, "PASS", 4) != 0)
+				setproctitle("%s: %s", proctitle, cbuf);
+#endif /* SETPROCTITLE */
+			if ((cp = strchr(cbuf, '\r'))) {
+				*cp++ = '\n';
+				*cp = '\0';
+			}
+			if ((cp = strpbrk(cbuf, " \n")))
+				cpos = cp - cbuf;
+			if (cpos == 0)
+				cpos = 4;
+			c = cbuf[cpos];
+			cbuf[cpos] = '\0';
+			upper(cbuf);
+			p = lookup(cmdtab, cbuf);
+			cbuf[cpos] = c;
+			if (p != 0) {
+				if (p->implemented == 0) {
+					nack(p->name);
+					longjmp(errcatch,0);
+					/* NOTREACHED */
+				}
+				state = p->state;
+				*(const char **)(&yylval) = p->name;
+				return (p->token);
+			}
+			break;
+
+		case SITECMD:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				return (SP);
+			}
+			cp = &cbuf[cpos];
+			if ((cp2 = strpbrk(cp, " \n")))
+				cpos = cp2 - cbuf;
+			c = cbuf[cpos];
+			cbuf[cpos] = '\0';
+			upper(cp);
+			p = lookup(sitetab, cp);
+			cbuf[cpos] = c;
+			if (p != 0) {
+				if (p->implemented == 0) {
+					state = CMD;
+					nack(p->name);
+					longjmp(errcatch,0);
+					/* NOTREACHED */
+				}
+				state = p->state;
+				*(const char **)(&yylval) = p->name;
+				return (p->token);
+			}
+			state = CMD;
+			break;
+
+		case OSTR:
+			if (cbuf[cpos] == '\n') {
+				state = CMD;
+				return (CRLF);
+			}
+			/* FALLTHROUGH */
+
+		case STR1:
+		case ZSTR1:
+		dostr1:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				if (state == OSTR)
+					state = STR2;
+				else
+					++state;
+				return (SP);
+			}
+			break;
+
+		case ZSTR2:
+			if (cbuf[cpos] == '\n') {
+				state = CMD;
+				return (CRLF);
+			}
+			/* FALLTHROUGH */
+
+		case STR2:
+			cp = &cbuf[cpos];
+			n = strlen(cp);
+			cpos += n - 1;
+			/*
+			 * Make sure the string is nonempty and \n terminated.
+			 */
+			if (n > 1 && cbuf[cpos] == '\n') {
+				cbuf[cpos] = '\0';
+				*(char **)&yylval = copy(cp);
+				cbuf[cpos] = '\n';
+				state = ARGS;
+				return (STRING);
+			}
+			break;
+
+		case NSTR:
+			if (cbuf[cpos] == ' ') {
+				cpos++;
+				return (SP);
+			}
+			if (isdigit(cbuf[cpos])) {
+				cp = &cbuf[cpos];
+				while (isdigit(cbuf[++cpos]))
+					;
+				c = cbuf[cpos];
+				cbuf[cpos] = '\0';
+				yylval = atoi(cp);
+				cbuf[cpos] = c;
+				state = STR1;
+				return (NUMBER);
+			}
+			state = STR1;
+			goto dostr1;
+
+		case ARGS:
+			if (isdigit(cbuf[cpos])) {
+				cp = &cbuf[cpos];
+				while (isdigit(cbuf[++cpos]))
+					;
+				c = cbuf[cpos];
+				cbuf[cpos] = '\0';
+				yylval = atoi(cp);
+				cbuf[cpos] = c;
+				return (NUMBER);
+			}
+			switch (cbuf[cpos++]) {
+
+			case '\n':
+				state = CMD;
+				return (CRLF);
+
+			case ' ':
+				return (SP);
+
+			case ',':
+				return (COMMA);
+
+			case 'A':
+			case 'a':
+				return (A);
+
+			case 'B':
+			case 'b':
+				return (B);
+
+			case 'C':
+			case 'c':
+				return (C);
+
+			case 'E':
+			case 'e':
+				return (E);
+
+			case 'F':
+			case 'f':
+				return (F);
+
+			case 'I':
+			case 'i':
+				return (I);
+
+			case 'L':
+			case 'l':
+				return (L);
+
+			case 'N':
+			case 'n':
+				return (N);
+
+			case 'P':
+			case 'p':
+				return (P);
+
+			case 'R':
+			case 'r':
+				return (R);
+
+			case 'S':
+			case 's':
+				return (S);
+
+			case 'T':
+			case 't':
+				return (T);
+
+			}
+			break;
+
+		default:
+			fatal("Unknown state in scanner.");
+		}
+		yyerror((char *) 0);
+		state = CMD;
+		longjmp(errcatch,0);
+	}
+}
+
+static void
+upper(char *s)
+{
+	while (*s != '\0') {
+		if (islower(*s))
+			*s = toupper(*s);
+		s++;
+	}
+}
+
+static char *
+copy(const char *s)
+{
+	char *p;
+
+	p = (char * )malloc(strlen(s) + 1);
+	if (p == 0)
+		fatal("Ran out of memory.");
+	else
+		(void) strcpy(p, s);
+	return (p);
+}
+
+static void
+help(struct tab *ctab, char *s)
+{
+	register struct tab *c;
+	register int width, NCMDS;
+	const char *help_type;
+
+	if (ctab == sitetab)
+		help_type = "SITE ";
+	else
+		help_type = "";
+	width = 0, NCMDS = 0;
+	for (c = ctab; c->name != 0; c++) {
+		int len = strlen(c->name);
+
+		if (len > width)
+			width = len;
+		NCMDS++;
+	}
+	width = (width + 8) &~ 7;
+	if (s == 0) {
+		register int i, j, w;
+		int columns, lines;
+
+		lreply(214, "The following %scommands are recognized %s.",
+		    help_type, "(* =>'s unimplemented)");
+		columns = 76 / width;
+		if (columns == 0)
+			columns = 1;
+		lines = (NCMDS + columns - 1) / columns;
+		for (i = 0; i < lines; i++) {
+			printf("   ");
+			for (j = 0; j < columns; j++) {
+				c = ctab + j * lines + i;
+				assert(c->name != 0);
+				printf("%s%c", c->name,
+					c->implemented ? ' ' : '*');
+				if (c + lines >= &ctab[NCMDS])
+					break;
+				w = strlen(c->name) + 1;
+				while (w < width) {
+					putchar(' ');
+					w++;
+				}
+			}
+			printf("\r\n");
+		}
+		(void) fflush(stdout);
+		reply(214, "Direct comments to ftp-bugs@%s.", hostname);
+		return;
+	}
+	upper(s);
+	c = lookup(ctab, s);
+	if (c == (struct tab *)0) {
+		reply(502, "Unknown command %s.", s);
+		return;
+	}
+	if (c->implemented)
+		reply(214, "Syntax: %s%s %s", help_type, c->name, c->help);
+	else
+		reply(214, "%s%-*s\t%s; unimplemented.", help_type, width,
+		    c->name, c->help);
+}
+
+static void
+sizecmd(char *filename)
+{
+	switch (type) {
+	case TYPE_L:
+	case TYPE_I: {
+		struct stat stbuf;
+		if (stat(filename, &stbuf) < 0 ||
+		    (stbuf.st_mode&S_IFMT) != S_IFREG)
+			reply(550, "%s: not a plain file.", filename);
+		else
+#ifdef HAVE_LONG_LONG
+			reply(213, "%llu", (long long) stbuf.st_size);
+#else
+			reply(213, "%lu", stbuf.st_size);
+#endif
+		break;}
+	case TYPE_A: {
+		FILE *fin;
+		register int c, count;
+		struct stat stbuf;
+		fin = fopen(filename, "r");
+		if (fin == 0) {
+			perror_reply(550, filename);
+			return;
+		}
+		if (fstat(fileno(fin), &stbuf) < 0 ||
+		    (stbuf.st_mode&S_IFMT) != S_IFREG) {
+			reply(550, "%s: not a plain file.", filename);
+			(void) fclose(fin);
+			return;
+		}
+
+		count = 0;
+		while((c=getc(fin)) != EOF) {
+			if (c == '\n')	/* will get expanded to \r\n */
+				count++;
+			count++;
+		}
+		(void) fclose(fin);
+
+		reply(213, "%ld", count);
+		break;}
+	default:
+		reply(504, "SIZE not implemented for Type %c.", "?AEIL"[type]);
+	}
+}
+#line 1013 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 2:
+#line 150 "ftp.y"
+	{
+			fromname = (char *) 0;
+		}
+break;
+case 4:
+#line 157 "ftp.y"
+	{
+			user((char *) yystack.l_mark[-1]);
+			free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 5:
+#line 162 "ftp.y"
+	{
+			pass((char *) yystack.l_mark[-1]);
+			free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 6:
+#line 167 "ftp.y"
+	{
+			usedefault = 0;
+			if (pdata >= 0) {
+				(void) close(pdata);
+				pdata = -1;
+			}
+			reply(200, "PORT command successful.");
+		}
+break;
+case 7:
+#line 176 "ftp.y"
+	{
+			passive();
+		}
+break;
+case 8:
+#line 180 "ftp.y"
+	{
+			switch (cmd_type) {
+
+			case TYPE_A:
+				if (cmd_form == FORM_N) {
+					reply(200, "Type set to A.");
+					type = cmd_type;
+					form = cmd_form;
+				} else
+					reply(504, "Form must be N.");
+				break;
+
+			case TYPE_E:
+				reply(504, "Type E not implemented.");
+				break;
+
+			case TYPE_I:
+				reply(200, "Type set to I.");
+				type = cmd_type;
+				break;
+
+			case TYPE_L:
+#if NBBY == 8
+				if (cmd_bytesz == 8) {
+					reply(200,
+					    "Type set to L (byte size 8).");
+					type = cmd_type;
+				} else
+					reply(504, "Byte size must be 8.");
+#else /* NBBY == 8 */
+				UNIMPLEMENTED for NBBY != 8
+#endif /* NBBY == 8 */
+			}
+		}
+break;
+case 9:
+#line 215 "ftp.y"
+	{
+			switch (yystack.l_mark[-1]) {
+
+			case STRU_F:
+				reply(200, "STRU F ok.");
+				break;
+
+			default:
+				reply(504, "Unimplemented STRU type.");
+			}
+		}
+break;
+case 10:
+#line 227 "ftp.y"
+	{
+			switch (yystack.l_mark[-1]) {
+
+			case MODE_S:
+				reply(200, "MODE S ok.");
+				break;
+
+			default:
+				reply(502, "Unimplemented MODE type.");
+			}
+		}
+break;
+case 11:
+#line 239 "ftp.y"
+	{
+			reply(202, "ALLO command ignored.");
+		}
+break;
+case 12:
+#line 243 "ftp.y"
+	{
+			reply(202, "ALLO command ignored.");
+		}
+break;
+case 13:
+#line 247 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				retrieve((char *) 0, (char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 14:
+#line 254 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				store((char *) yystack.l_mark[-1], "w", 0);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 15:
+#line 261 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				store((char *) yystack.l_mark[-1], "a", 0);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 16:
+#line 268 "ftp.y"
+	{
+			if (yystack.l_mark[-1])
+				send_file_list(".");
+		}
+break;
+case 17:
+#line 273 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				send_file_list((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 18:
+#line 280 "ftp.y"
+	{
+			if (yystack.l_mark[-1])
+				retrieve("/bin/ls -lgA", "");
+		}
+break;
+case 19:
+#line 285 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				retrieve("/bin/ls -lgA %s", (char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 20:
+#line 292 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				statfilecmd((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 21:
+#line 299 "ftp.y"
+	{
+			statcmd();
+		}
+break;
+case 22:
+#line 303 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				remove((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 23:
+#line 310 "ftp.y"
+	{
+			if (fromname) {
+				renamecmd(fromname, (char *) yystack.l_mark[-1]);
+				free(fromname);
+				fromname = (char *) 0;
+			} else {
+				reply(503, "Bad sequence of commands.");
+			}
+			free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 24:
+#line 321 "ftp.y"
+	{
+			reply(225, "ABOR command successful.");
+		}
+break;
+case 25:
+#line 325 "ftp.y"
+	{
+			if (yystack.l_mark[-1])
+				cwd(pw->pw_dir);
+		}
+break;
+case 26:
+#line 330 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				cwd((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 27:
+#line 337 "ftp.y"
+	{
+			help(cmdtab, (char *) 0);
+		}
+break;
+case 28:
+#line 341 "ftp.y"
+	{
+			register char *cp = (char *)yystack.l_mark[-1];
+
+			if (strncasecmp(cp, "SITE", 4) == 0) {
+				cp = (char *)yystack.l_mark[-1] + 4;
+				if (*cp == ' ')
+					cp++;
+				if (*cp)
+					help(sitetab, cp);
+				else
+					help(sitetab, (char *) 0);
+			} else
+				help(cmdtab, (char *) yystack.l_mark[-1]);
+		}
+break;
+case 29:
+#line 356 "ftp.y"
+	{
+			reply(200, "NOOP command successful.");
+		}
+break;
+case 30:
+#line 360 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				makedir((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 31:
+#line 367 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				removedir((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 32:
+#line 374 "ftp.y"
+	{
+			if (yystack.l_mark[-1])
+				pwd();
+		}
+break;
+case 33:
+#line 379 "ftp.y"
+	{
+			if (yystack.l_mark[-1])
+				cwd("..");
+		}
+break;
+case 34:
+#line 384 "ftp.y"
+	{
+			help(sitetab, (char *) 0);
+		}
+break;
+case 35:
+#line 388 "ftp.y"
+	{
+			help(sitetab, (char *) yystack.l_mark[-1]);
+		}
+break;
+case 36:
+#line 392 "ftp.y"
+	{
+			int oldmask;
+
+			if (yystack.l_mark[-1]) {
+				oldmask = umask(0);
+				(void) umask(oldmask);
+				reply(200, "Current UMASK is %03o", oldmask);
+			}
+		}
+break;
+case 37:
+#line 402 "ftp.y"
+	{
+			int oldmask;
+
+			if (yystack.l_mark[-3]) {
+				if ((yystack.l_mark[-1] == -1) || (yystack.l_mark[-1] > 0777)) {
+					reply(501, "Bad UMASK value");
+				} else {
+					oldmask = umask(yystack.l_mark[-1]);
+					reply(200,
+					    "UMASK set to %03o (was %03o)",
+					    yystack.l_mark[-1], oldmask);
+				}
+			}
+		}
+break;
+case 38:
+#line 417 "ftp.y"
+	{
+			if (yystack.l_mark[-5] && (yystack.l_mark[-1] != 0)) {
+				if (yystack.l_mark[-3] > 0777)
+					reply(501,
+				"CHMOD: Mode value must be between 0 and 0777");
+				else if (chmod((char *) yystack.l_mark[-1], yystack.l_mark[-3]) < 0)
+					perror_reply(550, (char *) yystack.l_mark[-1]);
+				else
+					reply(200, "CHMOD command successful.");
+			}
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 39:
+#line 431 "ftp.y"
+	{
+			reply(200,
+			    "Current IDLE time limit is %d seconds; max %d",
+				timeout, maxtimeout);
+		}
+break;
+case 40:
+#line 437 "ftp.y"
+	{
+			if (yystack.l_mark[-1] < 30 || yystack.l_mark[-1] > maxtimeout) {
+				reply(501,
+			"Maximum IDLE time must be between 30 and %d seconds",
+				    maxtimeout);
+			} else {
+				timeout = yystack.l_mark[-1];
+				(void) alarm((unsigned) timeout);
+				reply(200,
+				    "Maximum IDLE time set to %d seconds",
+				    timeout);
+			}
+		}
+break;
+case 41:
+#line 451 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				store((char *) yystack.l_mark[-1], "w", 1);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 42:
+#line 458 "ftp.y"
+	{
+#ifdef unix
+#ifdef BSD
+			reply(215, "UNIX Type: L%d Version: BSD-%d",
+				NBBY, BSD);
+#else /* BSD */
+			reply(215, "UNIX Type: L%d", NBBY);
+#endif /* BSD */
+#else /* unix */
+			reply(215, "UNKNOWN Type: L%d", NBBY);
+#endif /* unix */
+		}
+break;
+case 43:
+#line 479 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0)
+				sizecmd((char *) yystack.l_mark[-1]);
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 44:
+#line 496 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1] != 0) {
+				struct stat stbuf;
+				if (stat((char *) yystack.l_mark[-1], &stbuf) < 0)
+					perror_reply(550, "%s", (char *) yystack.l_mark[-1]);
+				else if ((stbuf.st_mode&S_IFMT) != S_IFREG) {
+					reply(550, "%s: not a plain file.",
+						(char *) yystack.l_mark[-1]);
+				} else {
+					register struct tm *t;
+					t = gmtime(&stbuf.st_mtime);
+					reply(213,
+					    "%04d%02d%02d%02d%02d%02d",
+					    1900 + t->tm_year,
+					    t->tm_mon+1, t->tm_mday,
+					    t->tm_hour, t->tm_min, t->tm_sec);
+				}
+			}
+			if (yystack.l_mark[-1] != 0)
+				free((char *) yystack.l_mark[-1]);
+		}
+break;
+case 45:
+#line 518 "ftp.y"
+	{
+			reply(221, "Goodbye.");
+			dologout(0);
+		}
+break;
+case 46:
+#line 523 "ftp.y"
+	{
+			yyerrok;
+		}
+break;
+case 47:
+#line 528 "ftp.y"
+	{
+			if (yystack.l_mark[-3] && yystack.l_mark[-1]) {
+				fromname = renamefrom((char *) yystack.l_mark[-1]);
+				if (fromname == (char *) 0 && yystack.l_mark[-1]) {
+					free((char *) yystack.l_mark[-1]);
+				}
+			}
+		}
+break;
+case 49:
+#line 542 "ftp.y"
+	{
+			*(const char **)(&(yyval)) = "";
+		}
+break;
+case 52:
+#line 553 "ftp.y"
+	{
+			register char *a, *p;
+
+			a = (char *)&data_dest.sin_addr;
+			a[0] = yystack.l_mark[-10]; a[1] = yystack.l_mark[-8]; a[2] = yystack.l_mark[-6]; a[3] = yystack.l_mark[-4];
+			p = (char *)&data_dest.sin_port;
+			p[0] = yystack.l_mark[-2]; p[1] = yystack.l_mark[0];
+			data_dest.sin_family = AF_INET;
+		}
+break;
+case 53:
+#line 565 "ftp.y"
+	{
+		yyval = FORM_N;
+	}
+break;
+case 54:
+#line 569 "ftp.y"
+	{
+		yyval = FORM_T;
+	}
+break;
+case 55:
+#line 573 "ftp.y"
+	{
+		yyval = FORM_C;
+	}
+break;
+case 56:
+#line 579 "ftp.y"
+	{
+		cmd_type = TYPE_A;
+		cmd_form = FORM_N;
+	}
+break;
+case 57:
+#line 584 "ftp.y"
+	{
+		cmd_type = TYPE_A;
+		cmd_form = yystack.l_mark[0];
+	}
+break;
+case 58:
+#line 589 "ftp.y"
+	{
+		cmd_type = TYPE_E;
+		cmd_form = FORM_N;
+	}
+break;
+case 59:
+#line 594 "ftp.y"
+	{
+		cmd_type = TYPE_E;
+		cmd_form = yystack.l_mark[0];
+	}
+break;
+case 60:
+#line 599 "ftp.y"
+	{
+		cmd_type = TYPE_I;
+	}
+break;
+case 61:
+#line 603 "ftp.y"
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = NBBY;
+	}
+break;
+case 62:
+#line 608 "ftp.y"
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = yystack.l_mark[0];
+	}
+break;
+case 63:
+#line 614 "ftp.y"
+	{
+		cmd_type = TYPE_L;
+		cmd_bytesz = yystack.l_mark[0];
+	}
+break;
+case 64:
+#line 621 "ftp.y"
+	{
+		yyval = STRU_F;
+	}
+break;
+case 65:
+#line 625 "ftp.y"
+	{
+		yyval = STRU_R;
+	}
+break;
+case 66:
+#line 629 "ftp.y"
+	{
+		yyval = STRU_P;
+	}
+break;
+case 67:
+#line 635 "ftp.y"
+	{
+		yyval = MODE_S;
+	}
+break;
+case 68:
+#line 639 "ftp.y"
+	{
+		yyval = MODE_B;
+	}
+break;
+case 69:
+#line 643 "ftp.y"
+	{
+		yyval = MODE_C;
+	}
+break;
+case 70:
+#line 649 "ftp.y"
+	{
+		/*
+		 * Problem: this production is used for all pathname
+		 * processing, but only gives a 550 error reply.
+		 * This is a valid reply in some cases but not in others.
+		 */
+		if (logged_in && yystack.l_mark[0] && strncmp((char *) yystack.l_mark[0], "~", 1) == 0) {
+			*(char **)&(yyval) = *glob((char *) yystack.l_mark[0]);
+			if (globerr != 0) {
+				reply(550, globerr);
+				yyval = 0;
+			}
+			free((char *) yystack.l_mark[0]);
+		} else
+			yyval = yystack.l_mark[0];
+	}
+break;
+case 72:
+#line 671 "ftp.y"
+	{
+		register int ret, dec, multby, digit;
+
+		/*
+		 * Convert a number that was read as decimal number
+		 * to what it would be if it had been read as octal.
+		 */
+		dec = yystack.l_mark[0];
+		multby = 1;
+		ret = 0;
+		while (dec) {
+			digit = dec%10;
+			if (digit > 7) {
+				ret = -1;
+				break;
+			}
+			ret += digit * multby;
+			multby *= 8;
+			dec /= 10;
+		}
+		yyval = ret;
+	}
+break;
+case 73:
+#line 696 "ftp.y"
+	{
+		if (logged_in)
+			yyval = 1;
+		else {
+			reply(530, "Please login with USER and PASS.");
+			yyval = 0;
+		}
+	}
+break;
+#line 1852 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.08.out b/usr.bin/yacc/tests/regress.08.out
new file mode 100644
index 000000000000..d5d3ae0545b6
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.08.out
@@ -0,0 +1,1942 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 9 "grammar.y"
+#ifdef YYBISON
+#include <stdlib.h>
+#define YYSTYPE_IS_DECLARED
+#define yyerror yaccError
+#endif
+
+#if defined(YYBISON) || !defined(YYBYACC)
+static void yyerror(const char *s);
+#endif
+#line 81 "grammar.y"
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#define OPT_LINTLIBRARY 1
+
+#ifndef TRUE
+#define	TRUE	(1)
+#endif
+
+#ifndef FALSE
+#define	FALSE	(0)
+#endif
+
+/* #include "cproto.h" */
+#define MAX_TEXT_SIZE 1024
+
+/* Prototype styles */
+#if OPT_LINTLIBRARY
+#define PROTO_ANSI_LLIB		-2	/* form ANSI lint-library source */
+#define PROTO_LINTLIBRARY	-1	/* form lint-library source */
+#endif
+#define PROTO_NONE		0	/* do not output any prototypes */
+#define PROTO_TRADITIONAL	1	/* comment out parameters */
+#define PROTO_ABSTRACT		2	/* comment out parameter names */
+#define PROTO_ANSI		3	/* ANSI C prototype */
+
+typedef int PrototypeStyle;
+
+typedef char boolean;
+
+extern boolean types_out;
+extern PrototypeStyle proto_style;
+
+#define ansiLintLibrary() (proto_style == PROTO_ANSI_LLIB)
+#define knrLintLibrary()  (proto_style == PROTO_LINTLIBRARY)
+#define lintLibrary()     (knrLintLibrary() || ansiLintLibrary())
+
+#if OPT_LINTLIBRARY
+#define FUNC_UNKNOWN		-1	/* unspecified */
+#else
+#define FUNC_UNKNOWN		0	/* unspecified (same as FUNC_NONE) */
+#endif
+#define FUNC_NONE		0	/* not a function definition */
+#define FUNC_TRADITIONAL	1	/* traditional style */
+#define FUNC_ANSI		2	/* ANSI style */
+#define FUNC_BOTH		3	/* both styles */
+
+typedef int FuncDefStyle;
+
+/* Source file text */
+typedef struct text {
+    char text[MAX_TEXT_SIZE];	/* source text */
+    long begin; 		/* offset in temporary file */
+} Text;
+
+/* Declaration specifier flags */
+#define DS_NONE 	0	/* default */
+#define DS_EXTERN	1	/* contains "extern" specifier */
+#define DS_STATIC	2	/* contains "static" specifier */
+#define DS_CHAR 	4	/* contains "char" type specifier */
+#define DS_SHORT	8	/* contains "short" type specifier */
+#define DS_FLOAT	16	/* contains "float" type specifier */
+#define DS_INLINE	32	/* contains "inline" specifier */
+#define DS_JUNK 	64	/* we're not interested in this declaration */
+
+/* This structure stores information about a declaration specifier. */
+typedef struct decl_spec {
+    unsigned short flags;	/* flags defined above */
+    char *text; 		/* source text */
+    long begin; 		/* offset in temporary file */
+} DeclSpec;
+
+/* This is a list of function parameters. */
+typedef struct _ParameterList {
+    struct parameter *first;	/* pointer to first parameter in list */
+    struct parameter *last;	/* pointer to last parameter in list */  
+    long begin_comment; 	/* begin offset of comment */
+    long end_comment;		/* end offset of comment */
+    char *comment;		/* comment at start of parameter list */
+} ParameterList;
+
+/* This structure stores information about a declarator. */
+typedef struct _Declarator {
+    char *name; 			/* name of variable or function */
+    char *text; 			/* source text */
+    long begin; 			/* offset in temporary file */
+    long begin_comment; 		/* begin offset of comment */
+    long end_comment;			/* end offset of comment */
+    FuncDefStyle func_def;		/* style of function definition */
+    ParameterList params;		/* function parameters */
+    boolean pointer;			/* TRUE if it declares a pointer */
+    struct _Declarator *head;		/* head function declarator */
+    struct _Declarator *func_stack;	/* stack of function declarators */
+    struct _Declarator *next;		/* next declarator in list */
+} Declarator;
+
+/* This structure stores information about a function parameter. */
+typedef struct parameter {
+    struct parameter *next;	/* next parameter in list */
+    DeclSpec decl_spec;
+    Declarator *declarator;
+    char *comment;		/* comment following the parameter */
+} Parameter;
+
+/* This is a list of declarators. */
+typedef struct declarator_list {
+    Declarator *first;		/* pointer to first declarator in list */
+    Declarator *last;		/* pointer to last declarator in list */  
+} DeclaratorList;
+
+/* #include "symbol.h" */
+typedef struct symbol {
+    struct symbol *next;	/* next symbol in list */
+    char *name; 		/* name of symbol */
+    char *value;		/* value of symbol (for defines) */
+    short flags;		/* symbol attributes */
+} Symbol;
+
+/* parser stack entry type */
+typedef union {
+    Text text;
+    DeclSpec decl_spec;
+    Parameter *parameter;
+    ParameterList param_list;
+    Declarator *declarator;
+    DeclaratorList decl_list;
+} YYSTYPE;
+
+/* The hash table length should be a prime number. */
+#define SYM_MAX_HASH 251
+
+typedef struct symbol_table {
+    Symbol *bucket[SYM_MAX_HASH];	/* hash buckets */
+} SymbolTable;
+
+extern SymbolTable *new_symbol_table	/* Create symbol table */
+	(void);
+extern void free_symbol_table		/* Destroy symbol table */
+	(SymbolTable *s);
+extern Symbol *find_symbol		/* Lookup symbol name */
+	(SymbolTable *s, const char *n);
+extern Symbol *new_symbol		/* Define new symbol */
+	(SymbolTable *s, const char *n, const char *v, int f);
+
+/* #include "semantic.h" */
+extern void new_decl_spec (DeclSpec *, const char *, long, int);
+extern void free_decl_spec (DeclSpec *);
+extern void join_decl_specs (DeclSpec *, DeclSpec *, DeclSpec *);
+extern void check_untagged (DeclSpec *);
+extern Declarator *new_declarator (const char *, const char *, long);
+extern void free_declarator (Declarator *);
+extern void new_decl_list (DeclaratorList *, Declarator *);
+extern void free_decl_list (DeclaratorList *);
+extern void add_decl_list (DeclaratorList *, DeclaratorList *, Declarator *);
+extern Parameter *new_parameter (DeclSpec *, Declarator *);
+extern void free_parameter (Parameter *);
+extern void new_param_list (ParameterList *, Parameter *);
+extern void free_param_list (ParameterList *);
+extern void add_param_list (ParameterList *, ParameterList *, Parameter *);
+extern void new_ident_list (ParameterList *);
+extern void add_ident_list (ParameterList *, ParameterList *, const char *);
+extern void set_param_types (ParameterList *, DeclSpec *, DeclaratorList *);
+extern void gen_declarations (DeclSpec *, DeclaratorList *);
+extern void gen_prototype (DeclSpec *, Declarator *);
+extern void gen_func_declarator (Declarator *);
+extern void gen_func_definition (DeclSpec *, Declarator *);
+
+extern void init_parser     (void);
+extern void process_file    (FILE *infile, char *name);
+extern char *cur_text       (void);
+extern char *cur_file_name  (void);
+extern char *implied_typedef (void);
+extern void include_file    (char *name, int convert);
+extern char *supply_parm    (int count);
+extern char *xstrdup        (const char *);
+extern int already_declared (char *name);
+extern int is_actual_func   (Declarator *d);
+extern int lint_ellipsis    (Parameter *p);
+extern int want_typedef     (void);
+extern void begin_tracking  (void);
+extern void begin_typedef   (void);
+extern void copy_typedef    (char *s);
+extern void ellipsis_varargs (Declarator *d);
+extern void end_typedef     (void);
+extern void flush_varargs   (void);
+extern void fmt_library     (int code);
+extern void imply_typedef   (const char *s);
+extern void indent          (FILE *outf);
+extern void put_blankline   (FILE *outf);
+extern void put_body        (FILE *outf, DeclSpec *decl_spec, Declarator *declarator);
+extern void put_char        (FILE *outf, int c);
+extern void put_error       (void);
+extern void put_newline     (FILE *outf);
+extern void put_padded      (FILE *outf, const char *s);
+extern void put_string      (FILE *outf, const char *s);
+extern void track_in        (void);
+
+extern boolean file_comments;
+extern FuncDefStyle func_style;
+extern char base_file[];
+
+extern	int	yylex (void);
+
+/* declaration specifier attributes for the typedef statement currently being
+ * scanned
+ */
+static int cur_decl_spec_flags;
+
+/* pointer to parameter list for the current function definition */
+static ParameterList *func_params;
+
+/* A parser semantic action sets this pointer to the current declarator in
+ * a function parameter declaration in order to catch any comments following
+ * the parameter declaration on the same line.  If the lexer scans a comment
+ * and <cur_declarator> is not NULL, then the comment is attached to the
+ * declarator.  To ignore subsequent comments, the lexer sets this to NULL
+ * after scanning a comment or end of line.
+ */
+static Declarator *cur_declarator;
+
+/* temporary string buffer */
+static char buf[MAX_TEXT_SIZE];
+
+/* table of typedef names */
+static SymbolTable *typedef_names;
+
+/* table of define names */
+static SymbolTable *define_names;
+
+/* table of type qualifiers */
+static SymbolTable *type_qualifiers;
+
+/* information about the current input file */
+typedef struct {
+    char *base_name;		/* base input file name */
+    char *file_name;		/* current file name */
+    FILE *file; 		/* input file */
+    unsigned line_num;		/* current line number in input file */
+    FILE *tmp_file;		/* temporary file */
+    long begin_comment; 	/* tmp file offset after last written ) or ; */
+    long end_comment;		/* tmp file offset after last comment */
+    boolean convert;		/* if TRUE, convert function definitions */
+    boolean changed;		/* TRUE if conversion done in this file */
+} IncludeStack;
+
+static IncludeStack *cur_file;	/* current input file */
+
+/* #include "yyerror.c" */
+
+static int haveAnsiParam (void);
+
+
+/* Flags to enable us to find if a procedure returns a value.
+ */
+static int return_val;	/* nonzero on BRACES iff return-expression found */
+
+static const char *
+dft_decl_spec (void)
+{
+    return (lintLibrary() && !return_val) ? "void" : "int";
+}
+
+static int
+haveAnsiParam (void)
+{
+    Parameter *p;
+    if (func_params != 0) {
+	for (p = func_params->first; p != 0; p = p->next) {
+	    if (p->declarator->func_def == FUNC_ANSI) {
+		return TRUE;
+	    }
+	}
+    }
+    return FALSE;
+}
+#line 306 "/dev/stdout"
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define T_IDENTIFIER 257
+#define T_TYPEDEF_NAME 258
+#define T_DEFINE_NAME 259
+#define T_AUTO 260
+#define T_EXTERN 261
+#define T_REGISTER 262
+#define T_STATIC 263
+#define T_TYPEDEF 264
+#define T_INLINE 265
+#define T_EXTENSION 266
+#define T_CHAR 267
+#define T_DOUBLE 268
+#define T_FLOAT 269
+#define T_INT 270
+#define T_VOID 271
+#define T_LONG 272
+#define T_SHORT 273
+#define T_SIGNED 274
+#define T_UNSIGNED 275
+#define T_ENUM 276
+#define T_STRUCT 277
+#define T_UNION 278
+#define T_Bool 279
+#define T_Complex 280
+#define T_Imaginary 281
+#define T_TYPE_QUALIFIER 282
+#define T_BRACKETS 283
+#define T_LBRACE 284
+#define T_MATCHRBRACE 285
+#define T_ELLIPSIS 286
+#define T_INITIALIZER 287
+#define T_STRING_LITERAL 288
+#define T_ASM 289
+#define T_ASMARG 290
+#define T_VA_DCL 291
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,   26,   26,   27,   27,   27,   27,   27,   27,
+   27,   31,   30,   30,   28,   28,   34,   28,   32,   32,
+   33,   33,   35,   35,   37,   38,   29,   39,   29,   36,
+   36,   36,   40,   40,    1,    1,    2,    2,    2,    3,
+    3,    3,    3,    3,    3,    4,    4,    4,    4,    4,
+    4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
+    5,    5,    6,    6,    6,   19,   19,    8,    8,    9,
+   41,    9,    7,    7,    7,   25,   23,   23,   10,   10,
+   11,   11,   11,   11,   11,   20,   20,   21,   21,   22,
+   22,   14,   14,   15,   15,   16,   16,   16,   17,   17,
+   18,   18,   24,   24,   12,   12,   12,   13,   13,   13,
+   13,   13,   13,   13,
+};
+static const short yylen[] = {                            2,
+    0,    1,    1,    2,    1,    1,    1,    1,    3,    2,
+    2,    2,    3,    3,    2,    3,    0,    5,    2,    1,
+    0,    1,    1,    3,    0,    0,    7,    0,    5,    0,
+    1,    1,    1,    2,    1,    2,    1,    1,    1,    1,
+    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+    1,    1,    3,    2,    2,    1,    1,    1,    3,    1,
+    0,    4,    3,    2,    2,    1,    1,    1,    2,    1,
+    1,    3,    2,    4,    4,    2,    3,    0,    1,    1,
+    2,    1,    3,    1,    3,    2,    2,    1,    0,    1,
+    1,    3,    1,    2,    1,    2,    1,    3,    2,    1,
+    4,    3,    3,    2,
+};
+static const short yydefred[] = {                         0,
+    0,    0,    0,    0,   77,    0,   62,   40,    0,   42,
+   43,   20,   44,    0,   46,   47,   48,   49,   54,   50,
+   51,   52,   53,   76,   66,   67,   55,   56,   57,   61,
+    0,    7,    0,    0,   35,   37,   38,   39,   59,   60,
+   28,    0,    0,    0,  103,   81,    0,    0,    3,    5,
+    6,    8,    0,   10,   11,   78,    0,   90,    0,    0,
+  104,    0,   19,    0,   41,   45,   15,   36,    0,   68,
+    0,    0,    0,   83,    0,    0,   64,    0,    0,   74,
+    4,   58,    0,   82,   87,   91,    0,   14,   13,    9,
+   16,    0,   71,    0,   31,   33,    0,    0,    0,    0,
+    0,   94,    0,    0,  101,   12,   63,   73,    0,    0,
+   69,    0,    0,    0,   34,    0,  110,   96,   97,    0,
+    0,   84,    0,   85,    0,   23,    0,    0,   72,   26,
+   29,  114,    0,    0,    0,  109,    0,   93,   95,  102,
+   18,    0,    0,  108,  113,  112,    0,   24,   27,  111,
+};
+static const short yydgoto[] = {                         33,
+   87,   35,   36,   37,   38,   39,   40,   69,   70,   41,
+   42,  119,  120,  100,  101,  102,  103,  104,   43,   44,
+   59,   60,   45,   46,   47,   48,   49,   50,   51,   52,
+   77,   53,  127,  109,  128,   97,   94,  143,   72,   98,
+  112,
+};
+static const short yysindex[] = {                        -2,
+   -3,   27, -239, -177,    0,    0,    0,    0, -274,    0,
+    0,    0,    0, -246,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+ -266,    0,    0,  455,    0,    0,    0,    0,    0,    0,
+    0,  -35, -245,  128,    0,    0, -245,   -2,    0,    0,
+    0,    0,  642,    0,    0,    0,  -15,    0,  -12, -239,
+    0,  590,    0,  -27,    0,    0,    0,    0,  -10,    0,
+  -11,  534,  -72,    0, -237, -232,    0,  -35, -232,    0,
+    0,    0,  642,    0,    0,    0,  455,    0,    0,    0,
+    0,   27,    0,  534,    0,    0, -222,  617,  209,   34,
+   39,    0,   44,   42,    0,    0,    0,    0,   27,  -11,
+    0, -200, -196, -195,    0,  174,    0,    0,    0,  -33,
+  243,    0,  561,    0, -177,    0,   33,   49,    0,    0,
+    0,    0,   53,   55,  417,    0,  -33,    0,    0,    0,
+    0,   27, -188,    0,    0,    0,   57,    0,    0,    0,
+};
+static const short yyrindex[] = {                        99,
+    0,    0,  275,    0,    0,  -38,    0,    0,  481,    0,
+    0,    0,    0,  509,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   30,    0,    0,    0,    0,    0,  101,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  343,  309,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   98, -182,   62,    0,    0,  133,    0,   64,  379,    0,
+    0,    0,   -5,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0, -182,    0,    0,    0, -180,  -19,    0,
+   65,    0,    0,   68,    0,    0,    0,    0,   51,    9,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  -13,
+   19,    0,    0,    0,    0,    0,    0,   52,    0,    0,
+    0,    0,    0,    0,    0,    0,   35,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+};
+static const short yygindex[] = {                         0,
+   11,  -17,    0,    0,   13,    0,    0,    0,   20,    8,
+  -43,   -1,   -8,  -89,    0,   -9,    0,    0,    0,  -44,
+    0,    0,    4,    0,    0,    0,   70,  -53,    0,    0,
+  -18,    0,    0,    0,    0,   22,    0,    0,    0,    0,
+    0,
+};
+#define YYTABLESIZE 924
+static const short yytable[] = {                         58,
+   78,   58,   58,   58,   73,   58,  135,   61,   88,   57,
+   34,    5,   56,   62,   85,   58,   68,   63,   96,    7,
+   58,   98,   78,   64,   98,   84,  134,  107,   80,    3,
+  107,   90,   17,   92,   17,    4,   17,    2,   75,    3,
+   96,   71,   30,   89,  115,  147,   76,  106,   91,   93,
+   79,   75,   70,   17,  121,   55,   32,  107,   34,  105,
+  108,  114,  105,   83,    4,   68,    2,   70,    3,   68,
+   80,  121,   86,   80,  122,  106,  105,   78,  106,    5,
+   56,   68,  123,   99,  124,  125,  129,  130,   80,  131,
+   80,  141,  142,  144,  110,  145,  149,  150,    1,  110,
+    2,   30,   99,   32,   79,   92,  118,   79,  100,   21,
+   22,  111,  137,  139,  133,  113,  126,   81,    0,    0,
+    0,    0,   79,   57,   79,    0,   99,    0,  140,    0,
+    0,    0,    0,   99,    0,    0,    0,    0,    0,    0,
+    0,   70,    0,    0,    0,   99,    0,    0,    0,  148,
+    0,    0,    0,    0,    0,    0,   70,    0,    0,    0,
+    0,    0,    0,    0,    0,    4,    0,    2,    0,    0,
+   65,    0,   65,   65,   65,    0,   65,    0,    0,    0,
+    0,    0,    0,    0,    5,    6,    7,    8,   65,   10,
+   11,   65,   13,   66,   15,   16,   17,   18,   19,   20,
+   21,   22,   23,   24,   25,   26,   27,   28,   29,   30,
+    0,    4,    0,  116,  132,    3,    0,    0,   58,   58,
+   58,   58,   58,   58,   58,   78,   58,   58,   58,   58,
+   58,   58,   58,   58,   58,   58,   58,   58,   58,   58,
+   58,   58,   58,   58,   58,   78,    4,   74,  116,  136,
+    3,   17,   78,    1,    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,
+    4,   54,  116,    5,   56,    0,   31,   80,   80,   80,
+   80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
+   80,   80,   80,   80,   80,   80,   80,   80,   80,   80,
+   80,   80,   88,   80,   88,   88,   88,    0,   88,    0,
+   80,   79,   79,   79,   79,   79,   79,   79,   79,   79,
+   79,   79,   79,   79,   79,   79,   79,   79,   79,   79,
+   79,   79,   79,   79,   79,   79,   89,   79,   89,   89,
+   89,    0,   89,    0,   79,   25,   25,   25,   25,   25,
+   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+   25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+   86,   25,   86,   86,    5,   56,   86,    0,   25,   65,
+   65,   65,   65,   65,   65,   65,    0,   65,   65,   65,
+   65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
+   65,   65,   65,   65,   65,   65,   75,    0,   75,   75,
+   75,    0,   75,    0,    0,    0,    0,    0,    0,    0,
+    5,    6,    7,    8,   65,   10,   11,   75,   13,   66,
+   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,
+   25,   26,   27,   28,   29,   30,  117,  146,    0,    0,
+    0,    0,    0,    0,    0,    5,    6,    7,    8,   65,
+   10,   11,    0,   13,   66,   15,   16,   17,   18,   19,
+   20,   21,   22,   23,   24,   25,   26,   27,   28,   29,
+   30,  117,    4,    0,    2,    0,    3,    0,    0,    5,
+   56,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   67,    0,    0,    0,    0,   41,    0,
+   41,    0,   41,    0,    0,  117,    0,    0,    0,    0,
+    0,   88,   88,    0,    0,    0,    0,    0,    0,   41,
+    0,    0,    0,    0,    0,    0,   45,    0,   45,    0,
+   45,    0,    0,    0,    0,    0,    0,   88,    0,    0,
+    0,    0,    0,    0,    0,   89,   89,   45,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   89,    0,    0,    0,    0,    0,    0,    0,   86,
+   86,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   86,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   75,   75,   75,   75,   75,
+   75,   75,    0,   75,   75,   75,   75,   75,   75,   75,
+   75,   75,   75,   75,   75,   75,   75,   75,   75,   75,
+   75,   75,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   82,    7,    8,   65,   10,   11,
+    0,   13,   66,   15,   16,   17,   18,   19,   20,   21,
+   22,   23,   24,   25,   26,   27,   28,   29,   30,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    5,    6,    7,    8,   65,   10,   11,    0,   13,
+   66,   15,   16,   17,   18,   19,   20,   21,   22,   23,
+   24,   25,   26,   27,   28,   29,   30,   41,   41,   41,
+   41,   41,   41,   41,    0,   41,   41,   41,   41,   41,
+   41,   41,   41,   41,   41,   41,   41,   41,   41,   41,
+   41,   41,   41,    0,    0,   45,   45,   45,   45,   45,
+   45,   45,    0,   45,   45,   45,   45,   45,   45,   45,
+   45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
+   45,   82,    7,    8,   65,   10,   11,   12,   13,   14,
+   15,   16,   17,   18,   19,   20,   21,   22,   23,   24,
+   25,   26,   27,   28,   29,   30,    0,    0,   82,    7,
+    8,   65,   10,   11,   95,   13,   66,   15,   16,   17,
+   18,   19,   20,   21,   22,   23,   24,   25,   26,   27,
+   28,   29,   30,    0,    0,    0,  138,   82,    7,    8,
+   65,   10,   11,   12,   13,   14,   15,   16,   17,   18,
+   19,   20,   21,   22,   23,   24,   25,   26,   27,   28,
+   29,   30,    0,   75,   82,    7,    8,   65,   10,   11,
+   12,   13,   14,   15,   16,   17,   18,   19,   20,   21,
+   22,   23,   24,   25,   26,   27,   28,   29,   30,   82,
+    7,    8,   65,   10,   11,    0,   13,   66,   15,   16,
+   17,   18,   19,   20,   21,   22,   23,   24,   25,   26,
+   27,   28,   29,   30,
+};
+static const short yycheck[] = {                         38,
+   44,   40,   41,   42,   40,   44,   40,    4,   62,    2,
+    0,  257,  258,  288,   59,    3,   34,  264,   72,  259,
+   59,   41,   61,  290,   44,   41,  116,   41,   47,   42,
+   44,   59,   38,   44,   40,   38,   42,   40,  284,   42,
+   94,   34,  282,   62,   98,  135,   43,  285,   59,   61,
+   47,  284,   44,   59,   99,   59,   59,   76,   48,   41,
+   79,  284,   44,   53,   38,   83,   40,   59,   42,   87,
+   41,  116,   60,   44,   41,   41,   73,  121,   44,  257,
+  258,   99,   44,   73,   41,   44,  287,  284,   59,  285,
+   61,   59,   44,   41,   87,   41,  285,   41,    0,   92,
+    0,  284,   41,  284,   41,   41,   99,   44,   41,   59,
+   59,   92,  121,  123,  116,   94,  109,   48,   -1,   -1,
+   -1,   -1,   59,  116,   61,   -1,  116,   -1,  125,   -1,
+   -1,   -1,   -1,  123,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   44,   -1,   -1,   -1,  135,   -1,   -1,   -1,  142,
+   -1,   -1,   -1,   -1,   -1,   -1,   59,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   38,   -1,   40,   -1,   -1,
+   38,   -1,   40,   41,   42,   -1,   44,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,  262,
+  263,   59,  265,  266,  267,  268,  269,  270,  271,  272,
+  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
+   -1,   38,   -1,   40,   41,   42,   -1,   -1,  257,  258,
+  259,  260,  261,  262,  263,  264,  265,  266,  267,  268,
+  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
+  279,  280,  281,  282,  283,  284,   38,  283,   40,  283,
+   42,  257,  291,  256,  257,  258,  259,  260,  261,  262,
+  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
+  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
+   38,  285,   40,  257,  258,   -1,  289,  258,  259,  260,
+  261,  262,  263,  264,  265,  266,  267,  268,  269,  270,
+  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
+  281,  282,   38,  284,   40,   41,   42,   -1,   44,   -1,
+  291,  258,  259,  260,  261,  262,  263,  264,  265,  266,
+  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
+  277,  278,  279,  280,  281,  282,   38,  284,   40,   41,
+   42,   -1,   44,   -1,  291,  258,  259,  260,  261,  262,
+  263,  264,  265,  266,  267,  268,  269,  270,  271,  272,
+  273,  274,  275,  276,  277,  278,  279,  280,  281,  282,
+   38,  284,   40,   41,  257,  258,   44,   -1,  291,  257,
+  258,  259,  260,  261,  262,  263,   -1,  265,  266,  267,
+  268,  269,  270,  271,  272,  273,  274,  275,  276,  277,
+  278,  279,  280,  281,  282,  283,   38,   -1,   40,   41,
+   42,   -1,   44,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  257,  258,  259,  260,  261,  262,  263,   59,  265,  266,
+  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
+  277,  278,  279,  280,  281,  282,  283,   41,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,
+  262,  263,   -1,  265,  266,  267,  268,  269,  270,  271,
+  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,
+  282,  283,   38,   -1,   40,   -1,   42,   -1,   -1,  257,
+  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   59,   -1,   -1,   -1,   -1,   38,   -1,
+   40,   -1,   42,   -1,   -1,  283,   -1,   -1,   -1,   -1,
+   -1,  257,  258,   -1,   -1,   -1,   -1,   -1,   -1,   59,
+   -1,   -1,   -1,   -1,   -1,   -1,   38,   -1,   40,   -1,
+   42,   -1,   -1,   -1,   -1,   -1,   -1,  283,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,  258,   59,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  283,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
+  258,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  283,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,  258,  259,  260,  261,
+  262,  263,   -1,  265,  266,  267,  268,  269,  270,  271,
+  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,
+  282,  283,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  258,  259,  260,  261,  262,  263,
+   -1,  265,  266,  267,  268,  269,  270,  271,  272,  273,
+  274,  275,  276,  277,  278,  279,  280,  281,  282,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  257,  258,  259,  260,  261,  262,  263,   -1,  265,
+  266,  267,  268,  269,  270,  271,  272,  273,  274,  275,
+  276,  277,  278,  279,  280,  281,  282,  257,  258,  259,
+  260,  261,  262,  263,   -1,  265,  266,  267,  268,  269,
+  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,
+  280,  281,  282,   -1,   -1,  257,  258,  259,  260,  261,
+  262,  263,   -1,  265,  266,  267,  268,  269,  270,  271,
+  272,  273,  274,  275,  276,  277,  278,  279,  280,  281,
+  282,  258,  259,  260,  261,  262,  263,  264,  265,  266,
+  267,  268,  269,  270,  271,  272,  273,  274,  275,  276,
+  277,  278,  279,  280,  281,  282,   -1,   -1,  258,  259,
+  260,  261,  262,  263,  291,  265,  266,  267,  268,  269,
+  270,  271,  272,  273,  274,  275,  276,  277,  278,  279,
+  280,  281,  282,   -1,   -1,   -1,  286,  258,  259,  260,
+  261,  262,  263,  264,  265,  266,  267,  268,  269,  270,
+  271,  272,  273,  274,  275,  276,  277,  278,  279,  280,
+  281,  282,   -1,  284,  258,  259,  260,  261,  262,  263,
+  264,  265,  266,  267,  268,  269,  270,  271,  272,  273,
+  274,  275,  276,  277,  278,  279,  280,  281,  282,  258,
+  259,  260,  261,  262,  263,   -1,  265,  266,  267,  268,
+  269,  270,  271,  272,  273,  274,  275,  276,  277,  278,
+  279,  280,  281,  282,
+};
+#define YYFINAL 33
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 291
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const 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,
+"T_IDENTIFIER","T_TYPEDEF_NAME","T_DEFINE_NAME","T_AUTO","T_EXTERN",
+"T_REGISTER","T_STATIC","T_TYPEDEF","T_INLINE","T_EXTENSION","T_CHAR",
+"T_DOUBLE","T_FLOAT","T_INT","T_VOID","T_LONG","T_SHORT","T_SIGNED",
+"T_UNSIGNED","T_ENUM","T_STRUCT","T_UNION","T_Bool","T_Complex","T_Imaginary",
+"T_TYPE_QUALIFIER","T_BRACKETS","T_LBRACE","T_MATCHRBRACE","T_ELLIPSIS",
+"T_INITIALIZER","T_STRING_LITERAL","T_ASM","T_ASMARG","T_VA_DCL",
+"illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : program",
+"program :",
+"program : translation_unit",
+"translation_unit : external_declaration",
+"translation_unit : translation_unit external_declaration",
+"external_declaration : declaration",
+"external_declaration : function_definition",
+"external_declaration : ';'",
+"external_declaration : linkage_specification",
+"external_declaration : T_ASM T_ASMARG ';'",
+"external_declaration : error T_MATCHRBRACE",
+"external_declaration : error ';'",
+"braces : T_LBRACE T_MATCHRBRACE",
+"linkage_specification : T_EXTERN T_STRING_LITERAL braces",
+"linkage_specification : T_EXTERN T_STRING_LITERAL declaration",
+"declaration : decl_specifiers ';'",
+"declaration : decl_specifiers init_declarator_list ';'",
+"$$1 :",
+"declaration : any_typedef decl_specifiers $$1 opt_declarator_list ';'",
+"any_typedef : T_EXTENSION T_TYPEDEF",
+"any_typedef : T_TYPEDEF",
+"opt_declarator_list :",
+"opt_declarator_list : declarator_list",
+"declarator_list : declarator",
+"declarator_list : declarator_list ',' declarator",
+"$$2 :",
+"$$3 :",
+"function_definition : decl_specifiers declarator $$2 opt_declaration_list T_LBRACE $$3 T_MATCHRBRACE",
+"$$4 :",
+"function_definition : declarator $$4 opt_declaration_list T_LBRACE T_MATCHRBRACE",
+"opt_declaration_list :",
+"opt_declaration_list : T_VA_DCL",
+"opt_declaration_list : declaration_list",
+"declaration_list : declaration",
+"declaration_list : declaration_list declaration",
+"decl_specifiers : decl_specifier",
+"decl_specifiers : decl_specifiers decl_specifier",
+"decl_specifier : storage_class",
+"decl_specifier : type_specifier",
+"decl_specifier : type_qualifier",
+"storage_class : T_AUTO",
+"storage_class : T_EXTERN",
+"storage_class : T_REGISTER",
+"storage_class : T_STATIC",
+"storage_class : T_INLINE",
+"storage_class : T_EXTENSION",
+"type_specifier : T_CHAR",
+"type_specifier : T_DOUBLE",
+"type_specifier : T_FLOAT",
+"type_specifier : T_INT",
+"type_specifier : T_LONG",
+"type_specifier : T_SHORT",
+"type_specifier : T_SIGNED",
+"type_specifier : T_UNSIGNED",
+"type_specifier : T_VOID",
+"type_specifier : T_Bool",
+"type_specifier : T_Complex",
+"type_specifier : T_Imaginary",
+"type_specifier : T_TYPEDEF_NAME",
+"type_specifier : struct_or_union_specifier",
+"type_specifier : enum_specifier",
+"type_qualifier : T_TYPE_QUALIFIER",
+"type_qualifier : T_DEFINE_NAME",
+"struct_or_union_specifier : struct_or_union any_id braces",
+"struct_or_union_specifier : struct_or_union braces",
+"struct_or_union_specifier : struct_or_union any_id",
+"struct_or_union : T_STRUCT",
+"struct_or_union : T_UNION",
+"init_declarator_list : init_declarator",
+"init_declarator_list : init_declarator_list ',' init_declarator",
+"init_declarator : declarator",
+"$$5 :",
+"init_declarator : declarator '=' $$5 T_INITIALIZER",
+"enum_specifier : enumeration any_id braces",
+"enum_specifier : enumeration braces",
+"enum_specifier : enumeration any_id",
+"enumeration : T_ENUM",
+"any_id : T_IDENTIFIER",
+"any_id : T_TYPEDEF_NAME",
+"declarator : pointer direct_declarator",
+"declarator : direct_declarator",
+"direct_declarator : identifier_or_ref",
+"direct_declarator : '(' declarator ')'",
+"direct_declarator : direct_declarator T_BRACKETS",
+"direct_declarator : direct_declarator '(' parameter_type_list ')'",
+"direct_declarator : direct_declarator '(' opt_identifier_list ')'",
+"pointer : '*' opt_type_qualifiers",
+"pointer : '*' opt_type_qualifiers pointer",
+"opt_type_qualifiers :",
+"opt_type_qualifiers : type_qualifier_list",
+"type_qualifier_list : type_qualifier",
+"type_qualifier_list : type_qualifier_list type_qualifier",
+"parameter_type_list : parameter_list",
+"parameter_type_list : parameter_list ',' T_ELLIPSIS",
+"parameter_list : parameter_declaration",
+"parameter_list : parameter_list ',' parameter_declaration",
+"parameter_declaration : decl_specifiers declarator",
+"parameter_declaration : decl_specifiers abs_declarator",
+"parameter_declaration : decl_specifiers",
+"opt_identifier_list :",
+"opt_identifier_list : identifier_list",
+"identifier_list : any_id",
+"identifier_list : identifier_list ',' any_id",
+"identifier_or_ref : any_id",
+"identifier_or_ref : '&' any_id",
+"abs_declarator : pointer",
+"abs_declarator : pointer direct_abs_declarator",
+"abs_declarator : direct_abs_declarator",
+"direct_abs_declarator : '(' abs_declarator ')'",
+"direct_abs_declarator : direct_abs_declarator T_BRACKETS",
+"direct_abs_declarator : T_BRACKETS",
+"direct_abs_declarator : direct_abs_declarator '(' parameter_type_list ')'",
+"direct_abs_declarator : direct_abs_declarator '(' ')'",
+"direct_abs_declarator : '(' parameter_type_list ')'",
+"direct_abs_declarator : '(' ')'",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 1014 "grammar.y"
+
+/* lex.yy.c */
+#define BEGIN yy_start = 1 + 2 *
+
+#define CPP1 1
+#define INIT1 2
+#define INIT2 3
+#define CURLY 4
+#define LEXYACC 5
+#define ASM 6
+#define CPP_INLINE 7
+
+extern char *yytext;
+extern FILE *yyin, *yyout;
+
+static int curly;			/* number of curly brace nesting levels */
+static int ly_count;			/* number of occurrences of %% */
+static int inc_depth;			/* include nesting level */
+static SymbolTable *included_files;	/* files already included */
+static int yy_start = 0;		/* start state number */
+
+#define grammar_error(s) yaccError(s)
+
+static void
+yaccError (const char *msg)
+{
+    func_params = NULL;
+    put_error();		/* tell what line we're on, and what file */
+    fprintf(stderr, "%s at token '%s'\n", msg, yytext);
+}
+
+/* Initialize the table of type qualifier keywords recognized by the lexical
+ * analyzer.
+ */
+void
+init_parser (void)
+{
+    static const char *keywords[] = {
+	"const",
+	"restrict",
+	"volatile",
+	"interrupt",
+#ifdef vms
+	"noshare",
+	"readonly",
+#endif
+#if defined(MSDOS) || defined(OS2)
+	"__cdecl",
+	"__export",
+	"__far",
+	"__fastcall",
+	"__fortran",
+	"__huge",
+	"__inline",
+	"__interrupt",
+	"__loadds",
+	"__near",
+	"__pascal",
+	"__saveregs",
+	"__segment",
+	"__stdcall",
+	"__syscall",
+	"_cdecl",
+	"_cs",
+	"_ds",
+	"_es",
+	"_export",
+	"_far",
+	"_fastcall",
+	"_fortran",
+	"_huge",
+	"_interrupt",
+	"_loadds",
+	"_near",
+	"_pascal",
+	"_saveregs",
+	"_seg",
+	"_segment",
+	"_ss",
+	"cdecl",
+	"far",
+	"huge",
+	"near",
+	"pascal",
+#ifdef OS2
+	"__far16",
+#endif
+#endif
+#ifdef __GNUC__
+	/* gcc aliases */
+	"__builtin_va_arg",
+	"__builtin_va_list",
+	"__const",
+	"__const__",
+	"__inline",
+	"__inline__",
+	"__restrict",
+	"__restrict__",
+	"__volatile",
+	"__volatile__",
+#endif
+    };
+    unsigned i;
+
+    /* Initialize type qualifier table. */
+    type_qualifiers = new_symbol_table();
+    for (i = 0; i < sizeof(keywords)/sizeof(keywords[0]); ++i) {
+	new_symbol(type_qualifiers, keywords[i], NULL, DS_NONE);
+    }
+}
+
+/* Process the C source file.  Write function prototypes to the standard
+ * output.  Convert function definitions and write the converted source
+ * code to a temporary file.
+ */
+void
+process_file (FILE *infile, char *name)
+{
+    char *s;
+
+    if (strlen(name) > 2) {
+	s = name + strlen(name) - 2;
+	if (*s == '.') {
+	    ++s;
+	    if (*s == 'l' || *s == 'y')
+		BEGIN LEXYACC;
+#if defined(MSDOS) || defined(OS2)
+	    if (*s == 'L' || *s == 'Y')
+		BEGIN LEXYACC;
+#endif
+	}
+    }
+
+    included_files = new_symbol_table();
+    typedef_names = new_symbol_table();
+    define_names = new_symbol_table();
+    inc_depth = -1;
+    curly = 0;
+    ly_count = 0;
+    func_params = NULL;
+    yyin = infile;
+    include_file(strcpy(base_file, name), func_style != FUNC_NONE);
+    if (file_comments) {
+#if OPT_LINTLIBRARY
+    	if (lintLibrary()) {
+	    put_blankline(stdout);
+	    begin_tracking();
+	}
+#endif
+	put_string(stdout, "/* ");
+	put_string(stdout, cur_file_name());
+	put_string(stdout, " */\n");
+    }
+    yyparse();
+    free_symbol_table(define_names);
+    free_symbol_table(typedef_names);
+    free_symbol_table(included_files);
+}
+
+#ifdef NO_LEAKS
+void
+free_parser(void)
+{
+    free_symbol_table (type_qualifiers);
+#ifdef FLEX_SCANNER
+    if (yy_current_buffer != 0)
+	yy_delete_buffer(yy_current_buffer);
+#endif
+}
+#endif
+#line 1006 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 10:
+#line 377 "grammar.y"
+	{
+	    yyerrok;
+	}
+break;
+case 11:
+#line 381 "grammar.y"
+	{
+	    yyerrok;
+	}
+break;
+case 13:
+#line 392 "grammar.y"
+	{
+	    /* Provide an empty action here so bison will not complain about
+	     * incompatible types in the default action it normally would
+	     * have generated.
+	     */
+	}
+break;
+case 14:
+#line 399 "grammar.y"
+	{
+	    /* empty */
+	}
+break;
+case 15:
+#line 406 "grammar.y"
+	{
+#if OPT_LINTLIBRARY
+	    if (types_out && want_typedef()) {
+		gen_declarations(&yystack.l_mark[-1].decl_spec, (DeclaratorList *)0);
+		flush_varargs();
+	    }
+#endif
+	    free_decl_spec(&yystack.l_mark[-1].decl_spec);
+	    end_typedef();
+	}
+break;
+case 16:
+#line 417 "grammar.y"
+	{
+	    if (func_params != NULL) {
+		set_param_types(func_params, &yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list);
+	    } else {
+		gen_declarations(&yystack.l_mark[-2].decl_spec, &yystack.l_mark[-1].decl_list);
+#if OPT_LINTLIBRARY
+		flush_varargs();
+#endif
+		free_decl_list(&yystack.l_mark[-1].decl_list);
+	    }
+	    free_decl_spec(&yystack.l_mark[-2].decl_spec);
+	    end_typedef();
+	}
+break;
+case 17:
+#line 431 "grammar.y"
+	{
+	    cur_decl_spec_flags = yystack.l_mark[0].decl_spec.flags;
+	    free_decl_spec(&yystack.l_mark[0].decl_spec);
+	}
+break;
+case 18:
+#line 436 "grammar.y"
+	{
+	    end_typedef();
+	}
+break;
+case 19:
+#line 443 "grammar.y"
+	{
+	    begin_typedef();
+	}
+break;
+case 20:
+#line 447 "grammar.y"
+	{
+	    begin_typedef();
+	}
+break;
+case 23:
+#line 459 "grammar.y"
+	{
+	    int flags = cur_decl_spec_flags;
+
+	    /* If the typedef is a pointer type, then reset the short type
+	     * flags so it does not get promoted.
+	     */
+	    if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0)
+		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
+	    new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags);
+	    free_declarator(yystack.l_mark[0].declarator);
+	}
+break;
+case 24:
+#line 471 "grammar.y"
+	{
+	    int flags = cur_decl_spec_flags;
+
+	    if (strcmp(yystack.l_mark[0].declarator->text, yystack.l_mark[0].declarator->name) != 0)
+		flags &= ~(DS_CHAR | DS_SHORT | DS_FLOAT);
+	    new_symbol(typedef_names, yystack.l_mark[0].declarator->name, NULL, flags);
+	    free_declarator(yystack.l_mark[0].declarator);
+	}
+break;
+case 25:
+#line 483 "grammar.y"
+	{
+	    check_untagged(&yystack.l_mark[-1].decl_spec);
+	    if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &(yystack.l_mark[0].declarator->head->params);
+	    func_params->begin_comment = cur_file->begin_comment;
+	    func_params->end_comment = cur_file->end_comment;
+	}
+break;
+case 26:
+#line 494 "grammar.y"
+	{
+	    /* If we're converting to K&R and we've got a nominally K&R
+	     * function which has a parameter which is ANSI (i.e., a prototyped
+	     * function pointer), then we must override the deciphered value of
+	     * 'func_def' so that the parameter will be converted.
+	     */
+	    if (func_style == FUNC_TRADITIONAL
+	     && haveAnsiParam()
+	     && yystack.l_mark[-3].declarator->head->func_def == func_style) {
+		yystack.l_mark[-3].declarator->head->func_def = FUNC_BOTH;
+	    }
+
+	    func_params = NULL;
+
+	    if (cur_file->convert)
+		gen_func_definition(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator);
+	    gen_prototype(&yystack.l_mark[-4].decl_spec, yystack.l_mark[-3].declarator);
+#if OPT_LINTLIBRARY
+	    flush_varargs();
+#endif
+	    free_decl_spec(&yystack.l_mark[-4].decl_spec);
+	    free_declarator(yystack.l_mark[-3].declarator);
+	}
+break;
+case 28:
+#line 519 "grammar.y"
+	{
+	    if (yystack.l_mark[0].declarator->func_def == FUNC_NONE) {
+		yyerror("syntax error");
+		YYERROR;
+	    }
+	    func_params = &(yystack.l_mark[0].declarator->head->params);
+	    func_params->begin_comment = cur_file->begin_comment;
+	    func_params->end_comment = cur_file->end_comment;
+	}
+break;
+case 29:
+#line 529 "grammar.y"
+	{
+	    DeclSpec decl_spec;
+
+	    func_params = NULL;
+
+	    new_decl_spec(&decl_spec, dft_decl_spec(), yystack.l_mark[-4].declarator->begin, DS_NONE);
+	    if (cur_file->convert)
+		gen_func_definition(&decl_spec, yystack.l_mark[-4].declarator);
+	    gen_prototype(&decl_spec, yystack.l_mark[-4].declarator);
+#if OPT_LINTLIBRARY
+	    flush_varargs();
+#endif
+	    free_decl_spec(&decl_spec);
+	    free_declarator(yystack.l_mark[-4].declarator);
+	}
+break;
+case 36:
+#line 560 "grammar.y"
+	{
+	    join_decl_specs(&yyval.decl_spec, &yystack.l_mark[-1].decl_spec, &yystack.l_mark[0].decl_spec);
+	    free(yystack.l_mark[-1].decl_spec.text);
+	    free(yystack.l_mark[0].decl_spec.text);
+	}
+break;
+case 40:
+#line 575 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 41:
+#line 579 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_EXTERN);
+	}
+break;
+case 42:
+#line 583 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 43:
+#line 587 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_STATIC);
+	}
+break;
+case 44:
+#line 591 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_INLINE);
+	}
+break;
+case 45:
+#line 595 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_JUNK);
+	}
+break;
+case 46:
+#line 602 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR);
+	}
+break;
+case 47:
+#line 606 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 48:
+#line 610 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_FLOAT);
+	}
+break;
+case 49:
+#line 614 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 50:
+#line 618 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 51:
+#line 622 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_SHORT);
+	}
+break;
+case 52:
+#line 626 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 53:
+#line 630 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 54:
+#line 634 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 55:
+#line 638 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_CHAR);
+	}
+break;
+case 56:
+#line 642 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 57:
+#line 646 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 58:
+#line 650 "grammar.y"
+	{
+	    Symbol *s;
+	    s = find_symbol(typedef_names, yystack.l_mark[0].text.text);
+	    if (s != NULL)
+		new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags);
+	}
+break;
+case 61:
+#line 662 "grammar.y"
+	{
+	    new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, DS_NONE);
+	}
+break;
+case 62:
+#line 666 "grammar.y"
+	{
+	    /* This rule allows the <pointer> nonterminal to scan #define
+	     * names as if they were type modifiers.
+	     */
+	    Symbol *s;
+	    s = find_symbol(define_names, yystack.l_mark[0].text.text);
+	    if (s != NULL)
+		new_decl_spec(&yyval.decl_spec, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin, s->flags);
+	}
+break;
+case 63:
+#line 679 "grammar.y"
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+	        (void)sprintf(s = buf, "%s %s", yystack.l_mark[-2].text.text, yystack.l_mark[-1].text.text);
+	    new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE);
+	}
+break;
+case 64:
+#line 686 "grammar.y"
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text);
+	    new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE);
+	}
+break;
+case 65:
+#line 693 "grammar.y"
+	{
+	    (void)sprintf(buf, "%s %s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text);
+	    new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE);
+	}
+break;
+case 66:
+#line 701 "grammar.y"
+	{
+	    imply_typedef(yyval.text.text);
+	}
+break;
+case 67:
+#line 705 "grammar.y"
+	{
+	    imply_typedef(yyval.text.text);
+	}
+break;
+case 68:
+#line 712 "grammar.y"
+	{
+	    new_decl_list(&yyval.decl_list, yystack.l_mark[0].declarator);
+	}
+break;
+case 69:
+#line 716 "grammar.y"
+	{
+	    add_decl_list(&yyval.decl_list, &yystack.l_mark[-2].decl_list, yystack.l_mark[0].declarator);
+	}
+break;
+case 70:
+#line 723 "grammar.y"
+	{
+	    if (yystack.l_mark[0].declarator->func_def != FUNC_NONE && func_params == NULL &&
+		func_style == FUNC_TRADITIONAL && cur_file->convert) {
+		gen_func_declarator(yystack.l_mark[0].declarator);
+		fputs(cur_text(), cur_file->tmp_file);
+	    }
+	    cur_declarator = yyval.declarator;
+	}
+break;
+case 71:
+#line 732 "grammar.y"
+	{
+	    if (yystack.l_mark[-1].declarator->func_def != FUNC_NONE && func_params == NULL &&
+		func_style == FUNC_TRADITIONAL && cur_file->convert) {
+		gen_func_declarator(yystack.l_mark[-1].declarator);
+		fputs(" =", cur_file->tmp_file);
+	    }
+	}
+break;
+case 73:
+#line 744 "grammar.y"
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "enum %s", yystack.l_mark[-1].text.text);
+	    new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-2].text.begin, DS_NONE);
+	}
+break;
+case 74:
+#line 751 "grammar.y"
+	{
+	    char *s;
+	    if ((s = implied_typedef()) == 0)
+		(void)sprintf(s = buf, "%s {}", yystack.l_mark[-1].text.text);
+	    new_decl_spec(&yyval.decl_spec, s, yystack.l_mark[-1].text.begin, DS_NONE);
+	}
+break;
+case 75:
+#line 758 "grammar.y"
+	{
+	    (void)sprintf(buf, "enum %s", yystack.l_mark[0].text.text);
+	    new_decl_spec(&yyval.decl_spec, buf, yystack.l_mark[-1].text.begin, DS_NONE);
+	}
+break;
+case 76:
+#line 766 "grammar.y"
+	{
+	    imply_typedef("enum");
+	    yyval.text = yystack.l_mark[0].text;
+	}
+break;
+case 79:
+#line 779 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[0].declarator;
+	    (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	    yyval.declarator->begin = yystack.l_mark[-1].text.begin;
+	    yyval.declarator->pointer = TRUE;
+	}
+break;
+case 81:
+#line 792 "grammar.y"
+	{
+	    yyval.declarator = new_declarator(yystack.l_mark[0].text.text, yystack.l_mark[0].text.text, yystack.l_mark[0].text.begin);
+	}
+break;
+case 82:
+#line 796 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[-1].declarator;
+	    (void)sprintf(buf, "(%s)", yyval.declarator->text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	    yyval.declarator->begin = yystack.l_mark[-2].text.begin;
+	}
+break;
+case 83:
+#line 804 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[-1].declarator;
+	    (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	}
+break;
+case 84:
+#line 811 "grammar.y"
+	{
+	    yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin);
+	    yyval.declarator->params = yystack.l_mark[-1].param_list;
+	    yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
+	    yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
+	    yyval.declarator->func_def = FUNC_ANSI;
+	}
+break;
+case 85:
+#line 819 "grammar.y"
+	{
+	    yyval.declarator = new_declarator("%s()", yystack.l_mark[-3].declarator->name, yystack.l_mark[-3].declarator->begin);
+	    yyval.declarator->params = yystack.l_mark[-1].param_list;
+	    yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
+	    yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
+	    yyval.declarator->func_def = FUNC_TRADITIONAL;
+	}
+break;
+case 86:
+#line 830 "grammar.y"
+	{
+	    (void)sprintf(yyval.text.text, "*%s", yystack.l_mark[0].text.text);
+	    yyval.text.begin = yystack.l_mark[-1].text.begin;
+	}
+break;
+case 87:
+#line 835 "grammar.y"
+	{
+	    (void)sprintf(yyval.text.text, "*%s%s", yystack.l_mark[-1].text.text, yystack.l_mark[0].text.text);
+	    yyval.text.begin = yystack.l_mark[-2].text.begin;
+	}
+break;
+case 88:
+#line 843 "grammar.y"
+	{
+	    strcpy(yyval.text.text, "");
+	    yyval.text.begin = 0L;
+	}
+break;
+case 90:
+#line 852 "grammar.y"
+	{
+	    (void)sprintf(yyval.text.text, "%s ", yystack.l_mark[0].decl_spec.text);
+	    yyval.text.begin = yystack.l_mark[0].decl_spec.begin;
+	    free(yystack.l_mark[0].decl_spec.text);
+	}
+break;
+case 91:
+#line 858 "grammar.y"
+	{
+	    (void)sprintf(yyval.text.text, "%s%s ", yystack.l_mark[-1].text.text, yystack.l_mark[0].decl_spec.text);
+	    yyval.text.begin = yystack.l_mark[-1].text.begin;
+	    free(yystack.l_mark[0].decl_spec.text);
+	}
+break;
+case 93:
+#line 868 "grammar.y"
+	{
+	    add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, "...");
+	}
+break;
+case 94:
+#line 875 "grammar.y"
+	{
+	    new_param_list(&yyval.param_list, yystack.l_mark[0].parameter);
+	}
+break;
+case 95:
+#line 879 "grammar.y"
+	{
+	    add_param_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].parameter);
+	}
+break;
+case 96:
+#line 886 "grammar.y"
+	{
+	    check_untagged(&yystack.l_mark[-1].decl_spec);
+	    yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator);
+	}
+break;
+case 97:
+#line 891 "grammar.y"
+	{
+	    check_untagged(&yystack.l_mark[-1].decl_spec);
+	    yyval.parameter = new_parameter(&yystack.l_mark[-1].decl_spec, yystack.l_mark[0].declarator);
+	}
+break;
+case 98:
+#line 896 "grammar.y"
+	{
+	    check_untagged(&yystack.l_mark[0].decl_spec);
+	    yyval.parameter = new_parameter(&yystack.l_mark[0].decl_spec, (Declarator *)0);
+	}
+break;
+case 99:
+#line 904 "grammar.y"
+	{
+	    new_ident_list(&yyval.param_list);
+	}
+break;
+case 101:
+#line 912 "grammar.y"
+	{
+	    new_ident_list(&yyval.param_list);
+	    add_ident_list(&yyval.param_list, &yyval.param_list, yystack.l_mark[0].text.text);
+	}
+break;
+case 102:
+#line 917 "grammar.y"
+	{
+	    add_ident_list(&yyval.param_list, &yystack.l_mark[-2].param_list, yystack.l_mark[0].text.text);
+	}
+break;
+case 103:
+#line 924 "grammar.y"
+	{
+	    yyval.text = yystack.l_mark[0].text;
+	}
+break;
+case 104:
+#line 928 "grammar.y"
+	{
+#if OPT_LINTLIBRARY
+	    if (lintLibrary()) { /* Lint doesn't grok C++ ref variables */
+		yyval.text = yystack.l_mark[0].text;
+	    } else
+#endif
+		(void)sprintf(yyval.text.text, "&%s", yystack.l_mark[0].text.text);
+	    yyval.text.begin = yystack.l_mark[-1].text.begin;
+	}
+break;
+case 105:
+#line 941 "grammar.y"
+	{
+	    yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin);
+	}
+break;
+case 106:
+#line 945 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[0].declarator;
+	    (void)sprintf(buf, "%s%s", yystack.l_mark[-1].text.text, yyval.declarator->text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	    yyval.declarator->begin = yystack.l_mark[-1].text.begin;
+	}
+break;
+case 108:
+#line 957 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[-1].declarator;
+	    (void)sprintf(buf, "(%s)", yyval.declarator->text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	    yyval.declarator->begin = yystack.l_mark[-2].text.begin;
+	}
+break;
+case 109:
+#line 965 "grammar.y"
+	{
+	    yyval.declarator = yystack.l_mark[-1].declarator;
+	    (void)sprintf(buf, "%s%s", yyval.declarator->text, yystack.l_mark[0].text.text);
+	    free(yyval.declarator->text);
+	    yyval.declarator->text = xstrdup(buf);
+	}
+break;
+case 110:
+#line 972 "grammar.y"
+	{
+	    yyval.declarator = new_declarator(yystack.l_mark[0].text.text, "", yystack.l_mark[0].text.begin);
+	}
+break;
+case 111:
+#line 976 "grammar.y"
+	{
+	    yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-3].declarator->begin);
+	    yyval.declarator->params = yystack.l_mark[-1].param_list;
+	    yyval.declarator->func_stack = yystack.l_mark[-3].declarator;
+	    yyval.declarator->head = (yystack.l_mark[-3].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-3].declarator->head;
+	    yyval.declarator->func_def = FUNC_ANSI;
+	}
+break;
+case 112:
+#line 984 "grammar.y"
+	{
+	    yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].declarator->begin);
+	    yyval.declarator->func_stack = yystack.l_mark[-2].declarator;
+	    yyval.declarator->head = (yystack.l_mark[-2].declarator->func_stack == NULL) ? yyval.declarator : yystack.l_mark[-2].declarator->head;
+	    yyval.declarator->func_def = FUNC_ANSI;
+	}
+break;
+case 113:
+#line 991 "grammar.y"
+	{
+	    Declarator *d;
+
+	    d = new_declarator("", "", yystack.l_mark[-2].text.begin);
+	    yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-2].text.begin);
+	    yyval.declarator->params = yystack.l_mark[-1].param_list;
+	    yyval.declarator->func_stack = d;
+	    yyval.declarator->head = yyval.declarator;
+	    yyval.declarator->func_def = FUNC_ANSI;
+	}
+break;
+case 114:
+#line 1002 "grammar.y"
+	{
+	    Declarator *d;
+
+	    d = new_declarator("", "", yystack.l_mark[-1].text.begin);
+	    yyval.declarator = new_declarator("%s()", "", yystack.l_mark[-1].text.begin);
+	    yyval.declarator->func_stack = d;
+	    yyval.declarator->head = yyval.declarator;
+	    yyval.declarator->func_def = FUNC_ANSI;
+	}
+break;
+#line 1882 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.09.out b/usr.bin/yacc/tests/regress.09.out
new file mode 100644
index 000000000000..b6c13e222cc6
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.09.out
@@ -0,0 +1,599 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "pure_calc.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM &yylval
+#define YYLEX_DECL() yylex(YYSTYPE *yylval)
+#define YYERROR_DECL() yyerror(const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+#line 35 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define DIGIT 257
+#define LETTER 258
+#define UMINUS 259
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,   17,    0,    0,    0,    0,    0,    0,    3,
+    0,   15,   14,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    9,
+   10,   11,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -40,   -7,    0,  -55,  -38,  -38,    1,  -29, -247,    0,
+  -38,    0,    0,   22,    0,  -38,  -38,  -38,  -38,  -38,
+  -38,  -38,    0,  -29,    0,   51,   60,  -20,  -20,    0,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    2,    0,    0,    0,    9,   -9,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   10,    0,   -6,   14,    5,   13,    0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+    0,   65,    0,
+};
+#define YYTABLESIZE 220
+static const short yytable[] = {                          6,
+   16,    6,   10,   13,    5,   11,    5,   22,   17,   23,
+   15,   15,   20,   18,    7,   19,   22,   21,    4,    5,
+    0,   20,    8,   12,    0,    0,   21,   16,   16,    0,
+    0,   16,   16,   16,   13,   16,    0,   16,   15,   15,
+    0,    0,    7,   15,   15,    7,   15,    7,   15,    7,
+    8,   12,    0,    8,   12,    8,    0,    8,   22,   17,
+    0,    0,   25,   20,   18,    0,   19,    0,   21,   13,
+   14,    0,    0,    0,    0,   24,    0,    0,    0,    0,
+   26,   27,   28,   29,   30,   31,   32,   22,   17,    0,
+    0,    0,   20,   18,   16,   19,   22,   21,    0,    0,
+    0,   20,   18,    0,   19,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,   16,    0,    0,   13,    0,    0,
+    0,    0,    0,    0,    0,   15,    0,    0,    7,    0,
+    0,    0,    0,    0,    0,    0,    8,   12,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    2,    3,    4,    3,   12,
+};
+static const short yycheck[] = {                         40,
+   10,   40,   10,   10,   45,   61,   45,   37,   38,  257,
+   10,   10,   42,   43,   10,   45,   37,   47,   10,   10,
+   -1,   42,   10,   10,   -1,   -1,   47,   37,   38,   -1,
+   -1,   41,   42,   43,   41,   45,   -1,   47,   37,   38,
+   -1,   -1,   38,   42,   43,   41,   45,   43,   47,   45,
+   38,   38,   -1,   41,   41,   43,   -1,   45,   37,   38,
+   -1,   -1,   41,   42,   43,   -1,   45,   -1,   47,    5,
+    6,   -1,   -1,   -1,   -1,   11,   -1,   -1,   -1,   -1,
+   16,   17,   18,   19,   20,   21,   22,   37,   38,   -1,
+   -1,   -1,   42,   43,  124,   45,   37,   47,   -1,   -1,
+   -1,   42,   43,   -1,   45,   -1,   47,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,  124,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  124,  124,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  124,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  257,  258,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 259
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr '+' expr",
+"expr : expr '-' expr",
+"expr : expr '*' expr",
+"expr : expr '/' expr",
+"expr : expr '%' expr",
+"expr : expr '&' expr",
+"expr : expr '|' expr",
+"expr : '-' expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 72 "pure_calc.y"
+ /* start of programs */
+
+#ifdef YYBYACC
+static int YYLEX_DECL();
+#endif
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+YYERROR_DECL()
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+YYLEX_DECL()
+{
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	*yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	*yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 277 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 34 "pure_calc.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 38 "pure_calc.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 40 "pure_calc.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 44 "pure_calc.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 46 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 48 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 50 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 52 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 54 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 56 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 58 "pure_calc.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 60 "pure_calc.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 62 "pure_calc.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 67 "pure_calc.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 69 "pure_calc.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 539 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.10.out b/usr.bin/yacc/tests/regress.10.out
new file mode 100644
index 000000000000..f4a5ba4348b0
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.10.out
@@ -0,0 +1,429 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "pure_error.y"
+
+#ifdef YYBISON
+#define YYSTYPE int
+#define YYLEX_PARAM &yylval
+#define YYLEX_DECL() yylex(YYSTYPE *yylval)
+#define YYERROR_DECL() yyerror(const char *s)
+int YYLEX_DECL();
+static void YYERROR_DECL();
+#endif
+
+#line 30 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,
+};
+static const short yylen[] = {                            2,
+    1,
+};
+static const short yydefred[] = {                         0,
+    1,    0,
+};
+static const short yydgoto[] = {                          2,
+};
+static const short yysindex[] = {                      -256,
+    0,    0,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,
+};
+static const short yygindex[] = {                         0,
+};
+#define YYTABLESIZE 0
+static const short yytable[] = {                          1,
+};
+static const short yycheck[] = {                        256,
+};
+#define YYFINAL 2
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 0
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : S",
+"S : error",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 17 "pure_error.y"
+
+#include <stdio.h>
+
+#ifdef YYBYACC
+extern int YYLEX_DECL();
+#endif
+
+int
+main(void)
+{
+    printf("yyparse() = %d\n", yyparse());
+    return 0;
+}
+
+int
+yylex(YYSTYPE *value)
+{
+    return value ? 0 : -1;
+}
+
+static void
+yyerror(const char* s)
+{
+    printf("%s\n", s);
+}
+#line 168 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.11.out b/usr.bin/yacc/tests/regress.11.out
new file mode 100644
index 000000000000..8668971b4208
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.11.out
@@ -0,0 +1,610 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "quote_calc.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+#line 29 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define OP_ADD 257
+#define ADD 258
+#define OP_SUB 259
+#define SUB 260
+#define OP_MUL 261
+#define MUL 262
+#define OP_DIV 263
+#define DIV 264
+#define OP_MOD 265
+#define MOD 266
+#define OP_AND 267
+#define AND 268
+#define DIGIT 269
+#define LETTER 270
+#define UMINUS 271
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
+   15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
+    0,    0,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -38,    5,  -36,    0,  -51,  -36,    7, -121, -248,    0,
+    0, -243,  -36,  -22,    0,  -36,  -36,  -36,  -36,  -36,
+  -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
+ -121, -243,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    0,   -9,    0,    0,   13,  -10,    0,
+    0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   15,    0,   -3,   -2,   -1,    1,    2,
+    3,   -4,
+};
+static const short yygindex[] = {                         0,
+    0,   42,    0,
+};
+#define YYTABLESIZE 258
+static const short yytable[] = {                         16,
+   15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
+   10,   11,   12,   16,   10,   17,   15,   18,   25,   19,
+   23,   20,    4,   21,    5,    0,    0,    0,    0,    0,
+   16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
+    0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
+    0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
+   29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,   17,    0,   18,
+    0,   19,    0,   20,    0,   21,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
+    3,    0,    3,    0,    0,    0,    0,    0,    0,    0,
+    4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
+   19,    0,   20,    0,   21,    0,   16,   15,   16,   15,
+   16,   15,   16,   15,   16,   15,   16,   15,
+};
+static const short yycheck[] = {                         10,
+   10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
+   10,   10,   10,  257,   10,  259,   10,  261,   41,  263,
+  269,  265,   10,  267,   10,   -1,   -1,   -1,   -1,   -1,
+   41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
+   -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
+   -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
+   19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,   -1,  259,   -1,  261,
+   -1,  263,   -1,  265,   -1,  267,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+  259,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  269,  270,  269,  270,  257,   -1,  259,   -1,  261,   -1,
+  263,   -1,  265,   -1,  267,   -1,  257,  257,  259,  259,
+  261,  261,  263,  263,  265,  265,  267,  267,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 271
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
+"\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
+"illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr OP_ADD expr",
+"expr : expr OP_SUB expr",
+"expr : expr OP_MUL expr",
+"expr : expr OP_DIV expr",
+"expr : expr OP_MOD expr",
+"expr : expr OP_AND expr",
+"expr : expr '|' expr",
+"expr : OP_SUB expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 73 "quote_calc.y"
+ /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 288 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 35 "quote_calc.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 39 "quote_calc.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 41 "quote_calc.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 45 "quote_calc.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 47 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 49 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 51 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 53 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 55 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 57 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 59 "quote_calc.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 61 "quote_calc.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 63 "quote_calc.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 68 "quote_calc.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 70 "quote_calc.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 550 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.12.out b/usr.bin/yacc/tests/regress.12.out
new file mode 100644
index 000000000000..757c977d430a
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.12.out
@@ -0,0 +1,610 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "quote_calc2.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+#line 29 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define OP_ADD 257
+#define ADD 258
+#define OP_SUB 259
+#define SUB 260
+#define OP_MUL 261
+#define MUL 262
+#define OP_DIV 263
+#define DIV 264
+#define OP_MOD 265
+#define MOD 266
+#define OP_AND 267
+#define AND 268
+#define DIGIT 269
+#define LETTER 270
+#define UMINUS 271
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
+   15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
+    0,    0,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -38,    4,  -36,    0,  -51,  -36,    6, -121, -249,    0,
+    0, -243,  -36,  -23,    0,  -36,  -36,  -36,  -36,  -36,
+  -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
+ -121, -243,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    0,   -9,    0,    0,   12,  -10,    0,
+    0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   14,    0,   -3,   -2,   -1,    1,    2,
+    3,   -4,
+};
+static const short yygindex[] = {                         0,
+    0,   42,    0,
+};
+#define YYTABLESIZE 259
+static const short yytable[] = {                         16,
+   15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
+   10,   11,   12,   10,   16,   15,   17,   25,   18,   23,
+   19,    4,   20,    5,   21,    0,    0,    0,    0,    0,
+   16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
+    0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
+    0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
+   29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   22,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   16,    0,   17,    0,
+   18,    0,   19,    0,   20,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
+    0,    3,    0,    3,    0,    0,    0,    0,    0,    0,
+    4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
+   19,    0,   20,    0,   21,    0,    0,   16,   15,   16,
+   15,   16,   15,   16,   15,   16,   15,   16,   15,
+};
+static const short yycheck[] = {                         10,
+   10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
+   10,   10,   10,   10,  258,   10,  260,   41,  262,  269,
+  264,   10,  266,   10,  268,   -1,   -1,   -1,   -1,   -1,
+   41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
+   -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
+   -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
+   19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,  260,   -1,
+  262,   -1,  264,   -1,  266,   -1,  268,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+   -1,  260,   -1,  260,   -1,   -1,   -1,   -1,   -1,   -1,
+  269,  270,  269,  270,  258,   -1,  260,   -1,  262,   -1,
+  264,   -1,  266,   -1,  268,   -1,   -1,  258,  258,  260,
+  260,  262,  262,  264,  264,  266,  266,  268,  268,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 271
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
+"\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
+"illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr \"ADD\" expr",
+"expr : expr \"SUB\" expr",
+"expr : expr \"MUL\" expr",
+"expr : expr \"DIV\" expr",
+"expr : expr \"MOD\" expr",
+"expr : expr \"AND\" expr",
+"expr : expr '|' expr",
+"expr : \"SUB\" expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 73 "quote_calc2.y"
+ /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 288 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 35 "quote_calc2.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 39 "quote_calc2.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 41 "quote_calc2.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 45 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 47 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 49 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 51 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 53 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 55 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 57 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 59 "quote_calc2.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 61 "quote_calc2.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 63 "quote_calc2.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 68 "quote_calc2.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 70 "quote_calc2.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 550 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.13.out b/usr.bin/yacc/tests/regress.13.out
new file mode 100644
index 000000000000..94b717ef9624
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.13.out
@@ -0,0 +1,604 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "quote_calc3.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+#line 29 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define OP_ADD 257
+#define OP_SUB 259
+#define OP_MUL 261
+#define OP_DIV 263
+#define OP_MOD 265
+#define OP_AND 267
+#define DIGIT 269
+#define LETTER 270
+#define UMINUS 271
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
+   15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
+    0,    0,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -38,    5,  -36,    0,  -51,  -36,    7, -121, -248,    0,
+    0, -243,  -36,  -22,    0,  -36,  -36,  -36,  -36,  -36,
+  -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
+ -121, -243,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    0,   -9,    0,    0,   13,  -10,    0,
+    0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   15,    0,   -3,   -2,   -1,    1,    2,
+    3,   -4,
+};
+static const short yygindex[] = {                         0,
+    0,   42,    0,
+};
+#define YYTABLESIZE 258
+static const short yytable[] = {                         16,
+   15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
+   10,   11,   12,   16,   10,   17,   15,   18,   25,   19,
+   23,   20,    4,   21,    5,    0,    0,    0,    0,    0,
+   16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
+    0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
+    0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
+   29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   16,    0,   17,    0,   18,
+    0,   19,    0,   20,    0,   21,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
+    3,    0,    3,    0,    0,    0,    0,    0,    0,    0,
+    4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
+   19,    0,   20,    0,   21,    0,   16,   15,   16,   15,
+   16,   15,   16,   15,   16,   15,   16,   15,
+};
+static const short yycheck[] = {                         10,
+   10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
+   10,   10,   10,  257,   10,  259,   10,  261,   41,  263,
+  269,  265,   10,  267,   10,   -1,   -1,   -1,   -1,   -1,
+   41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
+   -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
+   -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
+   19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  257,   -1,  259,   -1,  261,
+   -1,  263,   -1,  265,   -1,  267,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+  259,   -1,  259,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  269,  270,  269,  270,  257,   -1,  259,   -1,  261,   -1,
+  263,   -1,  265,   -1,  267,   -1,  257,  257,  259,  259,
+  261,  261,  263,  263,  265,  265,  267,  267,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 271
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"OP_ADD","\"ADD-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
+"\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
+"OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr OP_ADD expr",
+"expr : expr OP_SUB expr",
+"expr : expr OP_MUL expr",
+"expr : expr OP_DIV expr",
+"expr : expr OP_MOD expr",
+"expr : expr OP_AND expr",
+"expr : expr '|' expr",
+"expr : OP_SUB expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 73 "quote_calc3.y"
+ /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 282 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 35 "quote_calc3.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 39 "quote_calc3.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 41 "quote_calc3.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 45 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 47 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 49 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 51 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 53 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 55 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 57 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 59 "quote_calc3.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 61 "quote_calc3.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 63 "quote_calc3.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 68 "quote_calc3.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 70 "quote_calc3.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 544 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.14.out b/usr.bin/yacc/tests/regress.14.out
new file mode 100644
index 000000000000..aecfb49d161d
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.14.out
@@ -0,0 +1,604 @@
+#ifndef lint
+static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
+#endif
+
+#define YYBYACC 1
+#define YYMAJOR 1
+#define YYMINOR 9
+#define YYPATCH 20140101
+
+#define YYEMPTY        (-1)
+#define yyclearin      (yychar = YYEMPTY)
+#define yyerrok        (yyerrflag = 0)
+#define YYRECOVERING() (yyerrflag != 0)
+
+#define YYPREFIX "yy"
+
+#define YYPURE 0
+
+#line 2 "quote_calc4.y"
+# include <stdio.h>
+# include <ctype.h>
+
+int regs[26];
+int base;
+
+int yylex(void);
+static void yyerror(const char *s);
+
+#line 29 "/dev/stdout"
+
+#ifndef YYSTYPE
+typedef int YYSTYPE;
+#endif
+
+/* compatibility with bison */
+#ifdef YYPARSE_PARAM
+/* compatibility with FreeBSD */
+# ifdef YYPARSE_PARAM_TYPE
+#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
+# else
+#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
+# endif
+#else
+# define YYPARSE_DECL() yyparse(void)
+#endif
+
+/* Parameters sent to lex. */
+#ifdef YYLEX_PARAM
+# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
+# define YYLEX yylex(YYLEX_PARAM)
+#else
+# define YYLEX_DECL() yylex(void)
+# define YYLEX yylex()
+#endif
+
+/* Parameters sent to yyerror. */
+#ifndef YYERROR_DECL
+#define YYERROR_DECL() yyerror(const char *s)
+#endif
+#ifndef YYERROR_CALL
+#define YYERROR_CALL(msg) yyerror(msg)
+#endif
+
+extern int YYPARSE_DECL();
+
+#define OP_ADD 257
+#define OP_SUB 259
+#define OP_MUL 261
+#define OP_DIV 263
+#define OP_MOD 265
+#define OP_AND 267
+#define DIGIT 269
+#define LETTER 270
+#define UMINUS 271
+#define YYERRCODE 256
+static const short yylhs[] = {                           -1,
+    0,    0,    0,    1,    1,    2,    2,    2,    2,    2,
+    2,    2,    2,    2,    2,    2,    3,    3,
+};
+static const short yylen[] = {                            2,
+    0,    3,    3,    1,    3,    3,    3,    3,    3,    3,
+    3,    3,    3,    2,    1,    1,    1,    2,
+};
+static const short yydefred[] = {                         1,
+    0,    0,    0,   17,    0,    0,    0,    0,    0,    3,
+   15,    0,    0,    0,    2,    0,    0,    0,    0,    0,
+    0,    0,   18,    0,    6,    0,    0,    0,    0,    0,
+    0,    0,
+};
+static const short yydgoto[] = {                          1,
+    7,    8,    9,
+};
+static const short yysindex[] = {                         0,
+  -38,    4,  -36,    0,  -51,  -36,    6, -121, -249,    0,
+    0, -243,  -36,  -23,    0,  -36,  -36,  -36,  -36,  -36,
+  -36,  -36,    0, -121,    0, -121, -121, -121, -121, -121,
+ -121, -243,
+};
+static const short yyrindex[] = {                         0,
+    0,    0,    0,    0,   -9,    0,    0,   12,  -10,    0,
+    0,   -5,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   14,    0,   -3,   -2,   -1,    1,    2,
+    3,   -4,
+};
+static const short yygindex[] = {                         0,
+    0,   42,    0,
+};
+#define YYTABLESIZE 259
+static const short yytable[] = {                         16,
+   15,    6,   22,    6,   14,   13,    7,    8,    9,   13,
+   10,   11,   12,   10,   16,   15,   17,   25,   18,   23,
+   19,    4,   20,    5,   21,    0,    0,    0,    0,    0,
+   16,    0,    0,    0,    0,   14,   13,    7,    8,    9,
+    0,   10,   11,   12,   12,    0,    0,   14,    0,    0,
+    0,    0,    0,    0,   24,    0,    0,   26,   27,   28,
+   29,   30,   31,   32,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   22,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   16,   15,    0,    0,    0,   14,   13,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   16,    0,   17,    0,
+   18,    0,   19,    0,   20,    0,   21,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    2,    0,    0,
+    0,    3,    0,    3,    0,    0,    0,    0,    0,    0,
+    4,    5,    4,   11,   16,    0,   17,    0,   18,    0,
+   19,    0,   20,    0,   21,    0,    0,   16,   15,   16,
+   15,   16,   15,   16,   15,   16,   15,   16,   15,
+};
+static const short yycheck[] = {                         10,
+   10,   40,  124,   40,   10,   10,   10,   10,   10,   61,
+   10,   10,   10,   10,  258,   10,  260,   41,  262,  269,
+  264,   10,  266,   10,  268,   -1,   -1,   -1,   -1,   -1,
+   41,   -1,   -1,   -1,   -1,   41,   41,   41,   41,   41,
+   -1,   41,   41,   41,    3,   -1,   -1,    6,   -1,   -1,
+   -1,   -1,   -1,   -1,   13,   -1,   -1,   16,   17,   18,
+   19,   20,   21,   22,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  124,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  124,  124,   -1,   -1,   -1,  124,  124,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  258,   -1,  260,   -1,
+  262,   -1,  264,   -1,  266,   -1,  268,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+   -1,  260,   -1,  260,   -1,   -1,   -1,   -1,   -1,   -1,
+  269,  270,  269,  270,  258,   -1,  260,   -1,  262,   -1,
+  264,   -1,  266,   -1,  268,   -1,   -1,  258,  258,  260,
+  260,  262,  262,  264,  264,  266,  266,  268,  268,
+};
+#define YYFINAL 1
+#ifndef YYDEBUG
+#define YYDEBUG 0
+#endif
+#define YYMAXTOKEN 271
+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? (YYMAXTOKEN + 1) : (a))
+#if YYDEBUG
+static const char *yyname[] = {
+
+"end-of-file",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,
+0,0,0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+0,0,0,0,0,0,"OP_ADD","\"ADD-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
+"\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
+"OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS","illegal-symbol",
+};
+static const char *yyrule[] = {
+"$accept : list",
+"list :",
+"list : list stat '\\n'",
+"list : list error '\\n'",
+"stat : expr",
+"stat : LETTER '=' expr",
+"expr : '(' expr ')'",
+"expr : expr \"ADD-operator\" expr",
+"expr : expr \"SUB-operator\" expr",
+"expr : expr \"MUL-operator\" expr",
+"expr : expr \"DIV-operator\" expr",
+"expr : expr \"MOD-operator\" expr",
+"expr : expr \"AND-operator\" expr",
+"expr : expr '|' expr",
+"expr : \"SUB-operator\" expr",
+"expr : LETTER",
+"expr : number",
+"number : DIGIT",
+"number : number DIGIT",
+
+};
+#endif
+
+int      yydebug;
+int      yynerrs;
+
+int      yyerrflag;
+int      yychar;
+YYSTYPE  yyval;
+YYSTYPE  yylval;
+
+/* define the initial stack-sizes */
+#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
+
+typedef struct {
+    unsigned stacksize;
+    short    *s_base;
+    short    *s_mark;
+    short    *s_last;
+    YYSTYPE  *l_base;
+    YYSTYPE  *l_mark;
+} YYSTACKDATA;
+/* variables for the parser stack */
+static YYSTACKDATA yystack;
+#line 73 "quote_calc4.y"
+ /* start of programs */
+
+int
+main (void)
+{
+    while(!feof(stdin)) {
+	yyparse();
+    }
+    return 0;
+}
+
+static void
+yyerror(const char *s)
+{
+    fprintf(stderr, "%s\n", s);
+}
+
+int
+yylex(void) {
+	/* lexical analysis routine */
+	/* returns LETTER for a lower case letter, yylval = 0 through 25 */
+	/* return DIGIT for a digit, yylval = 0 through 9 */
+	/* all other characters are returned immediately */
+
+    int c;
+
+    while( (c=getchar()) == ' ' )   { /* skip blanks */ }
+
+    /* c is now nonblank */
+
+    if( islower( c )) {
+	yylval = c - 'a';
+	return ( LETTER );
+    }
+    if( isdigit( c )) {
+	yylval = c - '0';
+	return ( DIGIT );
+    }
+    return( c );
+}
+#line 282 "/dev/stdout"
+
+#if YYDEBUG
+#include <stdio.h>		/* needed for printf */
+#endif
+
+#include <stdlib.h>	/* needed for malloc, etc */
+#include <string.h>	/* needed for memset */
+
+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
+static int yygrowstack(YYSTACKDATA *data)
+{
+    int i;
+    unsigned newsize;
+    short *newss;
+    YYSTYPE *newvs;
+
+    if ((newsize = data->stacksize) == 0)
+        newsize = YYINITSTACKSIZE;
+    else if (newsize >= YYMAXDEPTH)
+        return -1;
+    else if ((newsize *= 2) > YYMAXDEPTH)
+        newsize = YYMAXDEPTH;
+
+    i = (int) (data->s_mark - data->s_base);
+    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
+    if (newss == 0)
+        return -1;
+
+    data->s_base = newss;
+    data->s_mark = newss + i;
+
+    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
+    if (newvs == 0)
+        return -1;
+
+    data->l_base = newvs;
+    data->l_mark = newvs + i;
+
+    data->stacksize = newsize;
+    data->s_last = data->s_base + newsize - 1;
+    return 0;
+}
+
+#if YYPURE || defined(YY_NO_LEAKS)
+static void yyfreestack(YYSTACKDATA *data)
+{
+    free(data->s_base);
+    free(data->l_base);
+    memset(data, 0, sizeof(*data));
+}
+#else
+#define yyfreestack(data) /* nothing */
+#endif
+
+#define YYABORT  goto yyabort
+#define YYREJECT goto yyabort
+#define YYACCEPT goto yyaccept
+#define YYERROR  goto yyerrlab
+
+int
+YYPARSE_DECL()
+{
+    int yym, yyn, yystate;
+#if YYDEBUG
+    const char *yys;
+
+    if ((yys = getenv("YYDEBUG")) != 0)
+    {
+        yyn = *yys;
+        if (yyn >= '0' && yyn <= '9')
+            yydebug = yyn - '0';
+    }
+#endif
+
+    yynerrs = 0;
+    yyerrflag = 0;
+    yychar = YYEMPTY;
+    yystate = 0;
+
+#if YYPURE
+    memset(&yystack, 0, sizeof(yystack));
+#endif
+
+    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
+    yystack.s_mark = yystack.s_base;
+    yystack.l_mark = yystack.l_base;
+    yystate = 0;
+    *yystack.s_mark = 0;
+
+yyloop:
+    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
+    if (yychar < 0)
+    {
+        if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            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 (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+        {
+            goto yyoverflow;
+        }
+        yystate = yytable[yyn];
+        *++yystack.s_mark = yytable[yyn];
+        *++yystack.l_mark = yylval;
+        yychar = YYEMPTY;
+        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;
+
+    yyerror("syntax error");
+
+    goto yyerrlab;
+
+yyerrlab:
+    ++yynerrs;
+
+yyinrecovery:
+    if (yyerrflag < 3)
+    {
+        yyerrflag = 3;
+        for (;;)
+        {
+            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
+                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: state %d, error recovery shifting\
+ to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
+#endif
+                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+                {
+                    goto yyoverflow;
+                }
+                yystate = yytable[yyn];
+                *++yystack.s_mark = yytable[yyn];
+                *++yystack.l_mark = yylval;
+                goto yyloop;
+            }
+            else
+            {
+#if YYDEBUG
+                if (yydebug)
+                    printf("%sdebug: error recovery discarding state %d\n",
+                            YYPREFIX, *yystack.s_mark);
+#endif
+                if (yystack.s_mark <= yystack.s_base) goto yyabort;
+                --yystack.s_mark;
+                --yystack.l_mark;
+            }
+        }
+    }
+    else
+    {
+        if (yychar == 0) goto yyabort;
+#if YYDEBUG
+        if (yydebug)
+        {
+            yys = yyname[YYTRANSLATE(yychar)];
+            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
+                    YYPREFIX, yystate, yychar, yys);
+        }
+#endif
+        yychar = YYEMPTY;
+        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 = yystack.l_mark[1-yym];
+    else
+        memset(&yyval, 0, sizeof yyval);
+    switch (yyn)
+    {
+case 3:
+#line 35 "quote_calc4.y"
+	{  yyerrok ; }
+break;
+case 4:
+#line 39 "quote_calc4.y"
+	{  printf("%d\n",yystack.l_mark[0]);}
+break;
+case 5:
+#line 41 "quote_calc4.y"
+	{  regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
+break;
+case 6:
+#line 45 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-1]; }
+break;
+case 7:
+#line 47 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
+break;
+case 8:
+#line 49 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
+break;
+case 9:
+#line 51 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
+break;
+case 10:
+#line 53 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
+break;
+case 11:
+#line 55 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
+break;
+case 12:
+#line 57 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
+break;
+case 13:
+#line 59 "quote_calc4.y"
+	{  yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
+break;
+case 14:
+#line 61 "quote_calc4.y"
+	{  yyval = - yystack.l_mark[0]; }
+break;
+case 15:
+#line 63 "quote_calc4.y"
+	{  yyval = regs[yystack.l_mark[0]]; }
+break;
+case 17:
+#line 68 "quote_calc4.y"
+	{  yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
+break;
+case 18:
+#line 70 "quote_calc4.y"
+	{  yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
+break;
+#line 544 "/dev/stdout"
+    }
+    yystack.s_mark -= yym;
+    yystate = *yystack.s_mark;
+    yystack.l_mark -= 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;
+        *++yystack.s_mark = YYFINAL;
+        *++yystack.l_mark = yyval;
+        if (yychar < 0)
+        {
+            if ((yychar = YYLEX) < 0) yychar = 0;
+#if YYDEBUG
+            if (yydebug)
+            {
+                yys = yyname[YYTRANSLATE(yychar)];
+                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, *yystack.s_mark, yystate);
+#endif
+    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
+    {
+        goto yyoverflow;
+    }
+    *++yystack.s_mark = (short) yystate;
+    *++yystack.l_mark = yyval;
+    goto yyloop;
+
+yyoverflow:
+    yyerror("yacc stack overflow");
+
+yyabort:
+    yyfreestack(&yystack);
+    return (1);
+
+yyaccept:
+    yyfreestack(&yystack);
+    return (0);
+}
diff --git a/usr.bin/yacc/tests/regress.sh b/usr.bin/yacc/tests/regress.sh
new file mode 100644
index 000000000000..fb3b5a5df44b
--- /dev/null
+++ b/usr.bin/yacc/tests/regress.sh
@@ -0,0 +1,28 @@
+# $FreeBSD$
+
+echo 1..15
+
+test_yacc() {
+	yacc "${@}" | sed -e "s,${SRCDIR}/,,g"
+}
+
+REGRESSION_START($1)
+
+REGRESSION_TEST(`00', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/undefined.y')
+REGRESSION_TEST(`01', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/calc.y')
+REGRESSION_TEST(`02', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/calc1.y')
+REGRESSION_TEST(`03', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/calc3.y')
+REGRESSION_TEST(`04', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/code_calc.y')
+REGRESSION_TEST(`05', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/code_error.y')
+REGRESSION_TEST(`06', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/error.y')
+REGRESSION_TEST(`07', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/ftp.y')
+REGRESSION_TEST(`08', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/grammar.y')
+REGRESSION_TEST(`09', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/pure_calc.y')
+REGRESSION_TEST(`10', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/pure_error.y')
+REGRESSION_TEST(`11', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/quote_calc.y')
+REGRESSION_TEST(`12', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/quote_calc2.y')
+REGRESSION_TEST(`13', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/quote_calc3.y')
+REGRESSION_TEST(`14', `test_yacc -b regress -o /dev/stdout ${SRCDIR}/quote_calc4.y')
+
+REGRESSION_END()
+
diff --git a/usr.bin/yacc/tests/undefined.y b/usr.bin/yacc/tests/undefined.y
new file mode 100644
index 000000000000..33ba005e4f57
--- /dev/null
+++ b/usr.bin/yacc/tests/undefined.y
@@ -0,0 +1,5 @@
+%type <int> rule
+%%
+rule:
+    ;
+%%