Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
[The "BSD licence"]
Copyright (c) 2005-2007 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.Map;
import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
/** 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);
}
}
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(null, 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();
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(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
