| java.lang.Object
 persistence.antlr.ASTFactory
| ASTFactory | | public class ASTFactory (Code) | | AST Support code shared by TreeParser and Parser.
We use delegation to share code (and have only one
bit of code to maintain) rather than subclassing
or superclassing (forces AST support code to be
loaded even when you don't want to do AST stuff).
Typically, setASTNodeType is used to specify the
homogeneous type of node to create, but you can override
create to make heterogeneous nodes etc...
|
| Constructor Summary | |
| public | ASTFactory()
| | public | ASTFactory(Hashtable tokenTypeToClassMap)
Create factory with a specific mapping from token type
to Java AST node type. |
| Method Summary | |
| public void | addASTChild(ASTPair currentAST, AST child)
| | public AST | create()
Create a new empty AST node; if the user did not specify
an AST node type, then create a default one: CommonAST. | | public AST | create(int type)
| | public AST | create(int type, String txt)
| | public AST | create(int type, String txt, String className)
Create an AST node with the token type and text passed in, but
with a specific Java object type. | | public AST | create(AST tr)
Create a new empty AST node; if the user did not specify
an AST node type, then create a default one: CommonAST. | | public AST | create(Token tok)
| | public AST | create(Token tok, String className)
ANTLR generates reference to this when you reference a token
that has a specified heterogeneous AST node type. | | public AST | create(String className)
| | protected AST | create(Class c)
| | protected AST | createUsingCtor(Token token, String className)
| | public AST | dup(AST t)
Copy a single node with same Java AST objec type.
Ignore the tokenType->Class mapping since you know
the type of the node, t.getClass(), and doing a dup.
clone() is not used because we want all AST creation
to go thru the factory so creation can be
tracked. | | public AST | dupList(AST t)
Duplicate tree including siblings of root. | | public AST | dupTree(AST t)
Duplicate a tree, assuming this is a root node of a tree--
duplicate that node and what's below; ignore siblings of root node. | | public void | error(String e)
To change where error messages go, can subclass/override this method
and then setASTFactory in Parser and TreeParser. | | public Class | getASTNodeType(int tokenType)
| | public Hashtable | getTokenTypeToASTClassMap()
| | public AST | make(AST[] nodes)
Make a tree from a list of nodes. | | public AST | make(ASTArray nodes)
| | public void | makeASTRoot(ASTPair currentAST, AST root)
| | public void | setASTNodeClass(String t)
| | public void | setASTNodeType(String t)
Specify the type of node to create during tree building. | | public void | setTokenTypeASTNodeType(int tokenType, String className)
Specify an "override" for the Java AST object created for a
specific token. | | public void | setTokenTypeToASTClassMap(Hashtable tokenTypeToClassMap)
|
| theASTNodeType | | protected String theASTNodeType(Code) | | Name of AST class to create during tree construction.
Null implies that the create method should create
a default AST type such as CommonAST. This is for
homogeneous nodes.
|
| theASTNodeTypeClass | | protected Class theASTNodeTypeClass(Code) | | |
| tokenTypeToASTClassMap | | protected Hashtable tokenTypeToASTClassMap(Code) | | How to specify the classname to create for a particular
token type. Note that ANTLR allows you to say, for example,
tokens {
PLUS;
...
}
and it tracks everything statically. #[PLUS] will make you
a PLUSNode w/o use of this table.
For tokens that ANTLR cannot track statically like #[i],
you can use this table to map PLUS (Integer) -> PLUSNode (Class)
etc... ANTLR sets the class map from the tokens {...} section
via the ASTFactory(Hashtable) ctor in persistence.antlr.Parser.
|
| ASTFactory | | public ASTFactory()(Code) | | |
| ASTFactory | | public ASTFactory(Hashtable tokenTypeToClassMap)(Code) | | Create factory with a specific mapping from token type
to Java AST node type. Your subclasses of ASTFactory
can override and reuse the map stuff.
|
| addASTChild | | public void addASTChild(ASTPair currentAST, AST child)(Code) | | Add a child to the current AST
|
| create | | public AST create()(Code) | | Create a new empty AST node; if the user did not specify
an AST node type, then create a default one: CommonAST.
|
| create | | public AST create(int type, String txt, String className)(Code) | | Create an AST node with the token type and text passed in, but
with a specific Java object type. Typically called when you
say @[PLUS,"+",PLUSNode] in an antlr action.
since:
2.7.2 |
| create | | public AST create(AST tr)(Code) | | Create a new empty AST node; if the user did not specify
an AST node type, then create a default one: CommonAST.
|
| create | | public AST create(Token tok, String className)(Code) | | ANTLR generates reference to this when you reference a token
that has a specified heterogeneous AST node type. This is
also a special case node creation routine for backward
compatibility. Before, ANTLR generated "new T(tokenObject)"
and so I must call the appropriate constructor not T().
since:
2.7.2 |
| dup | | public AST dup(AST t)(Code) | | Copy a single node with same Java AST objec type.
Ignore the tokenType->Class mapping since you know
the type of the node, t.getClass(), and doing a dup.
clone() is not used because we want all AST creation
to go thru the factory so creation can be
tracked. Returns null if t is null.
|
| dupList | | public AST dupList(AST t)(Code) | | Duplicate tree including siblings of root.
|
| dupTree | | public AST dupTree(AST t)(Code) | | Duplicate a tree, assuming this is a root node of a tree--
duplicate that node and what's below; ignore siblings of root node.
|
| error | | public void error(String e)(Code) | | To change where error messages go, can subclass/override this method
and then setASTFactory in Parser and TreeParser. This method removes
a prior dependency on class persistence.antlr.Tool.
|
| getASTNodeType | | public Class getASTNodeType(int tokenType)(Code) | | For a given token type, what is the AST node object type to create
for it?
since:
2.7.2 |
| getTokenTypeToASTClassMap | | public Hashtable getTokenTypeToASTClassMap()(Code) | | |
| make | | public AST make(AST[] nodes)(Code) | | Make a tree from a list of nodes. The first element in the
array is the root. If the root is null, then the tree is
a simple list not a tree. Handles null children nodes correctly.
For example, build(a, b, null, c) yields tree (a b c). build(null,a,b)
yields tree (nil a b).
|
| make | | public AST make(ASTArray nodes)(Code) | | Make a tree from a list of nodes, where the nodes are contained
in an ASTArray object
|
| makeASTRoot | | public void makeASTRoot(ASTPair currentAST, AST root)(Code) | | Make an AST the root of current AST
|
| setASTNodeType | | public void setASTNodeType(String t)(Code) | | Specify the type of node to create during tree building.
|
| setTokenTypeASTNodeType | | public void setTokenTypeASTNodeType(int tokenType, String className) throws IllegalArgumentException(Code) | | Specify an "override" for the Java AST object created for a
specific token. It is provided as a convenience so
you can specify node types dynamically. ANTLR sets
the token type mapping automatically from the tokens{...}
section, but you can change that mapping with this method.
ANTLR does it's best to statically determine the node
type for generating parsers, but it cannot deal with
dynamic values like #[LT(1)]. In this case, it relies
on the mapping. Beware differences in the tokens{...}
section and what you set via this method. Make sure
they are the same.
Set className to null to remove the mapping.
since:
2.7.2 |
| setTokenTypeToASTClassMap | | public void setTokenTypeToASTClassMap(Hashtable tokenTypeToClassMap)(Code) | | |
|
|