/projects/antlr-3.4/runtime/ObjC/Framework/ANTLRTreeWizard.m

//
//  ANTLRTreeWizard.m
//  ANTLR
//
//  Created by Alan Condit on 6/18/10.
// [The "BSD licence"]
// Copyright (c) 2010 Alan Condit
// 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.

#import "ANTLRTreeWizard.h"
#import "ANTLRTreePatternLexer.h"
#import "ANTLRTreePatternParser.h"
#import "ANTLRIntArray.h"

@implementation ANTLRVisitor

+ (ANTLRVisitor *)newANTLRVisitor:(NSInteger)anAction Actor:(id)anActor Object:(id)anObject1 Object:(id)anObject2
{
    return [[ANTLRVisitor alloc] initWithAction:anAction Actor:(id)anActor Object:(id)anObject1 Object:(id)anObject2];
}

- (id) initWithAction:(NSInteger)anAction Actor:(id)anActor Object:(id)anObject1 Object:(id)anObject2
{
    if ((self = [super init]) != nil) {
        action = anAction;
        actor = anActor;
        if ( actor ) [actor retain];
        object1 = anObject1;
        if ( object1 ) [object1 retain];
        object2 = anObject2;
        if ( object2 ) [object2 retain];
    }
    return self;
}

- (void) dealloc
{
#ifdef DEBUG_DEALLOC
    NSLog( @"called dealloc in ANTLRVisitor" );
#endif
    if ( actor ) [actor release];
    if ( object1 ) [object1 release];
    if ( object2 ) [object2 release];
    [super dealloc];
}

- (void) visit:(ANTLRCommonTree *)t Parent:(ANTLRCommonTree *)parent ChildIndex:(NSInteger)childIndex Map:(ANTLRMap *)labels
{
    switch (action) {
        case 0:
            [(ANTLRMap *)object2 /* labels */ clear];
            if ( [(ANTLRTreeWizard *)actor _parse:t Pattern:object1/* tpattern */ Map:object2 /* labels */] ) {
                [self visit:t Parent:parent ChildIndex:childIndex Map:object2 /* labels */];
            }
            break;
        case 1:
            if ( [(ANTLRTreeWizard *)actor _parse:t Pattern:object1/* tpattern */ Map:nil] ) {
                [(AMutableArray *)object2/* subtrees */ addObject:t];
            }
            break;
    }
    // [self visit:t];
    return;
}

- (void) visit:(ANTLRCommonTree *)t
{
    [object1 addObject:t];
    return;
}

@synthesize action;
@synthesize actor;
@synthesize object1;
@synthesize object2;
@end

/** When using %label:TOKENNAME in a tree for parse(), we must
 *  track the label.
 */
@implementation ANTLRTreePattern

@synthesize label;
@synthesize hasTextArg;

+ (ANTLRCommonTree *)newANTLRTreePattern:(id<ANTLRToken>)payload
{
    return (ANTLRCommonTree *)[[ANTLRTreePattern alloc] initWithToken:payload];
}

- (id) initWithToken:(id<ANTLRToken>)payload
{
    self = [super initWithToken:payload];
    if ( self != nil ) {
    }
    return (ANTLRCommonTree *)self;
}

- (void) dealloc
{
#ifdef DEBUG_DEALLOC
    NSLog( @"called dealloc in ANTLRTreePattern" );
#endif
    if ( label ) [label release];
    [super dealloc];
}

- (NSString *)toString
{
    if ( label != nil ) {
        return [NSString stringWithFormat:@"\% %@ : %@", label, [super toString]];
    }
    else {
        return [super toString];				
    }
}

@end

@implementation ANTLRWildcardTreePattern

+ (ANTLRWildcardTreePattern *)newANTLRWildcardTreePattern:(id<ANTLRToken>)payload
{
    return(ANTLRWildcardTreePattern *)[[ANTLRWildcardTreePattern alloc] initWithToken:(id<ANTLRToken>)payload];
}

- (id) initWithToken:(id<ANTLRToken>)payload
{
    self = [super initWithToken:payload];
    if ( self != nil ) {
    }
    return self;
}

@end

/** This adaptor creates TreePattern objects for use during scan() */
@implementation ANTLRTreePatternTreeAdaptor

+ (ANTLRTreePatternTreeAdaptor *)newTreeAdaptor
{
    return [[ANTLRTreePatternTreeAdaptor alloc] init];
}

- (id) init
{
    self = [super init];
    if ( self != nil ) {
    }
    return self;
}

- (ANTLRCommonTree *)createTreePattern:(id<ANTLRToken>)payload
{
    return (ANTLRCommonTree *)[super create:payload];
}
          
@end

@implementation ANTLRTreeWizard

// 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 nil,
 *  then none are indexed.
 protected Set tokenTypesToReverseIndex = nil;
 */

+ (ANTLRTreeWizard *) newANTLRTreeWizard:(id<ANTLRTreeAdaptor>)anAdaptor
{
    return [[ANTLRTreeWizard alloc] initWithAdaptor:anAdaptor];
}

+ (ANTLRTreeWizard *)newANTLRTreeWizard:(id<ANTLRTreeAdaptor>)anAdaptor Map:(ANTLRMap *)aTokenNameToTypeMap
{
    return [[ANTLRTreeWizard alloc] initWithAdaptor:anAdaptor Map:aTokenNameToTypeMap];
}

+ (ANTLRTreeWizard *)newANTLRTreeWizard:(id<ANTLRTreeAdaptor>)anAdaptor TokenNames:(NSArray *)theTokNams
{
    return [[ANTLRTreeWizard alloc] initWithTokenNames:anAdaptor TokenNames:theTokNams];
}

+ (ANTLRTreeWizard *)newANTLRTreeWizardWithTokenNames:(NSArray *)theTokNams
{
    return [[ANTLRTreeWizard alloc] initWithTokenNames:theTokNams];
}

- (id) init
{
    if ((self = [super init]) != nil) {
    }
    return self;
}

- (id) initWithAdaptor:(id<ANTLRTreeAdaptor>)anAdaptor
{
    if ((self = [super init]) != nil) {
        adaptor = anAdaptor;
        if ( adaptor ) [adaptor retain];
    }
    return self;
}
            
- (id) initWithAdaptor:(id<ANTLRTreeAdaptor>)anAdaptor Map:(ANTLRMap *)aTokenNameToTypeMap
{
    if ((self = [super init]) != nil) {
        adaptor = anAdaptor;
        if ( adaptor ) [adaptor retain];
        tokenNameToTypeMap = aTokenNameToTypeMap;
   }
    return self;
}

- (id) initWithTokenNames:(NSArray *)theTokNams
{
    if ((self = [super init]) != nil) {
#pragma warning Fix initWithTokenNames.
        // adaptor = anAdaptor;
        //tokenNameToTypeMap = aTokenNameToTypeMap;
        tokenNameToTypeMap = [[self computeTokenTypes:theTokNams] retain];
    }
    return self;
}
             
- (id) initWithTokenNames:(id<ANTLRTreeAdaptor>)anAdaptor TokenNames:(NSArray *)theTokNams
{
    if ((self = [super init]) != nil) {
        adaptor = anAdaptor;
        if ( adaptor ) [adaptor retain];
        // tokenNameToTypeMap = aTokenNameToTypeMap;
        tokenNameToTypeMap = [[self computeTokenTypes:theTokNams] retain];
    }
    return self;
}
            
- (void) dealloc
{
#ifdef DEBUG_DEALLOC
    NSLog( @"called dealloc in ANTLRTreePatternTreeAdaptor" );
#endif
    if ( adaptor ) [adaptor release];
    if ( tokenNameToTypeMap ) [tokenNameToTypeMap release];
    [super dealloc];
}

/** Compute a Map<String, Integer> that is an inverted index of
 *  tokenNames (which maps int token types to names).
 */
- (ANTLRMap *)computeTokenTypes:(NSArray *)theTokNams
{
    ANTLRMap *m = [ANTLRMap newANTLRMap];
    if ( theTokNams == nil ) {
        return m;
    }
    for (int ttype = ANTLRTokenTypeMIN; ttype < [theTokNams count]; ttype++) {
        NSString *name = (NSString *) [theTokNams objectAtIndex:ttype];
        [m putName:name TType:ttype];
    }
    return m;
}

/** Using the map of token names to token types, return the type. */
- (NSInteger)getTokenType:(NSString *)tokenName
{
    if ( tokenNameToTypeMap == nil ) {
        return ANTLRTokenTypeInvalid;
    }
    NSInteger aTType = (NSInteger)[tokenNameToTypeMap getTType:tokenName];
    if ( aTType != -1 ) {
        return aTType;
    }
    return ANTLRTokenTypeInvalid;
}

/** 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<Integer, List> 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
 */
- (ANTLRMap *)index:(ANTLRCommonTree *)t
{
    ANTLRMap *m = [ANTLRMap newANTLRMap];
    [self _index:t Map:m];
    return m;
}

/** Do the work for index */
- (void) _index:(ANTLRCommonTree *)t Map:(ANTLRMap *)m
{
    if ( t==nil ) {
        return;
    }
#pragma warning Fix _index use of ANTLRMap.
    NSInteger ttype = [adaptor getType:t];
    ANTLRMap *elements = (ANTLRMap *)[m getName:ttype];
    if ( elements == nil ) {
        elements = [ANTLRMap newANTLRMapWithLen:100];
        [m putNode:ttype Node:elements];
    }
    [elements addObject:t];
    int n = [adaptor getChildCount:t];
    for (int i=0; i<n; i++) {
        ANTLRCommonTree * child = [adaptor getChild:t At:i];
        [self _index:child Map:m];
    }
}

/** Return a List of tree nodes with token type ttype */
- (AMutableArray *)find:(ANTLRCommonTree *)t Type:(NSInteger)ttype
{
#ifdef DONTUSENOMO
    final List nodes = new ArrayList();
    visit(t, ttype, new TreeWizard.Visitor() {
        public void visit(Object t) {
            [nodes addObject t];
        }
    } );
#endif
    AMutableArray *nodes = [AMutableArray arrayWithCapacity:100];
    ANTLRVisitor *contextVisitor = [ANTLRVisitor newANTLRVisitor:3 Actor:self Object:(id)nodes Object:nil];
    [self visit:t Type:ttype Visitor:contextVisitor];
    return nodes;
}

/** Return a List of subtrees matching pattern. */
- (AMutableArray *)find:(ANTLRCommonTree *)t Pattern:(NSString *)pattern
{
    AMutableArray *subtrees = [AMutableArray arrayWithCapacity:100];
    // Create a TreePattern from the pattern
    ANTLRTreePatternLexer *tokenizer = [ANTLRTreePatternLexer newANTLRTreePatternLexer:pattern];
    ANTLRTreePatternParser *parser = [ANTLRTreePatternParser newANTLRTreePatternParser:tokenizer
                                                                                     Wizard:self
                                                                                    Adaptor:[ANTLRTreePatternTreeAdaptor newTreeAdaptor]];
    ANTLRCommonTree *tpattern = (ANTLRCommonTree *)[parser pattern];
    // don't allow invalid patterns
    if ( tpattern == nil ||
        [tpattern isNil] ||
        [tpattern class] == [ANTLRWildcardTreePattern class] )
    {
        return nil;
    }
    int rootTokenType = [tpattern type];
#ifdef DONTUSENOMO
    visit(t, rootTokenType, new TreeWizard.ContextVisitor() {
        public void visit(Object t, Object parent, int childIndex, Map labels) {
            if ( _parse(t, tpattern, null) ) {
                subtrees.add(t);
            }
        }
    } );
#endif
    ANTLRVisitor *contextVisitor = [ANTLRVisitor newANTLRVisitor:1 Actor:self Object:tpattern Object:subtrees];
    [self visit:t Type:rootTokenType Visitor:contextVisitor];
    return subtrees;
}

- (ANTLRTreeWizard *)findFirst:(ANTLRCommonTree *) t Type:(NSInteger)ttype
{
    return nil;
}

- (ANTLRTreeWizard *)findFirst:(ANTLRCommonTree *) t Pattern:(NSString *)pattern
{
    return nil;
}

/** Visit every ttype node in t, invoking the visitor.  This is a quicker
 *  version of the general visit(t, pattern) method.  The labels arg
 *  of the visitor action method is never set (it's nil) since using
 *  a token type rather than a pattern doesn't let us set a label.
 */
- (void) visit:(ANTLRCommonTree *)t Type:(NSInteger)ttype Visitor:(ANTLRVisitor *)visitor
{
    [self _visit:t Parent:nil ChildIndex:0 Type:ttype Visitor:visitor];
}

/** Do the recursive work for visit */
- (void) _visit:(ANTLRCommonTree *)t
         Parent:(ANTLRCommonTree *)parent
     ChildIndex:(NSInteger)childIndex
           Type:(NSInteger)ttype
        Visitor:(ANTLRVisitor *)visitor
{
    if ( t == nil ) {
        return;
    }
    if ( [adaptor getType:t] == ttype ) {
        [visitor visit:t Parent:parent ChildIndex:childIndex Map:nil];
    }
    int n = [adaptor getChildCount:t];
    for (int i=0; i<n; i++) {
        ANTLRCommonTree * child = [adaptor getChild:t At:i];
        [self _visit:child Parent:t ChildIndex:i Type:ttype Visitor:visitor];
    }
}

/** For all subtrees that match the pattern, execute the visit action.
 *  The implementation uses the root node of the pattern in combination
 *  with visit(t, ttype, visitor) so nil-rooted patterns are not allowed.
 *  Patterns with wildcard roots are also not allowed.
 */
- (void)visit:(ANTLRCommonTree *)t Pattern:(NSString *)pattern Visitor:(ANTLRVisitor *)visitor
{
    // Create a TreePattern from the pattern
    ANTLRTreePatternLexer *tokenizer = [ANTLRTreePatternLexer newANTLRTreePatternLexer:pattern];
    ANTLRTreePatternParser *parser =
    [ANTLRTreePatternParser newANTLRTreePatternParser:tokenizer Wizard:self Adaptor:[ANTLRTreePatternTreeAdaptor newTreeAdaptor]];
    ANTLRCommonTree *tpattern = [parser pattern];
    // don't allow invalid patterns
    if ( tpattern == nil ||
        [tpattern isNil] ||
        [tpattern class] == [ANTLRWildcardTreePattern class] )
    {
        return;
    }
    ANTLRMapElement *labels = [ANTLRMap newANTLRMap]; // reused for each _parse
    int rootTokenType = [tpattern type];
#pragma warning This is another one of those screwy nested constructs that I have to figure out
#ifdef DONTUSENOMO
    visit(t, rootTokenType, new TreeWizard.ContextVisitor() {
        public void visit(Object t, Object parent, int childIndex, Map unusedlabels) {
            // the unusedlabels arg is null as visit on token type doesn't set.
            labels.clear();
            if ( _parse(t, tpattern, labels) ) {
                visitor.visit(t, parent, childIndex, labels);
            }
        }
    });
#endif
    ANTLRVisitor *contextVisitor = [ANTLRVisitor newANTLRVisitor:0 Actor:self Object:tpattern Object:labels];
    [self visit:t Type:rootTokenType Visitor:contextVisitor];
}

/** Given a pattern like (ASSIGN %lhs:ID %rhs:.) with optional labels
 *  on the various nodes and '.' (dot) as the node/subtree wildcard,
 *  return true if the pattern matches and fill the labels Map with
 *  the labels pointing at the appropriate nodes.  Return false if
 *  the pattern is malformed or the tree does not match.
 *
 *  If a node specifies a text arg in pattern, then that must match
 *  for that node in t.
 *
 *  TODO: what's a better way to indicate bad pattern? Exceptions are a hassle 
 */
- (BOOL)parse:(ANTLRCommonTree *)t Pattern:(NSString *)pattern Map:(ANTLRMap *)labels
{
#ifdef DONTUSENOMO
    TreePatternLexer tokenizer = new TreePatternLexer(pattern);
    TreePatternParser parser =
    new TreePatternParser(tokenizer, this, new TreePatternTreeAdaptor());
    TreePattern tpattern = (TreePattern)parser.pattern();
    /*
     System.out.println("t="+((Tree)t).toStringTree());
     System.out.println("scant="+tpattern.toStringTree());
     */
    boolean matched = _parse(t, tpattern, labels);
    return matched;
#endif
    ANTLRTreePatternLexer *tokenizer = [ANTLRTreePatternLexer newANTLRTreePatternLexer:pattern];
    ANTLRTreePatternParser *parser = [ANTLRTreePatternParser newANTLRTreePatternParser:tokenizer
                                                                                Wizard:self
                                                                               Adaptor:[ANTLRTreePatternTreeAdaptor newTreeAdaptor]];
    ANTLRCommonTree *tpattern = [parser pattern];
    /*
     System.out.println("t="+((Tree)t).toStringTree());
     System.out.println("scant="+tpattern.toStringTree());
     */
    //BOOL matched = [self _parse:t Pattern:tpattern Map:labels];
    //return matched;
    return [self _parse:t Pattern:tpattern Map:labels];
}

- (BOOL) parse:(ANTLRCommonTree *)t Pattern:(NSString *)pattern
{
    return [self parse:t Pattern:pattern Map:nil];
}

/** Do the work for parse. Check to see if the t2 pattern fits the
 *  structure and token types in t1.  Check text if the pattern has
 *  text arguments on nodes.  Fill labels map with pointers to nodes
 *  in tree matched against nodes in pattern with labels.
 */
- (BOOL) _parse:(ANTLRCommonTree *)t1 Pattern:(ANTLRCommonTree *)aTPattern Map:(ANTLRMap *)labels
{
    ANTLRTreePattern *tpattern;
    // make sure both are non-nil
    if ( t1 == nil || aTPattern == nil ) {
        return NO;
    }
    if ( [aTPattern isKindOfClass:[ANTLRWildcardTreePattern class]] ) {
        tpattern = (ANTLRTreePattern *)aTPattern;
    }
    // check roots (wildcard matches anything)
    if ( [tpattern class] != [ANTLRWildcardTreePattern class] ) {
        if ( [adaptor getType:t1] != [tpattern type] )
            return NO;
        // if pattern has text, check node text
        if ( tpattern.hasTextArg && ![[adaptor getText:t1] isEqualToString:[tpattern text]] ) {
            return NO;
        }
    }
    if ( tpattern.label != nil && labels!=nil ) {
        // map label in pattern to node in t1
        [labels putName:tpattern.label Node:t1];
    }
    // check children
    int n1 = [adaptor getChildCount:t1];
    int n2 = [tpattern getChildCount];
    if ( n1 != n2 ) {
        return NO;
    }
    for (int i=0; i<n1; i++) {
        ANTLRCommonTree * child1 = [adaptor getChild:t1 At:i];
        ANTLRCommonTree *child2 = (ANTLRCommonTree *)[tpattern getChild:i];
        if ( ![self _parse:child1 Pattern:child2 Map:labels] ) {
            return NO;
        }
    }
    return YES;
}

/** Create a tree or node from the indicated tree pattern that closely
 *  follows ANTLR tree grammar tree element syntax:
 *
 * 		(root child1 ... child2).
 *
 *  You can also just pass in a node: ID
 * 
 *  Any node can have a text argument: ID[foo]
 *  (notice there are no quotes around foo--it's clear it's a string).
 *
 *  nil is a special name meaning "give me a nil node".  Useful for
 *  making lists: (nil A B C) is a list of A B C.
 */
- (ANTLRCommonTree *) createTree:(NSString *)pattern
{
    ANTLRTreePatternLexer *tokenizer = [ANTLRTreePatternLexer newANTLRTreePatternLexer:pattern];
    ANTLRTreePatternParser *parser = [ANTLRTreePatternParser newANTLRTreePatternParser:tokenizer Wizard:self Adaptor:adaptor];
    ANTLRCommonTree * t = [parser pattern];
    return t;
}

/** Compare t1 and t2; return true if token types/text, structure match exactly.
 *  The trees are examined in their entirety so that (A B) does not match
 *  (A B C) nor (A (B C)). 
 // TODO: allow them to pass in a comparator
 *  TODO: have a version that is nonstatic so it can use instance adaptor
 *
 *  I cannot rely on the tree node's equals() implementation as I make
 *  no constraints at all on the node types nor interface etc... 
 */
- (BOOL)equals:(id)t1 O2:(id)t2 Adaptor:(id<ANTLRTreeAdaptor>)anAdaptor
{
    return [self _equals:t1 O2:t2 Adaptor:anAdaptor];
}

/** Compare type, structure, and text of two trees, assuming adaptor in
 *  this instance of a TreeWizard.
 */
- (BOOL)equals:(id)t1 O2:(id)t2
{
    return [self _equals:t1 O2:t2 Adaptor:adaptor];
}

- (BOOL) _equals:(id)t1 O2:(id)t2 Adaptor:(id<ANTLRTreeAdaptor>)anAdaptor
{
    // make sure both are non-nil
    if ( t1==nil || t2==nil ) {
        return NO;
    }
    // check roots
    if ( [anAdaptor getType:t1] != [anAdaptor getType:t2] ) {
        return NO;
    }
    if ( ![[anAdaptor getText:t1] isEqualTo:[anAdaptor getText:t2]] ) {
        return NO;
    }
    // check children
    NSInteger n1 = [anAdaptor getChildCount:t1];
    NSInteger n2 = [anAdaptor getChildCount:t2];
    if ( n1 != n2 ) {
        return NO;
    }
    for (int i=0; i<n1; i++) {
        ANTLRCommonTree * child1 = [anAdaptor getChild:t1 At:i];
        ANTLRCommonTree * child2 = [anAdaptor getChild:t2 At:i];
        if ( ![self _equals:child1 O2:child2 Adaptor:anAdaptor] ) {
            return NO;
        }
    }
    return YES;
}

// TODO: next stuff taken from CommonTreeNodeStream

/** Given a node, add this to the reverse index tokenTypeToStreamIndexesMap.
 *  You can override this method to alter how indexing occurs.  The
 *  default is to create a
 *
 *    Map<Integer token type,ArrayList<Integer stream index>>
 *
 *  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<Integertoken type, Map<Object tree node, Integer stream index>>
 *
 *  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.
- (void)fillReverseIndex:(ANTLRCommonTree *)node Index:(NSInteger)streamIndex
{
    //System.out.println("revIndex "+node+"@"+streamIndex);
    if ( tokenTypesToReverseIndex == nil ) {
        return; // no indexing if this is empty (nothing of interest)
    }
    if ( tokenTypeToStreamIndexesMap == nil ) {
        tokenTypeToStreamIndexesMap = [ANTLRMap newANTLRMap]; // 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
    }
    NSInteger streamIndexI = streamIndex;
    AMutableArray *indexes = (AMutableArray *)[tokenTypeToStreamIndexesMap objectAtIndex:tokenTypeI];
    if ( indexes==nil ) {
        indexes = [AMutableArray arrayWithCapacity:100]; // no list yet for this token type
        indexes.add(streamIndexI); // not there yet, add
        [tokenTypeToStreamIndexesMap put:tokenTypeI Idexes: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:(NSInteger)tokenType
{
    if ( tokenTypesToReverseIndex == nil ) {
        tokenTypesToReverseIndex = [ANTLRMap newANTLRMap];
    }
    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==nil ) {
        return getNodeIndexLinearly(node);
    }
    int tokenType = adaptor.getType(node);
    Integer tokenTypeI = new Integer(tokenType);
    ArrayList indexes = (ArrayList)tokenTypeToStreamIndexesMap.get(tokenTypeI);
    if ( indexes==nil ) {
        //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;
}
 
*/

@synthesize adaptor;
@synthesize tokenNameToTypeMap;
@end