//
// ANTLRTokenRewriteStream.m
// ANTLR
//
// Created by Alan Condit on 6/19/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 "ANTLRTokenRewriteStream.h"
#import "ANTLRRuntimeException.h"
static NSString *DEFAULT_PROGRAM_NAME = @"default";
static NSInteger PROGRAM_INIT_SIZE = 100;
static NSInteger MIN_TOKEN_INDEX = 0;
extern NSInteger debug;
// Define the rewrite operation hierarchy
@implementation ANTLRRewriteOperation
@synthesize instructionIndex;
@synthesize rwIndex;
@synthesize text;
+ (ANTLRRewriteOperation *) newANTLRRewriteOperation:(NSInteger)anIndex Text:(NSString *)theText
{
return [[ANTLRRewriteOperation alloc] initWithIndex:anIndex Text:theText];
}
- (id) initWithIndex:(NSInteger)anIndex Text:(NSString *)theText
{
if ((self = [super init]) != nil) {
rwIndex = anIndex;
text = theText;
}
return self;
}
/** Execute the rewrite operation by possibly adding to the buffer.
* Return the rwIndex of the next token to operate on.
*/
- (NSInteger) execute:(NSString *)buf
{
return rwIndex;
}
- (NSString *)toString
{
NSString *opName = [self className];
int $index = [self indexOf:'$' inString:opName];
opName = [opName substringWithRange:NSMakeRange($index+1, [opName length])];
return [NSString stringWithFormat:@"<%@%d:\"%@\">", opName, rwIndex, opName];
}
- (NSInteger) indexOf:(char)aChar inString:(NSString *)aString
{
char indexedChar;
for( int i = 0; i < [aString length]; i++ ) {
indexedChar = [aString characterAtIndex:i];
if (indexedChar == aChar) {
return i;
}
}
return -1;
}
@end
@implementation ANTLRInsertBeforeOp
+ (ANTLRInsertBeforeOp *) newANTLRInsertBeforeOp:(NSInteger) anIndex Text:(NSString *)theText
{
return [[ANTLRInsertBeforeOp alloc] initWithIndex:anIndex Text:theText];
}
- (id) initWithIndex:(NSInteger)anIndex Text:(NSString *)theText
{
if ((self = [super initWithIndex:anIndex Text:theText]) != nil) {
rwIndex = anIndex;
text = theText;
}
return self;
}
- (NSInteger) execute:(NSMutableString *)buf
{
[buf appendString:text];
if ( ((ANTLRCommonToken *)[tokens objectAtIndex:rwIndex]).type != ANTLRTokenTypeEOF ) {
[buf appendString:[[tokens objectAtIndex:rwIndex] text]];
}
return rwIndex+1;
}
@end
/** I'm going to try replacing range from x..y with (y-x)+1 ANTLRReplaceOp
* instructions.
*/
@implementation ANTLRReplaceOp
@synthesize lastIndex;
+ (ANTLRReplaceOp *) newANTLRReplaceOp:(NSInteger)from ToIndex:(NSInteger)to Text:(NSString*)theText
{
return [[ANTLRReplaceOp alloc] initWithIndex:from ToIndex:to Text:theText];
}
- (id) initWithIndex:(NSInteger)from ToIndex:(NSInteger)to Text:(NSString *)theText
{
if ((self = [super initWithIndex:from Text:theText]) != nil) {
lastIndex = to;
}
return self;
}
- (NSInteger) execute:(NSMutableString *)buf
{
if ( text!=nil ) {
[buf appendString:text];
}
return lastIndex+1;
}
- (NSString *)toString
{
return [NSString stringWithFormat:@"<ANTLRReplaceOp@ %d..%d :>%@\n", rwIndex, lastIndex, text];
}
@end
@implementation ANTLRDeleteOp
+ (ANTLRDeleteOp *) newANTLRDeleteOp:(NSInteger)from ToIndex:(NSInteger)to
{
// super(from To:to, null);
return [[ANTLRDeleteOp alloc] initWithIndex:from ToIndex:to];
}
- (id) initWithIndex:(NSInteger)from ToIndex:(NSInteger)to
{
if ((self = [super initWithIndex:from ToIndex:to Text:nil]) != nil) {
lastIndex = to;
}
return self;
}
- (NSString *)toString
{
return [NSString stringWithFormat:@"<DeleteOp@ %d..%d\n", rwIndex, lastIndex];
}
@end
@implementation ANTLRTokenRewriteStream
@synthesize programs;
@synthesize lastRewriteTokenIndexes;
+ (ANTLRTokenRewriteStream *)newANTLRTokenRewriteStream
{
return [[ANTLRTokenRewriteStream alloc] init];
}
+ (ANTLRTokenRewriteStream *)newANTLRTokenRewriteStream:(id<ANTLRTokenSource>) aTokenSource
{
return [[ANTLRTokenRewriteStream alloc] initWithTokenSource:aTokenSource];
}
+ (ANTLRTokenRewriteStream *)newANTLRTokenRewriteStream:(id<ANTLRTokenSource>) aTokenSource Channel:(NSInteger)aChannel
{
return [[ANTLRTokenRewriteStream alloc] initWithTokenSource:aTokenSource Channel:aChannel];
}
- (id) init
{
if ((self = [super init]) != nil) {
programs = [ANTLRHashMap newANTLRHashMap];
[programs addObject:[ANTLRMapElement newANTLRMapElementWithName:DEFAULT_PROGRAM_NAME Node:[ANTLRHashMap newANTLRHashMapWithLen:PROGRAM_INIT_SIZE]]];
lastRewriteTokenIndexes = [ANTLRHashMap newANTLRHashMap];
}
return self;
}
- (id)initWithTokenSource:(id<ANTLRTokenSource>)aTokenSource
{
if ((self = [super init]) != nil) {
programs = [ANTLRHashMap newANTLRHashMap];
[programs addObject:[ANTLRMapElement newANTLRMapElementWithName:DEFAULT_PROGRAM_NAME Node:[ANTLRHashMap newANTLRHashMapWithLen:PROGRAM_INIT_SIZE]]];
lastRewriteTokenIndexes = [ANTLRHashMap newANTLRHashMap];
tokenSource = aTokenSource;
}
return self;
}
- (id)initWithTokenSource:(id<ANTLRTokenSource>)aTokenSource Channel:(NSInteger)aChannel
{
if ((self = [super init]) != nil) {
programs = [ANTLRHashMap newANTLRHashMap];
[programs addObject:[ANTLRMapElement newANTLRMapElementWithName:DEFAULT_PROGRAM_NAME Node:[ANTLRHashMap newANTLRHashMapWithLen:PROGRAM_INIT_SIZE]]];
lastRewriteTokenIndexes = [ANTLRHashMap newANTLRHashMap];
tokenSource = aTokenSource;
channel = aChannel;
}
return self;
}
- (ANTLRHashMap *)getPrograms
{
return programs;
}
- (void)setPrograms:(ANTLRHashMap *)aProgList
{
programs = aProgList;
}
- (void) rollback:(NSInteger)instructionIndex
{
[self rollback:DEFAULT_PROGRAM_NAME Index:instructionIndex];
}
/** Rollback the instruction stream for a program so that
* the indicated instruction (via instructionIndex) is no
* longer in the stream. UNTESTED!
*/
- (void) rollback:(NSString *)programName Index:(NSInteger)anInstructionIndex
{
id object;
ANTLRHashMap *is;
// AMutableArray *is = [programs get(programName)];
is = [self getPrograms];
object = [is getName:programName];
if ( is != nil ) {
#pragma warning this has to be fixed
[programs insertObject:programName atIndex:anInstructionIndex];
}
}
- (void) deleteProgram
{
[self deleteProgram:DEFAULT_PROGRAM_NAME];
}
/** Reset the program so that no instructions exist */
- (void) deleteProgram:(NSString *)programName
{
[self rollback:programName Index:MIN_TOKEN_INDEX];
}
- (void) insertAfterToken:(id<ANTLRToken>)t Text:(NSString *)theText
{
[self insertAfterProgNam:DEFAULT_PROGRAM_NAME Index:[t getTokenIndex] Text:theText];
}
- (void) insertAfterIndex:(NSInteger)anIndex Text:(NSString *)theText
{
[self insertAfterProgNam:DEFAULT_PROGRAM_NAME Index:(NSInteger)anIndex Text:(NSString *)theText];
}
- (void) insertAfterProgNam:(NSString *)programName Index:(NSInteger)anIndex Text:(NSString *)theText
{
// to insert after, just insert before next rwIndex (even if past end)
[self insertBeforeProgName:programName Index:anIndex+1 Text:theText];
//addToSortedRewriteList(programName, new InsertAfterOp(rwIndex,text));
}
- (void) insertBeforeToken:(id<ANTLRToken>)t Text:(NSString *)theText
{
[self insertBeforeProgName:DEFAULT_PROGRAM_NAME Index:[t getTokenIndex] Text:theText];
}
- (void) insertBeforeIndex:(NSInteger)anIndex Text:(NSString *)theText
{
[self insertBeforeProgName:DEFAULT_PROGRAM_NAME Index:anIndex Text:theText];
}
- (void) insertBeforeProgName:(NSString *)programName Index:(NSInteger)rwIndex Text:(NSString *)theText
{
//addToSortedRewriteList(programName, new ANTLRInsertBeforeOp(rwIndex,text));
ANTLRRewriteOperation *op = [ANTLRInsertBeforeOp newANTLRInsertBeforeOp:rwIndex Text:theText];
ANTLRHashMap *rewrites = [self getProgram:programName];
op.instructionIndex = [rewrites count];
[rewrites addObject:op];
}
- (void) replaceFromIndex:(NSInteger)anIndex Text:(NSString *)theText
{
[self replaceProgNam:DEFAULT_PROGRAM_NAME FromIndex:anIndex ToIndex:anIndex Text:theText];
}
- (void) replaceFromIndex:(NSInteger)from ToIndex:(NSInteger)to Text:(NSString *)theText
{
[self replaceProgNam:DEFAULT_PROGRAM_NAME FromIndex:from ToIndex:to Text:theText];
}
- (void) replaceFromToken:(id<ANTLRToken>)anIndexT Text:(NSString *)theText
{
[self replaceProgNam:DEFAULT_PROGRAM_NAME FromIndex:[anIndexT getTokenIndex] ToIndex:[anIndexT getTokenIndex] Text:theText];
}
- (void) replaceFromToken:(id<ANTLRToken>)from ToToken:(id<ANTLRToken>)to Text:(NSString *)theText
{
[self replaceProgNam:DEFAULT_PROGRAM_NAME FromIndex:[from getTokenIndex] ToIndex:[to getTokenIndex] Text:theText];
}
- (void) replaceProgNam:(NSString *)programName Token:(id<ANTLRToken>)from Token:(id<ANTLRToken>)to Text:(NSString *)theText
{
[self replaceProgNam:programName FromIndex:[from getTokenIndex] ToIndex:[to getTokenIndex] Text:theText];
}
- (void) replaceProgNam:(NSString *)programName FromIndex:(NSInteger)from ToIndex:(NSInteger)to Text:(NSString *)theText
{
if ( from > to || from < 0 || to < 0 || to >= [tokens count] ) {
@throw [ANTLRIllegalArgumentException newException:[NSString stringWithFormat:@"replace: range invalid: %d..%d size=%d\n", from, to, [tokens count]]];
}
ANTLRRewriteOperation *op = [ANTLRReplaceOp newANTLRReplaceOp:from ToIndex:to Text:theText];
ANTLRHashMap *rewrites = (ANTLRHashMap *)[lastRewriteTokenIndexes getName:programName];
op.instructionIndex = [rewrites count];
[rewrites addObject:op];
}
- (void) delete:(NSInteger)anIndex
{
[self delete:DEFAULT_PROGRAM_NAME FromIndex:(NSInteger)anIndex ToIndex:(NSInteger)anIndex];
}
- (void) delete:(NSInteger)from ToIndex:(NSInteger)to
{
[self delete:DEFAULT_PROGRAM_NAME FromIndex:from ToIndex:to];
}
- (void) deleteToken:(id<ANTLRToken>)anIndexT
{
[self delete:DEFAULT_PROGRAM_NAME FromIndex:[anIndexT getTokenIndex] ToIndex:[anIndexT getTokenIndex]];
}
- (void) deleteFromToken:(id<ANTLRToken>)from ToToken:(id<ANTLRToken>)to
{
[self delete:DEFAULT_PROGRAM_NAME FromIndex:[from getTokenIndex] ToIndex:[to getTokenIndex]];
}
- (void) delete:(NSString *)programName FromToken:(id<ANTLRToken>)from ToToken:(id<ANTLRToken>)to
{
[self replaceProgNam:programName FromIndex:[from getTokenIndex] ToIndex:[to getTokenIndex] Text:nil];
}
- (void) delete:(NSString *)programName FromIndex:(NSInteger)from ToIndex:(NSInteger)to
{
[self replaceProgNam:programName FromIndex:from ToIndex:to Text:nil];
}
- (NSInteger)getLastRewriteTokenIndex
{
return [self getLastRewriteTokenIndex:DEFAULT_PROGRAM_NAME];
}
- (NSInteger)getLastRewriteTokenIndex:(NSString *)programName
{
#pragma warning fix this to look up the hashed name
NSInteger anInt = -1;
ANTLRMapElement *node = [lastRewriteTokenIndexes lookup:programName Scope:0];
if ( node != nil ) {
anInt = [lastRewriteTokenIndexes hash:programName];
}
return anInt;
}
- (void)setLastRewriteTokenIndex:(NSString *)programName Index:(NSInteger)anInt
{
[lastRewriteTokenIndexes insertObject:programName atIndex:anInt];
}
-(ANTLRHashMap *) getProgram:(NSString *)name
{
ANTLRHashMap *is = (ANTLRHashMap *)[programs getName:name];
if ( is == nil ) {
is = [self initializeProgram:name];
}
return is;
}
-(ANTLRHashMap *) initializeProgram:(NSString *)name
{
ANTLRHashMap *is = [ANTLRHashMap newANTLRHashMapWithLen:PROGRAM_INIT_SIZE];
[is putName:name Node:nil];
return is;
}
- (NSString *)toOriginalString
{
[super fill];
return [self toOriginalString:MIN_TOKEN_INDEX End:[tokens count]-1];
}
- (NSString *)toOriginalString:(NSInteger)start End:(NSInteger)end
{
NSMutableString *buf = [NSMutableString stringWithCapacity:100];
for (int i = start; i >= MIN_TOKEN_INDEX && i <= end && i< [tokens count]; i++) {
if ( [[lastRewriteTokenIndexes objectAtIndex:i] type] != ANTLRTokenTypeEOF )
[buf appendString:[[tokens objectAtIndex:i] text]];
}
return [NSString stringWithString:buf];
}
- (NSString *)toString
{
[super fill];
return [self toStringFromStart:MIN_TOKEN_INDEX ToEnd:[tokens count]-1];
}
- (NSString *)toString:(NSString *)programName
{
[super fill];
return [self toString:programName FromStart:MIN_TOKEN_INDEX ToEnd:[[programs objectAtIndex:MIN_TOKEN_INDEX] count]-1];
}
- (NSString *)toStringFromStart:(NSInteger)start ToEnd:(NSInteger)end
{
return [self toString:DEFAULT_PROGRAM_NAME FromStart:start ToEnd:end];
}
- (NSString *)toString:(NSString *)programName FromStart:(NSInteger)start ToEnd:(NSInteger)end
{
ANTLRHashMap *rewrites = (ANTLRHashMap *)[programs getName:programName];
// ensure start/end are in range
if ( end > [tokens count]-1 ) end = [tokens count]-1;
if ( start < 0 )
start = 0;
if ( rewrites == nil || [rewrites count] == 0 ) {
return [self toOriginalString:start End:end]; // no instructions to execute
}
NSMutableString *buf = [NSMutableString stringWithCapacity:100];
// First, optimize instruction stream
ANTLRHashMap *indexToOp = [self reduceToSingleOperationPerIndex:rewrites];
// Walk buffer, executing instructions and emitting tokens
int i = start;
while ( i <= end && i < [tokens count] ) {
ANTLRRewriteOperation *op = (ANTLRRewriteOperation *)[indexToOp objectAtIndex:i];
[indexToOp setObject:nil atIndex:i]; // remove so any left have rwIndex size-1
id<ANTLRToken>t = (id<ANTLRToken>) [tokens objectAtIndex:i];
if ( op == nil ) {
// no operation at that rwIndex, just dump token
if ( t.type != ANTLRTokenTypeEOF )
[buf appendString:t.text];
i++; // move to next token
}
else {
i = [op execute:buf]; // execute operation and skip
}
}
// include stuff after end if it's last rwIndex in buffer
// So, if they did an insertAfter(lastValidIndex, "foo"), include
// foo if end==lastValidIndex.
//if ( end == [tokens size]-1 ) {
if ( end == [tokens count]-1 ) {
// Scan any remaining operations after last token
// should be included (they will be inserts).
int i2 = 0;
while ( i2 < [indexToOp count] - 1 ) {
ANTLRRewriteOperation *op = [indexToOp objectAtIndex:i2];
if ( op.rwIndex >= [tokens count]-1 ) {
[buf appendString:op.text];
}
}
}
return [NSString stringWithString:buf];
}
/** We need to combine operations and report invalid operations (like
* overlapping replaces that are not completed nested). Inserts to
* same rwIndex need to be combined etc... Here are the cases:
*
* I.i.u I.j.v leave alone, nonoverlapping
* I.i.u I.i.v combine: Iivu
*
* R.i-j.u R.x-y.v | i-j in x-y delete first R
* R.i-j.u R.i-j.v delete first R
* R.i-j.u R.x-y.v | x-y in i-j ERROR
* R.i-j.u R.x-y.v | boundaries overlap ERROR
*
* I.i.u R.x-y.v | i in x-y delete I
* I.i.u R.x-y.v | i not in x-y leave alone, nonoverlapping
* R.x-y.v I.i.u | i in x-y ERROR
* R.x-y.v I.x.u R.x-y.uv (combine, delete I)
* R.x-y.v I.i.u | i not in x-y leave alone, nonoverlapping
*
* I.i.u = insert u before op @ rwIndex i
* R.x-y.u = replace x-y indexed tokens with u
*
* First we need to examine replaces. For any replace op:
*
* 1. wipe out any insertions before op within that range.
* 2. Drop any replace op before that is contained completely within
* that range.
* 3. Throw exception upon boundary overlap with any previous replace.
*
* Then we can deal with inserts:
*
* 1. for any inserts to same rwIndex, combine even if not adjacent.
* 2. for any prior replace with same left boundary, combine this
* insert with replace and delete this replace.
* 3. throw exception if rwIndex in same range as previous replace
*
* Don't actually delete; make op null in list. Easier to walk list.
* Later we can throw as we add to rwIndex -> op map.
*
* Note that I.2 R.2-2 will wipe out I.2 even though, technically, the
* inserted stuff would be before the replace range. But, if you
* add tokens in front of a method body '{' and then delete the method
* body, I think the stuff before the '{' you added should disappear too.
*
* Return a map from token rwIndex to operation.
*/
- (ANTLRHashMap *)reduceToSingleOperationPerIndex:(ANTLRHashMap *)rewrites
{
//System.out.println("rewrites="+rewrites);
if (debug > 1) NSLog(@"rewrites=%@\n", [rewrites getName:DEFAULT_PROGRAM_NAME]);
// WALK REPLACES
for (int i = 0; i < [rewrites count]; i++) {
ANTLRRewriteOperation *op = (ANTLRRewriteOperation *)[rewrites objectAtIndex:i];
if ( op==nil )
continue;
if ( !([[op class] isKindOfClass:[ANTLRReplaceOp class]]) )
continue;
ANTLRReplaceOp *rop = (ANTLRReplaceOp *)[rewrites objectAtIndex:i];
// Wipe prior inserts within range
//List inserts = getKindOfOps(rewrites, ANTLRInsertBeforeOp.class, i);
ANTLRHashMap *inserts = [self getKindOfOps:rewrites KindOfClass:[ANTLRInsertBeforeOp class] Index:i];
for (int j = 0; j < [inserts size]; j++) {
ANTLRInsertBeforeOp *iop = (ANTLRInsertBeforeOp *)[inserts objectAtIndex:j];
if ( iop.rwIndex >= rop.rwIndex && iop.rwIndex <= rop.lastIndex ) {
// delete insert as it's a no-op.
[rewrites insertObject:nil atIndex:iop.instructionIndex];
}
}
// Drop any prior replaces contained within
ANTLRHashMap *prevReplaces = [self getKindOfOps:rewrites KindOfClass:[ANTLRReplaceOp class] Index:i];
for (int j = 0; j < [prevReplaces count]; j++) {
ANTLRReplaceOp *prevRop = (ANTLRReplaceOp *) [prevReplaces objectAtIndex:j];
if ( prevRop.rwIndex>=rop.rwIndex && prevRop.lastIndex <= rop.lastIndex ) {
// delete replace as it's a no-op.
[rewrites setObject:nil atIndex:prevRop.instructionIndex];
continue;
}
// throw exception unless disjoint or identical
BOOL disjoint = prevRop.lastIndex<rop.rwIndex || prevRop.rwIndex > rop.lastIndex;
BOOL same = prevRop.rwIndex==rop.rwIndex && prevRop.lastIndex==rop.lastIndex;
if ( !disjoint && !same ) {
@throw [ANTLRIllegalArgumentException newException:
[NSString stringWithFormat:@"replace op boundaries of %@, overlap with previous %@\n", rop, prevRop]];
}
}
}
// WALK INSERTS
for (int i = 0; i < [rewrites count]; i++) {
ANTLRRewriteOperation *op = (ANTLRRewriteOperation *)[rewrites objectAtIndex:i];
if ( op == nil )
continue;
if ( !([[op class] isKindOfClass:[ANTLRInsertBeforeOp class]]) )
continue;
ANTLRInsertBeforeOp *iop = (ANTLRInsertBeforeOp *)[rewrites objectAtIndex:i];
// combine current insert with prior if any at same rwIndex
ANTLRHashMap *prevInserts = (ANTLRHashMap *)[self getKindOfOps:rewrites KindOfClass:[ANTLRInsertBeforeOp class] Index:i];
for (int j = 0; j < [prevInserts count]; j++) {
ANTLRInsertBeforeOp *prevIop = (ANTLRInsertBeforeOp *) [prevInserts objectAtIndex:j];
if ( prevIop.rwIndex == iop.rwIndex ) { // combine objects
// convert to strings...we're in process of toString'ing
// whole token buffer so no lazy eval issue with any templates
iop.text = [self catOpText:iop.text PrevText:prevIop.text];
// delete redundant prior insert
[rewrites setObject:nil atIndex:prevIop.instructionIndex];
}
}
// look for replaces where iop.rwIndex is in range; error
ANTLRHashMap *prevReplaces = (ANTLRHashMap *)[self getKindOfOps:rewrites KindOfClass:[ANTLRReplaceOp class] Index:i];
for (int j = 0; j < [prevReplaces count]; j++) {
ANTLRReplaceOp *rop = (ANTLRReplaceOp *) [prevReplaces objectAtIndex:j];
if ( iop.rwIndex == rop.rwIndex ) {
rop.text = [self catOpText:iop.text PrevText:rop.text];
[rewrites setObject:nil atIndex:i]; // delete current insert
continue;
}
if ( iop.rwIndex >= rop.rwIndex && iop.rwIndex <= rop.lastIndex ) {
@throw [ANTLRIllegalArgumentException newException:[NSString stringWithFormat:@"insert op %d within boundaries of previous %d", iop, rop]];
}
}
}
// System.out.println("rewrites after="+rewrites);
ANTLRHashMap *m = [ANTLRHashMap newANTLRHashMapWithLen:15];
for (int i = 0; i < [rewrites count]; i++) {
ANTLRRewriteOperation *op = (ANTLRRewriteOperation *)[rewrites objectAtIndex:i];
if ( op == nil )
continue; // ignore deleted ops
if ( [m objectAtIndex:op.rwIndex] != nil ) {
@throw [ANTLRRuntimeException newException:@"should only be one op per rwIndex\n"];
}
//[m put(new Integer(op.rwIndex), op);
[m setObject:op atIndex:op.rwIndex];
}
//System.out.println("rwIndex to op: "+m);
if (debug > 1) NSLog(@"rwIndex to op %d\n", (NSInteger)m);
return m;
}
- (NSString *)catOpText:(id)a PrevText:(id)b
{
NSString *x = @"";
NSString *y = @"";
if ( a != nil )
x = [a toString];
if ( b != nil )
y = [b toString];
return [NSString stringWithFormat:@"%@%@",x, y];
}
- (ANTLRHashMap *)getKindOfOps:(ANTLRHashMap *)rewrites KindOfClass:(Class)kind
{
return [self getKindOfOps:rewrites KindOfClass:kind Index:[rewrites count]];
}
/** Get all operations before an rwIndex of a particular kind */
- (ANTLRHashMap *)getKindOfOps:(ANTLRHashMap *)rewrites KindOfClass:(Class)kind Index:(NSInteger)before
{
ANTLRHashMap *ops = [ANTLRHashMap newANTLRHashMapWithLen:15];
for (int i = 0; i < before && i < [rewrites count]; i++) {
ANTLRRewriteOperation *op = (ANTLRRewriteOperation *)[rewrites objectAtIndex:i];
if ( op == nil )
continue; // ignore deleted
if ( [op isKindOfClass:(Class)kind] )
[ops addObject:op];
}
return ops;
}
- (NSMutableString *)toDebugString
{
return [self toDebugStringFromStart:MIN_TOKEN_INDEX ToEnd:[tokens count]-1];
}
- (NSMutableString *)toDebugStringFromStart:(NSInteger)start ToEnd:(NSInteger)end
{
NSMutableString *buf = [NSMutableString stringWithCapacity:100];
for (int i = start; i >= MIN_TOKEN_INDEX && i <= end && i < [tokens count]; i++) {
[buf appendString:[[tokens objectAtIndex:i] text]];
}
return [NSString stringWithString:buf];
}
@end