gcc-4.4.0/libjava/classpath/tools/gnu/classpath/tools/gjdoc/expr/java-expression.g - toolchain/gcc - Git at Google

 /*
  * This grammar is derived from the Java 1.3 Recognizer
  * (http://www.antlr.org/grammar/java/java.g) by Mitchell, Parr, Lilley,
  * Stanchfield, Mohnen, Williams, Jacobs, Messick and Pybus, Version
  * 1.21.
  *
  * This grammar recognizes simple Java expressions. The following
  * language elements are NOT supported:
  *
  * - type casts to non-primitive types
  * - method calls
  * - constructor calls
  * - array access
  * - comma expressions
  * - increment and decrement operators (both prefix/postfix)
  * - expressions involving constant classes (Abc.class)
  */

 header {
    package gnu.classpath.tools.gjdoc.expr;
 }

 class JavaRecognizer extends Parser;
 options {
 	k = 2;                           // two token lookahead
 	exportVocab=Java;                // Call its vocabulary "Java"
 	codeGenMakeSwitchThreshold = 2;  // Some optimizations
 	codeGenBitsetTestThreshold = 3;
 	defaultErrorHandler = false;     // Don't generate parser error handlers
 	buildAST = true;
 }

 tokens {
 	BLOCK; MODIFIERS; OBJBLOCK; SLIST; CTOR_DEF; METHOD_DEF; VARIABLE_DEF;
 	INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF;
 	PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE;
 	PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP;
 	POST_INC; POST_DEC; METHOD_CALL; EXPR; ARRAY_INIT;
 	IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION;
 	FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract";
 	STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL;
 }

 // A builtin type specification is a builtin type with possible brackets
 // afterwards (which would make it an array type).
 builtInTypeSpec[boolean addImagNode] returns [Type t = null]
 	:	t=builtInType (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
 		{
 			if ( addImagNode ) {
 				#builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec);
 			}
 		}
 	;

 // A type name. which is either a (possibly qualified) class name or
 //   a primitive (builtin) type
 type returns [Type t]
 	:	t=builtInType
 	;

 // The primitive types.
 builtInType returns [Type t = null]
 	:	"void" {t=Type.VOID;}
 	|	"boolean" {t=Type.BOOLEAN;}
 	|	"byte" {t=Type.BYTE;}
 	|	"char" {t=Type.CHAR;}
 	|	"short" {t=Type.SHORT;}
 	|	"int" {t=Type.INTEGER;}
 	|	"float"{t=Type.FLOAT;}
 	|	"long" {t=Type.LONG;}
 	|	"double" {t=Type.DOUBLE;}
 	|	"String" {t=Type.STRING;}
 	;

 // A (possibly-qualified) java identifier.  We start with the first IDENT
 //   and expand its name by adding dots and following IDENTS
 identifier returns [String s = null;]
 	:	i:IDENT {s=i.getText();}  ( DOT^ i2:IDENT {s+="."+i2.getText();} )*
 	;

 expression returns [Expression e = null]
     :   e=conditionalExpression EOF!
     ;

 // conditional test (level 12)
 conditionalExpression returns [Expression e = null] { Expression a,b,c; }
 	:	e=logicalOrExpression
 		( QUESTION^ b=conditionalExpression COLON! c=conditionalExpression {e=new ConditionalExpression(e,b,c);} )?
 	;


 // logical or (||)  (level 11)
 logicalOrExpression returns [Expression e = null] { Expression a,b; }
 	:	e=logicalAndExpression (LOR^ b=logicalAndExpression {e=new LogicalOrExpression(e,b);})*
 	;


 // logical and (&&)  (level 10)
 logicalAndExpression returns [Expression e = null] { Expression a,b; }
 	:	e=inclusiveOrExpression (LAND^ b=inclusiveOrExpression {e=new LogicalAndExpression(e,b);})*
 	;


 // bitwise or non-short-circuiting or (|)  (level 9)
 inclusiveOrExpression returns [Expression e = null] { Expression a,b; }
 	:	e=exclusiveOrExpression (BOR^ b=exclusiveOrExpression {e=new InclusiveOrExpression(e,b);})*
 	;


 // exclusive or (^)  (level 8)
 exclusiveOrExpression returns [Expression e = null] { Expression a,b; }
 	:	e=andExpression (BXOR^ b=andExpression {e=new ExclusiveOrExpression(e,b);})*
 	;


 // bitwise or non-short-circuiting and (&)  (level 7)
 andExpression returns [Expression e = null] { Expression a,b; }
 	:	e=equalityExpression (BAND^ b=equalityExpression {e=new AndExpression(e,b);})*
 	;


 // equality/inequality (==/!=) (level 6)
 equalityExpression returns [Expression e = null] { Expression a,b; }
 	:	e=relationalExpression ((NOT_EQUAL^ a=relationalExpression {e=new NotEqualExpression(e,a);} | EQUAL^ a=relationalExpression {e=new EqualExpression(e,a);}))*
 	;


 // boolean relational expressions (level 5)
 relationalExpression returns [Expression e = null] { Expression a,b; }
 	:	e=shiftExpression
 		(	(	(	LT^ a=shiftExpression {e=new LessThanExpression(e,a);}
 				|	GT^ a=shiftExpression {e=new GreaterThanExpression(e,a);}
 				|	LE^ a=shiftExpression {e=new LessThanOrEqualExpression(e,a);}
 				|	GE^ a=shiftExpression {e=new GreaterThanOrEqualExpression(e,a);}
 				)

 			)*
 		)
 	;


 // bit shift expressions (level 4)
 shiftExpression returns [Expression e = null] { Expression a,b; }
 	:	e=additiveExpression ((SL^ a=additiveExpression {e=new ShiftLeftExpression(e,a);} | SR^ a=additiveExpression {e=new ShiftRightExpression(e,a);} | BSR^ a=additiveExpression {e=new BitShiftRightExpression(e,a);}))*
 	;


 // binary addition/subtraction (level 3)
 additiveExpression returns [Expression e = null] { Expression a,b; }
    :	e=multiplicativeExpression ((PLUS^ a=multiplicativeExpression {e=new AdditionExpression(e,a);} | MINUS^ a=multiplicativeExpression {e=new SubtractionExpression(e,a);}))*
 	;


 // multiplication/division/modulo (level 2)
 multiplicativeExpression returns [Expression e = null] { Expression a,b; }
 	:	e=unaryExpression ((STAR^ a=unaryExpression {e=new MultiplicationExpression(e,a);} | DIV^ a=unaryExpression {e=new DivisionExpression(e,a);} | MOD^ a=unaryExpression {e=new ModuloExpression(e,a);} ))*
 	;


 unaryExpression returns [Expression e = null] { Expression a,b; }
 	:	MINUS^ {#MINUS.setType(UNARY_MINUS);} a=unaryExpression {e=new NegateExpression(a);}
 	|	PLUS^  {#PLUS.setType(UNARY_PLUS);} e=unaryExpression
 	|	e=unaryExpressionNotPlusMinus
 	;

 unaryExpressionNotPlusMinus returns [Expression e = null] { Expression a; Type t; }
 	:	BNOT^ a=unaryExpression {e=new NotExpression(a);}
 	|	LNOT^ a=unaryExpression {e=new LogicalNotExpression(a);}

 		// use predicate to skip cases like: (int.class)
     |   (LPAREN builtInTypeSpec[true] RPAREN) =>
         lpb:LPAREN^ {#lpb.setType(TYPECAST);} t=builtInTypeSpec[true] RPAREN!
         a=unaryExpression {e=new TypeCastExpression(t,a);}

     |	e=primaryExpression
 	;

 // the basic element of an expression
 primaryExpression returns [Expression e = null; String i = null;]
 	:	e=constant
 	|	i=identifier {e=new IdentifierExpression(i);}
 	|	"true" { e=new ConstantBoolean(true); }
 	|	"false" { e=new ConstantBoolean(false); }
 	|	"null" { e=new ConstantNull(); }
     |	LPAREN! e=conditionalExpression RPAREN!
 	;

 /** Match a, a.b.c refs
  */
 identPrimary returns [Expression e = null]
 	:	IDENT
 		(
             options {
 				// .ident could match here or in postfixExpression.
 				// We do want to match here.  Turn off warning.
 				greedy=true;
 			}
 		:	DOT^ IDENT
 		)*
     ;

 constant returns [Expression e = null]
 	:	l1:NUM_INT {e=new ConstantInteger(l1.getText());}
 	|	l2:CHAR_LITERAL {e=new ConstantChar(l2.getText());}
 	|	l3:STRING_LITERAL {e=new ConstantString(l3.getText().substring(1, l3.getText().length()-1)); }
 	|	l4:NUM_FLOAT {e=new ConstantFloat(l4.getText());}
 	|	l5:NUM_LONG {e=new ConstantLong(l5.getText());}
 	|	l6:NUM_DOUBLE {e=new ConstantDouble(l6.getText());}
 	;


 //----------------------------------------------------------------------------
 // The Java scanner
 //----------------------------------------------------------------------------
 class JavaLexer extends Lexer;

 options {
 	exportVocab=Java;      // call the vocabulary "Java"
 	testLiterals=false;    // don't automatically test for literals
 	k=4;                   // four characters of lookahead
 	charVocabulary='\u0003'..'\uFFFF';
 	// without inlining some bitset tests, couldn't do unicode;
 	// I need to make ANTLR generate smaller bitsets; see
 	// bottom of JavaLexer.java
 	codeGenBitsetTestThreshold=20;
 }


 // OPERATORS
 QUESTION		:	'?'		;
 LPAREN			:	'('		;
 RPAREN			:	')'		;
 LBRACK			:	'['		;
 RBRACK			:	']'		;
 LCURLY			:	'{'		;
 RCURLY			:	'}'		;
 COLON			:	':'		;
 COMMA			:	','		;
 //DOT 			:	'.'		;
 ASSIGN			:	'='		;
 EQUAL			:	"=="	;
 LNOT			:	'!'		;
 BNOT			:	'~'		;
 NOT_EQUAL		:	"!="	;
 DIV				:	'/'		;
 DIV_ASSIGN		:	"/="	;
 PLUS			:	'+'		;
 PLUS_ASSIGN		:	"+="	;
 INC				:	"++"	;
 MINUS			:	'-'		;
 MINUS_ASSIGN	:	"-="	;
 DEC				:	"--"	;
 STAR			:	'*'		;
 STAR_ASSIGN		:	"*="	;
 MOD				:	'%'		;
 MOD_ASSIGN		:	"%="	;
 SR				:	">>"	;
 SR_ASSIGN		:	">>="	;
 BSR				:	">>>"	;
 BSR_ASSIGN		:	">>>="	;
 GE				:	">="	;
 GT				:	">"		;
 SL				:	"<<"	;
 SL_ASSIGN		:	"<<="	;
 LE				:	"<="	;
 LT				:	'<'		;
 BXOR			:	'^'		;
 BXOR_ASSIGN		:	"^="	;
 BOR				:	'|'		;
 BOR_ASSIGN		:	"|="	;
 LOR				:	"||"	;
 BAND			:	'&'		;
 BAND_ASSIGN		:	"&="	;
 LAND			:	"&&"	;
 SEMI			:	';'		;


 // Whitespace -- ignored
 WS	:	(	' '
 		|	'\t'
 		|	'\f'
 			// handle newlines
 		|	(	options {generateAmbigWarnings=false;}
 			:	"\r\n"  // Evil DOS
 			|	'\r'    // Macintosh
 			|	'\n'    // Unix (the right way)
 			)
 			{ newline(); }
 		)+
 		{ _ttype = Token.SKIP; }
 	;

 // Single-line comments
 SL_COMMIT
 	:	"//"
 		(~('\n'|'\r'))* ('\n'|'\r'('\n')?)
 		{$setType(Token.SKIP); newline();}
 	;

 // multiple-line comments
 ML_COMMENT
 	:	"/*"
 		(	/*	'\r' '\n' can be matched in one alternative or by matching
 				'\r' in one iteration and '\n' in another.  I am trying to
 				handle any flavor of newline that comes in, but the language
 				that allows both "\r\n" and "\r" and "\n" to all be valid
 				newline is ambiguous.  Consequently, the resulting grammar
 				must be ambiguous.  I'm shutting this warning off.
 			 */
 			options {
 				generateAmbigWarnings=false;
 			}
 		:
 			{ LA(2)!='/' }? '*'
 		|	'\r' '\n'		{newline();}
 		|	'\r'			{newline();}
 		|	'\n'			{newline();}
 		|	~('*'|'\n'|'\r')
 		)*
 		"*/"
 		{$setType(Token.SKIP);}
 	;


 // character literals
 CHAR_LITERAL
 	:	'\'' ( ESC | ~('\''|'\n'|'\r'|'\\') ) '\''
 	;

 // string literals
 STRING_LITERAL
 	:	'"' (ESC|~('"'|'\\'|'\n'|'\r'))* '"'
 	;


 // escape sequence -- note that this is protected; it can only be called
 //   from another lexer rule -- it will not ever directly return a token to
 //   the parser
 // There are various ambiguities hushed in this rule.  The optional
 // '0'...'9' digit matches should be matched here rather than letting
 // them go back to STRING_LITERAL to be matched.  ANTLR does the
 // right thing by matching immediately; hence, it's ok to shut off
 // the FOLLOW ambig warnings.
 protected
 ESC
 	:	'\\'
 		(	'n'
 		|	'r'
 		|	't'
 		|	'b'
 		|	'f'
 		|	'"'
 		|	'\''
 		|	'\\'
 		|	('u')+ HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
 		|	'0'..'3'
 			(
 				options {
 					warnWhenFollowAmbig = false;
 				}
 			:	'0'..'7'
 				(
 					options {
 						warnWhenFollowAmbig = false;
 					}
 				:	'0'..'7'
 				)?
 			)?
 		|	'4'..'7'
 			(
 				options {
 					warnWhenFollowAmbig = false;
 				}
 			:	'0'..'7'
 			)?
 		)
 	;


 // hexadecimal digit (again, note it's protected!)
 protected
 HEX_DIGIT
 	:	('0'..'9'|'A'..'F'|'a'..'f')
 	;


 // a dummy rule to force vocabulary to be all characters (except special
 //   ones that ANTLR uses internally (0 to 2)
 protected
 VOCAB
 	:	'\3'..'\377'
 	;


 // an identifier.  Note that testLiterals is set to true!  This means
 // that after we match the rule, we look in the literals table to see
 // if it's a literal or really an identifer
 IDENT
 	options {testLiterals=true;}
 	:	('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|'$')*
 	;


 // a numeric literal
 NUM_INT
 	{boolean isDecimal=false; Token t=null;}
     :   '.' {_ttype = DOT;}
             (	('0'..'9')+ (EXPONENT)? (f1:FLOAT_SUFFIX {t=f1;})?
                 {
 				if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
                 	_ttype = NUM_FLOAT;
 				}
 				else {
                 	_ttype = NUM_DOUBLE; // assume double
 				}
 				}
             )?

 	|	(	'0' {isDecimal = true;} // special case for just '0'
 			(	('x'|'X')
 				(											// hex
 					// the 'e'|'E' and float suffix stuff look
 					// like hex digits, hence the (...)+ doesn't
 					// know when to stop: ambig.  ANTLR resolves
 					// it correctly by matching immediately.  It
 					// is therefor ok to hush warning.
 					options {
 						warnWhenFollowAmbig=false;
 					}
 				:	HEX_DIGIT
 				)+

 			|	//float or double with leading zero
 				(('0'..'9')+ ('.'|EXPONENT|FLOAT_SUFFIX)) => ('0'..'9')+

 			|	('0'..'7')+									// octal
 			)?
 		|	('1'..'9') ('0'..'9')*  {isDecimal=true;}		// non-zero decimal
 		)
 		(	('l'|'L') { _ttype = NUM_LONG; }

 		// only check to see if it's a float if looks like decimal so far
 		|	{isDecimal}?
             (   '.' ('0'..'9')* (EXPONENT)? (f2:FLOAT_SUFFIX {t=f2;})?
             |   EXPONENT (f3:FLOAT_SUFFIX {t=f3;})?
             |   f4:FLOAT_SUFFIX {t=f4;}
             )
             {
 			if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
                 _ttype = NUM_FLOAT;
 			}
             else {
 	           	_ttype = NUM_DOUBLE; // assume double
 			}
 			}
         )?
 	;


 // a couple protected methods to assist in matching floating point numbers
 protected
 EXPONENT
 	:	('e'|'E') ('+'|'-')? ('0'..'9')+
 	;


 protected
 FLOAT_SUFFIX
 	:	'f'|'F'|'d'|'D'
 	;
	/*
	* This grammar is derived from the Java 1.3 Recognizer
	* (http://www.antlr.org/grammar/java/java.g) by Mitchell, Parr, Lilley,
	* Stanchfield, Mohnen, Williams, Jacobs, Messick and Pybus, Version
	* 1.21.
	*
	* This grammar recognizes simple Java expressions. The following
	* language elements are NOT supported:
	*
	* - type casts to non-primitive types
	* - method calls
	* - constructor calls
	* - array access
	* - comma expressions
	* - increment and decrement operators (both prefix/postfix)
	* - expressions involving constant classes (Abc.class)
	*/

	header {
	package gnu.classpath.tools.gjdoc.expr;
	}

	class JavaRecognizer extends Parser;
	options {
	k = 2; // two token lookahead
	exportVocab=Java; // Call its vocabulary "Java"
	codeGenMakeSwitchThreshold = 2; // Some optimizations
	codeGenBitsetTestThreshold = 3;
	defaultErrorHandler = false; // Don't generate parser error handlers
	buildAST = true;
	}

	tokens {
	BLOCK; MODIFIERS; OBJBLOCK; SLIST; CTOR_DEF; METHOD_DEF; VARIABLE_DEF;
	INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF;
	PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE;
	PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP;
	POST_INC; POST_DEC; METHOD_CALL; EXPR; ARRAY_INIT;
	IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION;
	FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract";
	STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL;
	}

	// A builtin type specification is a builtin type with possible brackets
	// afterwards (which would make it an array type).
	builtInTypeSpec[boolean addImagNode] returns [Type t = null]
	: t=builtInType (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
	{
	if ( addImagNode ) {
	#builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec);
	}
	}
	;

	// A type name. which is either a (possibly qualified) class name or
	// a primitive (builtin) type
	type returns [Type t]
	: t=builtInType
	;

	// The primitive types.
	builtInType returns [Type t = null]
	: "void" {t=Type.VOID;}
	\| "boolean" {t=Type.BOOLEAN;}
	\| "byte" {t=Type.BYTE;}
	\| "char" {t=Type.CHAR;}
	\| "short" {t=Type.SHORT;}
	\| "int" {t=Type.INTEGER;}
	\| "float"{t=Type.FLOAT;}
	\| "long" {t=Type.LONG;}
	\| "double" {t=Type.DOUBLE;}
	\| "String" {t=Type.STRING;}
	;

	// A (possibly-qualified) java identifier. We start with the first IDENT
	// and expand its name by adding dots and following IDENTS
	identifier returns [String s = null;]
	: i:IDENT {s=i.getText();} ( DOT^ i2:IDENT {s+="."+i2.getText();} )*
	;

	expression returns [Expression e = null]
	: e=conditionalExpression EOF!
	;

	// conditional test (level 12)
	conditionalExpression returns [Expression e = null] { Expression a,b,c; }
	: e=logicalOrExpression
	( QUESTION^ b=conditionalExpression COLON! c=conditionalExpression {e=new ConditionalExpression(e,b,c);} )?
	;


	// logical or (\|\|) (level 11)
	logicalOrExpression returns [Expression e = null] { Expression a,b; }
	: e=logicalAndExpression (LOR^ b=logicalAndExpression {e=new LogicalOrExpression(e,b);})*
	;


	// logical and (&&) (level 10)
	logicalAndExpression returns [Expression e = null] { Expression a,b; }
	: e=inclusiveOrExpression (LAND^ b=inclusiveOrExpression {e=new LogicalAndExpression(e,b);})*
	;


	// bitwise or non-short-circuiting or (\|) (level 9)
	inclusiveOrExpression returns [Expression e = null] { Expression a,b; }
	: e=exclusiveOrExpression (BOR^ b=exclusiveOrExpression {e=new InclusiveOrExpression(e,b);})*
	;


	// exclusive or (^) (level 8)
	exclusiveOrExpression returns [Expression e = null] { Expression a,b; }
	: e=andExpression (BXOR^ b=andExpression {e=new ExclusiveOrExpression(e,b);})*
	;


	// bitwise or non-short-circuiting and (&) (level 7)
	andExpression returns [Expression e = null] { Expression a,b; }
	: e=equalityExpression (BAND^ b=equalityExpression {e=new AndExpression(e,b);})*
	;


	// equality/inequality (==/!=) (level 6)
	equalityExpression returns [Expression e = null] { Expression a,b; }
	: e=relationalExpression ((NOT_EQUAL^ a=relationalExpression {e=new NotEqualExpression(e,a);} \| EQUAL^ a=relationalExpression {e=new EqualExpression(e,a);}))*
	;


	// boolean relational expressions (level 5)
	relationalExpression returns [Expression e = null] { Expression a,b; }
	: e=shiftExpression
	( ( ( LT^ a=shiftExpression {e=new LessThanExpression(e,a);}
	\| GT^ a=shiftExpression {e=new GreaterThanExpression(e,a);}
	\| LE^ a=shiftExpression {e=new LessThanOrEqualExpression(e,a);}
	\| GE^ a=shiftExpression {e=new GreaterThanOrEqualExpression(e,a);}
	)

	)*
	)
	;


	// bit shift expressions (level 4)
	shiftExpression returns [Expression e = null] { Expression a,b; }
	: e=additiveExpression ((SL^ a=additiveExpression {e=new ShiftLeftExpression(e,a);} \| SR^ a=additiveExpression {e=new ShiftRightExpression(e,a);} \| BSR^ a=additiveExpression {e=new BitShiftRightExpression(e,a);}))*
	;


	// binary addition/subtraction (level 3)
	additiveExpression returns [Expression e = null] { Expression a,b; }
	: e=multiplicativeExpression ((PLUS^ a=multiplicativeExpression {e=new AdditionExpression(e,a);} \| MINUS^ a=multiplicativeExpression {e=new SubtractionExpression(e,a);}))*
	;


	// multiplication/division/modulo (level 2)
	multiplicativeExpression returns [Expression e = null] { Expression a,b; }
	: e=unaryExpression ((STAR^ a=unaryExpression {e=new MultiplicationExpression(e,a);} \| DIV^ a=unaryExpression {e=new DivisionExpression(e,a);} \| MOD^ a=unaryExpression {e=new ModuloExpression(e,a);} ))*
	;


	unaryExpression returns [Expression e = null] { Expression a,b; }
	: MINUS^ {#MINUS.setType(UNARY_MINUS);} a=unaryExpression {e=new NegateExpression(a);}
	\| PLUS^ {#PLUS.setType(UNARY_PLUS);} e=unaryExpression
	\| e=unaryExpressionNotPlusMinus
	;

	unaryExpressionNotPlusMinus returns [Expression e = null] { Expression a; Type t; }
	: BNOT^ a=unaryExpression {e=new NotExpression(a);}
	\| LNOT^ a=unaryExpression {e=new LogicalNotExpression(a);}

	// use predicate to skip cases like: (int.class)
	\| (LPAREN builtInTypeSpec[true] RPAREN) =>
	lpb:LPAREN^ {#lpb.setType(TYPECAST);} t=builtInTypeSpec[true] RPAREN!
	a=unaryExpression {e=new TypeCastExpression(t,a);}

	\| e=primaryExpression
	;

	// the basic element of an expression
	primaryExpression returns [Expression e = null; String i = null;]
	: e=constant
	\| i=identifier {e=new IdentifierExpression(i);}
	\| "true" { e=new ConstantBoolean(true); }
	\| "false" { e=new ConstantBoolean(false); }
	\| "null" { e=new ConstantNull(); }
	\| LPAREN! e=conditionalExpression RPAREN!
	;

	/** Match a, a.b.c refs
	*/
	identPrimary returns [Expression e = null]
	: IDENT
	(
	options {
	// .ident could match here or in postfixExpression.
	// We do want to match here. Turn off warning.
	greedy=true;
	}
	: DOT^ IDENT
	)*
	;

	constant returns [Expression e = null]
	: l1:NUM_INT {e=new ConstantInteger(l1.getText());}
	\| l2:CHAR_LITERAL {e=new ConstantChar(l2.getText());}
	\| l3:STRING_LITERAL {e=new ConstantString(l3.getText().substring(1, l3.getText().length()-1)); }
	\| l4:NUM_FLOAT {e=new ConstantFloat(l4.getText());}
	\| l5:NUM_LONG {e=new ConstantLong(l5.getText());}
	\| l6:NUM_DOUBLE {e=new ConstantDouble(l6.getText());}
	;


	//----------------------------------------------------------------------------
	// The Java scanner
	//----------------------------------------------------------------------------
	class JavaLexer extends Lexer;

	options {
	exportVocab=Java; // call the vocabulary "Java"
	testLiterals=false; // don't automatically test for literals
	k=4; // four characters of lookahead
	charVocabulary='\u0003'..'\uFFFF';
	// without inlining some bitset tests, couldn't do unicode;
	// I need to make ANTLR generate smaller bitsets; see
	// bottom of JavaLexer.java
	codeGenBitsetTestThreshold=20;
	}



	// OPERATORS
	QUESTION : '?' ;
	LPAREN : '(' ;
	RPAREN : ')' ;
	LBRACK : '[' ;
	RBRACK : ']' ;
	LCURLY : '{' ;
	RCURLY : '}' ;
	COLON : ':' ;
	COMMA : ',' ;
	//DOT : '.' ;
	ASSIGN : '=' ;
	EQUAL : "==" ;
	LNOT : '!' ;
	BNOT : '~' ;
	NOT_EQUAL : "!=" ;
	DIV : '/' ;
	DIV_ASSIGN : "/=" ;
	PLUS : '+' ;
	PLUS_ASSIGN : "+=" ;
	INC : "++" ;
	MINUS : '-' ;
	MINUS_ASSIGN : "-=" ;
	DEC : "--" ;
	STAR : '*' ;
	STAR_ASSIGN : "*=" ;
	MOD : '%' ;
	MOD_ASSIGN : "%=" ;
	SR : ">>" ;
	SR_ASSIGN : ">>=" ;
	BSR : ">>>" ;
	BSR_ASSIGN : ">>>=" ;
	GE : ">=" ;
	GT : ">" ;
	SL : "<<" ;
	SL_ASSIGN : "<<=" ;
	LE : "<=" ;
	LT : '<' ;
	BXOR : '^' ;
	BXOR_ASSIGN : "^=" ;
	BOR : '\|' ;
	BOR_ASSIGN : "\|=" ;
	LOR : "\|\|" ;
	BAND : '&' ;
	BAND_ASSIGN : "&=" ;
	LAND : "&&" ;
	SEMI : ';' ;


	// Whitespace -- ignored
	WS : ( ' '
	\| '\t'
	\| '\f'
	// handle newlines
	\| ( options {generateAmbigWarnings=false;}
	: "\r\n" // Evil DOS
	\| '\r' // Macintosh
	\| '\n' // Unix (the right way)
	)
	{ newline(); }
	)+
	{ _ttype = Token.SKIP; }
	;

	// Single-line comments
	SL_COMMIT
	: "//"
	(~('\n'\|'\r'))* ('\n'\|'\r'('\n')?)
	{$setType(Token.SKIP); newline();}
	;

	// multiple-line comments
	ML_COMMENT
	: "/*"
	( /* '\r' '\n' can be matched in one alternative or by matching
	'\r' in one iteration and '\n' in another. I am trying to
	handle any flavor of newline that comes in, but the language
	that allows both "\r\n" and "\r" and "\n" to all be valid
	newline is ambiguous. Consequently, the resulting grammar
	must be ambiguous. I'm shutting this warning off.
	*/
	options {
	generateAmbigWarnings=false;
	}
	:
	{ LA(2)!='/' }? '*'
	\| '\r' '\n' {newline();}
	\| '\r' {newline();}
	\| '\n' {newline();}
	\| ~('*'\|'\n'\|'\r')
	)*
	"*/"
	{$setType(Token.SKIP);}
	;


	// character literals
	CHAR_LITERAL
	: '\'' ( ESC \| ~('\''\|'\n'\|'\r'\|'\\') ) '\''
	;

	// string literals
	STRING_LITERAL
	: '"' (ESC\|~('"'\|'\\'\|'\n'\|'\r'))* '"'
	;


	// escape sequence -- note that this is protected; it can only be called
	// from another lexer rule -- it will not ever directly return a token to
	// the parser
	// There are various ambiguities hushed in this rule. The optional
	// '0'...'9' digit matches should be matched here rather than letting
	// them go back to STRING_LITERAL to be matched. ANTLR does the
	// right thing by matching immediately; hence, it's ok to shut off
	// the FOLLOW ambig warnings.
	protected
	ESC
	: '\\'
	( 'n'
	\| 'r'
	\| 't'
	\| 'b'
	\| 'f'
	\| '"'
	\| '\''
	\| '\\'
	\| ('u')+ HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
	\| '0'..'3'
	(
	options {
	warnWhenFollowAmbig = false;
	}
	: '0'..'7'
	(
	options {
	warnWhenFollowAmbig = false;
	}
	: '0'..'7'
	)?
	)?
	\| '4'..'7'
	(
	options {
	warnWhenFollowAmbig = false;
	}
	: '0'..'7'
	)?
	)
	;


	// hexadecimal digit (again, note it's protected!)
	protected
	HEX_DIGIT
	: ('0'..'9'\|'A'..'F'\|'a'..'f')
	;


	// a dummy rule to force vocabulary to be all characters (except special
	// ones that ANTLR uses internally (0 to 2)
	protected
	VOCAB
	: '\3'..'\377'
	;


	// an identifier. Note that testLiterals is set to true! This means
	// that after we match the rule, we look in the literals table to see
	// if it's a literal or really an identifer
	IDENT
	options {testLiterals=true;}
	: ('a'..'z'\|'A'..'Z'\|'_'\|'$') ('a'..'z'\|'A'..'Z'\|'_'\|'0'..'9'\|'$')*
	;


	// a numeric literal
	NUM_INT
	{boolean isDecimal=false; Token t=null;}
	: '.' {_ttype = DOT;}
	( ('0'..'9')+ (EXPONENT)? (f1:FLOAT_SUFFIX {t=f1;})?
	{
	if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
	_ttype = NUM_FLOAT;
	}
	else {
	_ttype = NUM_DOUBLE; // assume double
	}
	}
	)?

	\| ( '0' {isDecimal = true;} // special case for just '0'
	( ('x'\|'X')
	( // hex
	// the 'e'\|'E' and float suffix stuff look
	// like hex digits, hence the (...)+ doesn't
	// know when to stop: ambig. ANTLR resolves
	// it correctly by matching immediately. It
	// is therefor ok to hush warning.
	options {
	warnWhenFollowAmbig=false;
	}
	: HEX_DIGIT
	)+

	\| //float or double with leading zero
	(('0'..'9')+ ('.'\|EXPONENT\|FLOAT_SUFFIX)) => ('0'..'9')+

	\| ('0'..'7')+ // octal
	)?
	\| ('1'..'9') ('0'..'9')* {isDecimal=true;} // non-zero decimal
	)
	( ('l'\|'L') { _ttype = NUM_LONG; }

	// only check to see if it's a float if looks like decimal so far
	\| {isDecimal}?
	( '.' ('0'..'9')* (EXPONENT)? (f2:FLOAT_SUFFIX {t=f2;})?
	\| EXPONENT (f3:FLOAT_SUFFIX {t=f3;})?
	\| f4:FLOAT_SUFFIX {t=f4;}
	)
	{
	if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
	_ttype = NUM_FLOAT;
	}
	else {
	_ttype = NUM_DOUBLE; // assume double
	}
	}
	)?
	;


	// a couple protected methods to assist in matching floating point numbers
	protected
	EXPONENT
	: ('e'\|'E') ('+'\|'-')? ('0'..'9')+
	;


	protected
	FLOAT_SUFFIX
	: 'f'\|'F'\|'d'\|'D'
	;