/* KJT 20/01/23: added function prototypes */
int yyparse();
int yyerror (char* mess);


# line 2 "gram.y"
/***********************************
  (C) Copyright 1992-1993; dit/upm
  Distributed under the conditions stated in the
  TOPO General Public License (see file LICENSE)
 ***********************************
 $Log: rdtts.spe,v $
Revision 1.13 2000/07/00  16:32:00  kjt
changed YYMAXDEPTH to 512

Revision 1.12  1993/08/02  16:59:33  lotos
fix declaration of flagxxxx (warning)

Revision 1.11  1993/06/23  16:30:02  lotos
who knows ...?

Revision 1.10  1993/06/23  16:27:36  lotos
no change

Revision 1.8  1993/06/15  13:11:00  lotos
fix colour keys to avoid collisions

Revision 1.6  1993/01/21  20:25:19  lotos
code generation for ildi

Revision 1.5  1993/01/20  13:38:05  lotos
generate test system for lola

Revision 1.3  1993/01/18  17:52:26  lotos
use priority annotations
distribution issues
portability issues

Revision 1.1  1992/11/19  18:22:32  lotos
Initial revision

 ***********************************/

# include "version.h"
#ifndef lint
static char rcsid[]= "$Id: rdtts.spe,v 1.12 1993/08/02 16:59:33 lotos Exp $";
#endif

# line 45 "gram.y"
# include "swbus.h"
# define YYMAXDEPTH      512
# define YYSTYPE         yystype
# define putgrn(n)       (void)ITadd(n, gl)
# define class(nt)       { cls= 0; xxc= nt-1;   \
	       for (xc= 0; xc < nt; xc++, xxc--)    \
			     if (stpick(xc)->type != tNULL) \
		 cls += (1 << xxc);}
# define ndput(tp)   { stput(tp);   \
	       if (gn != NULL){gn->value0=  \
		  (CLR_TYPE)IAT_IT_add(gl, grnl); \
		  gl->size= 0;} \
	       gn= (sttype() == tNULL) ? NULL : sttop(); }
# define ndterm(tp, val) { stput (tp);  \
		       staclr (c_lexv, (CLR_TYPE)val.name); \
		       staclr (c_line, (CLR_TYPE)val.line);}

IT* gl;
TNODE*  gn;
int cls;
int xc;
int xxc;

/* KJT 20/01/23: added function prototypes */
int yyparse();

# define LET 260
# define FOR 261
# define IN 262
# define IMPLICATION 263
# define OF 264
# define IDENTIFIER 265
# define SPECIAL 266
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern short yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
#ifndef YYSTYPE
#define YYSTYPE int
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256

# line 762 "gram.y"


PRIVATE int
yylex ()
{
    token *tk;

   tk = gtk ();
   yylval = tk->yylval;
   return tk->type;
}

PUBLIC TNODE*
bast ()
{
   gl= ITcreate (4, 2, 1);
   gn= NULL;
   (void)yyparse();
   if (gn != NULL) gn->value0= (CLR_TYPE)IAT_IT_add(gl, grnl);
   return sttop();
}
short yyexca[] ={
-1, 1,
	0, -1,
	-2, 0,
-1, 12,
	59, 20,
	-2, 31,
-1, 13,
	59, 21,
	-2, 32,
	};
# define YYNPROD 57
# define YYLAST 235
short yyact[]={

  20,  33,  20,  34,  20,  21,  22,  68,  73,  61,
  28,  84,  38,  31,  63,  62,  18,  91,  19, 100,
  60,  13,  99,  93,  49,  29,  72,   7,  65,  34,
  70,  27,  35,  54,  46,  90,  81,  30,  96,  47,
  89,  48,  44,  36,  32,  88,  69,  43,  17,  15,
  41,  12,   9,  52,  16,  26,  55,  25,  59,  66,
  64,   3,  24,  35,  23,  67,  42,  83,  76,  37,
  14,  35,  74,  71,  35,  10,  82,  80,  35,  79,
  77,  39,  53,  51,  50,  57,  35,  40,  58,  11,
  56,  78,   8,  85,  86,  67,  87,   5,   4,   2,
   1,  35,  92,   0,   0,  95,   0,  94,   0,   0,
   0,  97,   0,   0,   0,   0,  35, 101,  98,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,  75,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,  21,  22,   0,
   0,   0,   0,   0,   0,   0,   0,   0,  45,   0,
   6,  18,   0,   0,   0,  21,  22,  21,  22,  21,
  22,  21,  22,  21,  22 };
short yypact[]={

 -40,-1000, -40,-1000,-1000,-1000,-255,-1000, -66, -22,
-250,   0,-1000, -32,  -1,-1000,-252,-1000,-255,   7,
 -38,-1000,-1000,-1000, -27, -19,  -3,-1000,-1000, -67,
-1000, -36,-245, -28, -36, -36, -36,-1000,-256,-247,
-248,-260,-1000, -36, -34,   5, -83,-256,-255, -36,
 -23,-1000, -32,-1000, -36,-260,-253,-1000,-1000, -58,
-1000,-1000, -83, -83,-255,   4,  -4,-260,-1000,-1000,
 -24,-107,-1000, -36,-1000,-1000,-1000,-1000, -70, -36,
-1000,-1000,-260,-1000,-256,-1000,-1000, -20,-1000, -36,
-1000, -83, -71, -74,-1000,-1000,-256,-260,-1000,-1000,
-1000,-1000 };
short yypgo[]={

   0, 100,  99,  61,  98,  97,  62,  30,  27,  92,
  91,  89,  49,  87,  31,  18,  20,  79,  52,  75,
  51,  21,  73,  26,  28,  72,  70,  48,  69,  54,
  67,  66,  59,  57,  55 };
short yyr1[]={

   0,   2,   2,   1,   3,   3,   4,   5,   5,  11,
  11,   9,  12,  12,  13,  17,  17,  10,   8,   8,
  18,  18,  18,  22,  22,   7,  23,  23,  26,  26,
  19,  27,  27,  20,  28,  28,  21,  30,  30,  21,
  31,  31,  29,  29,  29,  32,  32,  24,   6,  34,
  34,  33,  16,  15,  15,  25,  14 };
short yyr2[]={

   0,   1,   2,   1,   1,   1,   5,   1,   6,   1,
   3,   1,   4,   4,   5,   1,   2,   1,   2,   4,
   1,   1,   4,   1,   3,   1,   3,   1,   1,   3,
   1,   1,   1,   3,   0,   2,   2,   0,   2,   4,
   0,   3,   2,   3,   3,   1,   3,   1,   3,   1,
   3,   1,   1,   1,   1,   1,   1 };
short yychk[]={

-1000,  -1,  -2,  -3,  -4,  -5, 260,  -8,  -9, -18,
 -19, -11, -20, -21, -26, -12, -29, -27, 261, -15,
  40, 265, 266,  -3,  -6, -33, -34, -14, 265,  91,
  59, 263,  44,  33,  61, -15,  44, -28, 264,  -6,
 -13, -14, -31,  40, -21, 256,  61,  58,  44,  91,
 -18, -20, -21, -12,  61, -21, -29, -27, -20, -21,
 -16, 265, 262, 262, -15, -24, -32, -21,  41,  41,
  -7, -22, -23,  91, -25, 265, -16, -14, -10, -17,
  -8,  59, -21, -30, 264,  -7,  -7, -14,  41,  44,
  59, 124, -24,  93,  -8, -16,  58, -21, -23,  93,
  93, -16 };
short yydef[]={

   0,  -2,   3,   1,   4,   5,   0,   7,   0,   0,
   0,  11,  -2,  -2,  30,   9,  34,  28,   0,  40,
   0,  53,  54,   2,   0,   0,  51,  49,  56,   0,
  18,   0,   0,   0,   0,   0,   0,  36,   0,   0,
   0,  49,  42,   0,   0,   0,   0,   0,   0,   0,
   0,  20,  21,  10,   0,  33,  37,  29,  31,  32,
  35,  52,   0,   0,   0,   0,  47,  45,  43,  44,
   0,  25,  23,   0,  27,  55,  48,  50,   0,  17,
  15,  19,  22,  39,   0,  12,  13,   0,  41,   0,
   6,   0,   0,   0,  16,  38,   0,  46,  24,  26,
   8,  14 };
# line 1 "/usr/lib/yaccpar"
#ifndef lint
static char yaccpar_sccsid[] = "@(#)yaccpar	4.1	(Berkeley)	2/11/83";
#endif

# define YYFLAG -1000
# define YYERROR goto yyerrlab
# define YYACCEPT return(0)
# define YYABORT return(1)

/*	parser for yacc output	*/

#ifdef YYDEBUG
int yydebug = 0; /* 1 for debugging */
#endif
YYSTYPE yyv[YYMAXDEPTH]; /* where the values are stored */
int yychar = -1; /* current input token number */
int yynerrs = 0;  /* number of errors */
short yyerrflag = 0;  /* error recovery flag */

/* KJT 20/01/23: added "int" type */
int yyparse() {

	short yys[YYMAXDEPTH];
	short yyj, yym;
	register YYSTYPE *yypvt;
	register short yystate, *yyps, yyn;
	register YYSTYPE *yypv;
	register short *yyxi;

	yystate = 0;
	yychar = -1;
	yynerrs = 0;
	yyerrflag = 0;
	yyps= &yys[-1];
	yypv= &yyv[-1];

 yystack:    /* put a state and value onto the stack */

#ifdef YYDEBUG
	if( yydebug  ) printf( "state %d, char 0%o\n", yystate, yychar );
#endif
		if( ++yyps>= &yys[YYMAXDEPTH] ) { yyerror( "yacc stack overflow" ); return(1); }
		*yyps = yystate;
		++yypv;
		*yypv = yyval;

 yynewstate:

	yyn = yypact[yystate];

	if( yyn<= YYFLAG ) goto yydefault; /* simple state */

	if( yychar<0 ) if( (yychar=yylex())<0 ) yychar=0;
	if( (yyn += yychar)<0 || yyn >= YYLAST ) goto yydefault;

	if( yychk[ yyn=yyact[ yyn ] ] == yychar ){ /* valid shift */
		yychar = -1;
		yyval = yylval;
		yystate = yyn;
		if( yyerrflag > 0 ) --yyerrflag;
		goto yystack;
		}

 yydefault:
	/* default state action */

	if( (yyn=yydef[yystate]) == -2 ) {
		if( yychar<0 ) if( (yychar=yylex())<0 ) yychar = 0;
		/* look through exception table */

		for( yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate) ; yyxi += 2 ) ; /* VOID */

		while( *(yyxi+=2) >= 0 ){
			if( *yyxi == yychar ) break;
			}
		if( (yyn = yyxi[1]) < 0 ) return(0);   /* accept */
		}

	if( yyn == 0 ){ /* error */
		/* error ... attempt to resume parsing */

		switch( yyerrflag ){

		case 0:   /* brand new error */

			yyerror( "syntax error" );
		yyerrlab:
			++yynerrs;

		case 1:
		case 2: /* incompletely recovered error ... try again */

			yyerrflag = 3;

			/* find a state where "error" is a legal shift action */

			while ( yyps >= yys ) {
			   yyn = yypact[*yyps] + YYERRCODE;
			   if( yyn>= 0 && yyn < YYLAST && yychk[yyact[yyn]] == YYERRCODE ){
			      yystate = yyact[yyn];  /* simulate a shift of "error" */
			      goto yystack;
			      }
			   yyn = yypact[*yyps];

			   /* the current yyps has no shift onn "error", pop stack */

#ifdef YYDEBUG
			   if( yydebug ) printf( "error recovery pops state %d, uncovers %d\n", *yyps, yyps[-1] );
#endif
			   --yyps;
			   --yypv;
			   }

			/* there is no state on the stack with an error shift ... abort */

	yyabort:
			return(1);


		case 3:  /* no shift yet; clobber input char */

#ifdef YYDEBUG
			if( yydebug ) printf( "error recovery discards char %d\n", yychar );
#endif

			if( yychar == 0 ) goto yyabort; /* don't discard EOF, quit */
			yychar = -1;
			goto yynewstate;   /* try again in the same state */

			}

		}

	/* reduction by production yyn */

#ifdef YYDEBUG
		if( yydebug ) printf("reduce %d\n",yyn);
#endif
		yyps -= yyr2[yyn];
		yypvt = yypv;
		yypv -= yyr2[yyn];
		yyval = yypv[1];
		yym=yyn;
			/* consult goto table to find next state */
		yyn = yyr1[yyn];
		yyj = yypgo[yyn] + *yyps + 1;
		if( yyj>=YYLAST || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
		switch(yym){

case 2:
# line 89 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 3:
# line 94 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tspecification);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(1);
	}
	} break;
case 4:
# line 110 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tobject);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(2);
	}
	} break;
case 5:
# line 126 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tobject);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(3);
	}
	} break;
case 6:
# line 142 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tdefinition);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(4);
	}
	} break;
case 7:
# line 159 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(ttest_case_block);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(5);
	}
	} break;
case 8:
# line 175 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(ttest_case_block);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(6);
	}
	} break;
case 10:
# line 196 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 11:
# line 201 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tlocal_definition_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(7);
	}
	} break;
case 12:
# line 217 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tlocal_definition);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(8);
	}
	} break;
case 13:
# line 234 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tlocal_definition);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(9);
	}
	} break;
case 14:
# line 251 "gram.y"
{
	if (errorcount == 0)
	{
	 class(4);
	 stlrlink ();
	 stlrlink ();
	 stlrlink ();
	 ndput(tmatrix);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(10);
	}
	} break;
case 16:
# line 274 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 17:
# line 279 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(ttest_case_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(11);
	}
	} break;
case 18:
# line 295 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(ttest_case);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(12);
	}
	} break;
case 19:
# line 311 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(ttest_case);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(13);
	}
	} break;
case 20:
# line 328 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tassertion);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(14);
	}
	} break;
case 21:
# line 344 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tassertion);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(15);
	}
	} break;
case 22:
# line 360 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tassertion);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(16);
	}
	} break;
case 24:
# line 381 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 25:
# line 386 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tset_declaration_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(17);
	}
	} break;
case 26:
# line 402 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tset_declaration);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(18);
	}
	} break;
case 27:
# line 418 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tset_declaration);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(19);
	}
	} break;
case 29:
# line 438 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 30:
# line 443 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tpremisses);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(20);
	}
	} break;
case 31:
# line 459 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tpremiss);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(21);
	}
	} break;
case 32:
# line 475 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tpremiss);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(22);
	}
	} break;
case 33:
# line 491 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tsimple_equation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(23);
	}
	} break;
case 34:
# line 508 "gram.y"
{ ndput (tNULL); } break;
case 36:
# line 517 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tvalue_expression);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(24);
	}
	} break;
case 37:
# line 536 "gram.y"
{ ndput (tNULL); } break;
case 39:
# line 545 "gram.y"
{
	if (errorcount == 0)
	{
	 class(4);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tvalue_expression);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(25);
	}
	} break;
case 40:
# line 570 "gram.y"
{ ndput (tNULL); } break;
case 42:
# line 579 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tterm_expression);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(26);
	}
	} break;
case 43:
# line 598 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tterm_expression);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(27);
	}
	} break;
case 44:
# line 614 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tterm_expression);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(28);
	}
	} break;
case 46:
# line 636 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 47:
# line 641 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tvalue_expression_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(29);
	}
	} break;
case 48:
# line 657 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 stlrlink ();
	 ndput(tidentifier_declaration);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(30);
	}
	} break;
case 50:
# line 678 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 51:
# line 683 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tidentifier_declaration_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(31);
	}
	} break;
case 52:
# line 699 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tsort_identifier);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(32);
	}
	} break;
case 53:
# line 712 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(toperation_identifier);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(33);
	}
	} break;
case 54:
# line 725 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(toperation_identifier);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(34);
	}
	} break;
case 55:
# line 738 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tidentifier);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(35);
	}
	} break;
case 56:
# line 751 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tidentifier_decl);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(36);
	}
	} break;
# line 148 "/usr/lib/yaccpar"

		}
		goto yystack;  /* stack new state and value */

	}
