y.tab.c

<B>Digital的Unix操作系统VAX 4.2源码</B>

  -7,  -7, -12,  44,  41,  44, -94, -95, -95, -97,
  -7,  14, -53, -98, -32,  44,  44,  -7 };
short yydef[]={

   0,  -2,   1,   2,   3,   0,   0,  -2, 271,   0,
  44,   0,   9, 278,  45,   0,   0,  44,  36, 277,
   0, 263, 245, 234, 235, 236, 237, 238, 239, 240,
   0,   0,   0,   0, 269, 228, 275, 273, 278,  67,
  43,   0,   0,   0,   0,   0,   0,   0,   0,   0,
   0, 255, 256, 257, 258, 259, 260, 261, 262, 228,
   0,   0, 242, 243, 244,   0, 229, 180, 178,   8,
 274, 276, 272,  10,   0,  37,  69,  34,   0,   0,
 246, 247, 248, 249, 250, 251, 252, 253, 254, 264,
   0, 270, 241, 226,   0,   0,   0,   5,  35,   0,
  68,  98, 267, 224, 160,  65,  66,  67,   0,   0,
   0, 278, 208,   0, 227, 181, 179,  11,   0, 275,
   0,  70,  99,  -2, 104, 109, 110, 111, 112, 113,
 114, 115, 116, 117, 118, 119, 121, 106,   0,   0,
   0,  98,  79,   0,   0, 155, 156,   0,  62,  63,
  64,   0,   0,  -2,  73,  58,   0,  71,   0,  32,
   0,   0,  36,   0,   6,  -2,  -2,  -2,   0, 120,
 146, 136, 124, 125, 126, 127, 128, 129, 130,   0,
   0,   0,   0, 232, 155, 107,   0,   0,   0,  88,
  98,  93,   0,   0,  98,   0,  77,   0, 152,   0,
 153,   0,   0, 268,   0,   0, 225,   0,   0, 161,
   0,   0,   0,   0,   0,  44,   0,   0,   0,  56,
 278,  60,   0,   0,  55,  72, 209, 278,  67, 278,
 278,   0,  -2, 105,   0,   0,   0,   0,   0,   0,
   0,   0,   0,   0, 131,   0, 133, 134, 135,   0,
 233, 184, 182, 232, 108, 122,   0, 148,  98,   0,
  92,   0,  98,   0,   0,   0,   0,   0,   0, 154,
   0,   0, 266,   0, 223,   0,   0, 159,  75,  76,
 278,   0,  74,  59,  57,   0,   0,   0,  33,   0,
  36,  36,   0, 137, 138, 139, 140, 141, 142, 143,
 144, 145, 147, 132, 230,   0,   0,   0, 123,   0,
   0,  89,  98,   0,  85,  80,   0,  98, 150, 151,
  90,   0,   0,   0, 214, 215, 216, 217, 218, 219,
   0,   0, 211, 212, 213, 199,   0, 188,   0, 170,
 167,   0,   0, 200, 201, 278,   0,  36, 278,  61,
  53,  50,   0, 199,   0,  12,  41,  41,  20, 185,
 183, 231, 149,  94,  95,  98,   0,  87,  86,   0,
   0,  91, 265, 222,   0,   0,   0,   0,   0,   0,
 196,   0,   0,   0,   0, 171, 172, 173, 174, 162,
   0,   0, 157, 278,  41,  49,   0,   0,  54, 275,
  30,  30, 275,   0,   0,  81,  78, 220, 221, 202,
   0,   0, 203,   0, 188, 198,   0,   0, 269, 177,
   0,   0, 163, 165,   0, 210,   0, 158,  67,  51,
   0,  13,   0,  42,   0,   0,  21,  96,  98,   0,
   0, 205,   0, 204, 197, 189, 186,   0,  -2, 176,
   0, 168, 166,   0,   0,  52,  14,  31, 267,  26,
 160,  25, 278,   0,   0,  17,   0,  98,  83, 206,
 194, 192,   0,   0, 164,   0, 207, 278, 275,  22,
  23,   0,  24,  38, 278, 278, 275,  97,   0,   0,
   0, 186, 188, 188, 186, 169,  47,  15, 278,  29,
  39,  40,  18,  82,  98, 190, 193, 195, 187, 194,
  27,   0,   0,   0, 278,  84, 191,  28 };
#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 */

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 3:
# line 154 "mod2.gram"
{ printf("Fatal error, cannot proceed\n");
				    exit(1); } break;
case 4:
# line 162 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],MODULE); } break;
case 5:
# line 163 "mod2.gram"
{ ScanEofOK(); } break;
case 6:
# line 164 "mod2.gram"
{ EndFile(); EndModule(yypvt[-7],yypvt[-3],yypvt[-2]); } break;
case 7:
# line 165 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],MODULE); } break;
case 8:
# line 167 "mod2.gram"
{ EndFile(); EndModule(yypvt[-3],0,yypvt[-1]); } break;
case 9:
# line 172 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],IMPLEMENTATION); } break;
case 10:
# line 173 "mod2.gram"
{ GetDefinitionModule(yypvt[-2]);} break;
case 11:
# line 174 "mod2.gram"
{ ProcessExports(yypvt[-4]); } break;
case 12:
# line 175 "mod2.gram"
{ ScanEofOK(); } break;
case 13:
# line 176 "mod2.gram"
{ EndFile(); EndModule(yypvt[-10],yypvt[-3],yypvt[-2]); } break;
case 14:
# line 182 "mod2.gram"
{ ScanEofOK(); } break;
case 15:
# line 182 "mod2.gram"
{ EndFile(); } break;
case 16:
# line 187 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],DEFINITION); } break;
case 17:
# line 189 "mod2.gram"
{ ScanEofOK(); } break;
case 18:
# line 190 "mod2.gram"
{ EndFile(); EndModule(yypvt[-7],0,yypvt[-2]); } break;
case 19:
# line 191 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],DEFINITION); } break;
case 20:
# line 192 "mod2.gram"
{ ScanEofOK(); } break;
case 21:
# line 193 "mod2.gram"
{ EndFile(); EndModule(yypvt[-4],0,yypvt[-2]); } break;
case 25:
# line 204 "mod2.gram"
{ EndProc(yypvt[-0],0,0); } break;
case 27:
# line 211 "mod2.gram"
{ DefineType(yypvt[-1],0); } break;
case 28:
# line 213 "mod2.gram"
{ DefineType(yypvt[-3],yypvt[-1]); } break;
case 32:
# line 227 "mod2.gram"
{ yyval = Import(0,yypvt[-1]); } break;
case 33:
# line 229 "mod2.gram"
{ yyval = Import(yypvt[-3],yypvt[-1]); } break;
case 34:
# line 234 "mod2.gram"
{ yyval = ReadImport(yypvt[-0]); } break;
case 35:
# line 236 "mod2.gram"
{ yyval = ReadImport(yypvt[-1]); } break;
case 37:
# line 243 "mod2.gram"
{ ProcessImport(yypvt[-0],0); } break;
case 38:
# line 248 "mod2.gram"
{ Export(yypvt[-1],EXPORT); } break;
case 39:
# line 250 "mod2.gram"
{ Export(yypvt[-1],QUALIFIED); } break;
case 40:
# line 252 "mod2.gram"
{ Export(yypvt[-1],ATUNQUALIFIED); } break;
case 43:
# line 264 "mod2.gram"
{ yyval = yypvt[-1]; } break;
case 46:
# line 275 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],MODULE); } break;
case 47:
# line 277 "mod2.gram"
{ EndModule(yypvt[-7],yypvt[-2],yypvt[-1]); } break;
case 48:
# line 278 "mod2.gram"
{ yyval = DefineModule(yypvt[-0],MODULE); } break;
case 49:
# line 280 "mod2.gram"
{ EndModule(yypvt[-3],0,yypvt[-1]); } break;
case 50:
# line 285 "mod2.gram"
{ yyval = TypeOf(yypvt[-0]); } break;
case 51:
# line 287 "mod2.gram"
{ yyval = ArrayType(0,TypeOf(yypvt[-0]),yypvt[-2],0); } break;
case 52:
# line 289 "mod2.gram"
{ yyval = ArrayType(0,TypeOf(yypvt[-0]),yypvt[-3],ATNOCOUNT); } break;
case 53:
# line 294 "mod2.gram"
{ yyval = MakeParamList(0,yypvt[-2],yypvt[-0]); } break;
case 54:
# line 296 "mod2.gram"
{ yyval = MakeParamList(VAR,yypvt[-2],yypvt[-0]); } break;
case 55:
# line 299 "mod2.gram"
{ yyval = MakeParamList(0,0,anyTypeNode); } break;
case 56:
# line 304 "mod2.gram"
{ yyval = 0; } break;
case 57:
# line 306 "mod2.gram"
{ yyval = yypvt[-1]; } break;
case 58:
# line 311 "mod2.gram"
{ yyval = 0; } break;
case 59:
# line 313 "mod2.gram"
{ yyval = TypeOf(yypvt[-0]); } break;
case 61:
# line 321 "mod2.gram"
{ yyval = AppendParamList(yypvt[-2],yypvt[-0]); } break;
case 69:
# line 346 "mod2.gram"
{ yyval = AddToStmtList(0,0); } break;
case 70:
# line 348 "mod2.gram"
{ yyval = yypvt[-0]; } break;
case 71:
# line 354 "mod2.gram"
{ yyval = DefineProc(yypvt[-0],PROCEDURE); } break;
case 72:
# line 356 "mod2.gram"
{ yyval = DefineProc(yypvt[-0],ATEXTERNAL); } break;
case 73:
# line 361 "mod2.gram"
{ yyval = AddTypeToProc(yypvt[-1],procTypeNode); } break;
case 74:
# line 363 "mod2.gram"
{ yyval = AddTypeToProc(yypvt[-3],ProcType(yypvt[-2],yypvt[-1])); } break;
case 75:
# line 368 "mod2.gram"
{ EndProc(yypvt[-3],yypvt[-2],yypvt[-1]); } break;
case 76:
# line 370 "mod2.gram"
{ EndProc(yypvt[-3],0,yypvt[-1]); } break;
case 77:
# line 373 "mod2.gram"
{ yyval = StartWith(yypvt[-0]); } break;
case 78:
# line 374 "mod2.gram"
{ yyval = WithStmtNode(yypvt[-3],yypvt[-1]); } break;
case 79:
# line 378 "mod2.gram"
{ yyval = StartLoop(); } break;
case 80:
# line 379 "mod2.gram"
{ yyval = LoopStmtNode(yypvt[-2],yypvt[-1]); } break;
case 81:
# line 384 "mod2.gram"
{ yyval = StartFor(yypvt[-4],yypvt[-2],yypvt[-0],0); } break;
case 82:
# line 386 "mod2.gram"
{ yyval = ForStmtNode(yypvt[-3],yypvt[-1]); } break;
case 83:
# line 388 "mod2.gram"
{ yyval = StartFor(yypvt[-6],yypvt[-4],yypvt[-2],yypvt[-0]); } break;
case 84:
# line 389 "mod2.gram"
{ yyval = ForStmtNode(yypvt[-3],yypvt[-1]); } break;
case 85:
# line 394 "mod2.gram"
{ yyval = RepeatStmtNode(yypvt[-2],yypvt[-0]); } break;
case 86:
# line 399 "mod2.gram"
{ yyval = WhileStmtNode(yypvt[-3],yypvt[-1]); } break;
case 87:
# line 404 "mod2.gram"
{ yyval = MakeCase(yypvt[-2],yypvt[-0]); } break;
case 89:
# line 412 "mod2.gram"
{ yyval = AddCaseElse(yypvt[-3],yypvt[-1]); } break;
case 90:
# line 417 "mod2.gram"
{ yyval = AddCase(CaseStmtNode(yypvt[-2]),yypvt[-0]); } break;
case 91:
# line 420 "mod2.gram"
{ yyval = AddCase(CaseStmtNode(yypvt[-3]),yypvt[-0]); } break;
case 92:
# line 423 "mod2.gram"
{ yyval = AddCase(yypvt[-2],yypvt[-0]); } break;
case 93:
# line 426 "mod2.gram"
{ yyval = yypvt[-1]; } break;
case 94: