myparser.y

Tiny 语言的Parser Generator 2 语法分析器

%{
#define YYPARSER 

#include "globals.h"
#include "util.h"
#include "scan.h"
#include "parse.h"
#include <yylex.h>

#define YYSTYPE TreeNode *
static char * savedName; 
char name[20];
static int savedLineNo;  /* ditto */
static TreeNode * savedTree; /* stores syntax tree for later return */

%}

%token ID NUM INT VOID IF ELSE WHILE ASSIGN COMMA SEMI
       LMPAREN RMPAREN LPAREN RPAREN LLPAREN RLPAREN
       LE LT GT GE EQ NE PLUS MINUS TIME DEVISION RETURN

%%
program					: declaration_list
							{ savedTree = $1;}
						;
declaration_list		: declaration_list declaration 
							{
								YYSTYPE t = $1;
								if (t != NULL)
								{
									while (t -> sibling != NULL)
									{
										t = t->sibling;
									}
									t->sibling = $2;
									$$ = $1;
								}
								else
								$$ = $2;
								//$$ = newStmtNode(Dec_listK);
								//$$->child[0] = $2;
							}
						| declaration  
							{
								$$ = $1;
							}
						;
declaration				: var_declaration
							{
								$$ = newStmtNode(DecK);
								$$ = $1;
							}
						| fun_declaration
							{
								$$ = newStmtNode(DecK);
								$$ = $1;
							}
						;
var_declaration			: type_specifier ID {strcpy(name,yytext);} SEMI
							{
								$2 = newStmtNode(IdK);
								strcpy($2->attr.name,name);
								$3 = newStmtNode(SemiK);
								$$ = newStmtNode(Var_decK);
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[3] = $3;	
							}
						| type_specifier ID {strcpy(name,yytext);} LMPAREN NUM RMPAREN SEMI
							{
								$2 = newStmtNode(IdK);
								strcpy($2->attr.name,name);
								$3 = newStmtNode(LMParenK);
								$4 = newStmtNode(NumK);
								$5 = newStmtNode(RMParenK);
								$6 = newStmtNode(SemiK);
								$$ = newStmtNode(Var_decK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$4->attr.val = atoi(yytext);
								$$->child[3] = $4;
								$$->child[4] = $5;
								$$->child[5] = $6;
							}
						;
type_specifier			: INT
							{
								$$ = newStmtNode(IntK);
							}
						| VOID
							{
								$$ = newStmtNode(VoidK);
							}
						;
fun_declaration			: type_specifier ID {strcpy(name,yytext);} LPAREN params RPAREN
							{
								$2 = newStmtNode(IdK);
								strcpy($2->attr.name,name);
								$3 = newStmtNode(LParenK);
								$5 = newStmtNode(RParenK);
								$$ = newStmtNode(Fun_decK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
								$$->child[4] = $5;
								
								
							}
						|  compound_stmt
							{
								$$ = $1;
							}
						;
params					: param_list
							{
								$$ = $1;
							}
						| VOID
							{
								$$ = newStmtNode(VoidK);
							}
						;
param_list				: param_list COMMA param
							{
								$2 = newStmtNode(CommaK);
								$$ = newStmtNode(Params_listK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
							}
						| param
							{ $$ = $1;}
						;
param					: type_specifier ID
							{
								$2 = newStmtNode(IdK);
								$$ = newStmtNode(ParamK);
								strcpy($2->attr.name,yytext);
								$$->child[0] = $1;
								$$->child[1] = $2;
							}
						| type_specifier ID {strcpy(name,yytext);} LMPAREN RMPAREN
							{
								$2 = newStmtNode(IdK);
								strcpy($2->attr.name,name);
								$3 = newStmtNode(LMParenK);
								$4 = newStmtNode(RMParenK);
								$$ = newStmtNode(ParamK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
							}
						;
compound_stmt			: LLPAREN local_declarations statement_list RLPAREN
							{
								$1 = newStmtNode(LLParenK);
								$4 = newStmtNode(RLParenK);
								$$ = newStmtNode(Compound_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
							}
						;
local_declarations		: local_declarations var_declaration
							{
								$$ = newStmtNode(Local_decK);
								$$->child[0] = $1;
								$$->child[0] = $2;
							}
						| 
							{
								$$ = newStmtNode(Local_decK);
							}
						;
statement_list			: statement_list statement
							{
								$$ = newStmtNode(State_listK);
								$$->child[0] = $1;
								$$->child[1] = $2;
							}
						| 
							{ 
								$$ = newStmtNode(State_listK);
							}
						;
statement				: expression_stmt	
						| compound_stmt
						| selection_stmt
						| iteration_stmt
						| return_stmt
							{ $$ = $1; }
						;
expression_stmt			: expression SEMI
							{
								$2 = newStmtNode(SemiK); 
								$$ = newStmtNode(Exp_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
							}
						| SEMI
							{
								$1 = newStmtNode(SemiK); 
								$$ = newStmtNode(Exp_stmtK);
								
								$$->child[0] = $1;
							}
						;
selection_stmt			: IF LPAREN expression RPAREN statement
							{
								$1 = newStmtNode(IfK);
								$2 = newStmtNode(LParenK);
								$4 = newStmtNode(RParenK);
								$$ = newStmtNode(Select_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
								$$->child[4] = $5;   
							}
						| IF LPAREN expression RPAREN statement ELSE statement
							{
								$1 = newStmtNode(IfK);
								$2 = newStmtNode(LParenK);
								$4 = newStmtNode(RParenK);
								$6 = newStmtNode(ElseK);
								$$ = newStmtNode(Select_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
								$$->child[4] = $5;
								$$->child[5] = $6;
								$$->child[6] = $7; 
							}
						;
iteration_stmt			: WHILE LPAREN expression RPAREN statement
							{
								$1 = newStmtNode(WhileK);
								$2 = newStmtNode(LParenK);
								$4 = newStmtNode(RParenK);
								$$ = newStmtNode(Iteration_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
								$$->child[4] = $5;
							}
						;
return_stmt				: RETURN SEMI
							{
								$1 = newStmtNode(ReturnK);
								$2 = newStmtNode(SemiK);
								$$ = newStmtNode(Return_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2; 
							}
						| RETURN expression SEMI
							{
								$1 = newStmtNode(ReturnK);
								$3 = newStmtNode(SemiK);
								$$ = newStmtNode(Return_stmtK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3; 
							}
						;
expression				: var ASSIGN expression
							{
								$2 = newStmtNode(AssignK);
								$$ = newStmtNode(ExpressionK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3; 
							}
						| simple_expression
							{
								$$ = $1;
							}
						;
var						: ID
							{
								$1 = newStmtNode(IdK);
								$$ = newStmtNode(VarK);
								strcpy($1->attr.name,yytext);
								$$->child[0] = $1;
							}
						| ID {strcpy(name,yytext);} LMPAREN expression RMPAREN
							{
								$1 = newStmtNode(IdK);
								strcpy($1->attr.name,name);
								$2 = newStmtNode(LMParenK);
								$4 = newStmtNode(RMParenK);
								$$ = newStmtNode(VarK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3; 
								$$->child[3] = $4;
							}
						;
simple_expression		: additive_expression relop additive_expression
							{
								$$ = newStmtNode(Simple_expK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
							}
						| additive_expression
							{
								$$ = newStmtNode(Simple_expK);
								
								$$->child[0] = $1;
							}
						;
relop					: LE
							{ $$ = newStmtNode(LEK); }
						| LT
							{ $$ = newStmtNode(LTK); }
						| GT
							{ $$ = newStmtNode(GTK); }
						| GE
							{ $$ = newStmtNode(GEK); }
						| EQ
							{ $$ = newStmtNode(EQK); }
						| NE
							{ $$ = newStmtNode(NEK); }
						;
additive_expression		: additive_expression addop term 
							{ 
								$$ = newStmtNode(Additive_expK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
							}
						| term
							{
								$$ = $1;
							}
						;
addop					: PLUS
							{$$ = newStmtNode(PlusK);}
						| MINUS
							{$$ = newStmtNode(MinusK);}
						;
term					: term mulop factor
							{
								$$ = newStmtNode(TermK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
							}
						| factor
							{ $$ = $1; }
						;
mulop					: TIME
							{ $$ = newStmtNode(TimeK); }
						| DEVISION
							{ $$ = newStmtNode(DevisionK); }
						;
factor					: LPAREN expression RPAREN
							{
								$1 = newStmtNode(LParenK);
								$3 = newStmtNode(RParenK);
								$$ = newStmtNode(FactorK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								
							}
						| var
							{$$ = $1;}
						| call
							{$$ = $1;}
						| NUM
							{
								$$ = newStmtNode(NumK); 
								$$->attr.val = atoi(yytext);
							}
						;
call					: ID{strcpy(name,yytext);} LPAREN args RPAREN
							{
								$1 = newStmtNode(IdK);
								strcpy($1->attr.name,name);
								$2 = newStmtNode(LParenK);
								$4 = newStmtNode(RParenK);
								$$ = newStmtNode(CallK);
								
								$$->child[0] = $1;
								$$->child[1] = $2;
								$$->child[2] = $3;
								$$->child[3] = $4;
							}
						;
args					: arg_list 
							{
								$$ = $1;
							}
						| 
							{
								$$ = newStmtNode(ArgsK);
							}
						;
arg_list				: arg_list COMMA expression
							{
								$2 = newStmtNode(CommaK);
								
								$$->child[0] = $2;
								$$->child[1] = $3;
							}
						| expression
							{
								$$ = $1;
							}
						;
%%
/*int yyerror(char * message)
{ fprintf(listing,"Syntax error at line %d: %s\n",lineno,message);
  fprintf(listing,"Current token: ");
  printToken(yychar,tokenString);
  Error = TRUE;
  return 0;
}*/

static int yylex(void)
{	
	return getToken(); 
}

TreeNode * parse(void)
{	
	yyin = source;
	yyout = listing;
	yyparse();
	return savedTree;
}