我正在使用 ANTLR 2.7.6，当我运行下一个类 Main.java
/**
* @param args
*/
public static void main(String[] args) {
FileInputStream fis;
try {
fis = new FileInputStream("src/main/entrada.txt");
Analex analex = null;
Anasint anasint = null;
analex = new Analex(fis);
anasint = new Anasint(analex);
anasint.memberDecl();
/*String[] tokens = anasint.get;
for(int i = 0; i < tokens.length; i++) {
System.out.println(tokens[i]);
}*/
CommonAST t = (CommonAST)anasint.getAST();
// Print the resulting tree out in LISP notation
System.out.println(t.toStringList());
ASTFrame frame= new ASTFrame("AST-entrada.txt",t);
frame.setVisible(true);
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (RecognitionException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (TokenStreamException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
我收到以下错误： 第 3:30 行：期待 LT，找到 'l' 第 4:82 行：意外令牌：l 第 6:34 行：期待 GT，找到 '=' 第 6:58 行：期待 LT，找到'= ' 第 7:76 行：意外标记：l
我的 Parser.g 和我的 Lexer.g
class Anasint extends Parser;
options {
buildAST = true;
}
memberDecl
: methodDeclaration
;
modifiers
:
(
PUBLIC
| PROTECTED
| PRIVATE
| STATIC
| ABSTRACT
| FINAL
)*
;
variableModifiers
: ( FINAL
)*
;
typeList
: type
(COMMA type
)*
;
typeParameters
: typeBound
|
LT
typeParameter
(COMMA typeParameter
)*
GT
;
typeParameter
: IDENTIFIER
(EXTENDS typeBound
)?
;
typeBound
: type
(AMP type
)*
;
methodDeclaration
:
modifiers
(typeParameters)
IDENTIFIER
formalParameters
(THROWS qualifiedNameList
)?
LBRACE
(blockStatement
)*
RBRACE
| modifiers
(typeParameters
)?
(type
| VOID
)
IDENTIFIER
formalParameters
(LBRACKET RBRACKET
)*
(THROWS qualifiedNameList
)?
(
block
| SEMI
)
;
/*fieldDeclaration
: modifiers
type
variableDeclarator
(COMMA variableDeclarator
)*
SEMI
;*/
variableDeclarator
: IDENTIFIER
(LBRACKET RBRACKET
)*
(EQ variableInitializer
)?
;
interfaceMethodDeclaration
: modifiers
(typeParameters
)?
(type
|VOID
)
IDENTIFIER
formalParameters
(LBRACKET RBRACKET
)*
(THROWS qualifiedNameList
)? SEMI
;
type
: primitiveType
(LBRACKET RBRACKET
)*
;
primitiveType
: BOOLEAN
| CHAR
| BYTE
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
| STRING
;
qualifiedNameList
: qualifiedName
(COMMA qualifiedName
)*
;
formalParameters
: LPAREN
(formalParameterDecls
)?
RPAREN
;
formalParameterDecls
: normalParameterDecl
(COMMA normalParameterDecl
)*
;
normalParameterDecl
: variableModifiers type IDENTIFIER
(LBRACKET RBRACKET
)*
;
qualifiedName
: IDENTIFIER
(DOT IDENTIFIER
)*
;
/*elementValuePairs
: elementValuePair
(COMMA elementValuePair
)*
// ;
/*elementValuePair
: IDENTIFIER EQ elementValue
;
elementValue
: conditionalExpression
| elementValueArrayInitializer
;
elementValueArrayInitializer
: LBRACE
(elementValue
(COMMA elementValue
)*
)? (COMMA)? RBRACE
; */
block
: LBRACE
(blockStatement
)*
RBRACE
;
/*
staticBlock returns [JCBlock tree]
@init {
ListBuffer<JCStatement> stats = new ListBuffer<JCStatement>();
int pos = ((AntlrJavacToken) $start).getStartIndex();
}
@after {
$tree = T.at(pos).Block(Flags.STATIC, stats.toList());
pu.storeEnd($tree, $stop);
// construct a dummy static modifiers for end position
pu.storeEnd(T.at(pos).Modifiers(Flags.STATIC, com.sun.tools.javac.util.List.<JCAnnotation>nil()),$st);
}
: st_1=STATIC LBRACE
(blockStatement
{
if ($blockStatement.tree == null) {
stats.appendList($blockStatement.list);
} else {
stats.append($blockStatement.tree);
}
}
)* RBRACE
;
*/
blockStatement
: localVariableDeclarationStatement
| statement
;
localVariableDeclarationStatement
: localVariableDeclaration
SEMI
;
localVariableDeclaration
: variableModifiers type
variableDeclarator
(COMMA variableDeclarator
)*
;
statement
: block
| ASSERT expression (COLON expression)? SEMI
| IF parExpression statement (ELSE statement)?
| forstatement
| WHILE parExpression statement
| DO statement WHILE parExpression SEMI
| trystatement
| SWITCH parExpression LBRACE switchBlockStatementGroups RBRACE
| SYNCHRONIZED parExpression block
| RETURN (expression )? SEMI
| THROW expression SEMI
| BREAK
(IDENTIFIER
)? SEMI
| CONTINUE
(IDENTIFIER
)? SEMI
| expression SEMI
| IDENTIFIER COLON statement
| SEMI
;
switchBlockStatementGroups
: (switchBlockStatementGroup )*
;
switchBlockStatementGroup
:
switchLabel
(blockStatement
)*
;
switchLabel
: CASE expression COLON
| DEFAULT COLON
;
trystatement
: TRY block
( catches FINALLY block
| catches
| FINALLY block
)
;
catches
: catchClause
(catchClause
)*
;
catchClause
: CATCH LPAREN formalParameter
RPAREN block
;
formalParameter
: variableModifiers type IDENTIFIER
(LBRACKET RBRACKET
)*
;
forstatement
:
// enhanced for loop
FOR LPAREN variableModifiers type IDENTIFIER COLON
expression RPAREN statement
// normal for loop
| FOR LPAREN
(forInit
)? SEMI
(expression
)? SEMI
(expressionList
)? RPAREN statement
;
forInit
: localVariableDeclaration
| expressionList
;
parExpression
: LPAREN expression RPAREN
;
expressionList
: expression
(COMMA expression
)*
;
expression
: conditionalExpression
(assignmentOperator expression
)?
;
assignmentOperator
: EQ
| PLUSEQ
| SUBEQ
| STAREQ
| SLASHEQ
| AMPEQ
| BAREQ
| CARETEQ
| PERCENTEQ
| LT LT EQ
| GT GT GT EQ
| GT GT EQ
;
conditionalExpression
: conditionalOrExpression
(QUES expression COLON conditionalExpression
)?
;
conditionalOrExpression
: conditionalAndExpression
(BARBAR conditionalAndExpression
)*
;
conditionalAndExpression
: inclusiveOrExpression
(AMPAMP inclusiveOrExpression
)*
;
inclusiveOrExpression
: exclusiveOrExpression
(BAR exclusiveOrExpression
)*
;
exclusiveOrExpression
: andExpression
(CARET andExpression
)*
;
andExpression
: equalityExpression
(AMP equalityExpression
)*
;
equalityExpression
: instanceOfExpression
(
( EQEQ
| BANGEQ
)
instanceOfExpression
)*
;
instanceOfExpression
: relationalExpression
(INSTANCEOF type
)?
;
relationalExpression
: shiftExpression
(relationalOp shiftExpression
)*
;
relationalOp
: LT EQ
| GT EQ
| LT
| GT
;
shiftExpression
: additiveExpression
(shiftOp additiveExpression
)*
;
shiftOp
: LT LT
| GT GT GT
| GT GT
;
additiveExpression
: multiplicativeExpression
(
( PLUS
| SUB
)
multiplicativeExpression
)*
;
multiplicativeExpression
:
unaryExpression
(
( STAR
| SLASH
| PERCENT
)
unaryExpression
)*
;
unaryExpression
: PLUS unaryExpression
| SUB unaryExpression
| PLUSPLUS unaryExpression
| SUBSUB unaryExpression
| unaryExpressionNotPlusMinus
;
unaryExpressionNotPlusMinus
: TILDE unaryExpression
| BANG unaryExpression
| castExpression
| primary
(selector
)*
( PLUSPLUS
| SUBSUB
)?
;
castExpression
: LPAREN primitiveType RPAREN unaryExpression
| LPAREN type RPAREN unaryExpressionNotPlusMinus
;
primary
: parExpression
| THIS
(DOT IDENTIFIER
)*
(identifierSuffix
)?
| IDENTIFIER
(DOT IDENTIFIER
)*
(identifierSuffix
)?
| SUPER
superSuffix
| literal
| creator
| primitiveType
(LBRACKET RBRACKET
)*
DOT CLASS
| VOID DOT CLASS
;
superSuffix
: arguments
| DOT (typeArguments
)?
IDENTIFIER
(arguments
)?
;
identifierSuffix
: (LBRACKET RBRACKET
)+
DOT CLASS
| (LBRACKET expression RBRACKET
)+
| arguments
| DOT CLASS
| DOT nonWildcardTypeArguments IDENTIFIER arguments
| DOT THIS
| DOT SUPER arguments
| innerCreator
;
selector
: DOT IDENTIFIER
(arguments
)?
| DOT THIS
| DOT SUPER
superSuffix
| innerCreator
| LBRACKET expression RBRACKET
;
creator
: NEW nonWildcardTypeArguments classOrInterfaceType classCreatorRest
| NEW classOrInterfaceType classCreatorRest
| arrayCreator
;
classBody
: LBRACE
(classBodyDeclaration
)*
RBRACE
;
classBodyDeclaration
: SEMI
| (STATIC
)?
block
| memberDecl
;
classOrInterfaceType
: IDENTIFIER
(typeArguments
)?
(DOT IDENTIFIER
(typeArguments
)?
)*
;
arrayCreator
: NEW createdName
LBRACKET RBRACKET
(LBRACKET RBRACKET
)*
arrayInitializer
| NEW createdName
LBRACKET expression
RBRACKET
( LBRACKET expression
RBRACKET
)*
(LBRACKET RBRACKET
)*
;
variableInitializer
: arrayInitializer
| expression
;
arrayInitializer
: LBRACE
(variableInitializer
(COMMA variableInitializer
)*
)?
(COMMA)?
RBRACE //Yang's fix, position change.
;
createdName
: classOrInterfaceType
| primitiveType
;
innerCreator
: DOT NEW
(nonWildcardTypeArguments
)?
IDENTIFIER
(typeArguments
)?
classCreatorRest
;
typeArguments
: LT typeArgument
(COMMA typeArgument
)*
GT
;
typeArgument
: type
| QUES
(
(EXTENDS
|SUPER
)
type
)?
;
classCreatorRest
: arguments
(classBody
)?
;
nonWildcardTypeArguments
: LT typeList
GT
;
arguments
: LPAREN (expressionList
)? RPAREN
;
literal
: INTLITERAL
| LONGLITERAL
| FLOATLITERAL
| DOUBLELITERAL
| CHARLITERAL
| STRINGLITERAL
| TRUE
| FALSE
| NULL
;
class Analex extends Lexer;
options {
importVocab = Anasint;
charVocabulary = '\0'..'\377';
k = 3;
}
LONGLITERAL
: IntegerNumber LongSuffix
;
INTLITERAL
: IntegerNumber
;
IntegerNumber
: '0'
| '1'..'9' ('0'..'9')*
| '0' ('0'..'7')+
;
LongSuffix
: 'l' | 'L'
;
NonIntegerNumber
: ('0' .. '9')+ '.' ('0' .. '9')*
| '.' ( '0' .. '9' )+
| ('0' .. '9')+
;
FloatSuffix
: 'f' | 'F'
;
DoubleSuffix
: 'd' | 'D'
;
FLOATLITERAL
: NonIntegerNumber FloatSuffix
;
DOUBLELITERAL
: NonIntegerNumber DoubleSuffix
;
CHARLITERAL
: '\''
( EscapeSequence
| ~( '\'' | '\\' | '\r' | '\n' )
)
'\''
;
STRINGLITERAL
: '"'
( EscapeSequence
| ~( '\\' | '"' | '\r' | '\n' )
)*
'"'
;
EscapeSequence
: '\\' (
'b'
| 't'
| 'n'
| 'f'
| 'r'
| '\"'
| '\''
| '\\'
|
('0'..'3') ('0'..'7') ('0'..'7')
|
('0'..'7') ('0'..'7')
|
('0'..'7')
)
;
COMMENT
: "/*" (options{greedy=false;}:(NUEVA_LINEA|.))* "*/"
{$setType(Token.SKIP);};
LINE_COMMENT
: "//" (~'\r')*
{$setType(Token.SKIP);};
ABSTRACT
: "abstract"
;
ASSERT
: "assert"
;
BOOLEAN
: "boolean"
;
BREAK
: "break"
;
BYTE
: "byte"
;
CASE
: "case"
;
CATCH
: "catch"
;
CHAR
: "char"
;
CONTINUE
: "continue"
;
DEFAULT
: "default"
;
DO
: "do"
;
DOUBLE
: "double"
;
ELSE
: "else"
;
ENUM
: "enum"
;
FINAL
: "final"
;
FINALLY
: "finally"
;
FLOAT
: "float"
;
FOR
: "for"
;
IF
: "if"
;
INSTANCEOF
: "instanceof"
;
INT
: "int"
;
INTERFACE
: "interface"
;
LONG
: "long"
;
NEW
: "new"
;
PRIVATE
: "private"
;
PROTECTED
: "protected"
;
PUBLIC
: "public"
;
RETURN
: "return"
;
SHORT
: "short"
;
STATIC
: "static"
;
EXTENDS
: "extends"
;
SUPER
: "super"
;
SWITCH
: "switch"
;
SYNCHRONIZED
: "synchronized"
;
THIS
: "this"
;
THROW
: "throw"
;
THROWS
: "throws"
;
TRY
: "try"
;
VOID
: "void"
;
WHILE
: "while"
;
TRUE
: "true"
;
FALSE
: "false"
;
NULL
: "null"
;
LPAREN
: '('
;
RPAREN
: ')'
;
LBRACE
: '{'
;
RBRACE
: '}'
;
LBRACKET
: '['
;
RBRACKET
: ']'
;
SEMI
: ';'
;
COMMA
: ','
;
DOT
: '.'
;
ELLIPSIS
: "..."
;
EQ
: '='
;
BANG
: '!'
;
TILDE
: '~'
;
QUES
: '?'
;
COLON
: ':'
;
EQEQ
: "=="
;
AMPAMP
: "&&"
;
BARBAR
: "||"
;
PLUSPLUS
: "++"
;
SUBSUB
: "--"
;
PLUS
: '+'
;
SUB
: '-'
;
STAR
: '*'
;
STRING
: "String"
;
SLASH
: '/'
;
AMP
: '&'
;
BAR
: '|'
;
CARET
: '^'
;
PERCENT
: '%'
;
PLUSEQ
: "+="
;
SUBEQ
: "-="
;
STAREQ
: "*="
;
SLASHEQ
: "/="
;
AMPEQ
: "&="
;
BAREQ
: "|="
;
CARETEQ
: "^="
;
PERCENTEQ
: "%="
;
MONKEYS_AT
: '@'
;
BANGEQ
: "!="
;
GT
: '>'
;
LT
: '<'
;
IDENTIFIER
: ('a'..'z' | 'A'..'Z'|'_')('a'..'z' | 'A'..'Z'|'0'..'9'|'_')*
;
protected NUEVA_LINEA : "\r\n"
{newline();};
BLANCO : (' '|'\t'|NUEVA_LINEA)
{$setType(Token.SKIP);};