You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@maven.apache.org by vs...@apache.org on 2007/10/15 23:57:41 UTC
svn commit: r584937 [1/2] - in
/maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr: java.g
javaG.g
Author: vsiveton
Date: Mon Oct 15 14:57:40 2007
New Revision: 584937
URL: http://svn.apache.org/viewvc?rev=584937&view=rev
Log:
o fixed package names due to r574907
Modified:
maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/java.g
maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/javaG.g
Modified: maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/java.g
URL: http://svn.apache.org/viewvc/maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/java.g?rev=584937&r1=584936&r2=584937&view=diff
==============================================================================
--- maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/java.g (original)
+++ maven/sandbox/trunk/jxr/maven-jxr/maven-jxr-java/src/main/antlr/java.g Mon Oct 15 14:57:40 2007
@@ -60,20 +60,20 @@
/* --- Begin Xref additions --- */
-// include an ANTLR "header" so all generated code will be in
-// package org.apache.alexandria.javasrc.xref
+// include an ANTLR "header" so all generated code will be in
+// package org.apache.maven.jxr.java.src.xref
header {
-package org.apache.alexandria.javasrc.xref;
+package org.apache.maven.jxr.java.src.xref;
}
// Import the necessary classes
{
import java.util.Vector;
import java.io.*;
-import org.apache.alexandria.javasrc.symtab.SymbolTable;
-import org.apache.alexandria.javasrc.symtab.JavaVector;
-import org.apache.alexandria.javasrc.symtab.DummyClass;
-import org.apache.alexandria.javasrc.util.*;
+import org.apache.maven.jxr.java.src.symtab.SymbolTable;
+import org.apache.maven.jxr.java.src.symtab.JavaVector;
+import org.apache.maven.jxr.java.src.symtab.DummyClass;
+import org.apache.maven.jxr.java.src.util.*;
}
class JavaXref extends Parser;
@@ -83,17 +83,17 @@
codeGenMakeSwitchThreshold = 2; // Some optimizations
codeGenBitsetTestThreshold = 3;
defaultErrorHandler = false; // Don't generate parser error handlers
- buildAST = true;
+ 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";
+ 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";
}
// Define some methods and variables to use in the generated parser.
@@ -112,28 +112,28 @@
// This method decides what action to take based on the type of
// file we are looking at
public static void doFile(File f, SymbolTable symbolTable,
- boolean doRecurse, FileListener listener)
+ boolean doRecurse, FileListener listener)
throws Exception {
// If this is a directory, walk each file/dir in that directory
if (f.isDirectory()) {
String files[] = f.list();
for(int i=0; i < files.length; i++) {
- File next;
+ File next;
- next = new File(f, files[i]);
- if (doRecurse || !next.isDirectory())
- doFile(next, symbolTable, doRecurse, listener);
- }
+ next = new File(f, files[i]);
+ if (doRecurse || !next.isDirectory())
+ doFile(next, symbolTable, doRecurse, listener);
+ }
}
// otherwise, if this is a java file, parse it!
else if ((f.getName().length()>5) &&
f.getName().substring(f.getName().length()-5).equals(".java")) {
- listener.notify(f.getAbsolutePath());
+ listener.notify(f.getAbsolutePath());
symbolTable.setFile(f);
System.err.println(" "+f.getAbsolutePath());
parseFile(new SkipCRInputStream(new FileInputStream(f)),
- symbolTable);
+ symbolTable);
}
}
@@ -145,10 +145,10 @@
// Create a scanner that reads from the input stream passed to us
JavaLexer lexer = new JavaLexer(s);
- lexer.setSymbolTable(symbolTable);
+ lexer.setSymbolTable(symbolTable);
// Tell the scanner to create tokens of class JavaToken
- lexer.setTokenObjectClass("org.apache.alexandria.javasrc.xref.JavaToken");
+ lexer.setTokenObjectClass("org.apache.maven.jxr.java.src.xref.JavaToken");
// Create a parser that reads from the scanner
JavaXref parser = new JavaXref(lexer);
@@ -161,7 +161,7 @@
}
catch (Exception e) {
System.err.println("parser exception: "+e);
- e.printStackTrace(); // so we can get stack trace
+ e.printStackTrace(); // so we can get stack trace
}
}
@@ -169,7 +169,7 @@
public void setSymbolTable(SymbolTable symbolTable) {
this.symbolTable = symbolTable;
}
-
+
//-------------------------------------------------------------------------
// Symboltable adapter methods
// The following methods are provided to give a single set of entry
@@ -179,7 +179,7 @@
// few have special function.
//-------------------------------------------------------------------------
- public void popScope()
+ public void popScope()
{
// System.out.println("popScope");
//RuntimeException ex = new RuntimeException();
@@ -239,110 +239,110 @@
}
/* --- End Xref additions --- */
-
+
// Compilation Unit: In Java, this is a single file. This is the start
// rule for this parser
compilationUnit
- : // A compilation unit starts with an optional package definition
- ( packageDefinition
- | /* nothing */ {useDefaultPackage();} // XR
- )
-
- // Next we have a series of zero or more import statements
- ( importDefinition )*
-
- // Wrapping things up with any number of class or interface
- // definitions
- ( typeDefinition )*
+ : // A compilation unit starts with an optional package definition
+ ( packageDefinition
+ | /* nothing */ {useDefaultPackage();} // XR
+ )
+
+ // Next we have a series of zero or more import statements
+ ( importDefinition )*
+
+ // Wrapping things up with any number of class or interface
+ // definitions
+ ( typeDefinition )*
- EOF!
+ EOF!
{endFile();} // XR: if a package were defined, pop its scope
- ;
+ ;
// Package statement: "package" followed by an identifier.
packageDefinition
- options {defaultErrorHandler = true;} // let ANTLR handle errors
+ options {defaultErrorHandler = true;} // let ANTLR handle errors
{JavaToken id;} // XR: define an id for the package name
- : p:"package"^ {#p.setType(PACKAGE_DEF);} id=identifier SEMI!
+ : p:"package"^ {#p.setType(PACKAGE_DEF);} id=identifier SEMI!
{definePackage(id);} // tell the symbol table about the package
- ;
+ ;
// Import statement: import followed by a package or class name
importDefinition
- options {defaultErrorHandler = true;}
- : i:"import"^ {#i.setType(IMPORT);} identifierStar SEMI!
- ;
+ options {defaultErrorHandler = true;}
+ : i:"import"^ {#i.setType(IMPORT);} identifierStar SEMI!
+ ;
// A type definition in a file is either a class or interface definition.
typeDefinition
- options {defaultErrorHandler = true;}
- : m:modifiers!
- ( classDefinition[#m]
- | interfaceDefinition[#m]
- )
- | SEMI!
- ;
+ options {defaultErrorHandler = true;}
+ : m:modifiers!
+ ( classDefinition[#m]
+ | interfaceDefinition[#m]
+ )
+ | SEMI!
+ ;
/** A declaration is the creation of a reference or primitive-type variable
* Create a separate Type/Var tree for each var in the var list.
*/
declaration!
{JavaToken type;}
- : m:modifiers type=t:typeSpec[false] v:variableDefinitions[#m,#t,type]
- {#declaration = #v;}
- ;
+ : m:modifiers type=t:typeSpec[false] v:variableDefinitions[#m,#t,type]
+ {#declaration = #v;}
+ ;
// A list of zero or more modifiers. We could have used (modifier)* in
// place of a call to modifiers, but I thought it was a good idea to keep
// this rule separate so they can easily be collected in a Vector if
// someone so desires
modifiers
- : ( modifier )*
- {#modifiers = #([MODIFIERS, "MODIFIERS"], #modifiers);}
- ;
+ : ( modifier )*
+ {#modifiers = #([MODIFIERS, "MODIFIERS"], #modifiers);}
+ ;
// A type specification is a type name with possible brackets afterwards
// (which would make it an array type).
typeSpec[boolean addImagNode] returns [JavaToken t]
{t=null;}
- : t=classTypeSpec[addImagNode]
- | t=builtInTypeSpec[addImagNode]
- ;
+ : t=classTypeSpec[addImagNode]
+ | t=builtInTypeSpec[addImagNode]
+ ;
// A class type specification is a class type with possible brackets afterwards
// (which would make it an array type).
classTypeSpec[boolean addImagNode] returns [JavaToken t]
{t=null;}
- : t=identifier (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
- {
- if ( addImagNode ) {
- #classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec);
- }
- }
- ;
+ : t=identifier (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+ {
+ if ( addImagNode ) {
+ #classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec);
+ }
+ }
+ ;
// A builtin type specification is a builtin type with possible brackets
// afterwards (which would make it an array type).
builtInTypeSpec[boolean addImagNode] returns [JavaToken t]
{t=null;}
- : t=builtInType (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
- {
- if ( addImagNode ) {
- #builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec);
- }
- }
- ;
+ : 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 [JavaToken t]
{t=null;}
- : t=identifier
- | t=builtInType
- ;
+ : t=identifier
+ | t=builtInType
+ ;
// The primitive types.
builtInType returns [JavaToken t]
@@ -362,15 +362,15 @@
// and expand its name by adding dots and following IDENTS
identifier returns [JavaToken t]
{t=null;}
- : id1:IDENT {t=(JavaToken)id1;}
- ( DOT^
+ : id1:IDENT {t=(JavaToken)id1;}
+ ( DOT^
id2:IDENT
{
t.setText(t.getText() + "." + id2.getText());
- t.setColumn(id2.getColumn());
+ t.setColumn(id2.getColumn());
}
)*
- ;
+ ;
// XR
// This is the special identifer rule used by package statements. We will
@@ -393,10 +393,10 @@
// the import statement
identifierStar
{String className=""; String packageName="";}
- : id:IDENT {className=id.getText();}
- ( DOT^ id2:IDENT
+ : id:IDENT {className=id.getText();}
+ ( DOT^ id2:IDENT
{packageName += "."+className; className = id2.getText();} )*
- ( DOT^ STAR {packageName += "."+className; className = null;} )?
+ ( DOT^ STAR {packageName += "."+className; className = null;} )?
{
// put the overall name in the token's text
@@ -410,285 +410,285 @@
// tell the symbol table about the import
addImport((JavaToken)id, className, packageName);
}
- ;
+ ;
// modifiers for Java classes, interfaces, class/instance vars and methods
modifier
- : "private"
- | "public"
- | "protected"
- | "static"
- | "transient"
- | "final"
- | "abstract"
- | "native"
- | "threadsafe"
- | "synchronized"
+ : "private"
+ | "public"
+ | "protected"
+ | "static"
+ | "transient"
+ | "final"
+ | "abstract"
+ | "native"
+ | "threadsafe"
+ | "synchronized"
// | "const" // reserved word; leave out
- | "volatile"
- ;
+ | "volatile"
+ ;
// Definition of a Java class
classDefinition![AST modifiers]
{JavaToken superClass=null; JavaVector interfaces=null;}
- : "class" id:IDENT
- // it _might_ have a superclass...
- superClass=sc:superClassClause
- // it might implement some interfaces...
- interfaces=ic:implementsClause
+ : "class" id:IDENT
+ // it _might_ have a superclass...
+ superClass=sc:superClassClause
+ // it might implement some interfaces...
+ interfaces=ic:implementsClause
// tell the symbol table about it
// Note that defineClass pushes the class' scope,
// so we'll have to pop...
{defineClass((JavaToken)id, superClass, interfaces);}
- // now parse the body of the class
- cb:classBlock
- //{#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"],
- // modifiers,IDENT,sc,ic,cb);}
+ // now parse the body of the class
+ cb:classBlock
+ //{#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"],
+ // modifiers,IDENT,sc,ic,cb);}
// tell the symbol table that we are exiting a scope
{popScope();}
- ;
+ ;
superClassClause! returns [JavaToken t]
{t=null;}
- : ( "extends" t=id:identifier )?
- {#superClassClause = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],id);}
- ;
+ : ( "extends" t=id:identifier )?
+ {#superClassClause = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],id);}
+ ;
// Definition of a Java Interface
interfaceDefinition![AST modifiers]
{JavaVector superInterfaces = null;}
- : "interface" id:IDENT // aha! an interface!
- // it might extend some other interfaces
- superInterfaces=ie:interfaceExtends
+ : "interface" id:IDENT // aha! an interface!
+ // it might extend some other interfaces
+ superInterfaces=ie:interfaceExtends
// tell the symbol table about it!
// Note that defineInterface pushes the interface scope, so
// we'll have to pop it...
{defineInterface((JavaToken)id, superInterfaces);}
- // now parse the body of the interface (looks like a class...)
- cb:classBlock
+ // now parse the body of the interface (looks like a class...)
+ cb:classBlock
- //{#interfaceDefinition = #(#[INTERFACE_DEF,"INTERFACE_DEF"],
- // modifiers,IDENT,ie,cb);}
+ //{#interfaceDefinition = #(#[INTERFACE_DEF,"INTERFACE_DEF"],
+ // modifiers,IDENT,ie,cb);}
// tell the symboltable that we are done in that scope
{popScope();}
- ;
+ ;
// This is the body of a class. You can have fields and extra semicolons,
// That's about it (until you see what a field is...)
classBlock
- : LCURLY!
- ( field | SEMI! )*
- RCURLY!
- {#classBlock = #([OBJBLOCK, "OBJBLOCK"], #classBlock);}
- ;
+ : LCURLY!
+ ( field | SEMI! )*
+ RCURLY!
+ {#classBlock = #([OBJBLOCK, "OBJBLOCK"], #classBlock);}
+ ;
// An interface can extend several other interfaces...
interfaceExtends returns [JavaVector supers]
{JavaToken id; supers = new JavaVector();}
- : (
- e:"extends"! id=identifier {supers.addElement(dummyClass(id));}
+ : (
+ e:"extends"! id=identifier {supers.addElement(dummyClass(id));}
( COMMA! id=identifier {supers.addElement(dummyClass(id));} )*
- )?
- {#interfaceExtends = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],
- #interfaceExtends);}
- ;
+ )?
+ {#interfaceExtends = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],
+ #interfaceExtends);}
+ ;
// A class can implement several interfaces...
implementsClause returns [JavaVector inters]
{inters = new JavaVector(); JavaToken id;}
- : (
- i:"implements"! id=identifier {inters.addElement(dummyClass(id));}
+ : (
+ i:"implements"! id=identifier {inters.addElement(dummyClass(id));}
( COMMA! id=identifier {inters.addElement(dummyClass(id));} )*
- )?
- {#implementsClause = #(#[IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE"],
- #implementsClause);}
- ;
+ )?
+ {#implementsClause = #(#[IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE"],
+ #implementsClause);}
+ ;
// Now the various things that can be defined inside a class or interface...
// Note that not all of these are really valid in an interface (constructors,
// for example), and if this grammar were used for a compiler there would
// need to be some semantic checks to make sure we're doing the right thing...
field!
- {JavaToken type; JavaVector exceptions=null;}
- : // method, constructor, or variable declaration
- mods:modifiers
- ( h:ctorHead s:compoundStatement[BODY] // constructor
- {#field = #(#[CTOR_DEF,"CTOR_DEF"], mods, h, s);}
-
- | cd:classDefinition[#mods] // inner class
- {#field = #cd;}
-
- | id:interfaceDefinition[#mods] // inner interface
- {#field = #id;}
+ {JavaToken type; JavaVector exceptions=null;}
+ : // method, constructor, or variable declaration
+ mods:modifiers
+ ( h:ctorHead s:compoundStatement[BODY] // constructor
+ {#field = #(#[CTOR_DEF,"CTOR_DEF"], mods, h, s);}
+
+ | cd:classDefinition[#mods] // inner class
+ {#field = #cd;}
- | type=t:typeSpec[false] // method or variable declaration(s)
- ( method:IDENT // the name of the method
+ | id:interfaceDefinition[#mods] // inner interface
+ {#field = #id;}
- // tell the symbol table about it. Note that this signals that
+ | type=t:typeSpec[false] // method or variable declaration(s)
+ ( method:IDENT // the name of the method
+
+ // tell the symbol table about it. Note that this signals that
// we are in a method header so we handle parameters appropriately
{defineMethod((JavaToken)method, type);}
- // parse the formal parameter declarations.
- LPAREN! param:parameterDeclarationList RPAREN!
+ // parse the formal parameter declarations.
+ LPAREN! param:parameterDeclarationList RPAREN!
- rt:returnTypeBrackersOnEndOfMethodHead[#t]
+ rt:returnTypeBrackersOnEndOfMethodHead[#t]
- // get the list of exceptions that this method is declared to throw
- (exceptions=tc:throwsClause)?
+ // get the list of exceptions that this method is declared to throw
+ (exceptions=tc:throwsClause)?
// tell the symbol table we are done with the method header. Note that
// this will tell the symbol table to handle variables normally
{endMethodHead(exceptions);}
-
- ( s2:compoundStatement[BODY] | SEMI {popScope();})
+
+ ( s2:compoundStatement[BODY] | SEMI {popScope();})
/*
- {#field = #(#[METHOD_DEF,"METHOD_DEF"],
- mods,
- #(#[TYPE,"TYPE"],rt),
- IDENT,
- param,
- tc,
- s2);}
+ {#field = #(#[METHOD_DEF,"METHOD_DEF"],
+ mods,
+ #(#[TYPE,"TYPE"],rt),
+ IDENT,
+ param,
+ tc,
+ s2);}
*/
- | v:variableDefinitions[#mods,#t,type] SEMI
+ | v:variableDefinitions[#mods,#t,type] SEMI
// {#field = #(#[VARIABLE_DEF,"VARIABLE_DEF"], v);}
- {#field = #v;}
- )
- )
+ {#field = #v;}
+ )
+ )
// "static { ... }" class initializer
- | "static" s3:compoundStatement[CLASS_INIT]
- {#field = #(#[STATIC_INIT,"STATIC_INIT"], s3);}
+ | "static" s3:compoundStatement[CLASS_INIT]
+ {#field = #(#[STATIC_INIT,"STATIC_INIT"], s3);}
// "{ ... }" instance initializer
- | s4:compoundStatement[INSTANCE_INIT]
- {#field = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4);}
- ;
+ | s4:compoundStatement[INSTANCE_INIT]
+ {#field = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4);}
+ ;
variableDefinitions[AST mods, AST t, JavaToken type]
- : variableDeclarator[getASTFactory().dupTree(mods),
- getASTFactory().dupTree(t),
+ : variableDeclarator[getASTFactory().dupTree(mods),
+ getASTFactory().dupTree(t),
type]
- ( COMMA!
- variableDeclarator[getASTFactory().dupTree(mods),
- getASTFactory().dupTree(t),
+ ( COMMA!
+ variableDeclarator[getASTFactory().dupTree(mods),
+ getASTFactory().dupTree(t),
type]
- )*
- ;
+ )*
+ ;
/** Declaration of a variable. This can be a class/instance variable,
* or a local variable in a method
* It can also include possible initialization.
*/
variableDeclarator![AST mods, AST t, JavaToken type]
- : id:IDENT d:declaratorBrackets[t] v:varInitializer
+ : id:IDENT d:declaratorBrackets[t] v:varInitializer
{defineVar((JavaToken)id, type);}
- {#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v);}
- ;
+ {#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v);}
+ ;
declaratorBrackets[AST typ]
- : {#declaratorBrackets=typ;}
- (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
- ;
+ : {#declaratorBrackets=typ;}
+ (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+ ;
varInitializer
- : ( ASSIGN^ initializer )?
- ;
+ : ( ASSIGN^ initializer )?
+ ;
// This is an initializer used to set up an array.
arrayInitializer
- : lc:LCURLY^ {#lc.setType(ARRAY_INIT);}
- ( initializer
- (
- // CONFLICT: does a COMMA after an initializer start a new
- // initializer or start the option ',' at end?
- // ANTLR generates proper code by matching
- // the comma as soon as possible.
- options {
- warnWhenFollowAmbig = false;
- }
- :
- COMMA! initializer
- )*
- (COMMA!)?
- )?
- RCURLY!
- ;
+ : lc:LCURLY^ {#lc.setType(ARRAY_INIT);}
+ ( initializer
+ (
+ // CONFLICT: does a COMMA after an initializer start a new
+ // initializer or start the option ',' at end?
+ // ANTLR generates proper code by matching
+ // the comma as soon as possible.
+ options {
+ warnWhenFollowAmbig = false;
+ }
+ :
+ COMMA! initializer
+ )*
+ (COMMA!)?
+ )?
+ RCURLY!
+ ;
// The two "things" that can initialize an array element are an expression
// and another (nested) array initializer.
initializer
- : expression
- | arrayInitializer
- ;
+ : expression
+ | arrayInitializer
+ ;
// This is the header of a method. It includes the name and parameters
// for the method.
// This also watches for a list of exception classes in a "throws" clause.
ctorHead
{JavaToken id; JavaVector exceptions = null;}
- : method:IDENT // the name of the method
+ : method:IDENT // the name of the method
{defineMethod((JavaToken)method, null);}
- // parse the formal parameter declarations.
- LPAREN! parameterDeclarationList RPAREN!
+ // parse the formal parameter declarations.
+ LPAREN! parameterDeclarationList RPAREN!
- // get the list of exceptions that this method is declared to throw
- (exceptions=throwsClause)?
+ // get the list of exceptions that this method is declared to throw
+ (exceptions=throwsClause)?
- { endMethodHead(exceptions); }
- ;
+ { endMethodHead(exceptions); }
+ ;
// This is a list of exception classes that the method is declared to throw
throwsClause returns [JavaVector exceptions]
{JavaToken id; exceptions = new JavaVector();}
- : "throws"^ id=identifier {exceptions.addElement(dummyClass(id));}
+ : "throws"^ id=identifier {exceptions.addElement(dummyClass(id));}
( COMMA! id=identifier {exceptions.addElement(dummyClass(id));} )*
- ;
+ ;
returnTypeBrackersOnEndOfMethodHead[AST typ]
- : {#returnTypeBrackersOnEndOfMethodHead = typ;}
- (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
- ;
+ : {#returnTypeBrackersOnEndOfMethodHead = typ;}
+ (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+ ;
// A list of formal parameters
parameterDeclarationList
- : ( parameterDeclaration ( COMMA! parameterDeclaration )* )?
- {#parameterDeclarationList = #(#[PARAMETERS,"PARAMETERS"],
- #parameterDeclarationList);}
- ;
+ : ( parameterDeclaration ( COMMA! parameterDeclaration )* )?
+ {#parameterDeclarationList = #(#[PARAMETERS,"PARAMETERS"],
+ #parameterDeclarationList);}
+ ;
// A formal parameter.
parameterDeclaration!
{JavaToken type;}
- : pm:parameterModifier type=t:typeSpec[false] id:IDENT
- pd:parameterDeclaratorBrackets[#t]
- {#parameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"],
- pm, #([TYPE,"TYPE"],pd), id);}
+ : pm:parameterModifier type=t:typeSpec[false] id:IDENT
+ pd:parameterDeclaratorBrackets[#t]
+ {#parameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"],
+ pm, #([TYPE,"TYPE"],pd), id);}
{defineVar((JavaToken)id, type);}
- ;
+ ;
parameterDeclaratorBrackets[AST t]
- : {#parameterDeclaratorBrackets = t;}
- (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
- ;
+ : {#parameterDeclaratorBrackets = t;}
+ (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+ ;
parameterModifier
- : (f:"final")?
- {#parameterModifier = #(#[MODIFIERS,"MODIFIERS"], f);}
- ;
+ : (f:"final")?
+ {#parameterModifier = #(#[MODIFIERS,"MODIFIERS"], f);}
+ ;
// Compound statement. This is used in many contexts:
// Inside a class definition prefixed with "static":
@@ -701,7 +701,7 @@
// with NEW_SCOPE as its scopeType
compoundStatement[int scopeType]
- : lc:LCURLY^ {#lc.setType(SLIST);}
+ : lc:LCURLY^ {#lc.setType(SLIST);}
{ // based on the scopeType we are processing
switch(scopeType) {
// if it's a new block, tell the symbol table
@@ -725,158 +725,158 @@
// otherwise, it's a body, so do nothing special
}
}
-
- // include the (possibly-empty) list of statements
- (statement)*
-
+
+ // include the (possibly-empty) list of statements
+ (statement)*
+
// tell the symbol table we're leaving a scope
{popScope();}
- RCURLY!
- ;
+ RCURLY!
+ ;
statement
{int count = -1;} // used for parameter counts in method calls
- // A list of statements in curly braces -- start a new scope!
- : compoundStatement[NEW_SCOPE]
+ // A list of statements in curly braces -- start a new scope!
+ : compoundStatement[NEW_SCOPE]
- // class definition
- | classDefinition[#[MODIFIERS, "MODIFIERS"]]
+ // class definition
+ | classDefinition[#[MODIFIERS, "MODIFIERS"]]
- // final class definition
- | "final"! classDefinition[#(#[MODIFIERS, "MODIFIERS"],#[FINAL,"final"])]
+ // final class definition
+ | "final"! classDefinition[#(#[MODIFIERS, "MODIFIERS"],#[FINAL,"final"])]
- // abstract class definition
- | "abstract"! classDefinition[#(#[MODIFIERS, "MODIFIERS"],#[ABSTRACT,"abstract"])]
-
- // declarations are ambiguous with "ID DOT" relative to expression
- // statements. Must backtrack to be sure. Could use a semantic
- // predicate to test symbol table to see what the type was coming
- // up, but that's pretty hard without a symbol table ;)
- | (declaration)=> declaration SEMI!
-
- // An expression statement. This could be a method call,
- // assignment statement, or any other expression evaluated for
- // side-effects.
- | expression SEMI!
-
- // Attach a label to the front of a statement
- | id:IDENT c:COLON^ {#c.setType(LABELED_STAT);} statement {defineLabel((JavaToken)id);}
-
- // If-else statement
- | "if"^ LPAREN! expression RPAREN! statement
- (
- // CONFLICT: the old "dangling-else" problem...
- // ANTLR generates proper code matching
- // as soon as possible. Hush warning.
- options {
- warnWhenFollowAmbig = false;
- }
- :
- "else"! statement
- )?
-
- // For statement
- | "for"^
- LPAREN!
- forInit SEMI! // initializer
- forCond SEMI! // condition test
- forIter // updater
- RPAREN!
- statement // statement to loop over
-
- // While statement
- | "while"^ LPAREN! expression RPAREN! statement
-
- // do-while statement
- | "do"^ statement "while"! LPAREN! expression RPAREN! SEMI!
-
- // get out of a loop (or switch)
- | "break"^ (bid:IDENT {reference((JavaToken)bid);})? SEMI!
-
- // do next iteration of a loop
- | "continue"^ (cid:IDENT {reference((JavaToken)cid);})? SEMI!
-
- // Return an expression
- | "return"^ (expression)? SEMI!
-
- // switch/case statement
- | "switch"^ LPAREN! expression RPAREN! LCURLY!
- ( casesGroup )*
- RCURLY!
-
- // exception try-catch block
- | tryBlock
-
- // throw an exception
- | "throw"^ expression SEMI!
-
- // synchronize a statement
- | "synchronized"^ LPAREN! expression RPAREN! compoundStatement[NEW_SCOPE]
-
- // empty statement
- | s:SEMI {#s.setType(EMPTY_STAT);}
- ;
+ // abstract class definition
+ | "abstract"! classDefinition[#(#[MODIFIERS, "MODIFIERS"],#[ABSTRACT,"abstract"])]
+
+ // declarations are ambiguous with "ID DOT" relative to expression
+ // statements. Must backtrack to be sure. Could use a semantic
+ // predicate to test symbol table to see what the type was coming
+ // up, but that's pretty hard without a symbol table ;)
+ | (declaration)=> declaration SEMI!
+
+ // An expression statement. This could be a method call,
+ // assignment statement, or any other expression evaluated for
+ // side-effects.
+ | expression SEMI!
+
+ // Attach a label to the front of a statement
+ | id:IDENT c:COLON^ {#c.setType(LABELED_STAT);} statement {defineLabel((JavaToken)id);}
+
+ // If-else statement
+ | "if"^ LPAREN! expression RPAREN! statement
+ (
+ // CONFLICT: the old "dangling-else" problem...
+ // ANTLR generates proper code matching
+ // as soon as possible. Hush warning.
+ options {
+ warnWhenFollowAmbig = false;
+ }
+ :
+ "else"! statement
+ )?
+
+ // For statement
+ | "for"^
+ LPAREN!
+ forInit SEMI! // initializer
+ forCond SEMI! // condition test
+ forIter // updater
+ RPAREN!
+ statement // statement to loop over
+
+ // While statement
+ | "while"^ LPAREN! expression RPAREN! statement
+
+ // do-while statement
+ | "do"^ statement "while"! LPAREN! expression RPAREN! SEMI!
+
+ // get out of a loop (or switch)
+ | "break"^ (bid:IDENT {reference((JavaToken)bid);})? SEMI!
+
+ // do next iteration of a loop
+ | "continue"^ (cid:IDENT {reference((JavaToken)cid);})? SEMI!
+
+ // Return an expression
+ | "return"^ (expression)? SEMI!
+
+ // switch/case statement
+ | "switch"^ LPAREN! expression RPAREN! LCURLY!
+ ( casesGroup )*
+ RCURLY!
+
+ // exception try-catch block
+ | tryBlock
+
+ // throw an exception
+ | "throw"^ expression SEMI!
+
+ // synchronize a statement
+ | "synchronized"^ LPAREN! expression RPAREN! compoundStatement[NEW_SCOPE]
+
+ // empty statement
+ | s:SEMI {#s.setType(EMPTY_STAT);}
+ ;
casesGroup
- : ( // CONFLICT: to which case group do the statements bind?
- // ANTLR generates proper code: it groups the
- // many "case"/"default" labels together then
- // follows them with the statements
- options {
- warnWhenFollowAmbig = false;
- }
- :
- aCase
- )+
- caseSList
- {#casesGroup = #([CASE_GROUP, "CASE_GROUP"], #casesGroup);}
- ;
+ : ( // CONFLICT: to which case group do the statements bind?
+ // ANTLR generates proper code: it groups the
+ // many "case"/"default" labels together then
+ // follows them with the statements
+ options {
+ warnWhenFollowAmbig = false;
+ }
+ :
+ aCase
+ )+
+ caseSList
+ {#casesGroup = #([CASE_GROUP, "CASE_GROUP"], #casesGroup);}
+ ;
aCase
- : ("case"^ expression | "default") COLON!
- ;
+ : ("case"^ expression | "default") COLON!
+ ;
caseSList
- : (statement)*
- {#caseSList = #(#[SLIST,"SLIST"],#caseSList);}
- ;
+ : (statement)*
+ {#caseSList = #(#[SLIST,"SLIST"],#caseSList);}
+ ;
// The initializer for a for loop
forInit
{int count = -1;}
- // if it looks like a declaration, it is
- : ( (declaration)=> declaration
- // otherwise it could be an expression list...
- | count=expressionList
- )?
- {#forInit = #(#[FOR_INIT,"FOR_INIT"],#forInit);}
- ;
+ // if it looks like a declaration, it is
+ : ( (declaration)=> declaration
+ // otherwise it could be an expression list...
+ | count=expressionList
+ )?
+ {#forInit = #(#[FOR_INIT,"FOR_INIT"],#forInit);}
+ ;
forCond
- : (expression)?
- {#forCond = #(#[FOR_CONDITION,"FOR_CONDITION"],#forCond);}
- ;
+ : (expression)?
+ {#forCond = #(#[FOR_CONDITION,"FOR_CONDITION"],#forCond);}
+ ;
forIter
- : (expressionList)?
- {#forIter = #(#[FOR_ITERATOR,"FOR_ITERATOR"],#forIter);}
- ;
+ : (expressionList)?
+ {#forIter = #(#[FOR_ITERATOR,"FOR_ITERATOR"],#forIter);}
+ ;
// an exception handler try/catch block
tryBlock
- : "try"^ compoundStatement[NEW_SCOPE]
- (handler)*
- ( "finally"^ compoundStatement[NEW_SCOPE] )?
- ;
+ : "try"^ compoundStatement[NEW_SCOPE]
+ (handler)*
+ ( "finally"^ compoundStatement[NEW_SCOPE] )?
+ ;
// an exception handler
handler
- : "catch"^ LPAREN! parameterDeclaration RPAREN! compoundStatement[NEW_SCOPE]
- ;
+ : "catch"^ LPAREN! parameterDeclaration RPAREN! compoundStatement[NEW_SCOPE]
+ ;
// expressions
@@ -906,7 +906,7 @@
// to point out that new has a higher precedence than '.', so you
// can validy use
// new Frame().show()
-//
+//
// Note that the above precedence levels map to the rules below...
// Once you have a precedence chart, writing the appropriate rules as below
// is usually very straightfoward
@@ -915,23 +915,23 @@
// the mother of all expressions
expression
- : assignmentExpression
- {#expression = #(#[EXPR,"EXPR"],#expression);}
- ;
+ : assignmentExpression
+ {#expression = #(#[EXPR,"EXPR"],#expression);}
+ ;
// This is a list of expressions.
expressionList returns [int count]
{count=1;}
- : expression (COMMA! expression {count++;})*
- {#expressionList = #(#[ELIST,"ELIST"], expressionList);}
- ;
+ : expression (COMMA! expression {count++;})*
+ {#expressionList = #(#[ELIST,"ELIST"], expressionList);}
+ ;
// assignment expression (level 13)
assignmentExpression
- : conditionalExpression
- ( ( ASSIGN^
+ : conditionalExpression
+ ( ( ASSIGN^
| PLUS_ASSIGN^
| MINUS_ASSIGN^
| STAR_ASSIGN^
@@ -944,219 +944,219 @@
| BXOR_ASSIGN^
| BOR_ASSIGN^
)
- assignmentExpression
- )?
- ;
+ assignmentExpression
+ )?
+ ;
// conditional test (level 12)
conditionalExpression
- : logicalOrExpression
- ( QUESTION^ assignmentExpression COLON! conditionalExpression )?
- ;
+ : logicalOrExpression
+ ( QUESTION^ assignmentExpression COLON! conditionalExpression )?
+ ;
// logical or (||) (level 11)
logicalOrExpression
- : logicalAndExpression (LOR^ logicalAndExpression)*
- ;
+ : logicalAndExpression (LOR^ logicalAndExpression)*
+ ;
// logical and (&&) (level 10)
logicalAndExpression
- : inclusiveOrExpression (LAND^ inclusiveOrExpression)*
- ;
+ : inclusiveOrExpression (LAND^ inclusiveOrExpression)*
+ ;
// bitwise or non-short-circuiting or (|) (level 9)
inclusiveOrExpression
- : exclusiveOrExpression (BOR^ exclusiveOrExpression)*
- ;
+ : exclusiveOrExpression (BOR^ exclusiveOrExpression)*
+ ;
// exclusive or (^) (level 8)
exclusiveOrExpression
- : andExpression (BXOR^ andExpression)*
- ;
+ : andExpression (BXOR^ andExpression)*
+ ;
// bitwise or non-short-circuiting and (&) (level 7)
andExpression
- : equalityExpression (BAND^ equalityExpression)*
- ;
+ : equalityExpression (BAND^ equalityExpression)*
+ ;
// equality/inequality (==/!=) (level 6)
equalityExpression
- : relationalExpression ((NOT_EQUAL^ | EQUAL^) relationalExpression)*
- ;
+ : relationalExpression ((NOT_EQUAL^ | EQUAL^) relationalExpression)*
+ ;
// boolean relational expressions (level 5)
relationalExpression
- : shiftExpression
- ( ( ( LT^
- | GT^
- | LE^
- | GE^
- )
- shiftExpression
- )*
- | "instanceof"^ typeSpec[true]
- )
- ;
+ : shiftExpression
+ ( ( ( LT^
+ | GT^
+ | LE^
+ | GE^
+ )
+ shiftExpression
+ )*
+ | "instanceof"^ typeSpec[true]
+ )
+ ;
// bit shift expressions (level 4)
shiftExpression
- : additiveExpression ((SL^ | SR^ | BSR^) additiveExpression)*
- ;
+ : additiveExpression ((SL^ | SR^ | BSR^) additiveExpression)*
+ ;
// binary addition/subtraction (level 3)
additiveExpression
- : multiplicativeExpression ((PLUS^ | MINUS^) multiplicativeExpression)*
- ;
+ : multiplicativeExpression ((PLUS^ | MINUS^) multiplicativeExpression)*
+ ;
// multiplication/division/modulo (level 2)
multiplicativeExpression
- : unaryExpression ((STAR^ | DIV^ | MOD^ ) unaryExpression)*
- ;
+ : unaryExpression ((STAR^ | DIV^ | MOD^ ) unaryExpression)*
+ ;
unaryExpression
- : INC^ unaryExpression
- | DEC^ unaryExpression
- | MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression
- | PLUS^ {#PLUS.setType(UNARY_PLUS);} unaryExpression
- | unaryExpressionNotPlusMinus
- ;
+ : INC^ unaryExpression
+ | DEC^ unaryExpression
+ | MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression
+ | PLUS^ {#PLUS.setType(UNARY_PLUS);} unaryExpression
+ | unaryExpressionNotPlusMinus
+ ;
unaryExpressionNotPlusMinus
{ JavaToken t; }
- : BNOT^ unaryExpression
- | LNOT^ unaryExpression
+ : BNOT^ unaryExpression
+ | LNOT^ unaryExpression
- | ( // subrule allows option to shut off warnings
- options {
- // "(int" ambig with postfixExpr due to lack of sequence
- // info in linear approximate LL(k). It's ok. Shut up.
- generateAmbigWarnings=false;
- }
- : // If typecast is built in type, must be numeric operand
- // Also, no reason to backtrack if type keyword like int, float...
- lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN!
- unaryExpression
-
- // Have to backtrack to see if operator follows. If no operator
- // follows, it's a typecast. No semantic checking needed to parse.
- // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
- | (LPAREN classTypeSpec[true] RPAREN unaryExpressionNotPlusMinus)=>
- lp:LPAREN^ {#lp.setType(TYPECAST);} t=classTypeSpec[true] RPAREN!
- unaryExpressionNotPlusMinus
+ | ( // subrule allows option to shut off warnings
+ options {
+ // "(int" ambig with postfixExpr due to lack of sequence
+ // info in linear approximate LL(k). It's ok. Shut up.
+ generateAmbigWarnings=false;
+ }
+ : // If typecast is built in type, must be numeric operand
+ // Also, no reason to backtrack if type keyword like int, float...
+ lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN!
+ unaryExpression
+
+ // Have to backtrack to see if operator follows. If no operator
+ // follows, it's a typecast. No semantic checking needed to parse.
+ // if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
+ | (LPAREN classTypeSpec[true] RPAREN unaryExpressionNotPlusMinus)=>
+ lp:LPAREN^ {#lp.setType(TYPECAST);} t=classTypeSpec[true] RPAREN!
+ unaryExpressionNotPlusMinus
{ reference(t); }
- | postfixExpression
- )
- ;
+ | postfixExpression
+ )
+ ;
// qualified names, array expressions, method invocation, post inc/dec
postfixExpression
{JavaToken t; JavaToken temp; int count=-1; }
- : t=primaryExpression // start with a primary
+ : t=primaryExpression // start with a primary
- ( // qualified id (id.id.id.id...) -- build the name
- DOT^ ( id:IDENT {if (t!=null)
- {
- temp = new JavaToken(t);
- reference(temp);
- t.setText(t.getText()+"."+id.getText());
- t.setColumn(id.getColumn());
- }
+ ( // qualified id (id.id.id.id...) -- build the name
+ DOT^ ( id:IDENT {if (t!=null)
+ {
+ temp = new JavaToken(t);
+ reference(temp);
+ t.setText(t.getText()+"."+id.getText());
+ t.setColumn(id.getColumn());
+ }
}
- | "this"
- | "class"
- | newExpression
- | "super" LPAREN ( expressionList )? RPAREN
- )
- // the above line needs a semantic check to make sure "class"
- // is the _last_ qualifier.
-
- // allow ClassName[].class
- | ( lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK! )+
- DOT^ "class"
-
- // an array indexing operation
- | lb:LBRACK^ {#lb.setType(INDEX_OP);} expression RBRACK!
-
- // method invocation
- // The next line is not strictly proper; it allows x(3)(4) or
- // x[2](4) which are not valid in Java. If this grammar were used
- // to validate a Java program a semantic check would be needed, or
- // this rule would get really ugly...
- | lp:LPAREN^ {#lp.setType(METHOD_CALL);}
- count=argList
- RPAREN!
+ | "this"
+ | "class"
+ | newExpression
+ | "super" LPAREN ( expressionList )? RPAREN
+ )
+ // the above line needs a semantic check to make sure "class"
+ // is the _last_ qualifier.
+
+ // allow ClassName[].class
+ | ( lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK! )+
+ DOT^ "class"
+
+ // an array indexing operation
+ | lb:LBRACK^ {#lb.setType(INDEX_OP);} expression RBRACK!
+
+ // method invocation
+ // The next line is not strictly proper; it allows x(3)(4) or
+ // x[2](4) which are not valid in Java. If this grammar were used
+ // to validate a Java program a semantic check would be needed, or
+ // this rule would get really ugly...
+ | lp:LPAREN^ {#lp.setType(METHOD_CALL);}
+ count=argList
+ RPAREN!
{
if (t!=null)
- {
+ {
t.setParamCount(count);
- }
- }
- )*
+ }
+ }
+ )*
// if we have a reference, tell the symbol table
- {
+ {
if (t != null)
- {
+ {
reference(t);
}
- }
+ }
- // possibly add on a post-increment or post-decrement.
- // allows INC/DEC on too much, but semantics can check
- ( in:INC^ {#in.setType(POST_INC);}
- | de:DEC^ {#de.setType(POST_DEC);}
- | // nothing
- )
-
- // look for int.class and int[].class
- | builtInType
- ( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )*
- DOT^ "class"
- ;
+ // possibly add on a post-increment or post-decrement.
+ // allows INC/DEC on too much, but semantics can check
+ ( in:INC^ {#in.setType(POST_INC);}
+ | de:DEC^ {#de.setType(POST_DEC);}
+ | // nothing
+ )
+
+ // look for int.class and int[].class
+ | builtInType
+ ( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )*
+ DOT^ "class"
+ ;
// the basic element of an expression
primaryExpression returns [JavaToken t]
{t=null;}
- : id:IDENT {t = (JavaToken)id;}
- | t=newExpression
- | constant
- | s:"super" {t = (JavaToken)s;}
- | "true"
- | "false"
- | th:"this" {t = (JavaToken)th; setNearestClassScope();}
- | "null"
- | LPAREN! assignmentExpression RPAREN!
- ;
+ : id:IDENT {t = (JavaToken)id;}
+ | t=newExpression
+ | constant
+ | s:"super" {t = (JavaToken)s;}
+ | "true"
+ | "false"
+ | th:"this" {t = (JavaToken)th; setNearestClassScope();}
+ | "null"
+ | LPAREN! assignmentExpression RPAREN!
+ ;
/** object instantiation.
* Trees are built as illustrated by the following input/tree pairs:
- *
+ *
* new T()
- *
+ *
* new
* |
* T -- ELIST
* |
* arg1 -- arg2 -- .. -- argn
- *
+ *
* new int[]
*
* new
* |
* int -- ARRAY_DECLARATOR
- *
+ *
* new int[] {1,2}
*
* new
@@ -1166,7 +1166,7 @@
* EXPR -- EXPR
* | |
* 1 2
- *
+ *
* new int[3]
* new
* |
@@ -1175,9 +1175,9 @@
* EXPR
* |
* 3
- *
+ *
* new int[1][2]
- *
+ *
* new
* |
* int -- ARRAY_DECLARATOR
@@ -1187,12 +1187,12 @@
* EXPR 1
* |
* 2
- *
+ *
*/
newExpression returns [JavaToken t]
{t=null; int count=-1;}
- : "new"^ t=type
- ( LPAREN! count=argList
+ : "new"^ t=type
+ ( LPAREN! count=argList
{
// t.setText(t.getText()+".~constructor~");
t.setText(t.getText()+"."+t.getText());
@@ -1200,63 +1200,63 @@
}
RPAREN! (classBlock)?
- //java 1.1
- // Note: This will allow bad constructs like
- // new int[4][][3] {exp,exp}.
- // There needs to be a semantic check here...
- // to make sure:
- // a) [ expr ] and [ ] are not mixed
- // b) [ expr ] and an init are not used together
-
- | newArrayDeclarator (arrayInitializer)?
- )
- ;
+ //java 1.1
+ // Note: This will allow bad constructs like
+ // new int[4][][3] {exp,exp}.
+ // There needs to be a semantic check here...
+ // to make sure:
+ // a) [ expr ] and [ ] are not mixed
+ // b) [ expr ] and an init are not used together
+
+ | newArrayDeclarator (arrayInitializer)?
+ )
+ ;
argList returns [int count]
{count=0;}
- : ( count=expressionList
- | /*nothing*/
- {#argList = #[ELIST,"ELIST"];}
- )
- ;
+ : ( count=expressionList
+ | /*nothing*/
+ {#argList = #[ELIST,"ELIST"];}
+ )
+ ;
newArrayDeclarator
- : (
- // CONFLICT:
- // newExpression is a primaryExpression which can be
- // followed by an array index reference. This is ok,
- // as the generated code will stay in this loop as
- // long as it sees an LBRACK (proper behavior)
- options {
- warnWhenFollowAmbig = false;
- }
- :
- lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);}
- (expression)?
- RBRACK!
- )+
- ;
+ : (
+ // CONFLICT:
+ // newExpression is a primaryExpression which can be
+ // followed by an array index reference. This is ok,
+ // as the generated code will stay in this loop as
+ // long as it sees an LBRACK (proper behavior)
+ options {
+ warnWhenFollowAmbig = false;
+ }
+ :
+ lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);}
+ (expression)?
+ RBRACK!
+ )+
+ ;
constant
- : NUM_INT
- | CHAR_LITERAL
- | STRING_LITERAL
- | NUM_FLOAT
- ;
+ : NUM_INT
+ | CHAR_LITERAL
+ | STRING_LITERAL
+ | NUM_FLOAT
+ ;
//----------------------------------------------------------------------------
// The Java scanner
//----------------------------------------------------------------------------
{
- import org.apache.alexandria.javasrc.symtab.SymbolTable;
+ import org.apache.maven.jxr.java.src.symtab.SymbolTable;
}
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
+ exportVocab=Java; // call the vocabulary "Java"
+ testLiterals=false; // don't automatically test for literals
+ k=4; // four characters of lookahead
// charVocabulary='\u0003'..'\uFFFF';
}
@@ -1275,13 +1275,13 @@
public void defineComment(int line,int column, String text)
{
symbolTable.defineComment(line,column, text);
- }
+ }
public void defineLiteral(int line,int column, String text)
{
symbolTable.defineLiteral(line,column, text);
}
-
+
// Test the token text against the literals table
// Override this method to perform a different literals test
public int testLiteralsTable(int ttype) {
@@ -1292,7 +1292,7 @@
ttype = literalsIndex.intValue();
}
return ttype;
- }
+ }
}
/* --- XR: End Xref additions --- */
@@ -1348,65 +1348,65 @@
// Whitespace -- ignored
WS : ( ' '
- | '\t'
- | '\f'
- // handle newlines
- | ( "\r\n" // Evil DOS
- | '\r' // Macintosh
- | '\n' // Unix (the right way)
- )
- { newline(); }
- )
- { _ttype = Token.SKIP; }
- ;
+ | '\t'
+ | '\f'
+ // handle newlines
+ | ( "\r\n" // Evil DOS
+ | '\r' // Macintosh
+ | '\n' // Unix (the right way)
+ )
+ { newline(); }
+ )
+ { _ttype = Token.SKIP; }
+ ;
// Single-line comments
SL_COMMENT
- : { clStart=getLine(); ccStart=getColumn(); } "//"
- (~('\n'|'\r'))*
- {defineComment(clStart,ccStart, getText());}
+ : { clStart=getLine(); ccStart=getColumn(); } "//"
+ (~('\n'|'\r'))*
+ {defineComment(clStart,ccStart, getText());}
('\n'|'\r'('\n')?)
- {$setType(Token.SKIP); newline();}
- ;
+ {$setType(Token.SKIP); newline();}
+ ;
// multiple-line comments
ML_COMMENT
- : { clStart=getLine(); ccStart=getColumn(); } "/*"
- ( /* '\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')
- )*
- "*/"
- {defineComment(clStart,ccStart,getText());}
- {$setType(Token.SKIP);}
- ;
+ : { clStart=getLine(); ccStart=getColumn(); } "/*"
+ ( /* '\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')
+ )*
+ "*/"
+ {defineComment(clStart,ccStart,getText());}
+ {$setType(Token.SKIP);}
+ ;
// character literals
CHAR_LITERAL
- : '\'' ( ESC | ~'\'' ) '\''
- ;
+ : '\'' ( ESC | ~'\'' ) '\''
+ ;
// string literals
STRING_LITERAL
- : { clStart=getLine(); ccStart=getColumn(); } '"'
- (ESC|~('"'|'\\'))*
- '"'
- {defineLiteral(clStart,ccStart,getText());}
- ;
+ : { clStart=getLine(); ccStart=getColumn(); } '"'
+ (ESC|~('"'|'\\'))*
+ '"'
+ {defineLiteral(clStart,ccStart,getText());}
+ ;
// escape sequence -- note that this is protected; it can only be called
@@ -1419,108 +1419,108 @@
// 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'..'9')
- )?
- )
- ;
+ : '\\'
+ ( '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'..'9')
+ )?
+ )
+ ;
// hexadecimal digit (again, note it's protected!)
protected
HEX_DIGIT
- : ('0'..'9'|'A'..'F'|'a'..'f')
- ;
+ : ('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'
- ;
+ : '\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'|'$')*
- ;
+ options {testLiterals=true;}
+ : ('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|'$')*
+ ;
// a numeric literal
NUM_INT
- {boolean isDecimal=false;}
- : '.' {_ttype = DOT;}
- (('0'..'9')+ (EXPONENT)? (FLOAT_SUFFIX)? { _ttype = NUM_FLOAT; })?
- | ( '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
- )+
- | ('0'..'7')+ // octal
- )?
- | ('1'..'9') ('0'..'9')* {isDecimal=true;} // non-zero decimal
- )
- ( ('l'|'L')
-
- // only check to see if it's a float if looks like decimal so far
- | {isDecimal}?
- ( '.' ('0'..'9')* (EXPONENT)? (FLOAT_SUFFIX)?
- | EXPONENT (FLOAT_SUFFIX)?
- | FLOAT_SUFFIX
- )
- { _ttype = NUM_FLOAT; }
- )?
- ;
+ {boolean isDecimal=false;}
+ : '.' {_ttype = DOT;}
+ (('0'..'9')+ (EXPONENT)? (FLOAT_SUFFIX)? { _ttype = NUM_FLOAT; })?
+ | ( '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
+ )+
+ | ('0'..'7')+ // octal
+ )?
+ | ('1'..'9') ('0'..'9')* {isDecimal=true;} // non-zero decimal
+ )
+ ( ('l'|'L')
+
+ // only check to see if it's a float if looks like decimal so far
+ | {isDecimal}?
+ ( '.' ('0'..'9')* (EXPONENT)? (FLOAT_SUFFIX)?
+ | EXPONENT (FLOAT_SUFFIX)?
+ | FLOAT_SUFFIX
+ )
+ { _ttype = NUM_FLOAT; }
+ )?
+ ;
// a couple protected methods to assist in matching floating point numbers
protected
EXPONENT
- : ('e'|'E') ('+'|'-')? ('0'..'9')+
- ;
+ : ('e'|'E') ('+'|'-')? ('0'..'9')+
+ ;
protected
FLOAT_SUFFIX
- : 'f'|'F'|'d'|'D'
- ;
+ : 'f'|'F'|'d'|'D'
+ ;