复件 my.cup

非常好的编译源代码 将一个l语言转换为中间代码 java版本

package parser;
import java_cup.runtime.*;


/**
*
*出错处理：
*/
parser code  {: 
  public void report_error(String message, Object info) {
    StringBuffer m = new StringBuffer("Error ");

    if (info instanceof java_cup.runtime.Symbol) 
      m.append( "("+info.toString()+")" );
     
    m.append(" : "+message);
   
    System.out.println(m);
  }
   
  public void report_fatal_error(String message, Object info) {
    report_error(message, info);
    throw new RuntimeException("Fatal Syntax Error");
  }
:};

/**
*
*终结符 表
*/
terminal BOOLEAN; // primitive_type
terminal BYTE,   LONG,INTEGER,SHORT, CHAR; // integral_type
terminal FLOAT, REAL; // floating_point_type
terminal ARRAY,LBRACK, RBRACK; // array_type
terminal DOT; // qualified_name
terminal SEMICOLON, MULT, COMMA, LBRACE, RBRACE, EQ, LPAREN, RPAREN, COLON;
terminal REPEAT,UNTIL;
terminal PROGRAM ;
terminal BEGIN,END; 
terminal VOID;  
terminal CALL,PROCEDURE; 
terminal IF, ELSE,THEN; // if_then_statement, if_then_else_statement
terminal SWITCH; // switch_statement
terminal CASE, DEFAULT; // switch_label
terminal DO, WHILE; // while_statement, do_statement
terminal FOR,TO; // for_statement
terminal BREAK; // break_statement
terminal CONTINUE; // continue_statement
terminal RETURN; // return_statement
terminal PLUSPLUS; // postincrement_expression
terminal MINUSMINUS; // postdecrement_expression
terminal PLUS, MINUS, COMP, NOT, DIV, MOD;
terminal LSHIFT, RSHIFT; // shift_expression
terminal LT, GT, LTEQ, GTEQ; // relational_expression
terminal EQEQ, NOTEQ; // equality_expression
terminal AND; // and_expression
terminal XOR; // exclusive_or_expression
terminal OR;  // inclusive_or_expression
terminal ANDAND; // conditional_and_expression
terminal OROR; // conditional_or_expression
terminal QUESTION; // conditional_expression
terminal MULTEQ, DIVEQ, MODEQ, PLUSEQ, MINUSEQ; // assignment_operator
terminal LSHIFTEQ, RSHIFTEQ; // assignment_operator
terminal ANDEQ, XOREQ, OREQ,ASSIGN; // assignment_operator
terminal READ,WRITE;

terminal java.lang.Number INTEGER_LITERAL;
terminal java.lang.Number FLOATING_POINT_LITERAL;
terminal java.lang.Boolean BOOLEAN_LITERAL;
terminal java.lang.Character CHARACTER_LITERAL;
terminal java.lang.String STRING_LITERAL;
terminal java.lang.String IDENTIFIER; // name
terminal CONST, GOTO;


/**
*
*非终结符 表
*/

//  The Syntactic Grammar
non terminal goal;
//  Lexical Structure
non terminal literal;
//  Types, Values, and Variables
non terminal type,  numeric_type;
non terminal integral_type, floating_point_type;

non terminal array_type,array_types;
//  Names
non terminal names;

non terminal explanations,explanation;
non terminal statements,statement,functionstatements,funinstatements;
non terminal define,functionexplanation,functiondefine,variablexplanation,procedurexplanation,proceduredefine,funvariablexplanation;
non terminal dims;
non terminal parameters,parameter;
non terminal inexplanations,inexplanation;
non terminal if_then_statement;


//  Expressions

non terminal method_invocation, array_access;
non terminal postfix_expression;
non terminal postincrement_expression, postdecrement_expression;
non terminal unary_expression, unary_expression_not_plus_minus;
non terminal preincrement_expression, predecrement_expression;
non terminal cast_expression;
non terminal multiplicative_expression, additive_expression;
non terminal shift_expression, relational_expression, equality_expression;
non terminal and_expression, exclusive_or_expression, inclusive_or_expression;
non terminal conditional_and_expression, conditional_or_expression;
non terminal conditional_expression, assignment_expression;
non terminal assignment;
non terminal left_hand_side;
non terminal assignment_operator;
non terminal expression,expressions,statement_expression;

non terminal call_list,call_lists;


/**
*
*文法 ：
*/
start with goal;

// The Syntactic Grammar
goal	::=	PROGRAM IDENTIFIER SEMICOLON explanations BEGIN statements END {:System.out.println("******************************************************程序分析完毕");:}
	;

//说明
explanations	::=	explanation explanations 
		|	{:System.out.println("*****************全局常量，函数，过程：声明完毕，定义，以下为 语句执行 :");:}
		;

explanation	::=	CONST type define  {:System.out.println("常量定义");:}
		|	functionexplanation {:System.out.println("函数声明");:}
		|	functiondefine {:System.out.println("********函数定义完毕");:}
		|	variablexplanation 
		|	procedurexplanation {:System.out.println("过程声明");:}
		|	proceduredefine {:System.out.println("********过程定义完毕");:}
		;

//数组说明
array_types	::=	array_type COMMA array_types 
		|	array_type
		;



array_type ::=	IDENTIFIER LBRACK dims RBRACK  
		;


//数组维数
dims	::=	INTEGER_LITERAL COMMA INTEGER_LITERAL
	|	INTEGER_LITERAL
	;

//变量说明
variablexplanation	::=	type COLON names SEMICOLON {:System.out.println("变量声明");:}
			|	type COLON array_types SEMICOLON {:System.out.println("数组说明");:}
			;

//标志符表
names	::=	IDENTIFIER COMMA names
	|	IDENTIFIER
	;


//常量定义
define	::=	IDENTIFIER EQ literal SEMICOLON define
	|	IDENTIFIER EQ literal SEMICOLON
	;

//函数说明
functionexplanation	::=	type IDENTIFIER LPAREN parameters RPAREN SEMICOLON
			;
//函数参数

parameter		::=	type IDENTIFIER
			;

parameters		::=	parameter COMMA parameters
			|	parameter
			|	
			;

funinstatements		::=	statements  RETURN expression SEMICOLON {:System.out.println("函数返回");:}
			;

functionstatements	::=	funinstatements functionstatements 
			|	statements
			;

//函数定义
functiondefine		::=	type IDENTIFIER LPAREN parameters RPAREN inexplanations BEGIN functionstatements END 
			;
//函数或过程内 说明
inexplanations	::=	inexplanation	inexplanations 
		|	{:System.out.println("*****函数(过程)内说明完毕，以下为函数过程内语句执行:");:}
		;

inexplanation	::=	CONST	define SEMICOLON {:System.out.println("函数(过程)内常量定义");:}
		|	funvariablexplanation 
		;

funvariablexplanation	::=	type COLON names SEMICOLON {:System.out.println("函数(过程)内变量声明");:}
			|	type COLON array_types SEMICOLON {:System.out.println("函数(过程)内数组说明");:}
			;

//过程说明
procedurexplanation	::=	PROCEDURE IDENTIFIER SEMICOLON
			;

//过程定义
proceduredefine	::=	PROCEDURE IDENTIFIER inexplanations BEGIN statements END
		;

//语句说明

statements	::=	statement  statements 
		|	 
		;
	
if_then_statement	::=	IF expression THEN statement
			;

statement_expression	::=	
		assignment  {:System.out.println("赋值语句");:}
	|	preincrement_expression {:System.out.println("++表达式");:}
	|	predecrement_expression {:System.out.println("--表达式");:}
	|	postincrement_expression {:System.out.println("表达式++");:}
	|	postdecrement_expression {:System.out.println("表达式--");:}
	|	method_invocation {:System.out.println("函数调用");:}
	|	CALL IDENTIFIER {:System.out.println("过程调用");:}
	;

statement	::=	statement_expression SEMICOLON  
		|	if_then_statement {:System.out.println("if语句");:}
		|	if_then_statement ELSE statement {:System.out.println("if else语句");:}
		|	WHILE expression DO statement {:System.out.println("while语句");:}
		|	REPEAT statements UNTIL expression SEMICOLON {:System.out.println("repeat 语句");:}
		|	FOR  IDENTIFIER ASSIGN expression TO expression DO statement {:System.out.println("for 语句");:}
		|	BEGIN statements END {:System.out.println("语句块");:}
		|	READ names SEMICOLON {:System.out.println("read 语句");:}
		|	WRITE expressions SEMICOLON {:System.out.println("write 语句");:}
		|	SEMICOLON {:System.out.println("分号");:}
		;



/***
*表达式
*/

expressions	::=	expression
		|	expression SEMICOLON expressions
		;



//函数，数组 参数列表
call_lists	::=	call_list
		|	call_list SEMICOLON call_lists
		|
		;

call_list	::=	expression
		;



method_invocation	::=	IDENTIFIER LPAREN call_lists RPAREN
			;
		  
array_access	::=	IDENTIFIER LBRACK call_lists RBRACK
		;


postfix_expression	::=	literal
			|	method_invocation
			|	array_access
			|	IDENTIFIER
			|	postincrement_expression
			|	postdecrement_expression
			;


postincrement_expression	::=	postfix_expression PLUSPLUS
				;


postdecrement_expression	::=	postfix_expression MINUSMINUS
				;


unary_expression	::=	preincrement_expression
			|	predecrement_expression
			|	PLUS unary_expression
			|	MINUS unary_expression
			|	unary_expression_not_plus_minus
			;


preincrement_expression	::=	PLUSPLUS unary_expression
			;


predecrement_expression ::=	MINUSMINUS unary_expression
			;


unary_expression_not_plus_minus	::=	postfix_expression
				|	NOT unary_expression
				;



multiplicative_expression	::=	unary_expression
				|	multiplicative_expression MULT unary_expression
				|	multiplicative_expression DIV unary_expression
				|	multiplicative_expression MOD unary_expression
				;


additive_expression	::=	multiplicative_expression
			|	additive_expression PLUS multiplicative_expression
			|	additive_expression MINUS multiplicative_expression
			;


shift_expression	::=	additive_expression
			|	shift_expression LSHIFT additive_expression
			|	shift_expression RSHIFT additive_expression
			;



relational_expression ::=
		shift_expression
	|	relational_expression LT shift_expression
	|	relational_expression GT shift_expression
	|	relational_expression LTEQ shift_expression
	|	relational_expression GTEQ shift_expression
	
	;


equality_expression ::=
		relational_expression
	|	equality_expression EQEQ relational_expression
	|	equality_expression NOTEQ relational_expression
	;



and_expression ::=
		equality_expression
	|	and_expression AND equality_expression
	;


exclusive_or_expression ::=
		and_expression
	|	exclusive_or_expression XOR and_expression
	;


inclusive_or_expression ::=
		exclusive_or_expression
	|	inclusive_or_expression OR exclusive_or_expression
	;



conditional_and_expression ::=
		inclusive_or_expression
	|	conditional_and_expression ANDAND inclusive_or_expression
	;



conditional_or_expression ::=
		conditional_and_expression
	|	conditional_or_expression OROR conditional_and_expression
	;



conditional_expression ::=
		conditional_or_expression
	|	conditional_or_expression QUESTION expression 
			COLON conditional_expression
	;
assignment_expression ::=
		conditional_expression
	|	assignment
	;



assignment ::=	left_hand_side assignment_operator assignment_expression
	;



left_hand_side ::=
		IDENTIFIER
	|	array_access
	;



assignment_operator ::=
		ASSIGN
	|	MULTEQ
	|	DIVEQ
	|	MODEQ
	|	PLUSEQ
	|	MINUSEQ
	|	LSHIFTEQ
	|	RSHIFTEQ
	|	ANDEQ
	|	XOREQ
	|	OREQ
	;



expression ::=	assignment_expression {:System.out.println("表达式");:}
	;





/**
*基本元素
*/

literal ::=	INTEGER_LITERAL
	|	FLOATING_POINT_LITERAL
	|	BOOLEAN_LITERAL
	|	CHARACTER_LITERAL
	|	STRING_LITERAL
	;





type ::=
		numeric_type
	|	BOOLEAN
	;



numeric_type::=	integral_type
	|	floating_point_type
	;



integral_type ::= 
		BYTE 
	|	SHORT 
	|	INTEGER 
	|	LONG 
	|	CHAR 
	;



floating_point_type ::= 
		FLOAT 
	|	REAL
	;




//****************************************************************END