
# line 2 "gram.y"
/***********************************************************************
     "glad.spe": General Language to Annotate Data, specification.
***********************************************************************/

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

 Revision 1.4  1993/06/10  13:56:52  lotos
 new annotation CALL

 Revision 1.3  1993/03/29  18:14:34  lotos
 keep lint shut down
 error recovery added

 Revision 1.2  1993/03/24  17:45:23  lotos
 new option -s
 new annotations: nofree, nodraw, noparse

 Revision 1.1  1993/03/18  11:14:24  lotos
 Initial revision

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

#ifndef lint
static char rcsid[]= "$Id: glad.spe,v 1.4 1993/06/10 13:56:52 lotos Exp $";
#endif

# line 36 "gram.y"
# include "rag.hh"
# include "nodes.h"
# include "grc.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;

#include "glad.hh"
#include "support.hh"
#include "token.hh"

#ifdef lint
#  define malloc(size)		_call_malloc(size)
#  define realloc(ptr, size)	_call_realloc(ALIN(void, ptr), size)
#  define free(ptr)		_call_free(ALIN(void, ptr))
#endif

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

# define SORTS 260
# define OPNS 261
# define IMPLICATION 262
# define SPECIFICATION 263
# define ANTBEGIN 264
# define ANTEND 265
# define ENDSPEC 266
# define ARROW 267
# define ANY 268
# define FORALL 269
# define IDENTIFIER 270
# define SPECIAL 271
# define LDC 272
# define ANTWORD 273
# define ANTTEXT 274
# define LDCINIT 275
# define USING 276
# define USINGSORT 277
# define NAME 278
# define LEXICAL 279
# define LEXICALIFPOSSIBLE 280
# define INTERNAL 281
# define EXTERN 282
# define FREE 283
# define NOFREE 284
# define EQUAL 285
# define DRAW 286
# define NODRAW 287
# define PARSE 288
# define NOPARSE 289
# define CALL 290
# define PARTIAL 291
# define CONSTRUCTOR 292
# define NONCONSTRUCTOR 293
#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 1816 "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,
	};
# define YYNPROD 143
# define YYLAST 281
short yyact[]={

 124, 178,  31,  21,  99,  22,  33,  34,  21, 133,
  22, 106, 166, 220, 175, 219, 112, 218, 176, 177,
 125, 126, 113, 114, 127, 128, 115, 107, 217, 165,
 108, 173, 174, 141, 129, 130, 131, 132, 113, 114,
 138, 216, 115, 116, 117, 118, 119, 120, 121, 122,
 139, 140, 161, 157, 155, 151, 145, 136, 137, 110,
 215, 101,  18, 104,  78,  81, 214, 213,  62, 160,
 156, 154, 150, 144,  21, 107,  22,   6,   7, 182,
  11, 180, 172,  12, 170, 168, 163, 159, 181, 153,
 179, 171, 149, 169, 167, 162, 158, 147, 152, 212,
 211, 148, 210, 209, 208, 207, 146, 206, 205, 204,
 203, 202, 201, 200, 199, 198, 197, 196, 195, 194,
 193, 192, 191, 190, 189, 188, 187, 164, 143, 142,
 135,  94,  77,  61,  54,  44,  41,  20,  65,  93,
  76,  60,  53,  38,  36,  19, 123,  68,  67,  66,
  55,  47,  45,  58,  50, 134,  51,  30,  15,  25,
  92,  91,  90,  28,  89,  87,  86,  83,  82,  80,
 100,  98,  97,  39,  29,  32, 183,  33,  34,  27,
  96,  95,  26, 103,  42,  79,  43,  24,  75,  46,
  74, 102,  88,  85,  84,  59, 186,  73,  72,  71,
  70,  69,  64, 111, 105,  17,  16,  63,  40,  14,
  57, 109,  10,  56,  59,  37,  52,  49,   9,  48,
  35,   8,  23,  13,   5,   4,   3,   2,  88,  85,
  84,   1,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0, 185, 103,   0,   0,   0,   0,   0,   0, 184,
 102 };
short yypact[]={

-1000,-1000,-1000,-183,-1000,-1000,-194, -93,-1000,-118,
-119,-1000,-1000,-1000,-194,-1000,-126,-1000,-1000,-1000,
-1000,-1000,-1000,-1000, -93,-1000,-127,  94,-1000,-1000,
-1000,-264,-1000,-1000,-1000,  92,-122,  91,-123,-1000,
   9,-124,-1000,   5,-125,-265, -32,-1000,-1000,-122,
-1000,-1000,-1000,-245,-1000,-1000,-1000,-123,-1000,-1000,
-197,-1000,-1000,-1000,-124,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-240,-1000,-1000,-1000,
-125,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-256,-1000,-258,-1000,-1000,-1000,-1000,
 111,-1000,-1000,-1000,-1000,-1000,-135,-216,-223,-1000,
-136,-1000,-137,-200,-159,-164,-201,-167,-202,-203,
-169,-204,-170,-1000,-138,-244,-171,-172,-174,-242,
-255,-175,-177,-260,-260,-1000,-139,-140,-141,-142,
-143,-144,-1000,-1000,-145,-146,-1000,-147,-1000,-148,
-149,-150,-1000,-151,-152,-153,-154,-155,-1000,-156,
-157,-158,-1000,-160,-1000,-161,-162,-1000,-163,-1000,
-165,-1000,-166,-198,-199,-205,-224,-237,-248,-1000,
-250,-1000,-252,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
-1000 };
short yypgo[]={

   0, 231, 227, 226, 225, 224, 223, 222, 221, 220,
 219, 218, 217, 154, 156, 216, 215, 213, 212, 210,
 153, 209, 158, 208, 207, 206, 205, 145, 137, 202,
 138, 149, 148, 147, 201, 200, 199, 198, 197, 190,
 188, 187, 159, 186, 185, 182, 181, 180, 179, 176,
 174, 157, 172, 171, 170,  61, 169,  65, 168, 167,
 166, 165, 164, 162, 161, 160 };
short yyr1[]={

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

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

-1000,  -1,  -2,  -3,  -4,  -5, 260, 261,  -8, -11,
 -18, 263, 266,  -6, -21, -22, -25, -26, 256, -27,
 -28, 268, 270,  -7, -41, -42, -45, -48, 256, -50,
 -51,  95, 268, 270, 271,  -9, 262, -16, 262, -22,
 -23, 262, -42, -43, 262,  58, -51,  59, -10, -12,
 -13, -14, -15, 264, 256,  59, -17, -19, -20, -14,
 264, 256,  59, -24, -29, -30, -31, -32, -33, -34,
 -35, -36, -37, -38, -39, -40, 264, 256,  59, -44,
 -56, -57, -58, -59, -31, -32, -60, -61, -33, -62,
 -63, -64, -65, 264, 256, -46, -47, -52, -53, 269,
 -54, -55, -27, -28,  95, -13, 256, 272, 275, -20,
 256, -30, 256, 278, 279, 282, 283, 284, 285, 286,
 287, 288, 289, -57, 256, 276, 277, 280, 281, 290,
 291, 292, 293, 267,  44, 265, 273, 274, 256, 273,
 274, 256, 265, 265, 273, 256, 265, 256, 265, 256,
 273, 256, 265, 256, 273, 256, 273, 256, 265, 256,
 273, 256, 265, 256, 265, 273, 256, 265, 256, 265,
 256, 265, 256, 273, 274, 256, 273, 274, 256, 265,
 256, 265, 256, -49, -27, -28, -55, 265, 265, 265,
 265, 265, 265, 265, 265, 265, 265, 265, 265, 265,
 265, 265, 265, 265, 265, 265, 265, 265, 265, 265,
 265, 265, 265, 265, 265, 265, 265, 265, 265, 265,
 265 };
short yydef[]={

   2,  -2,   1,   4,   3,   5,   0,   0,   8,   9,
  20,  12,  23,   6,  32,  30,  33,  36,  37,  38,
  39,  93,  96,   7,  57,  55,  58,   0,  64,  65,
  66,   0,  94,  97,  98,   0,   0,   0,   0,  31,
   0,   0,  56,   0,   0,  61,   0,  11,  10,  15,
  13,  16,  17,   0,  19,  22,  21,  26,  24,  27,
   0,  29,  35,  34,  42,  40,  43,  44,  45,  46,
  47,  48,  49,  50,  51,  52,   0,  54,  60,  59,
  79,  77,  80,  81,  82,  83,  84,  85,  86,  87,
  88,  89,  90,   0,  92,   0,  62,  68,  69,  95,
  72,  70,  73,  74,  67,  14,   0,   0,   0,  25,
   0,  41,   0,   0,   0,   0,   0,   0,   0,   0,
   0,   0,   0,  78,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0,   0,  18,   0,   0,   0,   0,
   0,   0,  28,  53,   0,   0, 111,   0, 117,   0,
   0,   0, 121,   0,   0,   0,   0,   0, 127,   0,
   0,   0, 131,   0,  91,   0,   0, 107,   0, 113,
   0, 115,   0,   0,   0,   0,   0,   0,   0, 139,
   0, 141,   0,  63,  75,  76,  71,  99, 100, 101,
 102, 103, 104, 109, 110, 112, 118, 119, 120, 122,
 123, 124, 125, 126, 128, 129, 130, 132, 105, 106,
 108, 114, 116, 133, 134, 135, 136, 137, 138, 140,
 142 };
# 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 */

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 1:
# line 114 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(1);
	}
	} break;
case 2:
# line 124 "gram.y"
{ ndput(tNULL); } break;
case 3:
# line 129 "gram.y"
{
	if (errorcount == 0)
	{
	 if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	}
	} break;
case 4:
# line 140 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(ttemplate);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(2);
	}
	} break;
case 5:
# line 158 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(3);
	}
	} break;
case 6:
# line 168 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(4);
	}
	} break;
case 7:
# line 178 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(5);
	}
	} break;
case 8:
# line 188 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(6);
	}
	} break;
case 9:
# line 198 "gram.y"
{ ndput (tNULL); } break;
case 11:
# line 207 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tinitial_rule);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(7);
	}
	} break;
case 12:
# line 226 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tinitial_pattern);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(8);
	}
	} break;
case 14:
# line 243 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 15:
# line 248 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tinitial_annotation_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(9);
	}
	} break;
case 16:
# line 264 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(10);
	}
	} break;
case 17:
# line 274 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(11);
	}
	} break;
case 18:
# line 284 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(12);
	}
	} break;
case 19:
# line 294 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(13);
	}
	} break;
case 20:
# line 304 "gram.y"
{ ndput (tNULL); } break;
case 22:
# line 313 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tfinal_rule);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(14);
	}
	} break;
case 23:
# line 332 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tfinal_pattern);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(15);
	}
	} break;
case 25:
# line 349 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 26:
# line 354 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tfinal_annotation_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(16);
	}
	} break;
case 27:
# line 370 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(17);
	}
	} break;
case 28:
# line 380 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(18);
	}
	} break;
case 29:
# line 390 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(19);
	}
	} break;
case 31:
# line 404 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 32:
# line 409 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tsort_rule_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(20);
	}
	} break;
case 33:
# line 425 "gram.y"
{ ndput (tNULL); } break;
case 35:
# line 434 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(tsort_rule);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(21);
	}
	} break;
case 36:
# line 453 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tsort_pattern);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(22);
	}
	} break;
case 37:
# line 469 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tsort_pattern);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(23);
	}
	} break;
case 38:
# line 487 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tsort_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(24);
	}
	} break;
case 39:
# line 503 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tsort_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(25);
	}
	} break;
case 41:
# line 523 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 42:
# line 528 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tsort_annotation_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(26);
	}
	} break;
case 43:
# line 544 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(27);
	}
	} break;
case 44:
# line 554 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(28);
	}
	} break;
case 45:
# line 564 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(29);
	}
	} break;
case 46:
# line 574 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(30);
	}
	} break;
case 47:
# line 584 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(31);
	}
	} break;
case 48:
# line 594 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(32);
	}
	} break;
case 49:
# line 604 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(33);
	}
	} break;
case 50:
# line 614 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(34);
	}
	} break;
case 51:
# line 624 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(35);
	}
	} break;
case 52:
# line 634 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(36);
	}
	} break;
case 53:
# line 644 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(37);
	}
	} break;
case 54:
# line 654 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(38);
	}
	} break;
case 56:
# line 668 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 57:
# line 673 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(toperation_rule_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(39);
	}
	} break;
case 58:
# line 689 "gram.y"
{ ndput (tNULL); } break;
case 60:
# line 698 "gram.y"
{
	if (errorcount == 0)
	{
	 class(2);
	 if (sttype() == tNULL) stpop();
	 else if (stpick(1)->type == tNULL) {stswap(); stpop();}
	 else stlrlink();
	 ndput(toperation_rule);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(40);
	}
	} break;
case 61:
# line 717 "gram.y"
{ ndput (tNULL); } break;
case 63:
# line 726 "gram.y"
{
	if (errorcount == 0)
	{
	 class(3);
	 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(toperation_pattern);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(41);
	}
	} break;
case 64:
# line 748 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(toperation_pattern);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(42);
	}
	} break;
case 65:
# line 766 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(toperation_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(43);
	}
	} break;
case 66:
# line 782 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(toperation_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(44);
	}
	} break;
case 67:
# line 798 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(toperation_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(45);
	}
	} break;
case 68:
# line 814 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(targument_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(46);
	}
	} break;
case 69:
# line 830 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(targument_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(47);
	}
	} break;
case 71:
# line 850 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 72:
# line 855 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(targument_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(48);
	}
	} break;
case 73:
# line 871 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(49);
	}
	} break;
case 74:
# line 881 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(50);
	}
	} break;
case 75:
# line 891 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tresult_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(51);
	}
	} break;
case 76:
# line 907 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(tresult_descriptor);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(52);
	}
	} break;
case 78:
# line 927 "gram.y"
{ if (errorcount == 0) stlrlink (); } break;
case 79:
# line 932 "gram.y"
{
	if (errorcount == 0)
	{
	 class(1);
	 ndput(toperation_annotation_list);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (stpick(1)->type == tNULL)
	      {stswap(); stpop();}
	 else stsflink ();
	 putgrn(53);
	}
	} break;
case 80:
# line 948 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(54);
	}
	} break;
case 81:
# line 958 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(55);
	}
	} break;
case 82:
# line 968 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(56);
	}
	} break;
case 83:
# line 978 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(57);
	}
	} break;
case 84:
# line 988 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(58);
	}
	} break;
case 85:
# line 998 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(59);
	}
	} break;
case 86:
# line 1008 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(60);
	}
	} break;
case 87:
# line 1018 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(61);
	}
	} break;
case 88:
# line 1028 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(62);
	}
	} break;
case 89:
# line 1038 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(63);
	}
	} break;
case 90:
# line 1048 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(64);
	}
	} break;
case 91:
# line 1058 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(65);
	}
	} break;
case 92:
# line 1068 "gram.y"
{
	if (errorcount == 0)
	{
	 putgrn(66);
	}
	} break;
case 93:
# line 1078 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tany_sort);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(67);
	}
	} break;
case 94:
# line 1091 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tany_operation);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(68);
	}
	} break;
case 95:
# line 1104 "gram.y"
{
	if (errorcount == 0)
	{
	 ndput(tany_argument_list);
	 staclr (c_lexv, (CLR_TYPE)yypvt[-0].name);
	 staclr (c_line, (CLR_TYPE)yypvt[-0].line);
	 putgrn(69);
	}
	} break;
case 96:
# line 1117 "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(70);
	}
	} break;
case 97:
# line 1130 "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(71);
	}
	} break;
case 98:
# line 1143 "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(72);
	}
	} break;
case 99:
# line 1156 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tldc_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(73);
	}
	} break;
case 100:
# line 1169 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tldc_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(74);
	}
	} break;
case 101:
# line 1182 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tldc_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(75);
	}
	} break;
case 102:
# line 1200 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tldcinit_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(76);
	}
	} break;
case 103:
# line 1213 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tldcinit_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(77);
	}
	} break;
case 104:
# line 1226 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tldcinit_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(78);
	}
	} break;
case 105:
# line 1244 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tusing_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(79);
	}
	} break;
case 106:
# line 1257 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tusing_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(80);
	}
	} break;
case 107:
# line 1275 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tusingsort_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(81);
	}
	} break;
case 108:
# line 1287 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tusingsort_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(82);
	}
	} break;
case 109:
# line 1305 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tname_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(83);
	}
	} break;
case 110:
# line 1318 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tname_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(84);
	}
	} break;
case 111:
# line 1336 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tlexical_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(85);
	}
	} break;
case 112:
# line 1348 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tlexical_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(86);
	}
	} break;
case 113:
# line 1366 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tlexicalifpossible_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(87);
	}
	} break;
case 114:
# line 1378 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tlexicalifpossible_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(88);
	}
	} break;
case 115:
# line 1396 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tinternal_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(89);
	}
	} break;
case 116:
# line 1408 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tinternal_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(90);
	}
	} break;
case 117:
# line 1426 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(textern_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(91);
	}
	} break;
case 118:
# line 1438 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(textern_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(92);
	}
	} break;
case 119:
# line 1456 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tfree_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(93);
	}
	} break;
case 120:
# line 1469 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tfree_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(94);
	}
	} break;
case 121:
# line 1487 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tnofree_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(95);
	}
	} break;
case 122:
# line 1499 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tnofree_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(96);
	}
	} break;
case 123:
# line 1517 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tequal_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(97);
	}
	} break;
case 124:
# line 1530 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tequal_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(98);
	}
	} break;
case 125:
# line 1548 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tdraw_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(99);
	}
	} break;
case 126:
# line 1561 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tdraw_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(100);
	}
	} break;
case 127:
# line 1579 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tnodraw_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(101);
	}
	} break;
case 128:
# line 1591 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tnodraw_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(102);
	}
	} break;
case 129:
# line 1609 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tparse_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(103);
	}
	} break;
case 130:
# line 1622 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tparse_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(104);
	}
	} break;
case 131:
# line 1640 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tnoparse_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(105);
	}
	} break;
case 132:
# line 1652 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tnoparse_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(106);
	}
	} break;
case 133:
# line 1670 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tcall_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(107);
	}
	} break;
case 134:
# line 1683 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tcall_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(108);
	}
	} break;
case 135:
# line 1696 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tcall_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(109);
	}
	} break;
case 136:
# line 1714 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tpartial_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(110);
	}
	} break;
case 137:
# line 1727 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tpartial_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-1].line);
  staclr(c_antv, (CLR_TYPE) ALIN(void, yypvt[-1].antv));
	 putgrn(111);
	}
	} break;
case 138:
# line 1740 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tpartial_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(112);
	}
	} break;
case 139:
# line 1758 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tconstructor_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(113);
	}
	} break;
case 140:
# line 1770 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tconstructor_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(114);
	}
	} break;
case 141:
# line 1788 "gram.y"
{
	if (errorcount == 0)
	{
  ndput(tnonconstructor_annotation);
  staclr(c_line, (CLR_TYPE) yypvt[-0].line);
	 putgrn(115);
	}
	} break;
case 142:
# line 1800 "gram.y"
{
	if (errorcount == 0)
	{
	 if (sttype() == tNULL){
		class(0);
		stpop();
	 }
	 else class(1);
	 ndput(tnonconstructor_annotation);
	 sttop()->value1= (CLR_TYPE)cls;
	 if (cls == 1) stsflink ();
	 putgrn(116);
	}
	} break;
# line 148 "/usr/lib/yaccpar"

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

	}
