xref: /external/antlr/antlr-3.4/runtime/ObjC/ANTLR.framework/Headers/ANTLRBaseRecognizer.h

// [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 <Cocoa/Cocoa.h>
#import <Foundation/Foundation.h>

#import "ANTLRIntStream.h"

// This is an abstract superclass for lexers and parsers.

#define ANTLR_MEMO_RULE_FAILED -2
#define ANTLR_MEMO_RULE_UNKNOWN -1
#define ANTLR_INITIAL_FOLLOW_STACK_SIZE 100

#import "ANTLRMapElement.h"
#import "ANTLRBitSet.h"
#import "ANTLRToken.h"
#import "ANTLRRecognizerSharedState.h"
#import "ANTLRRecognitionException.h"
#import "ANTLRMissingTokenException.h"
#import "ANTLRMismatchedTokenException.h"
#import "ANTLRMismatchedTreeNodeException.h"
#import "ANTLRUnwantedTokenException.h"
#import "ANTLRNoViableAltException.h"
#import "ANTLREarlyExitException.h"
#import "ANTLRMismatchedSetException.h"
#import "ANTLRMismatchedNotSetException.h"
#import "ANTLRFailedPredicateException.h"

@interface ANTLRBaseRecognizer : NSObject {
	ANTLRRecognizerSharedState *state;	// the state of this recognizer. Might be shared with other recognizers, e.g. in grammar import scenarios.
	NSString *grammarFileName;			// where did the grammar come from. filled in by codegeneration
//    BOOL failed;
    NSString *sourceName;
//    NSInteger numberOfSyntaxErrors;
    NSArray *tokenNames;
}

@property (retain, getter=getState, setter=setState) ANTLRRecognizerSharedState *state;
@property (retain, getter=getGrammarFileName, setter=setGrammarFileName) NSString *grammarFileName;
//@property (assign, getter=getFailed, setter=setFailed) BOOL failed;
@property (retain, getter=getTokenNames, setter=setTokenNames) NSArray *tokenNames;
@property (retain, getter=getSourceName, setter=setSourceName) NSString *sourceName;
//@property (assign, getter=getNumberOfSyntaxErrors, setter=setNumberOfSyntaxErrors) NSInteger numberOfSyntaxErrors;

+ (void) initialize;

+ (ANTLRBaseRecognizer *) newANTLRBaseRecognizer;
+ (ANTLRBaseRecognizer *) newANTLRBaseRecognizerWithRuleLen:(NSInteger)aLen;
+ (ANTLRBaseRecognizer *) newANTLRBaseRecognizer:(ANTLRRecognizerSharedState *)aState;

+ (NSArray *)getTokenNames;
+ (void)setTokenNames:(NSArray *)aTokNamArray;
+ (void)setGrammarFileName:(NSString *)aFileName;

- (id) init;
- (id) initWithLen:(NSInteger)aLen;
- (id) initWithState:(ANTLRRecognizerSharedState *)aState;

- (void) dealloc;

// simple accessors
- (NSInteger) getBacktrackingLevel;
- (void) setBacktrackingLevel:(NSInteger) level;

- (BOOL) getFailed;
- (void) setFailed: (BOOL) flag;

- (ANTLRRecognizerSharedState *) getState;
- (void) setState:(ANTLRRecognizerSharedState *) theState;

// reset this recognizer - might be extended by codegeneration/grammar
- (void) reset;

/** Match needs to return the current input symbol, which gets put
 *  into the label for the associated token ref; e.g., x=ID.  Token
 *  and tree parsers need to return different objects. Rather than test
 *  for input stream type or change the IntStream interface, I use
 *  a simple method to ask the recognizer to tell me what the current
 *  input symbol is.
 *
 *  This is ignored for lexers.
 */
- (id) getInput;

- (void)skip;

// do actual matching of tokens/characters
- (id) match:(id<ANTLRIntStream>)anInput TokenType:(NSInteger)ttype Follow:(ANTLRBitSet *)follow;
- (void) matchAny:(id<ANTLRIntStream>)anInput;
- (BOOL) mismatchIsUnwantedToken:(id<ANTLRIntStream>)anInput TokenType:(NSInteger) ttype;
- (BOOL) mismatchIsMissingToken:(id<ANTLRIntStream>)anInput Follow:(ANTLRBitSet *)follow;

// error reporting and recovery
- (void) reportError:(ANTLRRecognitionException *)e;
- (void) displayRecognitionError:(NSArray *)theTokNams Exception:(ANTLRRecognitionException *)e;
- (NSString *)getErrorMessage:(ANTLRRecognitionException *)e TokenNames:(NSArray *)theTokNams;
- (NSInteger) getNumberOfSyntaxErrors;
- (NSString *)getErrorHeader:(ANTLRRecognitionException *)e;
- (NSString *)getTokenErrorDisplay:(id<ANTLRToken>)t;
- (void) emitErrorMessage:(NSString *)msg;
- (void) recover:(id<ANTLRIntStream>)anInput Exception:(ANTLRRecognitionException *)e;

// begin hooks for debugger
- (void) beginResync;
- (void) endResync;
// end hooks for debugger

// compute the bitsets necessary to do matching and recovery
- (ANTLRBitSet *)computeErrorRecoverySet;
- (ANTLRBitSet *)computeContextSensitiveRuleFOLLOW;
- (ANTLRBitSet *)combineFollows:(BOOL) exact;

- (id<ANTLRToken>) recoverFromMismatchedToken:(id<ANTLRIntStream>)anInput
                                    TokenType:(NSInteger)ttype
                                       Follow:(ANTLRBitSet *)follow;

- (id<ANTLRToken>)recoverFromMismatchedSet:(id<ANTLRIntStream>)anInput
                                    Exception:(ANTLRRecognitionException *)e
                                    Follow:(ANTLRBitSet *)follow;

- (id) getCurrentInputSymbol:(id<ANTLRIntStream>)anInput;
- (id) getMissingSymbol:(id<ANTLRIntStream>)anInput
              Exception:(ANTLRRecognitionException *)e
              TokenType:(NSInteger) expectedTokenType
                Follow:(ANTLRBitSet *)follow;

// helper methods for recovery. try to resync somewhere
- (void) consumeUntilTType:(id<ANTLRIntStream>)anInput TokenType:(NSInteger)ttype;
- (void) consumeUntilFollow:(id<ANTLRIntStream>)anInput Follow:(ANTLRBitSet *)bitSet;
- (void) pushFollow:(ANTLRBitSet *)fset;
- (ANTLRBitSet *)popFollow;

// to be used by the debugger to do reporting. maybe hook in incremental stuff here, too.
- (NSMutableArray *) getRuleInvocationStack;
- (NSMutableArray *) getRuleInvocationStack:(ANTLRRecognitionException *)exception
					             Recognizer:(NSString *)recognizerClassName;

- (NSArray *) getTokenNames;
- (NSString *)getGrammarFileName;
- (NSString *)getSourceName;
- (NSMutableArray *) toStrings:(NSArray *)tokens;
// support for memoization
- (NSInteger) getRuleMemoization:(NSInteger)ruleIndex StartIndex:(NSInteger)ruleStartIndex;
- (BOOL) alreadyParsedRule:(id<ANTLRIntStream>)anInput RuleIndex:(NSInteger)ruleIndex;
- (void) memoize:(id<ANTLRIntStream>)anInput
	     RuleIndex:(NSInteger)ruleIndex
	    StartIndex:(NSInteger)ruleStartIndex;
- (NSInteger) getRuleMemoizationCacheSize;
- (void)traceIn:(NSString *)ruleName Index:(NSInteger)ruleIndex Object:(id)inputSymbol;
- (void)traceOut:(NSString *)ruleName Index:(NSInteger)ruleIndex Object:(id)inputSymbol;


// support for syntactic predicates. these are called indirectly to support funky stuff in grammars,
// like supplying selectors instead of writing code directly into the actions of the grammar.
- (BOOL) evaluateSyntacticPredicate:(SEL)synpredFragment;
// stream:(id<ANTLRIntStream>)anInput;

@end