|
ESC/Java2 © 2003,2004,2005 David Cok and Joseph Kiniry © 2005 UCD Dublin © 2003,2004 Radboud University Nijmegen © 1999,2000 Compaq Computer Corporation © 1997,1998,1999 Digital Equipment Corporation All Rights Reserved |
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectjavafe.parser.ParseUtil
javafe.parser.ParseType
javafe.parser.ParseExpr
javafe.parser.ParseStmt
Parse
objects parse Java statements, creating AST
structures for the parsed input using the static
make*()
methods of the classes in the
javafe.ast
package.
The concrete grammar for statements is as follows:
Statement: ';' | (Modifier | ModifierPragma)* ClassDeclaration | (Modifier | ModifierPragma)* Type { Idn [ '=' InitExpr ] },+ ';' | Idn ':' Stmt | Expr ';' | '{' BlockStmt* '}' // In an assert, BoolExpr must be of type boolean, NonVoidExpr must // not be of type void | 'assert' BoolExpr [ ':' NonVoidExpr ] ';' | 'break' [ Idn ] ';' | 'continue' [ Idn ] ';' | 'return' [ Expr ] ';' | 'throw' Expr ';' | 'if' '(' Expr ')' Stmt [ 'else' Stmt ] | 'do' Stmt 'while' '(' Expr ')' ';' | 'while' '(' Expr ')' Stmt | 'for' '(' [ VDeclInit | StmtExpr,* ] ';' Expr ';' StmtExpr,* ')' Stmt | 'switch' '(' Expr ')' '{' { {'case' Expr ':' | 'default:'}* BlockStmt* }* '}' | 'synchronized' '(' Expr ')' '{' BlockStmt* '}' | 'try' '{' BlockStmt* '}' { 'catch' '(' VDecl,* ')' '{' BlockStmt* '}' }* [ 'finally' '{' BlockStmt* '}' ] | StmtPragma
Currently, there is no error recovery. Upon detection of a
syntax error, all methods in this class throw a RuntimeException
with a (weak) error message.
Although the class as a whole is thread-safe, that is,
different threads can be calling methods of different instances of
ParseStmt
at the same time, individual instances are
not.
ASTNode
Field Summary | |
protected StackVector |
seqCatchClause
|
protected StackVector |
seqStmt
Internal working storage for many ParseStmt
functions. |
Fields inherited from class javafe.parser.ParseExpr |
seqExpr, seqTypeDeclElem, seqVarInit |
Fields inherited from class javafe.parser.ParseType |
seqIdentifier |
Fields inherited from class javafe.parser.ParseUtil |
modifierKeywords, modifierPragmas, seqModifierPragma |
Constructor Summary | |
ParseStmt()
|
Method Summary | |
protected void |
addStmt(Lex l)
Internal method for parsing a Stmt .
|
private void |
addVarDeclStmts(Lex l,
int modifiers,
ModifierPragmaVec modifierPragmas,
Type basetype)
Internal routine for parsing variable declarations after the leading type has been parsed. |
static boolean |
isStatementExpression(Expr e)
|
BlockStmt |
parseBlock(Lex l,
boolean specOnly)
Method for parsing a Block .
|
private CatchClauseVec |
parseCatches(Lex l)
Internal routine for parsing zero or more catch clauses. |
BlockStmt |
parseConstructorBody(Lex l)
Method for parsing a ConstructorBody .
|
FormalParaDecl |
parseFormalParaDecl(Lex l)
Routine for parsing a single formal parameter declarations. |
private ForStmt |
parseForStmt(Lex l,
int keywordloc)
Internal method for parsing a switch statement. |
Stmt |
parseStatement(Lex l)
Method for parsing a Stmt .
|
private SwitchStmt |
parseSwitchStmt(Lex l,
int keywordloc)
Internal method for parsing a switch statement. |
(package private) abstract TypeDecl |
parseTypeDeclTail(Lex l,
boolean specOnly,
int loc,
int modifiers,
ModifierPragmaVec modifierPragmas)
Parse a type declaration stating at the class/interface keyword. |
Methods inherited from class javafe.parser.ParseType |
isPrimitiveKeywordTag, parseBracketPairs, parseIdentifier, parseName, parsePrimitiveType, parsePrimitiveTypeOrTypeName, parseType, parseTypeModifierPragmas, parseTypeName |
Methods inherited from class javafe.parser.ParseUtil |
arrayToString, error, expect, fail, getJavaModifier, isJavaModifier, operatorTokenToTag, parseModifierPragmas, parseModifiers, parseMoreModifierPragmas |
Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
protected final StackVector seqStmt
ParseStmt
functions.
protected final StackVector seqCatchClause
Constructor Detail |
public ParseStmt()
Method Detail |
abstract TypeDecl parseTypeDeclTail(Lex l, boolean specOnly, int loc, int modifiers, ModifierPragmaVec modifierPragmas)
public Stmt parseStatement(Lex l)
Stmt
.
Effects: Parses a single Stmt
according to the
grammar at the top of this file, except that it does
not accept variable-declaration statements. If no syntax
errors are encountered, it adds one or more Stmt
to seqStmt
, leaving l
at the token
just after the trailing }
of the statement. More
than one statement is added only in the case of variable
declarations that declare more than one variable.
protected void addStmt(Lex l)
Stmt
.
Effects: Parses a single Stmt
according to the
grammar at the top of this file. If no syntax errors are
encountered, it adds one or more Stmt
to
seqStmt
, leaving l
at the token just
after the trailing }
of the statement. More than
one statement is added only in the case of variable
declarations that declare more than one variable.
public BlockStmt parseConstructorBody(Lex l)
ConstructorBody
.
Effects: Parses the following grammar:
Block ::= '{' [ { 'this' | 'super' ] '(' ArgumentList ')' ] { VarDeclInit | Stmt }* '}'
If no syntax errors are encountered, it returns a parse
tree for the parsed input, leaving l
at the token
just after the trailing }
of the statement.
public BlockStmt parseBlock(Lex l, boolean specOnly)
Block
.
Effects: Parses the following grammar:
Block ::= '{' { VarDeclInit | Stmt }* '}'
If no syntax errors are encountered, it returns a parse
tree for the parsed input, leaving l
at the token
just after the trailing }
of the statement.
private ForStmt parseForStmt(Lex l, int keywordloc)
Effects: Parses the following grammar:
ForStmtRemainder ::= '(' [VDeclInit | StmtExpr,* ] ';' Expr ';' StmtExpr,* ')' Stmt
Note that it assumes the leading for
has
already been parsed; keywordloc
is the location
assumed for the for
token.
If no syntax errors are encountered, it returns a parse
tree for the parsed input, leaving l
at the token
just after the trailing }
of the statement.
private SwitchStmt parseSwitchStmt(Lex l, int keywordloc)
Effects: Parses the following grammar:
SwitchStmtRemainder ::= '(' Expr ')' '{' { 'case' Expr ':' | 'default ':' | Stmt }* '}'
Note that it assumes the trailing switch
has
already been parsed; keywordLoc
is the location
assumed for the switch
token.
If no syntax errors are encountered, it returns a parse
tree for the parsed input, leaving l
at the token
just after the trailing }
of the statement.
private CatchClauseVec parseCatches(Lex l)
Effects: Parses the following grammar:
Catches ::= { 'catch' '(' [Modifiers] Type Idn ')' Block }*At the start of each iteration (including the first), if the first token is not
catch
, it stops trying to
parse, returning the (possibly empty) sequence of catch clauses
parsed already and leaving the token at the first token
following the last catch clause parsed. If the first token is
catch
, then it tries to parse a catch clause,
throwing an exception if a syntax error is found.
private void addVarDeclStmts(Lex l, int modifiers, ModifierPragmaVec modifierPragmas, Type basetype)
Effects: Parses the following grammar:
VarDeclRemainder ::= { Idn { '[' ']' }* [ '=' VariableInitializer ] },*
Each VarDeclRemainder
found is combined with
basetype
to create a VarDeclStmt
which is added to the end of seqStmt
.
On entry, it assumes at least one
VarDeclRemainder
is available, and throws an
exception if one isn't. At the end of each iteration, it stops
trying to parse if the comma is not present, leaving the token
at the first token following the last
VarDeclRemainder
parsed. If a comma is found,
then it tries to parse the next VarDeclRemainder
,
throwing an exception if a syntax error is found.
public FormalParaDecl parseFormalParaDecl(Lex l)
Effects: Parses the following grammar:
FormalParaDecl ::= { [Modifiers] Type Idn ModifierPragma* }returning an ASTNode representing the result. Leaves
l
pointing to the token just after the
FormalParaDecl
.
public static boolean isStatementExpression(Expr e)
e
is a Java
StatementExpression
as defined in the grammar
given in the language spec.
|
ESC/Java2 © 2003,2004,2005 David Cok and Joseph Kiniry © 2005 UCD Dublin © 2003,2004 Radboud University Nijmegen © 1999,2000 Compaq Computer Corporation © 1997,1998,1999 Digital Equipment Corporation All Rights Reserved |
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |