Home | History | Annotate | Download | only in Framework 
      1 // [The "BSD licence"]
      2 // Copyright (c) 2007 Kay Roepke 2010 Alan Condit
      3 // All rights reserved.
      4 //
      5 // Redistribution and use in source and binary forms, with or without
      6 // modification, are permitted provided that the following conditions
      7 // are met:
      8 // 1. Redistributions of source code must retain the above copyright
      9 //    notice, this list of conditions and the following disclaimer.
     10 // 2. Redistributions in binary form must reproduce the above copyright
     11 //    notice, this list of conditions and the following disclaimer in the
     12 //    documentation and/or other materials provided with the distribution.
     13 // 3. The name of the author may not be used to endorse or promote products
     14 //    derived from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     17 // IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     18 // OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     19 // IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     20 // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     21 // NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     22 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     23 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     24 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     25 // THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     26 
     27 #import "ANTLRRecognizerSharedState.h"
     28 #import "ANTLRCharStream.h"
     29 #import "ANTLRCommonToken.h"
     30 #import "ANTLRMismatchedTokenException.h"
     31 #import "ANTLRMismatchedRangeException.h"
     32 
     33 @implementation ANTLRRecognizerSharedState
     34 
     35 @synthesize following;
     36 @synthesize _fsp;
     37 @synthesize errorRecovery;
     38 @synthesize lastErrorIndex;
     39 @synthesize failed;
     40 @synthesize syntaxErrors;
     41 @synthesize backtracking;
     42 @synthesize ruleMemo;
     43 @synthesize token;
     44 @synthesize type;
     45 @synthesize channel;
     46 @synthesize tokenStartLine;
     47 @synthesize tokenStartCharPositionInLine;
     48 @synthesize tokenStartCharIndex;
     49 @synthesize text;
     50 
     51 + (ANTLRRecognizerSharedState *) newANTLRRecognizerSharedState
     52 {
     53     return [[[ANTLRRecognizerSharedState alloc] init] retain];
     54 }
     55 
     56 + (ANTLRRecognizerSharedState *) newANTLRRecognizerSharedStateWithRuleLen:(NSInteger)aLen
     57 {
     58     return [[[ANTLRRecognizerSharedState alloc] initWithRuleLen:aLen] retain];
     59 }
     60 
     61 + (ANTLRRecognizerSharedState *) newANTLRRecognizerSharedState:(ANTLRRecognizerSharedState *)aState
     62 {
     63     return [[[ANTLRRecognizerSharedState alloc] initWithState:aState] retain];
     64 }
     65 
     66 - (id) init
     67 {
     68     ANTLRHashRule *aHashRule;
     69 	if ((self = [super init]) != nil ) {
     70         following = [[AMutableArray arrayWithCapacity:10] retain];
     71         _fsp = -1;
     72         errorRecovery = NO;			// are we recovering?
     73         lastErrorIndex = -1;
     74         failed = NO;				// indicate that some match failed
     75         syntaxErrors = 0;
     76         backtracking = 0;			// the level of backtracking
     77         tokenStartCharIndex = -1;
     78         tokenStartLine = 0;
     79         int cnt = 200;
     80 		ruleMemo = [[ANTLRRuleStack newANTLRRuleStack:cnt] retain];
     81         for (int i = 0; i < cnt; i++ ) {
     82             aHashRule = [[ANTLRHashRule newANTLRHashRuleWithLen:17] retain];
     83             [ruleMemo addObject:aHashRule];
     84         }
     85 #ifdef DONTUSEYET
     86         token = state.token;
     87         tokenStartCharIndex = state.tokenStartCharIndex;
     88         tokenStartCharPositionInLine = state.tokenStartCharPositionInLine;
     89         channel = state.channel;
     90         type = state.type;
     91         text = state.text;
     92 #endif
     93 	}
     94 	return self;
     95 }
     96 
     97 - (id) initWithRuleLen:(NSInteger)aLen
     98 {
     99     ANTLRHashRule *aHashRule;
    100 	if ((self = [super init]) != nil ) {
    101         following = [[AMutableArray arrayWithCapacity:10] retain];
    102         _fsp = -1;
    103         errorRecovery = NO;			// are we recovering?
    104         lastErrorIndex = -1;
    105         failed = NO;				// indicate that some match failed
    106         syntaxErrors = 0;
    107         backtracking = 0;			// the level of backtracking
    108         tokenStartCharIndex = -1;
    109         tokenStartLine = 0;
    110 		ruleMemo = [[ANTLRRuleStack newANTLRRuleStack:aLen] retain];
    111         for (int i = 0; i < aLen; i++ ) {
    112             aHashRule = [[ANTLRHashRule newANTLRHashRuleWithLen:17] retain];
    113             [ruleMemo addObject:aHashRule];
    114         }
    115 #ifdef DONTUSEYET
    116         token = state.token;
    117         tokenStartCharIndex = state.tokenStartCharIndex;
    118         tokenStartCharPositionInLine = state.tokenStartCharPositionInLine;
    119         channel = state.channel;
    120         type = state.type;
    121         text = state.text;
    122 #endif
    123 	}
    124 	return self;
    125 }
    126 
    127 - (id) initWithState:(ANTLRRecognizerSharedState *)aState
    128 {
    129     ANTLRHashRule *aHashRule;
    130     if ( [following count] < [aState.following count] ) {
    131         //        following = new BitSet[state.following.size];
    132     }
    133     [following setArray:aState.following];
    134     _fsp = aState._fsp;
    135     errorRecovery = aState.errorRecovery;
    136     lastErrorIndex = aState.lastErrorIndex;
    137     failed = aState.failed;
    138     syntaxErrors = aState.syntaxErrors;
    139     backtracking = aState.backtracking;
    140     if ( aState.ruleMemo == nil ) {
    141         int cnt = 200;
    142         ruleMemo = [[ANTLRRuleStack newANTLRRuleStack:cnt] retain];
    143         for (int i = 0; i < cnt; i++ ) {
    144             aHashRule = [[ANTLRHashRule newANTLRHashRuleWithLen:17] retain];
    145             [ruleMemo addObject:aHashRule];
    146         }
    147     }
    148     else {
    149         ruleMemo = aState.ruleMemo;
    150         if ( [ruleMemo count] == 0 ) {
    151             int cnt = [ruleMemo length];
    152             for (int i = 0; i < cnt; i++ ) {
    153                 [ruleMemo addObject:[[ANTLRHashRule newANTLRHashRuleWithLen:17] retain]];
    154             }
    155         }
    156         else {
    157             [ruleMemo addObjectsFromArray:aState.ruleMemo];
    158         }
    159     }
    160     token = aState.token;
    161     tokenStartCharIndex = aState.tokenStartCharIndex;
    162     tokenStartCharPositionInLine = aState.tokenStartCharPositionInLine;
    163     tokenStartLine = aState.tokenStartLine;
    164     channel = aState.channel;
    165     type = aState.type;
    166     text = aState.text;
    167     return( self );
    168 }
    169 
    170 - (void) dealloc
    171 {
    172 #ifdef DEBUG_DEALLOC
    173     NSLog( @"called dealloc in ANTLRRecognizerSharedState" );
    174 #endif
    175     if ( token ) [token release];
    176 	if ( following ) [following release];
    177 	if ( ruleMemo ) [ruleMemo release];
    178 	[super dealloc];
    179 }
    180 
    181 // token stuff
    182 #pragma mark Tokens
    183 
    184 - (id<ANTLRToken>)getToken
    185 {
    186     return token; 
    187 }
    188 
    189 - (void) setToken: (id<ANTLRToken>) aToken
    190 {
    191     if (token != aToken) {
    192         [aToken retain];
    193         if ( token ) [token release];
    194         token = aToken;
    195     }
    196 }
    197 
    198 - (NSUInteger)channel
    199 {
    200     return channel;
    201 }
    202 
    203 - (void) setChannel:(NSUInteger) theChannel
    204 {
    205     channel = theChannel;
    206 }
    207 
    208 - (NSUInteger) getTokenStartLine
    209 {
    210     return tokenStartLine;
    211 }
    212 
    213 - (void) setTokenStartLine:(NSUInteger) theTokenStartLine
    214 {
    215     tokenStartLine = theTokenStartLine;
    216 }
    217 
    218 - (NSUInteger) charPositionInLine
    219 {
    220     return tokenStartCharPositionInLine;
    221 }
    222 
    223 - (void) setCharPositionInLine:(NSUInteger) theCharPosition
    224 {
    225     tokenStartCharPositionInLine = theCharPosition;
    226 }
    227 
    228 - (NSInteger) getTokenStartCharIndex;
    229 {
    230     return tokenStartCharIndex;
    231 }
    232 
    233 - (void) setTokenStartCharIndex:(NSInteger) theTokenStartCharIndex
    234 {
    235     tokenStartCharIndex = theTokenStartCharIndex;
    236 }
    237 
    238 // error handling
    239 - (void) reportError:(ANTLRRecognitionException *)e
    240 {
    241 	NSLog(@"%@", e.name);
    242 }
    243 
    244 - (AMutableArray *) getFollowing
    245 {
    246 	return following;
    247 }
    248 
    249 - (void)setFollowing:(AMutableArray *)aFollow
    250 {
    251     if ( following != aFollow ) {
    252         if ( following ) [following release];
    253         [aFollow retain];
    254     }
    255     following = aFollow;
    256 }
    257 
    258 - (ANTLRRuleStack *) getRuleMemo
    259 {
    260 	return ruleMemo;
    261 }
    262 
    263 - (void)setRuleMemo:(ANTLRRuleStack *)aRuleMemo
    264 {
    265     if ( ruleMemo != aRuleMemo ) {
    266         if ( ruleMemo ) [ruleMemo release];
    267         [aRuleMemo retain];
    268     }
    269     ruleMemo = aRuleMemo;
    270 }
    271 
    272 - (BOOL) isErrorRecovery
    273 {
    274 	return errorRecovery;
    275 }
    276 
    277 - (void) setIsErrorRecovery: (BOOL) flag
    278 {
    279 	errorRecovery = flag;
    280 }
    281 
    282 
    283 - (BOOL) getFailed
    284 {
    285 	return failed;
    286 }
    287 
    288 - (void) setFailed:(BOOL)flag
    289 {
    290 	failed = flag;
    291 }
    292 
    293 
    294 - (NSInteger) backtracking
    295 {
    296 	return backtracking;
    297 }
    298 
    299 - (void) setBacktracking:(NSInteger) value
    300 {
    301 	backtracking = value;
    302 }
    303 
    304 - (void) increaseBacktracking
    305 {
    306 	backtracking++;
    307 }
    308 
    309 - (void) decreaseBacktracking
    310 {
    311 	backtracking--;
    312 }
    313 
    314 - (BOOL) isBacktracking
    315 {
    316 	return backtracking > 0;
    317 }
    318 
    319 
    320 - (NSInteger) lastErrorIndex
    321 {
    322     return lastErrorIndex;
    323 }
    324 
    325 - (void) setLastErrorIndex:(NSInteger) value
    326 {
    327 	lastErrorIndex = value;
    328 }
    329 
    330 
    331 @end
    332