From 6ccfb5ea5233179909a6d83a6412c124bee86cbc Mon Sep 17 00:00:00 2001 From: Tom Copeland Date: Wed, 10 Sep 2003 19:47:00 +0000 Subject: [PATCH] Cleaning up unnecessary extra grammar git-svn-id: https://pmd.svn.sourceforge.net/svnroot/pmd/trunk@2247 51baf565-9d33-0410-a72c-fc3788e3496d --- pmd/etc/build.xml | 32 - pmd/etc/grammar/Java1.1.jjt | 1181 ----------------------------------- 2 files changed, 1213 deletions(-) delete mode 100644 pmd/etc/grammar/Java1.1.jjt diff --git a/pmd/etc/build.xml b/pmd/etc/build.xml index 9d818b6daf..29c91d1107 100644 --- a/pmd/etc/build.xml +++ b/pmd/etc/build.xml @@ -130,38 +130,6 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/pmd/etc/grammar/Java1.1.jjt b/pmd/etc/grammar/Java1.1.jjt deleted file mode 100644 index 0747f19d91..0000000000 --- a/pmd/etc/grammar/Java1.1.jjt +++ /dev/null @@ -1,1181 +0,0 @@ -/** - * - * Removed JDK 1.4 stuff - * Do I need to remove 1.2 stuff like strictfp? YAGNI, maybe. - * - * Tom Copeland, 9/03 - * =================================================================== - * This file is a modified version of one originally found in the - * VTransformer Examples directory of JavaCC1_1. It has been - * modified to accept Java source code for Java 1.2. Basically, - * this means a new key word was added, 'strictfp', and that keyword - * added to the appropriate productions and LOOKAHEADs (where other, - * similar keywords are listed as possible choices). This involved - * changing 11 lines. - * - * Some other minor changes were made, which can be found by doing - * a search on 'DW, 7/99'. - * - * The goal of this effort was for the grammar to be able to parse - * any legal Java 1.2 source code. It does not reject all illegal - * cases, but neither did the original. Plus, when it comes to - * the new 'strictfp' keyword, the Java Compiler from Sun (JDK1.2.1) - * also does not reject all illegal cases, as defined by the - * "Updates" document found at - * http://java.sun.com/docs/books/jls/strictfp-changes.pdf - * (see the testcases.txt file for details). - * - * David Williams, 7/99 - * =================================================================== - * - * - * Copyright (C) 1996, 1997 Sun Microsystems Inc. - * - * Use of this file and the system it is part of is constrained by the - * file COPYRIGHT in the root directory of this system. You may, however, - * make any modifications you wish to this file. - * - * Java files generated by running JavaCC on this file (or modified versions - * of this file) may be used in exactly the same manner as Java files - * generated from any grammar developed by you. - * - * Author: Sriram Sankar - * Date: 3/5/97 - * - * This file contains a Java grammar and actions that implement a front-end. - * - */ - -options { - JAVA_UNICODE_ESCAPE = true; - STATIC=false; - MULTI=true; - VISITOR=true; - NODE_USES_PARSER=true; - NODE_PACKAGE="net.sourceforge.pmd.ast11"; -} - -PARSER_BEGIN(JavaParser) -package net.sourceforge.pmd.ast11; -public class JavaParser -{ -} -PARSER_END(JavaParser) - -/* WHITE SPACE */ - -SPECIAL_TOKEN : -{ - " " -| "\t" -| "\n" -| "\r" -| "\f" -} - -SPECIAL_TOKEN : -{ -< SINGLE_LINE_COMMENT: "//"(~["\n","\r"])* ("\n"|"\r"|"\r\n")? > -} - -/* COMMENTS */ - -MORE : -{ - <"/**" ~["/"]> { input_stream.backup(1); } : IN_FORMAL_COMMENT -| - "/*" : IN_MULTI_LINE_COMMENT -} - - -SPECIAL_TOKEN : -{ - : DEFAULT -} - - -SPECIAL_TOKEN : -{ - : DEFAULT -} - - -MORE : -{ - < ~[] > -} - -/* RESERVED WORDS AND LITERALS */ - -TOKEN : -{ - < ABSTRACT: "abstract" > -| < BOOLEAN: "boolean" > -| < BREAK: "break" > -| < BYTE: "byte" > -| < CASE: "case" > -| < CATCH: "catch" > -| < CHAR: "char" > -| < CLASS: "class" > -| < CONST: "const" > -| < CONTINUE: "continue" > -| < _DEFAULT: "default" > -| < DO: "do" > -| < DOUBLE: "double" > -| < ELSE: "else" > -| < EXTENDS: "extends" > -| < FALSE: "false" > -| < FINAL: "final" > -| < FINALLY: "finally" > -| < FLOAT: "float" > -| < FOR: "for" > -| < GOTO: "goto" > -| < IF: "if" > -| < IMPLEMENTS: "implements" > -| < IMPORT: "import" > -| < INSTANCEOF: "instanceof" > -| < INT: "int" > -| < INTERFACE: "interface" > -| < LONG: "long" > -| < NATIVE: "native" > -| < NEW: "new" > -| < NULL: "null" > -| < PACKAGE: "package"> -| < PRIVATE: "private" > -| < PROTECTED: "protected" > -| < PUBLIC: "public" > -| < RETURN: "return" > -| < SHORT: "short" > -| < STATIC: "static" > -| < SUPER: "super" > -| < SWITCH: "switch" > -| < SYNCHRONIZED: "synchronized" > -| < THIS: "this" > -| < THROW: "throw" > -| < THROWS: "throws" > -| < TRANSIENT: "transient" > -| < TRUE: "true" > -| < TRY: "try" > -| < VOID: "void" > -| < VOLATILE: "volatile" > -| < WHILE: "while" > -| < STRICTFP: "strictfp" > -} - -/* LITERALS */ - -TOKEN : -{ - < INTEGER_LITERAL: - (["l","L"])? - | (["l","L"])? - | (["l","L"])? - > -| - < #DECIMAL_LITERAL: ["1"-"9"] (["0"-"9"])* > -| - < #HEX_LITERAL: "0" ["x","X"] (["0"-"9","a"-"f","A"-"F"])+ > -| - < #OCTAL_LITERAL: "0" (["0"-"7"])* > -| - < FLOATING_POINT_LITERAL: - (["0"-"9"])+ "." (["0"-"9"])* ()? (["f","F","d","D"])? - | "." (["0"-"9"])+ ()? (["f","F","d","D"])? - | (["0"-"9"])+ (["f","F","d","D"])? - | (["0"-"9"])+ ()? ["f","F","d","D"] - > -| - < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ > -| - < CHARACTER_LITERAL: - "'" - ( (~["'","\\","\n","\r"]) - | ("\\" - ( ["n","t","b","r","f","\\","'","\""] - | ["0"-"7"] ( ["0"-"7"] )? - | ["0"-"3"] ["0"-"7"] ["0"-"7"] - ) - ) - ) - "'" - > -| - < STRING_LITERAL: - "\"" - ( (~["\"","\\","\n","\r"]) - | ("\\" - ( ["n","t","b","r","f","\\","'","\""] - | ["0"-"7"] ( ["0"-"7"] )? - | ["0"-"3"] ["0"-"7"] ["0"-"7"] - ) - ) - )* - "\"" - > -} - -/* IDENTIFIERS */ - -TOKEN : -{ - < IDENTIFIER: (|)* > -| - < #LETTER: - [ - "\u0024", - "\u0041"-"\u005a", - "\u005f", - "\u0061"-"\u007a", - "\u00c0"-"\u00d6", - "\u00d8"-"\u00f6", - "\u00f8"-"\u00ff", - "\u0100"-"\u1fff", - "\u3040"-"\u318f", - "\u3300"-"\u337f", - "\u3400"-"\u3d2d", - "\u4e00"-"\u9fff", - "\uf900"-"\ufaff" - ] - > -| - < #DIGIT: - [ - "\u0030"-"\u0039", - "\u0660"-"\u0669", - "\u06f0"-"\u06f9", - "\u0966"-"\u096f", - "\u09e6"-"\u09ef", - "\u0a66"-"\u0a6f", - "\u0ae6"-"\u0aef", - "\u0b66"-"\u0b6f", - "\u0be7"-"\u0bef", - "\u0c66"-"\u0c6f", - "\u0ce6"-"\u0cef", - "\u0d66"-"\u0d6f", - "\u0e50"-"\u0e59", - "\u0ed0"-"\u0ed9", - "\u1040"-"\u1049" - ] - > -} - -/* SEPARATORS */ - -TOKEN : -{ - < LPAREN: "(" > -| < RPAREN: ")" > -| < LBRACE: "{" > -| < RBRACE: "}" > -| < LBRACKET: "[" > -| < RBRACKET: "]" > -| < SEMICOLON: ";" > -| < COMMA: "," > -| < DOT: "." > -} - -/* OPERATORS */ - -TOKEN : -{ - < ASSIGN: "=" > -| < GT: ">" > -| < LT: "<" > -| < BANG: "!" > -| < TILDE: "~" > -| < HOOK: "?" > -| < COLON: ":" > -| < EQ: "==" > -| < LE: "<=" > -| < GE: ">=" > -| < NE: "!=" > -| < SC_OR: "||" > -| < SC_AND: "&&" > -| < INCR: "++" > -| < DECR: "--" > -| < PLUS: "+" > -| < MINUS: "-" > -| < STAR: "*" > -| < SLASH: "/" > -| < BIT_AND: "&" > -| < BIT_OR: "|" > -| < XOR: "^" > -| < REM: "%" > -| < LSHIFT: "<<" > -| < RSIGNEDSHIFT: ">>" > -| < RUNSIGNEDSHIFT: ">>>" > -| < PLUSASSIGN: "+=" > -| < MINUSASSIGN: "-=" > -| < STARASSIGN: "*=" > -| < SLASHASSIGN: "/=" > -| < ANDASSIGN: "&=" > -| < ORASSIGN: "|=" > -| < XORASSIGN: "^=" > -| < REMASSIGN: "%=" > -| < LSHIFTASSIGN: "<<=" > -| < RSIGNEDSHIFTASSIGN: ">>=" > -| < RUNSIGNEDSHIFTASSIGN: ">>>=" > -} - - -/***************************************** - * THE JAVA LANGUAGE GRAMMAR STARTS HERE * - *****************************************/ - -/* - * Program structuring syntax follows. - */ - -ASTCompilationUnit CompilationUnit() : -{} -{ - [ PackageDeclaration() ] - ( ImportDeclaration() )* - ( TypeDeclaration() )* - ( < "\u001a" > )? - ( < "~[]" > )? - - { - return jjtThis; - } -} - -void PackageDeclaration() : -{} -{ - "package" Name() ";" -} - -void ImportDeclaration() : -{} -{ - "import" Name() [ "." "*" {jjtThis.setImportOnDemand();} ] ";" -} - -void TypeDeclaration() : -{} -{ - LOOKAHEAD( ( "abstract" | "final" | "public" | "strictfp" )* "class" ) - ClassDeclaration() -| - InterfaceDeclaration() -| - ";" -} - - -/* - * Declaration syntax follows. - */ - -void ClassDeclaration() : -{} -{ - ( "abstract" { jjtThis.setAbstract(); } - | "final" { jjtThis.setFinal(); } - | "public" { jjtThis.setPublic(); } - | "strictfp" { jjtThis.setStrict(); } - )* - UnmodifiedClassDeclaration() -} - -void UnmodifiedClassDeclaration() : -{ Token t = null; } -{ - "class" t= - { - jjtThis.setImage( t.image ); - } - [ "extends" Name() ] [ "implements" NameList() ] - ClassBody() -} - -void ClassBody() : -{} -{ - "{" ( ClassBodyDeclaration() )* "}" -} - -void NestedClassDeclaration() : -{} -{ - ("static" { jjtThis.setStatic(); } - | "abstract" { jjtThis.setAbstract(); } - | "final" { jjtThis.setFinal(); } - | "public" { jjtThis.setPublic(); } - | "protected" { jjtThis.setProtected(); } - | "private" { jjtThis.setPrivate(); } - | "strictfp" { jjtThis.setStrict(); } - )* - UnmodifiedClassDeclaration() -} - -void ClassBodyDeclaration() : -{} -{ - LOOKAHEAD(2) - Initializer() -| - LOOKAHEAD( ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp")* "class" ) - NestedClassDeclaration() -| - LOOKAHEAD( ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp")* "interface" ) - NestedInterfaceDeclaration() -| - LOOKAHEAD( [ "public" | "protected" | "private" ] Name() "(" ) - ConstructorDeclaration() -| - LOOKAHEAD( MethodDeclarationLookahead() ) - MethodDeclaration() -| - FieldDeclaration() -| - ";" -} - -// This production is to determine lookahead only. -void MethodDeclarationLookahead() : -{} -{ - ( "public" | "protected" | "private" | "static" | "abstract" | "final" | "native" | "synchronized" | "strictfp")* - ResultType() "(" -} - -void InterfaceDeclaration() : -{} -{ - ( "abstract" | "public" | "strictfp")* - UnmodifiedInterfaceDeclaration() -} - -void NestedInterfaceDeclaration() : -{} -{ - ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp")* - UnmodifiedInterfaceDeclaration() -} - -void UnmodifiedInterfaceDeclaration() : -{Token t = null; } -{ - "interface" t= - { - jjtThis.setImage( t.image ); - } - [ "extends" NameList() ] - "{" ( InterfaceMemberDeclaration() )* "}" -} - -void InterfaceMemberDeclaration() : -{} -{ - LOOKAHEAD( ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp")* "class" ) - NestedClassDeclaration() -| - LOOKAHEAD( ( "static" | "abstract" | "final" | "public" | "protected" | "private" | "strictfp")* "interface" ) - NestedInterfaceDeclaration() -| - LOOKAHEAD( MethodDeclarationLookahead() ) - MethodDeclaration() -| - FieldDeclaration() -| - ";" -} - -void FieldDeclaration() : -{ -} -{ - ( "public" { jjtThis.setPublic(); } - | "protected" { jjtThis.setProtected(); } - | "private" { jjtThis.setPrivate(); } - | "static" { jjtThis.setStatic(); } - | "final" { jjtThis.setFinal(); } - | "transient" { jjtThis.setTransient(); } - | "volatile" { jjtThis.setVolatile(); } )* - - Type() VariableDeclarator() ( "," VariableDeclarator() )* ";" -} - -void VariableDeclarator() : -{} -{ - VariableDeclaratorId() [ "=" VariableInitializer() ] -} - -void VariableDeclaratorId() : -{ - String s = null; - Token t = null; -} -{ - t= - { - s = t.image; - } - ( "[" "]" )* - { - jjtThis.setImage( s ); - } -} - -void VariableInitializer() : -{} -{ - ArrayInitializer() -| - Expression() -} - -void ArrayInitializer() : -{} -{ - "{" [ VariableInitializer() ( LOOKAHEAD(2) "," VariableInitializer() )* ] [ "," ] "}" -} - -void MethodDeclaration() : -{} -{ - ( "public" { jjtThis.setPublic(); } - | "protected" { jjtThis.setProtected(); } - | "private" { jjtThis.setPrivate(); } - | "static" { jjtThis.setStatic(); } - | "abstract" { jjtThis.setAbstract(); } - | "final" { jjtThis.setFinal(); } - | "native" { jjtThis.setNative(); } - | "synchronized" { jjtThis.setSynchronized(); } - | "strictfp" { jjtThis.setStrict(); } - )* - ResultType() MethodDeclarator() [ "throws" NameList() ] - ( Block() | ";" ) -} - -void MethodDeclarator() : -{ - Token t = null; -} -{ - t= { jjtThis.setImage( t.image ); } - FormalParameters() ( "[" "]" )* -} - - -void FormalParameters() : -{} -{ - "(" [ FormalParameter() ( "," FormalParameter() )* ] ")" -} - -void FormalParameter() : -{} -{ - [ "final" {jjtThis.setFinal();} ] Type() VariableDeclaratorId() -} - -void ConstructorDeclaration() : -{} -{ - [ - "public" { jjtThis.setPublic(); } - | "protected" { jjtThis.setProtected(); } - | "private" { jjtThis.setPrivate(); } - ] - FormalParameters() [ "throws" NameList() ] - "{" - [ LOOKAHEAD(ExplicitConstructorInvocation()) ExplicitConstructorInvocation() ] - ( BlockStatement() )* - "}" -} - -void ExplicitConstructorInvocation() : -{} -{ - LOOKAHEAD("this" Arguments() ";") "this" {((ASTExplicitConstructorInvocation)jjtThis).setIsThis();} Arguments() ";" -| - [ LOOKAHEAD(2) PrimaryExpression() "." ] "super" {((ASTExplicitConstructorInvocation)jjtThis).setIsSuper();} Arguments() ";" -} - -void Initializer() : -{} -{ - [ "static" {jjtThis.setStatic();} ] Block() -} - - -/* - * Type, name and expression syntax follows. - */ - -void Type() : -{} -{ - ( PrimitiveType() | Name() ) ( "[" "]" {jjtThis.setIsArray();} )* -} - -void PrimitiveType() : -{} -{ - "boolean" {jjtThis.setImage("boolean");} -| "char" {jjtThis.setImage("char");} -| "byte" {jjtThis.setImage("byte");} -| "short" {jjtThis.setImage("short");} -| "int" {jjtThis.setImage("int");} -| "long" {jjtThis.setImage("long");} -| "float" {jjtThis.setImage("float");} -| "double" {jjtThis.setImage("double");} -} - - -void ResultType() : -{} -{ - "void" -| Type() -} - -void Name() : -/* - * A lookahead of 2 is required below since "Name" can be followed - * by a ".*" when used in the context of an "ImportDeclaration". - */ -{ - StringBuffer s = new StringBuffer(); - Token t = null; -} -{ - t= - { - jjtThis.testingOnly__setBeginLine( t.beginLine); - jjtThis.testingOnly__setBeginColumn( t.beginColumn); - s.append(t.image); - } - ( LOOKAHEAD(2) "." t= - { - s.append("."); - s.append(t.image); - } - )* - { - jjtThis.setImage( s.toString() ); - } -} - -void NameList() : -{} -{ - Name() - ( "," Name() - )* -} - - -/* - * Expression syntax follows. - */ - -void Expression() : -/* - * This expansion has been written this way instead of: - * Assignment() | ConditionalExpression() - * for performance reasons. - * However, it is a weakening of the grammar for it allows the LHS of - * assignments to be any conditional expression whereas it can only be - * a primary expression. Consider adding a semantic predicate to work - * around this. - */ -{} -{ - ConditionalExpression() - [ - AssignmentOperator() Expression() - ] -} - -void AssignmentOperator() : -{} -{ - "=" | "*=" | "/=" | "%=" | "+=" | "-=" | "<<=" | ">>=" | ">>>=" | "&=" | "^=" | "|=" -} - -void ConditionalExpression() #void : -{} -{ - ConditionalOrExpression() [ "?" Expression() ":" ConditionalExpression() ] -} - -void ConditionalOrExpression() #void : -{} -{ - ConditionalAndExpression() ( "||" ConditionalAndExpression() )* -} - -void ConditionalAndExpression() : -{} -{ - InclusiveOrExpression() ( "&&" InclusiveOrExpression() )* -} - -void InclusiveOrExpression() #void : -{} -{ - ExclusiveOrExpression() ( "|" ExclusiveOrExpression() )* -} - -void ExclusiveOrExpression() #void : -{} -{ - AndExpression() ( "^" AndExpression() )* -} - -void AndExpression() #void : -{} -{ - EqualityExpression() ( "&" EqualityExpression() )* -} - -void EqualityExpression() #void : -{} -{ - InstanceOfExpression() ( ( "==" | "!=" ) InstanceOfExpression() )* -} - -void InstanceOfExpression() : -{} -{ - RelationalExpression() [ "instanceof" Type() ] -} - -void RelationalExpression() #void : -{} -{ - ShiftExpression() ( ( "<" | ">" | "<=" | ">=" ) ShiftExpression() )* -} - -void ShiftExpression() #void : -{} -{ - AdditiveExpression() ( ( "<<" | ">>" | ">>>" ) AdditiveExpression() )* -} - -void AdditiveExpression() #void : -{} -{ - MultiplicativeExpression() ( ( "+" | "-" ) MultiplicativeExpression() )* -} - -void MultiplicativeExpression() #void : -{} -{ - UnaryExpression() ( ( "*" | "/" | "%" ) UnaryExpression() )* -} - -void UnaryExpression() #void : -{} -{ - ( "+" | "-" ) UnaryExpression() -| - PreIncrementExpression() -| - PreDecrementExpression() -| - UnaryExpressionNotPlusMinus() -} - -void PreIncrementExpression() : -{} -{ - "++" PrimaryExpression() -} - -void PreDecrementExpression() : -{} -{ - "--" PrimaryExpression() -} - -void UnaryExpressionNotPlusMinus() #void : -{} -{ - ( "~" | "!" ) UnaryExpression() -| - LOOKAHEAD( CastLookahead() ) - CastExpression() -| - PostfixExpression() -} - -// This production is to determine lookahead only. The LOOKAHEAD specifications -// below are not used, but they are there just to indicate that we know about -// this. -void CastLookahead() : -{} -{ - LOOKAHEAD(2) - "(" PrimitiveType() -| - LOOKAHEAD("(" Name() "[") - "(" Name() "[" "]" -| - "(" Name() ")" ( "~" | "!" | "(" | | "this" | "super" | "new" | Literal() ) -} - -void PostfixExpression() #void : -{} -{ - PrimaryExpression() [ "++" | "--" ] -} - -void CastExpression() : -{} -{ - LOOKAHEAD("(" PrimitiveType()) - "(" Type() ")" UnaryExpression() -| -// removed a LOOKAHEAD which was not technically needed DW, 7/99 - "(" Type() ")" UnaryExpressionNotPlusMinus() -} - -void PrimaryExpression() : -{} -{ - PrimaryPrefix() ( LOOKAHEAD(2) PrimarySuffix() )* -} - -void PrimaryPrefix() : -{ - String s = null; - Token t = null; -} -{ - Literal() -| - "this" {jjtThis.setUsesThisModifier();} -| - "super" {jjtThis.setUsesSuperModifier();} "." t= {s = t.image;} {jjtThis.setImage(s);} -| - "(" Expression() ")" -| - AllocationExpression() -| - LOOKAHEAD( ResultType() "." "class" ) - ResultType() "." "class" -| - Name() -} - -void PrimarySuffix() : -{ - String s = null; - Token t = null; -} -{ - LOOKAHEAD(2) - "." "this" -| - LOOKAHEAD(2) - "." "super" -| - LOOKAHEAD(2) - "." AllocationExpression() -| - "[" Expression() "]" -| - "." t= {s = t.image;} {jjtThis.setImage(s);} -| - Arguments() {((ASTPrimarySuffix)jjtThis).setIsArguments();} -} - -void Literal() : -{} -{ -{ String intValue = ""; Token t = null;} -t= -{ intValue=t.image;} {jjtThis.setImage(intValue);} -| -{ String floatValue = "";} -t= -{ floatValue=t.image;} {jjtThis.setImage(floatValue);} -| -{ String charValue = "";} -t= -{ charValue=t.image;} {jjtThis.setImage(charValue);} -| -{ String stringValue = "";} -t= -{ stringValue=t.image;} {jjtThis.setImage(stringValue);} -| - BooleanLiteral() -| - NullLiteral() -} - -void BooleanLiteral() : -{} -{ - "true" -| - "false" -} - -void NullLiteral() : -{} -{ - "null" -} - -void Arguments() : -{} -{ - "(" [ ArgumentList() ] ")" -} - -void ArgumentList() : -{} -{ - Expression() ( "," Expression() )* -} - -void AllocationExpression() : -{} -{ - LOOKAHEAD(2) - "new" PrimitiveType() ArrayDimsAndInits() -| - "new" Name() - ( - ArrayDimsAndInits() - | - Arguments() [ ClassBody() ] - ) -} - -/* - * The second LOOKAHEAD specification below is to parse to PrimarySuffix - * if there is an expression between the "[...]". - */ -void ArrayDimsAndInits() : -{} -{ - LOOKAHEAD(2) - ( LOOKAHEAD(2) "[" Expression() "]" )+ ( LOOKAHEAD(2) "[" "]" )* -| - ( "[" "]" )+ ArrayInitializer() -} - - -/* - * Statement syntax follows. - */ - -void Statement() : -{} -{ - LOOKAHEAD(2) - LabeledStatement() -| - Block() -| - EmptyStatement() -| - StatementExpression() ";" -| - SwitchStatement() -| - IfStatement() -| - WhileStatement() -| - DoStatement() -| - ForStatement() -| - BreakStatement() -| - ContinueStatement() -| - ReturnStatement() -| - ThrowStatement() -| - SynchronizedStatement() -| - TryStatement() -} - -void LabeledStatement() : -{} -{ - ":" Statement() -} - -void Block() : -{} -{ - "{" ( BlockStatement() )* "}" -} - -void BlockStatement() : -{} -{ - LOOKAHEAD([ "final" ] Type() ) - LocalVariableDeclaration() ";" -| - "final" TypeDeclaration() -| - Statement() -| - UnmodifiedClassDeclaration() -| -// added this choice point to handle inner interfaces. DW, 7/99 - UnmodifiedInterfaceDeclaration() -} - -void LocalVariableDeclaration() : -{} -{ - [ "final" {jjtThis.setFinal();} ] Type() VariableDeclarator() ( "," VariableDeclarator() )* -} - -void EmptyStatement() : -{} -{ - ";" -} - -void StatementExpression() : -/* - * The last expansion of this production accepts more than the legal - * Java expansions for StatementExpression. This expansion does not - * use PostfixExpression for performance reasons. - */ -{} -{ - PreIncrementExpression() -| - PreDecrementExpression() -| - PrimaryExpression() - [ - "++" - | - "--" - | - AssignmentOperator() Expression() - ] -} - -void SwitchStatement() : -{} -{ - "switch" "(" Expression() ")" "{" - ( SwitchLabel() ( BlockStatement() )* )* - "}" -} - -void SwitchLabel() : -{} -{ - "case" Expression() ":" -| - "default" ":" -} - -void IfStatement() : -/* - * The disambiguating algorithm of JavaCC automatically binds dangling - * else's to the innermost if statement. The LOOKAHEAD specification - * is to tell JavaCC that we know what we are doing. - */ -{ -boolean hasElse = false; -} -{ - "if" "(" Expression() ")" Statement() [ LOOKAHEAD(1) "else" {hasElse = true;} Statement() ] -{ - if (hasElse) { - jjtThis.setHasElse(); - } -} -} - -void WhileStatement() : -{} -{ - "while" "(" Expression() ")" Statement() -} - -void DoStatement() : -{} -{ - "do" Statement() "while" "(" Expression() ")" ";" -} - -void ForStatement() : -{} -{ - "for" "(" [ ForInit() ] ";" [ Expression() ] ";" [ ForUpdate() ] ")" Statement() -} - -void ForInit() : -{} -{ - LOOKAHEAD( [ "final" ] Type() ) - LocalVariableDeclaration() -| - StatementExpressionList() -} - -void StatementExpressionList() : -{} -{ - StatementExpression() ( "," StatementExpression() )* -} - -void ForUpdate() : -{} -{ - StatementExpressionList() -} - -void BreakStatement() : -{} -{ - "break" [ ] ";" -} - -void ContinueStatement() : -{} -{ - "continue" [ ] ";" -} - -void ReturnStatement() : -{} -{ - "return" [ Expression() ] ";" -} - -void ThrowStatement() : -{} -{ - "throw" Expression() ";" -} - -void SynchronizedStatement() : -{} -{ - "synchronized" "(" Expression() ")" Block() -} - -void TryStatement() : -/* - * Semantic check required here to make sure that at least one - * finally/catch is present. - */ -{} -{ - "try" Block() - ( "catch" {jjtThis.setHasCatch();} "(" FormalParameter() ")" Block() )* - [ "finally" {jjtThis.setHasFinally();} Block() ] -}