java15.cup

来自「tiger编译器的Java实现」· CUP 代码 · 共 1,264 行 · 第 1/3 页

package Parse;

import java_cup.runtime.*;

/* Java 1.5 parser for CUP.
 * (actually "Java 1.4 with JSR-14" parser,
 *  since Java 1.5 has not yet been finalized)
 * Copyright (C) 2002 C. Scott Ananian <[e-mail]>
 * This program is released under the terms of the GPL; see the file
 * COPYING for more details.  There is NO WARRANTY on this code.
 */

/*
JDK 1.5 Features added:
  parameterized types.  a "smart lexer" is necessary to fit this into
  an LALR(1) grammar.
*/
parser code  {: 
  Lexer lexer;

  public  Grm15(Lexer l) {
    super();
    lexer=l;
  }

  public void syntax_error(java_cup.runtime.Symbol current) {
    report_error("Syntax error (" + current.sym + ")", current);
  }
  public void report_error(String message, java_cup.runtime.Symbol info) {
    lexer.errorMsg(message, info);
  }
:};

scan with {: return lexer.nextToken(); :};

terminal BOOLEAN; // primitive_type
terminal BYTE, SHORT, INT, LONG, CHAR; // integral_type
terminal FLOAT, DOUBLE; // floating_point_type
terminal LBRACK, RBRACK; // array_type
terminal IDENTIFIER; // name
terminal DOT; // qualified_name
terminal SEMICOLON, MULT, COMMA, LBRACE, RBRACE, EQ, LPAREN, RPAREN, COLON;
terminal PACKAGE; // package_declaration
terminal IMPORT; // import_declaration
terminal PUBLIC, PROTECTED, PRIVATE; // modifier
terminal STATIC; // modifier
terminal ABSTRACT, FINAL, NATIVE, SYNCHRONIZED, TRANSIENT, VOLATILE;
terminal CLASS; // class_declaration
terminal EXTENDS; // super
terminal IMPLEMENTS; // interfaces
terminal VOID; // method_header
terminal THROWS; // throws
terminal THIS, SUPER; // explicit_constructor_invocation
terminal INTERFACE; // interface_declaration
terminal IF, ELSE; // 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; // for_statement
terminal BREAK; // break_statement
terminal CONTINUE; // continue_statement
terminal RETURN; // return_statement
terminal THROW; // throw_statement
terminal TRY; // try_statement
terminal CATCH; // catch_clause
terminal FINALLY; // finally
terminal NEW; // class_instance_creation_expression
terminal PLUSPLUS; // postincrement_expression
terminal MINUSMINUS; // postdecrement_expression
terminal PLUS, MINUS, COMP, NOT, DIV, MOD;
terminal LSHIFT, RSHIFT, URSHIFT; // shift_expression
terminal LT, GT, LTEQ, GTEQ, INSTANCEOF; // 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, URSHIFTEQ; // assignment_operator
terminal ANDEQ, XOREQ, OREQ; // assignment_operator

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 NULL_LITERAL;

// Reserved but unused:
terminal CONST, GOTO;
// strictfp keyword, new in Java 1.2
terminal STRICTFP;
// assert keyword, new in Java 1.4
terminal ASSERT; // assert_statement
// 'start of a parameterized type' terminal, required for LALR(1) parsing
// of casts to parameterized types. it's an "LT with lookahead".
terminal PLT;

// 19.2) The Syntactic Grammar
non terminal goal;
// 19.3) Lexical Structure
non terminal literal;
// 19.4) Types, Values, and Variables
non terminal type, primitive_type, numeric_type;
non terminal integral_type, floating_point_type;
non terminal reference_type;
non terminal class_or_interface_type;
non terminal class_type, interface_type;
non terminal array_type;
// 19.5) Names
non terminal name, simple_name, qualified_name;
// 19.6) Packages
non terminal compilation_unit;
non terminal package_declaration_opt, package_declaration;
non terminal import_declarations_opt, import_declarations;
non terminal type_declarations_opt, type_declarations;
non terminal import_declaration;
non terminal single_type_import_declaration;
non terminal type_import_on_demand_declaration;
non terminal type_declaration;
// 19.7) Productions used only in the LALR(1) grammar
non terminal modifiers_opt, modifiers, modifier;
// 19.8.1) Class Declaration
non terminal class_declaration, super, super_opt;
non terminal interfaces, interfaces_opt, interface_type_list;
non terminal class_body;
non terminal class_body_declarations, class_body_declarations_opt;
non terminal class_body_declaration, class_member_declaration;
// 19.8.2) Field Declarations
non terminal field_declaration, variable_declarators, variable_declarator;
non terminal variable_declarator_id, variable_initializer;
// 19.8.3) Method Declarations
non terminal method_declaration, method_header, method_declarator;
non terminal formal_parameter_list_opt, formal_parameter_list;
non terminal formal_parameter;
non terminal throws_opt, throws;
non terminal class_type_list, method_body;
// 19.8.4) Static Initializers
non terminal static_initializer;
// 19.8.5) Constructor Declarations
non terminal constructor_declaration, constructor_declarator;
non terminal constructor_body;
non terminal explicit_constructor_invocation;
// 19.9.1) Interface Declarations
non terminal interface_declaration;
non terminal extends_interfaces_opt, extends_interfaces;
non terminal interface_body;
non terminal interface_member_declarations_opt, interface_member_declarations;
non terminal interface_member_declaration, constant_declaration;
non terminal abstract_method_declaration;
// 19.10) Arrays
non terminal array_initializer;
non terminal variable_initializers;
// 19.11) Blocks and Statements
non terminal block;
non terminal block_statements_opt, block_statements, block_statement;
non terminal local_variable_declaration_statement, local_variable_declaration;
non terminal statement, statement_no_short_if;
non terminal statement_without_trailing_substatement;
non terminal empty_statement;
non terminal labeled_statement, labeled_statement_no_short_if;
non terminal expression_statement, statement_expression;
non terminal if_then_statement;
non terminal if_then_else_statement, if_then_else_statement_no_short_if;
non terminal switch_statement, switch_block;
non terminal switch_block_statement_groups;
non terminal switch_block_statement_group;
non terminal switch_labels, switch_label;
non terminal while_statement, while_statement_no_short_if;
non terminal do_statement;
non terminal for_statement, for_statement_no_short_if;
non terminal for_init_opt, for_init;
non terminal for_update_opt, for_update;
non terminal statement_expression_list;
non terminal identifier_opt;
non terminal break_statement, continue_statement;
non terminal return_statement, throw_statement;
non terminal synchronized_statement, try_statement;
non terminal catches_opt, catches, catch_clause;
non terminal finally;
non terminal assert_statement;
// 19.12) Expressions
non terminal primary, primary_no_new_array;
non terminal class_instance_creation_expression;
non terminal argument_list_opt, argument_list;
non terminal array_creation_expression;
non terminal dim_exprs, dim_expr, dims_opt, dims;
non terminal field_access, 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 assignment_operator;
non terminal expression;
// JSR-14 2.1) Type Syntax 2.3) Handling Consecutive Type Brackets
non terminal type_variable;
non terminal type_arguments, type_arguments_opt;
non terminal reference_type_list;
non terminal reference_type_list_1, reference_type_1;
non terminal reference_type_list_2, reference_type_2;
non terminal reference_type_list_3, reference_type_3;
// JSR-14 2.2) Parameterized Type Declarations 2.3) Handling Consecutive...
non terminal type_parameters, type_parameters_opt;
non terminal type_parameter, type_parameter_list;
non terminal type_parameter_1, type_parameter_list_1;
non terminal type_bound, type_bound_opt;
non terminal type_bound_1;
non terminal additional_bound_list, additional_bound_list_opt;
non terminal additional_bound_list_1;
non terminal additional_bound;
non terminal additional_bound_1;
// not mentioned in the JSR: need to reduce the precedence of instanceof
non terminal instanceof_expression;
//// expressions which are Not a Name
non terminal postfix_expression_nn;
non terminal unary_expression_nn;
non terminal unary_expression_not_plus_minus_nn;
non terminal multiplicative_expression_nn;
non terminal additive_expression_nn;
non terminal shift_expression_nn;
non terminal relational_expression_nn;
non terminal instanceof_expression_nn;
non terminal equality_expression_nn;
non terminal and_expression_nn;
non terminal exclusive_or_expression_nn;
non terminal inclusive_or_expression_nn;
non terminal conditional_and_expression_nn;
non terminal conditional_or_expression_nn;
non terminal conditional_expression_nn;
non terminal assignment_expression_nn;
non terminal expression_nn, expression_nn_opt, constant_expression_nn;
//// expressions where LT may be mistaken for PLT
non terminal unary_expression_l;
non terminal preincrement_expression_l, predecrement_expression_l;
non terminal unary_expression_not_plus_minus_l;
non terminal cast_expression_l;
non terminal multiplicative_expression_l;
non terminal additive_expression_l;
non terminal shift_expression_l;
non terminal relational_expression_l;
non terminal instanceof_expression_l;
non terminal equality_expression_l;
non terminal and_expression_l;
non terminal exclusive_or_expression_l;
non terminal inclusive_or_expression_l;
non terminal conditional_and_expression_l;
non terminal conditional_or_expression_l;
non terminal conditional_expression_l;
non terminal assignment_expression_l, assignment_l;
non terminal expression_l;
non terminal statement_expression_l;

start with goal;

// 19.2) The Syntactic Grammar
goal ::=	compilation_unit
	;

// 19.3) Lexical Structure.
literal ::=	INTEGER_LITERAL
	|	FLOATING_POINT_LITERAL
	|	BOOLEAN_LITERAL
	|	CHARACTER_LITERAL
	|	STRING_LITERAL
	|	NULL_LITERAL
	;

// 19.4) Types, Values, and Variables
type	::=	primitive_type
	|	reference_type
	;
primitive_type ::=
		numeric_type
	|	BOOLEAN
	;
numeric_type::=	integral_type
	|	floating_point_type
	;
integral_type ::= 
		BYTE 
	|	SHORT 
	|	INT 
	|	LONG 
	|	CHAR 
	;
floating_point_type ::= 
		FLOAT 
	|	DOUBLE
	;

reference_type ::=
		class_or_interface_type
/* note that the 'type_variable' production will come out of the grammar
 * as a 'class_or_interface_type' with a 'simple_name'.  The semantic
 * checker will have to resolve whether this is a class name or a type
 * variable */
	|	array_type
	;
type_variable ::=
		IDENTIFIER
	;
class_or_interface_type ::=
		name type_arguments_opt
	;

class_type ::=	class_or_interface_type;
interface_type ::= class_or_interface_type;		

array_type ::=	primitive_type dims
	|	name dims
	|	name type_arguments dims
	;

type_arguments_opt ::= type_arguments | ;
type_arguments ::=
		PLT reference_type_list_1
	;
reference_type_list ::=
		reference_type
	|	reference_type_list COMMA reference_type
	;
reference_type_list_1 ::=
		reference_type_1
	|	reference_type_list COMMA reference_type_1
	;
reference_type_list_2 ::=
		reference_type_2
	|	reference_type_list COMMA reference_type_2
	;
reference_type_list_3 ::=
		reference_type_3
	|	reference_type_list COMMA reference_type_3
	;
// note the LT in place of the PLT, since the following RSHIFT will
// confuse the lexer lookahead.
reference_type_1 ::=
		reference_type GT
	|	name LT reference_type_list_2
	|	name PLT reference_type_list_2
	;
reference_type_2 ::=
		reference_type RSHIFT
	|	name LT reference_type_list_3
	|	name PLT reference_type_list_3
	;
reference_type_3 ::=
		reference_type URSHIFT
	;

// 19.5) Names
name	::=	simple_name
	|	qualified_name
	;
simple_name ::=	IDENTIFIER
	;
qualified_name ::=
		name DOT IDENTIFIER
	;

// 19.6) Packages
compilation_unit ::=
		package_declaration_opt 
		import_declarations_opt
		type_declarations_opt
		;
package_declaration_opt ::= package_declaration | ;
import_declarations_opt ::= import_declarations | ;
type_declarations_opt   ::= type_declarations   | ;

import_declarations ::= 
		import_declaration
	|	import_declarations import_declaration
	;
type_declarations ::= 
		type_declaration
	|	type_declarations type_declaration
	;
package_declaration ::= 
		PACKAGE name SEMICOLON
	;
import_declaration ::= 
		single_type_import_declaration
	|	type_import_on_demand_declaration
	;
single_type_import_declaration ::= 
		IMPORT name SEMICOLON
	;
type_import_on_demand_declaration ::=
		IMPORT name DOT MULT SEMICOLON
	;
type_declaration ::=
		class_declaration
	|	interface_declaration
	|	SEMICOLON
	;

// 19.7) Productions used only in the LALR(1) grammar
modifiers_opt::=
	|	modifiers
	;
modifiers ::= 	modifier
	|	modifiers modifier
	;
modifier ::=	PUBLIC | PROTECTED | PRIVATE
	|	STATIC
	|	ABSTRACT | FINAL | NATIVE | SYNCHRONIZED | TRANSIENT | VOLATILE
	|	STRICTFP // note that semantic analysis must check that the
	                 // context of the modifier allows strictfp.
	;

// 19.8) Classes

// 19.8.1) Class Declaration: