org.antlr.runtime.tree.TreeWizard Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of antlr-runtime Show documentation
Show all versions of antlr-runtime Show documentation
A framework for constructing recognizers, compilers, and translators from grammatical descriptions containing Java, C#, C++, or Python actions.
/*
[The "BSD license"]
Copyright (c) 2005-2009 Terence Parr
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The name of the author may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.antlr.runtime.tree;
import org.antlr.runtime.Token;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/** Build and navigate trees with this object. Must know about the names
* of tokens so you have to pass in a map or array of token names (from which
* this class can build the map). I.e., Token DECL means nothing unless the
* class can translate it to a token type.
*
* In order to create nodes and navigate, this class needs a TreeAdaptor.
*
* This class can build a token type -> node index for repeated use or for
* iterating over the various nodes with a particular type.
*
* This class works in conjunction with the TreeAdaptor rather than moving
* all this functionality into the adaptor. An adaptor helps build and
* navigate trees using methods. This class helps you do it with string
* patterns like "(A B C)". You can create a tree from that pattern or
* match subtrees against it.
*/
public class TreeWizard {
protected TreeAdaptor adaptor;
protected Map tokenNameToTypeMap;
public interface ContextVisitor {
// TODO: should this be called visit or something else?
public void visit(Object t, Object parent, int childIndex, Map labels);
}
public static abstract class Visitor implements ContextVisitor {
public void visit(Object t, Object parent, int childIndex, Map labels) {
visit(t);
}
public abstract void visit(Object t);
}
/** When using %label:TOKENNAME in a tree for parse(), we must
* track the label.
*/
public static class TreePattern extends CommonTree {
public String label;
public boolean hasTextArg;
public TreePattern(Token payload) {
super(payload);
}
public String toString() {
if ( label!=null ) {
return "%"+label+":"+super.toString();
}
else {
return super.toString();
}
}
}
public static class WildcardTreePattern extends TreePattern {
public WildcardTreePattern(Token payload) {
super(payload);
}
}
/** This adaptor creates TreePattern objects for use during scan() */
public static class TreePatternTreeAdaptor extends CommonTreeAdaptor {
public Object create(Token payload) {
return new TreePattern(payload);
}
}
// TODO: build indexes for the wizard
/** During fillBuffer(), we can make a reverse index from a set
* of token types of interest to the list of indexes into the
* node stream. This lets us convert a node pointer to a
* stream index semi-efficiently for a list of interesting
* nodes such as function definition nodes (you'll want to seek
* to their bodies for an interpreter). Also useful for doing
* dynamic searches; i.e., go find me all PLUS nodes.
protected Map tokenTypeToStreamIndexesMap;
/** If tokenTypesToReverseIndex set to INDEX_ALL then indexing
* occurs for all token types.
public static final Set INDEX_ALL = new HashSet();
/** A set of token types user would like to index for faster lookup.
* If this is INDEX_ALL, then all token types are tracked. If null,
* then none are indexed.
protected Set tokenTypesToReverseIndex = null;
*/
public TreeWizard(TreeAdaptor adaptor) {
this.adaptor = adaptor;
}
public TreeWizard(TreeAdaptor adaptor, Map tokenNameToTypeMap) {
this.adaptor = adaptor;
this.tokenNameToTypeMap = tokenNameToTypeMap;
}
public TreeWizard(TreeAdaptor adaptor, String[] tokenNames) {
this.adaptor = adaptor;
this.tokenNameToTypeMap = computeTokenTypes(tokenNames);
}
public TreeWizard(String[] tokenNames) {
this(new CommonTreeAdaptor(), tokenNames);
}
/** Compute a Map that is an inverted index of
* tokenNames (which maps int token types to names).
*/
public Map computeTokenTypes(String[] tokenNames) {
Map m = new HashMap();
if ( tokenNames==null ) {
return m;
}
for (int ttype = Token.MIN_TOKEN_TYPE; ttype < tokenNames.length; ttype++) {
String name = tokenNames[ttype];
m.put(name, new Integer(ttype));
}
return m;
}
/** Using the map of token names to token types, return the type. */
public int getTokenType(String tokenName) {
if ( tokenNameToTypeMap==null ) {
return Token.INVALID_TOKEN_TYPE;
}
Integer ttypeI = (Integer)tokenNameToTypeMap.get(tokenName);
if ( ttypeI!=null ) {
return ttypeI.intValue();
}
return Token.INVALID_TOKEN_TYPE;
}
/** Walk the entire tree and make a node name to nodes mapping.
* For now, use recursion but later nonrecursive version may be
* more efficient. Returns Map where the List is
* of your AST node type. The Integer is the token type of the node.
*
* TODO: save this index so that find and visit are faster
*/
public Map index(Object t) {
Map m = new HashMap();
_index(t, m);
return m;
}
/** Do the work for index */
protected void _index(Object t, Map m) {
if ( t==null ) {
return;
}
int ttype = adaptor.getType(t);
List elements = (List)m.get(new Integer(ttype));
if ( elements==null ) {
elements = new ArrayList();
m.put(new Integer(ttype), elements);
}
elements.add(t);
int n = adaptor.getChildCount(t);
for (int i=0; i>
*
* This data structure allows you to find all nodes with type INT in order.
*
* If you really need to find a node of type, say, FUNC quickly then perhaps
*
* Map>
*
* would be better for you. The interior maps map a tree node to
* the index so you don't have to search linearly for a specific node.
*
* If you change this method, you will likely need to change
* getNodeIndex(), which extracts information.
protected void fillReverseIndex(Object node, int streamIndex) {
//System.out.println("revIndex "+node+"@"+streamIndex);
if ( tokenTypesToReverseIndex==null ) {
return; // no indexing if this is empty (nothing of interest)
}
if ( tokenTypeToStreamIndexesMap==null ) {
tokenTypeToStreamIndexesMap = new HashMap(); // first indexing op
}
int tokenType = adaptor.getType(node);
Integer tokenTypeI = new Integer(tokenType);
if ( !(tokenTypesToReverseIndex==INDEX_ALL ||
tokenTypesToReverseIndex.contains(tokenTypeI)) )
{
return; // tokenType not of interest
}
Integer streamIndexI = new Integer(streamIndex);
ArrayList indexes = (ArrayList)tokenTypeToStreamIndexesMap.get(tokenTypeI);
if ( indexes==null ) {
indexes = new ArrayList(); // no list yet for this token type
indexes.add(streamIndexI); // not there yet, add
tokenTypeToStreamIndexesMap.put(tokenTypeI, indexes);
}
else {
if ( !indexes.contains(streamIndexI) ) {
indexes.add(streamIndexI); // not there yet, add
}
}
}
/** Track the indicated token type in the reverse index. Call this
* repeatedly for each type or use variant with Set argument to
* set all at once.
* @param tokenType
public void reverseIndex(int tokenType) {
if ( tokenTypesToReverseIndex==null ) {
tokenTypesToReverseIndex = new HashSet();
}
else if ( tokenTypesToReverseIndex==INDEX_ALL ) {
return;
}
tokenTypesToReverseIndex.add(new Integer(tokenType));
}
/** Track the indicated token types in the reverse index. Set
* to INDEX_ALL to track all token types.
public void reverseIndex(Set tokenTypes) {
tokenTypesToReverseIndex = tokenTypes;
}
/** Given a node pointer, return its index into the node stream.
* This is not its Token stream index. If there is no reverse map
* from node to stream index or the map does not contain entries
* for node's token type, a linear search of entire stream is used.
*
* Return -1 if exact node pointer not in stream.
public int getNodeIndex(Object node) {
//System.out.println("get "+node);
if ( tokenTypeToStreamIndexesMap==null ) {
return getNodeIndexLinearly(node);
}
int tokenType = adaptor.getType(node);
Integer tokenTypeI = new Integer(tokenType);
ArrayList indexes = (ArrayList)tokenTypeToStreamIndexesMap.get(tokenTypeI);
if ( indexes==null ) {
//System.out.println("found linearly; stream index = "+getNodeIndexLinearly(node));
return getNodeIndexLinearly(node);
}
for (int i = 0; i < indexes.size(); i++) {
Integer streamIndexI = (Integer)indexes.get(i);
Object n = get(streamIndexI.intValue());
if ( n==node ) {
//System.out.println("found in index; stream index = "+streamIndexI);
return streamIndexI.intValue(); // found it!
}
}
return -1;
}
*/
}