// [The "BSD licence"]
// Copyright (c) 2006-2007 Kay Roepke 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 "ANTLRCommonToken.h"
static ANTLRCommonToken *SKIP_TOKEN;
static ANTLRCommonToken *EOF_TOKEN;
static ANTLRCommonToken *INVALID_TOKEN;
@implementation ANTLRCommonToken
static NSInteger DEFAULT_CHANNEL = ANTLRTokenChannelDefault;
static NSInteger INVALID_TOKEN_TYPE = ANTLRTokenTypeInvalid;
@synthesize text;
@synthesize type;
@synthesize line;
@synthesize charPositionInLine;
@synthesize channel;
@synthesize index;
@synthesize startIndex;
@synthesize stopIndex;
@synthesize input;
+ (void) initialize
{
EOF_TOKEN = [ANTLRCommonToken newToken:ANTLRTokenTypeEOF Text:@"EOF"];
SKIP_TOKEN = [ANTLRCommonToken newToken:ANTLRTokenTypeInvalid Text:@"Skip"];
INVALID_TOKEN = [ANTLRCommonToken newToken:ANTLRTokenTypeInvalid Text:@"Invalid"];
[EOF_TOKEN retain];
[SKIP_TOKEN retain];
[INVALID_TOKEN retain];
}
+ (ANTLRCommonToken *)INVALID_TOKEN
{
return INVALID_TOKEN;
}
+ (NSInteger) DEFAULT_CHANNEL
{
return DEFAULT_CHANNEL;
}
+ (NSInteger) INVALID_TOKEN_TYPE
{
return INVALID_TOKEN_TYPE;
}
+ (ANTLRCommonToken *) newToken
{
return [[ANTLRCommonToken alloc] init];
}
+ (ANTLRCommonToken *) newToken:(id<ANTLRCharStream>)anInput Type:(NSInteger)aTType Channel:(NSInteger)aChannel Start:(NSInteger)aStart Stop:(NSInteger)aStop
{
return [[ANTLRCommonToken alloc] initWithInput:(id<ANTLRCharStream>)anInput Type:(NSInteger)aTType Channel:(NSInteger)aChannel Start:(NSInteger)aStart Stop:(NSInteger)aStop];
}
+ (ANTLRCommonToken *) newToken:(ANTLRTokenType)tokenType
{
return( [[ANTLRCommonToken alloc] initWithType:tokenType] );
}
+ (ANTLRCommonToken *) newToken:(NSInteger)tokenType Text:(NSString *)tokenText
{
return( [[ANTLRCommonToken alloc] initWithType:tokenType Text:tokenText] );
}
+ (ANTLRCommonToken *) newTokenWithToken:(ANTLRCommonToken *)fromToken
{
return( [[ANTLRCommonToken alloc] initWithToken:fromToken] );
}
// return the singleton EOF Token
+ (id<ANTLRToken>) eofToken
{
if (EOF_TOKEN == nil) {
EOF_TOKEN = [[ANTLRCommonToken newToken:ANTLRTokenTypeEOF Text:@"EOF"] retain];
}
return EOF_TOKEN;
}
// return the singleton skip Token
+ (id<ANTLRToken>) skipToken
{
if (SKIP_TOKEN == nil) {
SKIP_TOKEN = [[ANTLRCommonToken newToken:ANTLRTokenTypeInvalid Text:@"Skip"] retain];
}
return SKIP_TOKEN;
}
// return the singleton skip Token
+ (id<ANTLRToken>) invalidToken
{
if (INVALID_TOKEN == nil) {
INVALID_TOKEN = [[ANTLRCommonToken newToken:ANTLRTokenTypeInvalid Text:@"Invalid"] retain];
}
return SKIP_TOKEN;
}
// the default channel for this class of Tokens
+ (ANTLRTokenChannel) defaultChannel
{
return ANTLRTokenChannelDefault;
}
- (id) init
{
if ((self = [super init]) != nil) {
input = nil;
type = ANTLRTokenTypeInvalid;
channel = ANTLRTokenChannelDefault;
startIndex = 0;
stopIndex = 0;
}
return self;
}
// designated initializer
- (id) initWithInput:(id<ANTLRCharStream>)anInput
Type:(NSInteger)aTType
Channel:(NSInteger)aChannel
Start:(NSInteger)aStart
Stop:(NSInteger)aStop
{
if ((self = [super init]) != nil) {
input = anInput;
if ( input ) [input retain];
type = aTType;
channel = aChannel;
startIndex = aStart;
stopIndex = aStop;
if (type == ANTLRTokenTypeEOF)
text = @"EOF";
else
text = [input substringWithRange:NSMakeRange(startIndex, (stopIndex-startIndex)+1)];
if ( text ) [text retain];
}
return self;
}
- (id) initWithToken:(ANTLRCommonToken *)oldToken
{
if ((self = [super init]) != nil) {
text = [NSString stringWithString:oldToken.text];
if ( text ) [text retain];
type = oldToken.type;
line = oldToken.line;
index = oldToken.index;
charPositionInLine = oldToken.charPositionInLine;
channel = oldToken.channel;
input = oldToken.input;
if ( input ) [input retain];
if ( [oldToken isKindOfClass:[ANTLRCommonToken class]] ) {
startIndex = oldToken.startIndex;
stopIndex = oldToken.stopIndex;
}
}
return self;
}
- (id) initWithType:(ANTLRTokenType)aTType
{
if ((self = [super init]) != nil) {
self.type = aTType;
}
return self;
}
- (id) initWithType:(ANTLRTokenType)aTType Text:(NSString *)tokenText
{
if ((self = [super init]) != nil) {
self.type = aTType;
self.text = [NSString stringWithString:tokenText];
if ( text ) [text retain];
}
return self;
}
- (void)dealloc
{
#ifdef DEBUG_DEALLOC
NSLog( @"called dealloc in ANTLRCommonToken" );
#endif
if ( input ) [input release];
if ( text ) [text release];
[super dealloc];
}
// create a copy, including the text if available
// the input stream is *not* copied!
- (id) copyWithZone:(NSZone *)theZone
{
ANTLRCommonToken *copy = [[[self class] allocWithZone:theZone] init];
if (text)
copy.text = [text copyWithZone:nil];
copy.type = type;
copy.line = line;
copy.charPositionInLine = charPositionInLine;
copy.channel = channel;
copy.index = index;
copy.startIndex = startIndex;
copy.stopIndex = stopIndex;
copy.input = input;
return copy;
}
//----------------------------------------------------------
// charPositionInLine
//----------------------------------------------------------
- (NSUInteger) charPositionInLine
{
return charPositionInLine;
}
- (void) setCharPositionInLine:(NSUInteger)aCharPositionInLine
{
charPositionInLine = aCharPositionInLine;
}
//----------------------------------------------------------
// line
//----------------------------------------------------------
- (NSUInteger) line
{
return line;
}
- (void) setLine:(NSUInteger)aLine
{
line = aLine;
}
//----------------------------------------------------------
// text
//----------------------------------------------------------
- (NSString *) text
{
if (text != nil) {
return text;
}
if (input == nil) {
return nil;
}
return [input substringWithRange:NSMakeRange(startIndex, (stopIndex-startIndex)+1)];
}
- (void) setText:(NSString *)aText
{
if (text != aText) {
if ( text ) [text release];
text = aText;
[text retain];
}
}
//----------------------------------------------------------
// type
//----------------------------------------------------------
- (NSInteger)type
{
return type;
}
- (void) setType:(NSInteger)aType
{
type = aType;
}
//----------------------------------------------------------
// channel
//----------------------------------------------------------
- (NSUInteger)channel
{
return channel;
}
- (void) setChannel:(NSUInteger)aChannel
{
channel = aChannel;
}
//----------------------------------------------------------
// input
//----------------------------------------------------------
- (id<ANTLRCharStream>) input
{
return input;
}
- (void) setInput: (id<ANTLRCharStream>) anInput
{
if (input != anInput) {
if ( input ) [input release];
[anInput retain];
}
input = anInput;
}
//----------------------------------------------------------
// start
//----------------------------------------------------------
- (NSInteger) getStart
{
return startIndex;
}
- (void) setStart: (NSInteger) aStart
{
startIndex = aStart;
}
//----------------------------------------------------------
// stop
//----------------------------------------------------------
- (NSInteger) getStop
{
return stopIndex;
}
- (void) setStop: (NSInteger) aStop
{
stopIndex = aStop;
}
//----------------------------------------------------------
// index
//----------------------------------------------------------
- (NSInteger) getTokenIndex;
{
return index;
}
- (void) setTokenIndex: (NSInteger) aTokenIndex;
{
index = aTokenIndex;
}
// provide a textual representation for debugging
- (NSString *) description
{
NSString *channelStr;
NSMutableString *txtString;
channelStr = @"";
if ( channel > 0 ) {
channelStr = [NSString stringWithFormat:@",channel=%d\n", channel];
}
if ([self text] != nil) {
txtString = [NSMutableString stringWithString:[self text]];
[txtString replaceOccurrencesOfString:@"\n" withString:@"\\\\n" options:NSAnchoredSearch range:NSMakeRange(0, [txtString length])];
[txtString replaceOccurrencesOfString:@"\r" withString:@"\\\\r" options:NSAnchoredSearch range:NSMakeRange(0, [txtString length])];
[txtString replaceOccurrencesOfString:@"\t" withString:@"\\\\t" options:NSAnchoredSearch range:NSMakeRange(0, [txtString length])];
} else {
txtString = [NSMutableString stringWithString:@"<no text>"];
}
return [NSString stringWithFormat:@"[@%d, %d:%d='%@',<%d>%@,%d:%d]", index, startIndex, stopIndex, txtString, type, channelStr, line, charPositionInLine];
}
- (NSString *)toString
{
return [self description];
}
@end