y.tab.c

编译原理课程设计之pp2语法分析程序

| yydefault -- do the default action for the current state.  |
`-----------------------------------------------------------*/
yydefault:
  yyn = yydefact[yystate];
  if (yyn == 0)
    goto yyerrlab;
  goto yyreduce;


/*-----------------------------.
| yyreduce -- Do a reduction.  |
`-----------------------------*/
yyreduce:
  /* yyn is the number of a rule to reduce with.  */
  yylen = yyr2[yyn];

  /* If YYLEN is nonzero, implement the default value of the action:
     `$$ = $1'.

     Otherwise, the following line sets YYVAL to garbage.
     This behavior is undocumented and Bison
     users should not rely upon it.  Assigning to YYVAL
     unconditionally makes the parser a bit smaller, and it avoids a
     GCC warning that YYVAL may be used uninitialized.  */
  yyval = yyvsp[1-yylen];

  /* Default location. */
  YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);
  YY_REDUCE_PRINT (yyn);
  switch (yyn)
    {
        case 2:
#line 172 "parser.y"
    { 
	yylsp[0]; 
        /* pp2: The @1 is needed to convince 
         * yacc to set up yylloc. You can remove 
         * it oncde you have other uses of @n*/
        program = new Program(yyvsp[0].declList);
	/*
        if (ReportError::NumErrors() == 0)
		program->Print(0);
	*/
	}
    break;

  case 3:
#line 185 "parser.y"
    { printf("rule: DeclList->DeclList Decl\n");(yyval.declList=yyvsp[-1].declList)->Append(yyvsp[0].decl); }
    break;

  case 4:
#line 186 "parser.y"
    {printf("rule: DeclList->Decl\n"); (yyval.declList = new List<Decl*>)->Append(yyvsp[0].decl); }
    break;

  case 5:
#line 189 "parser.y"
    { printf("rule:Decl->VariableDecl\n");yyval.decl = yyvsp[0].varDecl; }
    break;

  case 6:
#line 190 "parser.y"
    {  printf("rule:Decl->ClassDecl\n");yyval.decl = yyvsp[0].decl; }
    break;

  case 7:
#line 191 "parser.y"
    {  printf("rule:Decl->FunctionDecl\n");yyval.decl = yyvsp[0].fnDecl; }
    break;

  case 8:
#line 193 "parser.y"
    { printf("rule:VariableDecl->Variable\n"); yyval.varDecl = yyvsp[-1].varDecl; }
    break;

  case 9:
#line 195 "parser.y"
    {printf("rule:Variable->Type Ident\n"); yyval.varDecl = new VarDecl(yyvsp[0].ident,yyvsp[-1].type); }
    break;

  case 10:
#line 197 "parser.y"
    {printf("rule:Ident->T_Identifier\n"); yyval.ident = new Identifier(yylsp[0],yyvsp[0].identifier);}
    break;

  case 11:
#line 199 "parser.y"
    {printf("rule:Type->T_Bool\n"); yyval.type = Type::boolType; }
    break;

  case 12:
#line 200 "parser.y"
    {printf("rule:Type->T_Int\n"); yyval.type = Type::intType; }
    break;

  case 13:
#line 201 "parser.y"
    {printf("rule:Type->T_Double\n"); yyval.type = Type::doubleType; }
    break;

  case 14:
#line 202 "parser.y"
    {printf("rule:Type->T_String\n"); yyval.type = Type::stringType; }
    break;

  case 15:
#line 203 "parser.y"
    { printf("rule:Type->Ident\n");NamedType *nameType = new NamedType(yyvsp[0].ident);yyval.type = nameType;}
    break;

  case 16:
#line 204 "parser.y"
    {printf("rule:Type->Type T_Dims\n");yyval.type = new ArrayType(yylsp[-1], yyvsp[-1].type);}
    break;

  case 17:
#line 206 "parser.y"
    {printf("rule:ClassDecl->T_Class Ident '{' Fieldlist '}' \n"); yyval.decl = new ClassDecl(yyvsp[-3].ident,NULL,yyvsp[-1].declList);}
    break;

  case 18:
#line 207 "parser.y"
    { printf("rule:ClassDecl->T_Class Ident T_Extends Ident '{' Fieldlist '}'\n");
			yyval.decl = new ClassDecl(yyvsp[-5].ident,new NamedType(yyvsp[-3].ident),yyvsp[-1].declList); 
			}
    break;

  case 19:
#line 211 "parser.y"
    {printf("rule:Fieldlist->Fieldlist Field\n");  (yyval.declList = yyvsp[-1].declList)->Append(yyvsp[0].decl);}
    break;

  case 20:
#line 212 "parser.y"
    { yyval.declList = new List<Decl*>; }
    break;

  case 21:
#line 214 "parser.y"
    {printf("rule:Field->VariableDecl\n"); yyval.decl = yyvsp[0].varDecl; }
    break;

  case 22:
#line 215 "parser.y"
    {printf("rule:Field->FunctionDecl\n"); yyval.decl = yyvsp[0].fnDecl; }
    break;

  case 23:
#line 218 "parser.y"
    {printf("rule:FunctionDecl->Type Ident '(' Formals ')' StmtBlock\n");yyval.fnDecl = new FnDecl(yyvsp[-4].ident,yyvsp[-5].type,yyvsp[-2].varDeclList);yyval.fnDecl->SetFunctionBody(yyvsp[0].stmtBlock);}
    break;

  case 24:
#line 219 "parser.y"
    {printf("rule:FunctionDecl->T_Void Ident '(' Formals ')' StmtBlock\n");
			yyval.fnDecl = new FnDecl(yyvsp[-4].ident,Type::voidType,yyvsp[-2].varDeclList);yyval.fnDecl->SetFunctionBody(yyvsp[0].stmtBlock);}
    break;

  case 25:
#line 221 "parser.y"
    {printf("rule:FunctionDecl->Type Ident '('')' StmtBlock\n");yyval.fnDecl = new FnDecl(yyvsp[-3].ident,yyvsp[-4].type,new List<VarDecl*>);yyval.fnDecl->SetFunctionBody(yyvsp[0].stmtBlock);}
    break;

  case 26:
#line 222 "parser.y"
    {printf("rule:FunctionDecl->T_Void Ident '(' ')' StmtBlock\n");
			yyval.fnDecl = new FnDecl(yyvsp[-3].ident,Type::voidType,new List<VarDecl*>);yyval.fnDecl->SetFunctionBody(yyvsp[0].stmtBlock);}
    break;

  case 27:
#line 225 "parser.y"
    { printf("rule:Formals->Variable\n");(yyval.varDeclList = new List<VarDecl*>)->Append(yyvsp[0].varDecl); }
    break;

  case 28:
#line 226 "parser.y"
    {  printf("rule:Formals->Formals','Variable\n");(yyval.varDeclList = yyvsp[-2].varDeclList)->Append(yyvsp[0].varDecl); }
    break;

  case 29:
#line 228 "parser.y"
    { printf("rule:StmtBlock->'{' NonEmptyVList NonEmptySList '}' \n");yyval.stmtBlock = new StmtBlock(yyvsp[-2].varDeclList,yyvsp[-1].stmtList);}
    break;

  case 30:
#line 229 "parser.y"
    { printf("rule:StmtBlock->'{' NonEmptyVList '}' \n");
						List<Stmt*> *emptySList = new List<Stmt*>;
						yyval.stmtBlock = new StmtBlock(yyvsp[-1].varDeclList,emptySList);
					}
    break;

  case 31:
#line 233 "parser.y"
    {printf("rule:StmtBlock->'{' NonEmptySList '}' \n");
						List<VarDecl*> *emptyVList = new List<VarDecl*>;
						yyval.stmtBlock = new StmtBlock(emptyVList,yyvsp[-1].stmtList);
					}
    break;

  case 32:
#line 237 "parser.y"
    {printf("rule:StmtBlock->'{' '}' \n");
		                         List<Stmt*> *emptyStmtList = new List<Stmt*>;
					 List<VarDecl*> *emptyVarList = new List<VarDecl*>;
					 yyval.stmtBlock = new StmtBlock(emptyVarList,emptyStmtList);}
    break;

  case 33:
#line 242 "parser.y"
    {printf("rule:NonEmptyVList->VariableDecl \n"); (yyval.varDeclList = new List<VarDecl*>)->Append(yyvsp[0].varDecl); }
    break;

  case 34:
#line 243 "parser.y"
    {printf("rule:NonEmptyVList->NonEmptyVList VariableDecl \n"); (yyval.varDeclList = yyvsp[-1].varDeclList)->Append(yyvsp[0].varDecl);}
    break;

  case 35:
#line 245 "parser.y"
    {printf("rule:NonEmptySList->Stmt \n"); (yyval.stmtList=new List<Stmt*>)->Append(yyvsp[0].stmt);}
    break;

  case 36:
#line 246 "parser.y"
    {printf("rule:NonEmptyVList->NonEmptySList Stmt \n"); (yyval.stmtList=yyvsp[-1].stmtList)->Append(yyvsp[0].stmt);}
    break;

  case 37:
#line 248 "parser.y"
    {printf("rule:Stmt->';' \n");yyval.stmt=new ExprStmt(yylsp[0],NULL);}
    break;

  case 38:
#line 249 "parser.y"
    {printf("rule:Stmt->Expr';' \n");yyval.stmt=new ExprStmt(yylsp[-1],yyvsp[-1].expr);}
    break;

  case 39:
#line 250 "parser.y"
    {printf("rule:Stmt->StmtBlock \n");yyval.stmt=yyvsp[0].stmtBlock;}
    break;

  case 40:
#line 251 "parser.y"
    {printf("rule:Stmt->IfStmt\n");yyval.stmt=yyvsp[0].ifStmt;}
    break;

  case 41:
#line 252 "parser.y"
    {printf("rule:Stmt->SwitchStmt \n");yyval.stmt=yyvsp[0].switchStmt;}
    break;

  case 42:
#line 253 "parser.y"
    {printf("rule:Stmt->WhileStmt \n");yyval.stmt=yyvsp[0].whileStmt;}
    break;

  case 43:
#line 254 "parser.y"
    {printf("rule:Stmt->ForStmt \n");yyval.stmt=yyvsp[0].forStmt;}
    break;

  case 44:
#line 255 "parser.y"
    {printf("rule:Stmt->ReturnStmt \n");yyval.stmt=yyvsp[0].returnStmt;}
    break;

  case 45:
#line 256 "parser.y"
    {printf("rule:Stmt->BreakStmt \n");yyval.stmt=yyvsp[0].breakStmt;}
    break;

  case 46:
#line 257 "parser.y"
    {printf("rule:Stmt->PrintStmt \n");yyval.stmt=yyvsp[0].printStmt;}
    break;

  case 47:
#line 258 "parser.y"
    {printf("rule:Stmt->TryCatchBlockStmt \n");yyval.stmt=yyvsp[0].tryStmt;}
    break;

  case 48:
#line 259 "parser.y"
    {printf("rule:Stmt->ThrowStmt \n");yyval.stmt=yyvsp[0].throwStmt;}
    break;

  case 49:
#line 261 "parser.y"
    {printf("rule:ThrowStmt->T_Throw Expr ';' \n");yyval.throwStmt = new ThrowStmt(yylsp[-1],yyvsp[-1].expr);}
    break;

  case 50:
#line 263 "parser.y"
    {printf("rule:TryCatchBlock->T_Try '{' StmtList '}'CatchBlockList \n");yyval.tryStmt = new TryStmt(yyvsp[-2].stmtList,yyvsp[0].catchStmtList);}
    break;

  case 51:
#line 265 "parser.y"
    {printf("rule:StmtList->NonEmptySList\n"); yyval.stmtList=yyvsp[0].stmtList;}
    break;

  case 52:
#line 266 "parser.y"
    {printf("rule:StmtList-> \n");yyval.stmtList=new List<Stmt*>;}
    break;

  case 53:
#line 268 "parser.y"
    {printf("rule:NonEmptyCBList->CatchBlock\n");(yyval.catchStmtList=new List<CatchStmt*>)->Append(yyvsp[0].catchStmt);}
    break;

  case 54:
#line 269 "parser.y"
    {printf("rule:NonEmptyCBList->NonEmptyCBList CatchBlock\n");(yyval.catchStmtList=yyvsp[-1].catchStmtList)->Append(yyvsp[0].catchStmt);}
    break;

  case 55:
#line 271 "parser.y"
    {printf("rule:CatchBlockList->NonEmptyCBList\n");yyval.catchStmtList = yyvsp[0].catchStmtList;}
    break;

  case 56:
#line 272 "parser.y"
    {yyval.catchStmtList=new List<CatchStmt*>;}
    break;

  case 57:
#line 274 "parser.y"
    {printf("rule:CatchBlock->T_Catch '(' Variable ')' '{' StmtList '}'\n");yyval.catchStmt = new CatchStmt(yyvsp[-4].varDecl,yyvsp[-1].stmtList);}
    break;

  case 58:
#line 276 "parser.y"
    {printf("rule:PrintStmt->T_Print '(' NonEmptyActuals ')' ';' \n");yyval.printStmt = new PrintStmt(yyvsp[-2].exprList);}
    break;

  case 59:
#line 278 "parser.y"
    {printf("rule:BreakStmt->T_Break ';' \n");yyval.breakStmt = new BreakStmt(yylsp[-1]);}
    break;

  case 60:
#line 280 "parser.y"
    {printf("rule:ReturnStmt->T_Return Expr ';'  \n");yyval.returnStmt = new ReturnStmt(yylsp[-1],yyvsp[-1].expr);}
    break;

  case 61:
#line 281 "parser.y"
    {printf("rule:ReturnStmt->T_Return ';'  \n");yyval.returnStmt = new ReturnStmt(yylsp[-1],new EmptyExpr());}
    break;

  case 62:
#line 283 "parser.y"
    {printf("rule:IfStmt->T_If '(' Expr ')' Stmt