// This implementation prints messages to {@link System//err} containing the // values of {@code line}, {@code charPositionInLine}, and {@code msg} using // the following format.
// //// line line:charPositionInLine msg //// func (c *ConsoleErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException) { fmt.Fprintln(os.Stderr, "line "+strconv.Itoa(line)+":"+strconv.Itoa(column)+" "+msg) } type ProxyErrorListener struct { *DefaultErrorListener delegates []ErrorListener } func NewProxyErrorListener(delegates []ErrorListener) *ProxyErrorListener { if delegates == nil { panic("delegates is not provided") } l := new(ProxyErrorListener) l.delegates = delegates return l } func (p *ProxyErrorListener) SyntaxError(recognizer Recognizer, offendingSymbol interface{}, line, column int, msg string, e RecognitionException) { for _, d := range p.delegates { d.SyntaxError(recognizer, offendingSymbol, line, column, msg, e) } } func (p *ProxyErrorListener) ReportAmbiguity(recognizer Parser, dfa *DFA, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet) { for _, d := range p.delegates { d.ReportAmbiguity(recognizer, dfa, startIndex, stopIndex, exact, ambigAlts, configs) } } func (p *ProxyErrorListener) ReportAttemptingFullContext(recognizer Parser, dfa *DFA, startIndex, stopIndex int, conflictingAlts *BitSet, configs ATNConfigSet) { for _, d := range p.delegates { d.ReportAttemptingFullContext(recognizer, dfa, startIndex, stopIndex, conflictingAlts, configs) } } func (p *ProxyErrorListener) ReportContextSensitivity(recognizer Parser, dfa *DFA, startIndex, stopIndex, prediction int, configs ATNConfigSet) { for _, d := range p.delegates { d.ReportContextSensitivity(recognizer, dfa, startIndex, stopIndex, prediction, configs) } } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/error_strategy.go 0000664 0000000 0000000 00000066362 14102210121 0025744 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "fmt" "reflect" "strconv" "strings" ) type ErrorStrategy interface { reset(Parser) RecoverInline(Parser) Token Recover(Parser, RecognitionException) Sync(Parser) inErrorRecoveryMode(Parser) bool ReportError(Parser, RecognitionException) ReportMatch(Parser) } // This is the default implementation of {@link ANTLRErrorStrategy} used for // error Reporting and recovery in ANTLR parsers. // type DefaultErrorStrategy struct { errorRecoveryMode bool lastErrorIndex int lastErrorStates *IntervalSet } var _ ErrorStrategy = &DefaultErrorStrategy{} func NewDefaultErrorStrategy() *DefaultErrorStrategy { d := new(DefaultErrorStrategy) // Indicates whether the error strategy is currently "recovering from an // error". This is used to suppress Reporting multiple error messages while // attempting to recover from a detected syntax error. // // @see //inErrorRecoveryMode // d.errorRecoveryMode = false // The index into the input stream where the last error occurred. // This is used to prevent infinite loops where an error is found // but no token is consumed during recovery...another error is found, // ad nauseum. This is a failsafe mechanism to guarantee that at least // one token/tree node is consumed for two errors. // d.lastErrorIndex = -1 d.lastErrorStates = nil return d } //
The default implementation simply calls {@link //endErrorCondition} to // ensure that the handler is not in error recovery mode.
func (d *DefaultErrorStrategy) reset(recognizer Parser) { d.endErrorCondition(recognizer) } // // This method is called to enter error recovery mode when a recognition // exception is Reported. // // @param recognizer the parser instance // func (d *DefaultErrorStrategy) beginErrorCondition(recognizer Parser) { d.errorRecoveryMode = true } func (d *DefaultErrorStrategy) inErrorRecoveryMode(recognizer Parser) bool { return d.errorRecoveryMode } // // This method is called to leave error recovery mode after recovering from // a recognition exception. // // @param recognizer // func (d *DefaultErrorStrategy) endErrorCondition(recognizer Parser) { d.errorRecoveryMode = false d.lastErrorStates = nil d.lastErrorIndex = -1 } // // {@inheritDoc} // //The default implementation simply calls {@link //endErrorCondition}.
// func (d *DefaultErrorStrategy) ReportMatch(recognizer Parser) { d.endErrorCondition(recognizer) } // // {@inheritDoc} // //The default implementation returns immediately if the handler is already // in error recovery mode. Otherwise, it calls {@link //beginErrorCondition} // and dispatches the Reporting task based on the runtime type of {@code e} // according to the following table.
// //The default implementation reSynchronizes the parser by consuming tokens // until we find one in the reSynchronization set--loosely the set of tokens // that can follow the current rule.
// func (d *DefaultErrorStrategy) Recover(recognizer Parser, e RecognitionException) { if d.lastErrorIndex == recognizer.GetInputStream().Index() && d.lastErrorStates != nil && d.lastErrorStates.contains(recognizer.GetState()) { // uh oh, another error at same token index and previously-Visited // state in ATN must be a case where LT(1) is in the recovery // token set so nothing got consumed. Consume a single token // at least to prevent an infinite loop d is a failsafe. recognizer.Consume() } d.lastErrorIndex = recognizer.GetInputStream().Index() if d.lastErrorStates == nil { d.lastErrorStates = NewIntervalSet() } d.lastErrorStates.addOne(recognizer.GetState()) followSet := d.getErrorRecoverySet(recognizer) d.consumeUntil(recognizer, followSet) } // The default implementation of {@link ANTLRErrorStrategy//Sync} makes sure // that the current lookahead symbol is consistent with what were expecting // at d point in the ATN. You can call d anytime but ANTLR only // generates code to check before subrules/loops and each iteration. // //Implements Jim Idle's magic Sync mechanism in closures and optional // subrules. E.g.,
// //
// a : Sync ( stuff Sync )*
// Sync : {consume to what can follow Sync}
//
//
// At the start of a sub rule upon error, {@link //Sync} performs single
// token deletion, if possible. If it can't do that, it bails on the current
// rule and uses the default error recovery, which consumes until the
// reSynchronization set of the current rule.
//
// If the sub rule is optional ({@code (...)?}, {@code (...)*}, or block // with an empty alternative), then the expected set includes what follows // the subrule.
// //During loop iteration, it consumes until it sees a token that can start a // sub rule or what follows loop. Yes, that is pretty aggressive. We opt to // stay in the loop as long as possible.
// //ORIGINS
// //Previous versions of ANTLR did a poor job of their recovery within loops. // A single mismatch token or missing token would force the parser to bail // out of the entire rules surrounding the loop. So, for rule
// //
// classfunc : 'class' ID '{' member* '}'
//
//
// input with an extra token between members would force the parser to
// consume until it found the next class definition rather than the next
// member definition of the current class.
//
// This functionality cost a little bit of effort because the parser has to // compare token set at the start of the loop and at each iteration. If for // some reason speed is suffering for you, you can turn off d // functionality by simply overriding d method as a blank { }.
// func (d *DefaultErrorStrategy) Sync(recognizer Parser) { // If already recovering, don't try to Sync if d.inErrorRecoveryMode(recognizer) { return } s := recognizer.GetInterpreter().atn.states[recognizer.GetState()] la := recognizer.GetTokenStream().LA(1) // try cheaper subset first might get lucky. seems to shave a wee bit off nextTokens := recognizer.GetATN().NextTokens(s, nil) if nextTokens.contains(TokenEpsilon) || nextTokens.contains(la) { return } switch s.GetStateType() { case ATNStateBlockStart, ATNStateStarBlockStart, ATNStatePlusBlockStart, ATNStateStarLoopEntry: // Report error and recover if possible if d.SingleTokenDeletion(recognizer) != nil { return } panic(NewInputMisMatchException(recognizer)) case ATNStatePlusLoopBack, ATNStateStarLoopBack: d.ReportUnwantedToken(recognizer) expecting := NewIntervalSet() expecting.addSet(recognizer.GetExpectedTokens()) whatFollowsLoopIterationOrRule := expecting.addSet(d.getErrorRecoverySet(recognizer)) d.consumeUntil(recognizer, whatFollowsLoopIterationOrRule) default: // do nothing if we can't identify the exact kind of ATN state } } // This is called by {@link //ReportError} when the exception is a // {@link NoViableAltException}. // // @see //ReportError // // @param recognizer the parser instance // @param e the recognition exception // func (d *DefaultErrorStrategy) ReportNoViableAlternative(recognizer Parser, e *NoViableAltException) { tokens := recognizer.GetTokenStream() var input string if tokens != nil { if e.startToken.GetTokenType() == TokenEOF { input = "This method is called when {@link //singleTokenDeletion} identifies // single-token deletion as a viable recovery strategy for a mismatched // input error.
// //The default implementation simply returns if the handler is already in // error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to // enter error recovery mode, followed by calling // {@link Parser//NotifyErrorListeners}.
// // @param recognizer the parser instance // func (d *DefaultErrorStrategy) ReportUnwantedToken(recognizer Parser) { if d.inErrorRecoveryMode(recognizer) { return } d.beginErrorCondition(recognizer) t := recognizer.GetCurrentToken() tokenName := d.GetTokenErrorDisplay(t) expecting := d.GetExpectedTokens(recognizer) msg := "extraneous input " + tokenName + " expecting " + expecting.StringVerbose(recognizer.GetLiteralNames(), recognizer.GetSymbolicNames(), false) recognizer.NotifyErrorListeners(msg, t, nil) } // This method is called to Report a syntax error which requires the // insertion of a missing token into the input stream. At the time d // method is called, the missing token has not yet been inserted. When d // method returns, {@code recognizer} is in error recovery mode. // //This method is called when {@link //singleTokenInsertion} identifies // single-token insertion as a viable recovery strategy for a mismatched // input error.
// //The default implementation simply returns if the handler is already in // error recovery mode. Otherwise, it calls {@link //beginErrorCondition} to // enter error recovery mode, followed by calling // {@link Parser//NotifyErrorListeners}.
// // @param recognizer the parser instance // func (d *DefaultErrorStrategy) ReportMissingToken(recognizer Parser) { if d.inErrorRecoveryMode(recognizer) { return } d.beginErrorCondition(recognizer) t := recognizer.GetCurrentToken() expecting := d.GetExpectedTokens(recognizer) msg := "missing " + expecting.StringVerbose(recognizer.GetLiteralNames(), recognizer.GetSymbolicNames(), false) + " at " + d.GetTokenErrorDisplay(t) recognizer.NotifyErrorListeners(msg, t, nil) } //The default implementation attempts to recover from the mismatched input // by using single token insertion and deletion as described below. If the // recovery attempt fails, d method panics an // {@link InputMisMatchException}.
// //EXTRA TOKEN (single token deletion)
// //{@code LA(1)} is not what we are looking for. If {@code LA(2)} has the // right token, however, then assume {@code LA(1)} is some extra spurious // token and delete it. Then consume and return the next token (which was // the {@code LA(2)} token) as the successful result of the Match operation.
// //This recovery strategy is implemented by {@link // //singleTokenDeletion}.
// //MISSING TOKEN (single token insertion)
// //If current token (at {@code LA(1)}) is consistent with what could come // after the expected {@code LA(1)} token, then assume the token is missing // and use the parser's {@link TokenFactory} to create it on the fly. The // "insertion" is performed by returning the created token as the successful // result of the Match operation.
// //This recovery strategy is implemented by {@link // //singleTokenInsertion}.
// //EXAMPLE
// //For example, Input {@code i=(3} is clearly missing the {@code ')'}. When // the parser returns from the nested call to {@code expr}, it will have // call chain:
// //// stat &rarr expr &rarr atom //// // and it will be trying to Match the {@code ')'} at d point in the // derivation: // //
// => ID '=' '(' INT ')' ('+' atom)* ''
// ^
//
//
// The attempt to Match {@code ')'} will fail when it sees {@code ''} and
// call {@link //recoverInline}. To recover, it sees that {@code LA(1)==''}
// is in the set of tokens that can follow the {@code ')'} token reference
// in rule {@code atom}. It can assume that you forgot the {@code ')'}.
//
func (d *DefaultErrorStrategy) RecoverInline(recognizer Parser) Token {
// SINGLE TOKEN DELETION
MatchedSymbol := d.SingleTokenDeletion(recognizer)
if MatchedSymbol != nil {
// we have deleted the extra token.
// now, move past ttype token as if all were ok
recognizer.Consume()
return MatchedSymbol
}
// SINGLE TOKEN INSERTION
if d.SingleTokenInsertion(recognizer) {
return d.GetMissingSymbol(recognizer)
}
// even that didn't work must panic the exception
panic(NewInputMisMatchException(recognizer))
}
//
// This method implements the single-token insertion inline error recovery
// strategy. It is called by {@link //recoverInline} if the single-token
// deletion strategy fails to recover from the mismatched input. If this
// method returns {@code true}, {@code recognizer} will be in error recovery
// mode.
//
// This method determines whether or not single-token insertion is viable by // checking if the {@code LA(1)} input symbol could be successfully Matched // if it were instead the {@code LA(2)} symbol. If d method returns // {@code true}, the caller is responsible for creating and inserting a // token with the correct type to produce d behavior.
// // @param recognizer the parser instance // @return {@code true} if single-token insertion is a viable recovery // strategy for the current mismatched input, otherwise {@code false} // func (d *DefaultErrorStrategy) SingleTokenInsertion(recognizer Parser) bool { currentSymbolType := recognizer.GetTokenStream().LA(1) // if current token is consistent with what could come after current // ATN state, then we know we're missing a token error recovery // is free to conjure up and insert the missing token atn := recognizer.GetInterpreter().atn currentState := atn.states[recognizer.GetState()] next := currentState.GetTransitions()[0].getTarget() expectingAtLL2 := atn.NextTokens(next, recognizer.GetParserRuleContext()) if expectingAtLL2.contains(currentSymbolType) { d.ReportMissingToken(recognizer) return true } return false } // This method implements the single-token deletion inline error recovery // strategy. It is called by {@link //recoverInline} to attempt to recover // from mismatched input. If this method returns nil, the parser and error // handler state will not have changed. If this method returns non-nil, // {@code recognizer} will not be in error recovery mode since the // returned token was a successful Match. // //If the single-token deletion is successful, d method calls // {@link //ReportUnwantedToken} to Report the error, followed by // {@link Parser//consume} to actually "delete" the extraneous token. Then, // before returning {@link //ReportMatch} is called to signal a successful // Match.
// // @param recognizer the parser instance // @return the successfully Matched {@link Token} instance if single-token // deletion successfully recovers from the mismatched input, otherwise // {@code nil} // func (d *DefaultErrorStrategy) SingleTokenDeletion(recognizer Parser) Token { NextTokenType := recognizer.GetTokenStream().LA(2) expecting := d.GetExpectedTokens(recognizer) if expecting.contains(NextTokenType) { d.ReportUnwantedToken(recognizer) // print("recoverFromMisMatchedToken deleting " \ // + str(recognizer.GetTokenStream().LT(1)) \ // + " since " + str(recognizer.GetTokenStream().LT(2)) \ // + " is what we want", file=sys.stderr) recognizer.Consume() // simply delete extra token // we want to return the token we're actually Matching MatchedSymbol := recognizer.GetCurrentToken() d.ReportMatch(recognizer) // we know current token is correct return MatchedSymbol } return nil } // Conjure up a missing token during error recovery. // // The recognizer attempts to recover from single missing // symbols. But, actions might refer to that missing symbol. // For example, x=ID {f($x)}. The action clearly assumes // that there has been an identifier Matched previously and that // $x points at that token. If that token is missing, but // the next token in the stream is what we want we assume that // d token is missing and we keep going. Because we // have to return some token to replace the missing token, // we have to conjure one up. This method gives the user control // over the tokens returned for missing tokens. Mostly, // you will want to create something special for identifier // tokens. For literals such as '{' and ',', the default // action in the parser or tree parser works. It simply creates // a CommonToken of the appropriate type. The text will be the token. // If you change what tokens must be created by the lexer, // override d method to create the appropriate tokens. // func (d *DefaultErrorStrategy) GetMissingSymbol(recognizer Parser) Token { currentSymbol := recognizer.GetCurrentToken() expecting := d.GetExpectedTokens(recognizer) expectedTokenType := expecting.first() var tokenText string if expectedTokenType == TokenEOF { tokenText = "// This error strategy is useful in the following scenarios.
// //// {@code myparser.setErrorHandler(NewBailErrorStrategy())}
// // @see Parser//setErrorHandler(ANTLRErrorStrategy) type BailErrorStrategy struct { *DefaultErrorStrategy } var _ ErrorStrategy = &BailErrorStrategy{} func NewBailErrorStrategy() *BailErrorStrategy { b := new(BailErrorStrategy) b.DefaultErrorStrategy = NewDefaultErrorStrategy() return b } // Instead of recovering from exception {@code e}, re-panic it wrapped // in a {@link ParseCancellationException} so it is not caught by the // rule func catches. Use {@link Exception//getCause()} to get the // original {@link RecognitionException}. // func (b *BailErrorStrategy) Recover(recognizer Parser, e RecognitionException) { context := recognizer.GetParserRuleContext() for context != nil { context.SetException(e) context = context.GetParent().(ParserRuleContext) } panic(NewParseCancellationException()) // TODO we don't emit e properly } // Make sure we don't attempt to recover inline if the parser // successfully recovers, it won't panic an exception. // func (b *BailErrorStrategy) RecoverInline(recognizer Parser) Token { b.Recover(recognizer, NewInputMisMatchException(recognizer)) return nil } // Make sure we don't attempt to recover from problems in subrules.// func (b *BailErrorStrategy) Sync(recognizer Parser) { // pass } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/errors.go 0000664 0000000 0000000 00000016015 14102210121 0024173 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr // The root of the ANTLR exception hierarchy. In general, ANTLR tracks just // 3 kinds of errors: prediction errors, failed predicate errors, and // mismatched input errors. In each case, the parser knows where it is // in the input, where it is in the ATN, the rule invocation stack, // and what kind of problem occurred. type RecognitionException interface { GetOffendingToken() Token GetMessage() string GetInputStream() IntStream } type BaseRecognitionException struct { message string recognizer Recognizer offendingToken Token offendingState int ctx RuleContext input IntStream } func NewBaseRecognitionException(message string, recognizer Recognizer, input IntStream, ctx RuleContext) *BaseRecognitionException { // todo // Error.call(this) // // if (!!Error.captureStackTrace) { // Error.captureStackTrace(this, RecognitionException) // } else { // stack := NewError().stack // } // TODO may be able to use - "runtime" func Stack(buf []byte, all bool) int t := new(BaseRecognitionException) t.message = message t.recognizer = recognizer t.input = input t.ctx = ctx // The current {@link Token} when an error occurred. Since not all streams // support accessing symbols by index, we have to track the {@link Token} // instance itself. t.offendingToken = nil // Get the ATN state number the parser was in at the time the error // occurred. For {@link NoViableAltException} and // {@link LexerNoViableAltException} exceptions, this is the // {@link DecisionState} number. For others, it is the state whose outgoing // edge we couldn't Match. t.offendingState = -1 if t.recognizer != nil { t.offendingState = t.recognizer.GetState() } return t } func (b *BaseRecognitionException) GetMessage() string { return b.message } func (b *BaseRecognitionException) GetOffendingToken() Token { return b.offendingToken } func (b *BaseRecognitionException) GetInputStream() IntStream { return b.input } //If the state number is not known, b method returns -1.
// // Gets the set of input symbols which could potentially follow the // previously Matched symbol at the time b exception was panicn. // //If the set of expected tokens is not known and could not be computed, // b method returns {@code nil}.
// // @return The set of token types that could potentially follow the current // state in the ATN, or {@code nil} if the information is not available. // / func (b *BaseRecognitionException) getExpectedTokens() *IntervalSet { if b.recognizer != nil { return b.recognizer.GetATN().getExpectedTokens(b.offendingState, b.ctx) } return nil } func (b *BaseRecognitionException) String() string { return b.message } type LexerNoViableAltException struct { *BaseRecognitionException startIndex int deadEndConfigs ATNConfigSet } func NewLexerNoViableAltException(lexer Lexer, input CharStream, startIndex int, deadEndConfigs ATNConfigSet) *LexerNoViableAltException { l := new(LexerNoViableAltException) l.BaseRecognitionException = NewBaseRecognitionException("", lexer, input, nil) l.startIndex = startIndex l.deadEndConfigs = deadEndConfigs return l } func (l *LexerNoViableAltException) String() string { symbol := "" if l.startIndex >= 0 && l.startIndex < l.input.Size() { symbol = l.input.(CharStream).GetTextFromInterval(NewInterval(l.startIndex, l.startIndex)) } return "LexerNoViableAltException" + symbol } type NoViableAltException struct { *BaseRecognitionException startToken Token offendingToken Token ctx ParserRuleContext deadEndConfigs ATNConfigSet } // Indicates that the parser could not decide which of two or more paths // to take based upon the remaining input. It tracks the starting token // of the offending input and also knows where the parser was // in the various paths when the error. Reported by ReportNoViableAlternative() // func NewNoViableAltException(recognizer Parser, input TokenStream, startToken Token, offendingToken Token, deadEndConfigs ATNConfigSet, ctx ParserRuleContext) *NoViableAltException { if ctx == nil { ctx = recognizer.GetParserRuleContext() } if offendingToken == nil { offendingToken = recognizer.GetCurrentToken() } if startToken == nil { startToken = recognizer.GetCurrentToken() } if input == nil { input = recognizer.GetInputStream().(TokenStream) } n := new(NoViableAltException) n.BaseRecognitionException = NewBaseRecognitionException("", recognizer, input, ctx) // Which configurations did we try at input.Index() that couldn't Match // input.LT(1)?// n.deadEndConfigs = deadEndConfigs // The token object at the start index the input stream might // not be buffering tokens so get a reference to it. (At the // time the error occurred, of course the stream needs to keep a // buffer all of the tokens but later we might not have access to those.) n.startToken = startToken n.offendingToken = offendingToken return n } type InputMisMatchException struct { *BaseRecognitionException } // This signifies any kind of mismatched input exceptions such as // when the current input does not Match the expected token. // func NewInputMisMatchException(recognizer Parser) *InputMisMatchException { i := new(InputMisMatchException) i.BaseRecognitionException = NewBaseRecognitionException("", recognizer, recognizer.GetInputStream(), recognizer.GetParserRuleContext()) i.offendingToken = recognizer.GetCurrentToken() return i } // A semantic predicate failed during validation. Validation of predicates // occurs when normally parsing the alternative just like Matching a token. // Disambiguating predicate evaluation occurs when we test a predicate during // prediction. type FailedPredicateException struct { *BaseRecognitionException ruleIndex int predicateIndex int predicate string } func NewFailedPredicateException(recognizer Parser, predicate string, message string) *FailedPredicateException { f := new(FailedPredicateException) f.BaseRecognitionException = NewBaseRecognitionException(f.formatMessage(predicate, message), recognizer, recognizer.GetInputStream(), recognizer.GetParserRuleContext()) s := recognizer.GetInterpreter().atn.states[recognizer.GetState()] trans := s.GetTransitions()[0] if trans2, ok := trans.(*PredicateTransition); ok { f.ruleIndex = trans2.ruleIndex f.predicateIndex = trans2.predIndex } else { f.ruleIndex = 0 f.predicateIndex = 0 } f.predicate = predicate f.offendingToken = recognizer.GetCurrentToken() return f } func (f *FailedPredicateException) formatMessage(predicate, message string) string { if message != "" { return message } return "failed predicate: {" + predicate + "}?" } type ParseCancellationException struct { } func NewParseCancellationException() *ParseCancellationException { // Error.call(this) // Error.captureStackTrace(this, ParseCancellationException) return new(ParseCancellationException) } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/file_stream.go 0000664 0000000 0000000 00000001512 14102210121 0025145 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "bytes" "io" "os" ) // This is an InputStream that is loaded from a file all at once // when you construct the object. type FileStream struct { *InputStream filename string } func NewFileStream(fileName string) (*FileStream, error) { buf := bytes.NewBuffer(nil) f, err := os.Open(fileName) if err != nil { return nil, err } defer f.Close() _, err = io.Copy(buf, f) if err != nil { return nil, err } fs := new(FileStream) fs.filename = fileName s := string(buf.Bytes()) fs.InputStream = NewInputStream(s) return fs, nil } func (f *FileStream) GetSourceName() string { return f.filename } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/input_stream.go 0000664 0000000 0000000 00000004124 14102210121 0025367 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr type InputStream struct { name string index int data []rune size int } func NewInputStream(data string) *InputStream { is := new(InputStream) is.name = "The {@code Skip} command does not have any parameters, so l action is // implemented as a singleton instance exposed by {@link //INSTANCE}.
type LexerSkipAction struct { *BaseLexerAction } func NewLexerSkipAction() *LexerSkipAction { la := new(LexerSkipAction) la.BaseLexerAction = NewBaseLexerAction(LexerActionTypeSkip) return la } // Provides a singleton instance of l parameterless lexer action. var LexerSkipActionINSTANCE = NewLexerSkipAction() func (l *LexerSkipAction) execute(lexer Lexer) { lexer.Skip() } func (l *LexerSkipAction) String() string { return "skip" } // Implements the {@code type} lexer action by calling {@link Lexer//setType} // with the assigned type. type LexerTypeAction struct { *BaseLexerAction thetype int } func NewLexerTypeAction(thetype int) *LexerTypeAction { l := new(LexerTypeAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypeType) l.thetype = thetype return l } func (l *LexerTypeAction) execute(lexer Lexer) { lexer.SetType(l.thetype) } func (l *LexerTypeAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.thetype) return murmurFinish(h, 2) } func (l *LexerTypeAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerTypeAction); !ok { return false } else { return l.thetype == other.(*LexerTypeAction).thetype } } func (l *LexerTypeAction) String() string { return "actionType(" + strconv.Itoa(l.thetype) + ")" } // Implements the {@code pushMode} lexer action by calling // {@link Lexer//pushMode} with the assigned mode. type LexerPushModeAction struct { *BaseLexerAction mode int } func NewLexerPushModeAction(mode int) *LexerPushModeAction { l := new(LexerPushModeAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypePushMode) l.mode = mode return l } //This action is implemented by calling {@link Lexer//pushMode} with the // value provided by {@link //getMode}.
func (l *LexerPushModeAction) execute(lexer Lexer) { lexer.PushMode(l.mode) } func (l *LexerPushModeAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.mode) return murmurFinish(h, 2) } func (l *LexerPushModeAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerPushModeAction); !ok { return false } else { return l.mode == other.(*LexerPushModeAction).mode } } func (l *LexerPushModeAction) String() string { return "pushMode(" + strconv.Itoa(l.mode) + ")" } // Implements the {@code popMode} lexer action by calling {@link Lexer//popMode}. // //The {@code popMode} command does not have any parameters, so l action is // implemented as a singleton instance exposed by {@link //INSTANCE}.
type LexerPopModeAction struct { *BaseLexerAction } func NewLexerPopModeAction() *LexerPopModeAction { l := new(LexerPopModeAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypePopMode) return l } var LexerPopModeActionINSTANCE = NewLexerPopModeAction() //This action is implemented by calling {@link Lexer//popMode}.
func (l *LexerPopModeAction) execute(lexer Lexer) { lexer.PopMode() } func (l *LexerPopModeAction) String() string { return "popMode" } // Implements the {@code more} lexer action by calling {@link Lexer//more}. // //The {@code more} command does not have any parameters, so l action is // implemented as a singleton instance exposed by {@link //INSTANCE}.
type LexerMoreAction struct { *BaseLexerAction } func NewLexerMoreAction() *LexerMoreAction { l := new(LexerMoreAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypeMore) return l } var LexerMoreActionINSTANCE = NewLexerMoreAction() //This action is implemented by calling {@link Lexer//popMode}.
func (l *LexerMoreAction) execute(lexer Lexer) { lexer.More() } func (l *LexerMoreAction) String() string { return "more" } // Implements the {@code mode} lexer action by calling {@link Lexer//mode} with // the assigned mode. type LexerModeAction struct { *BaseLexerAction mode int } func NewLexerModeAction(mode int) *LexerModeAction { l := new(LexerModeAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypeMode) l.mode = mode return l } //This action is implemented by calling {@link Lexer//mode} with the // value provided by {@link //getMode}.
func (l *LexerModeAction) execute(lexer Lexer) { lexer.SetMode(l.mode) } func (l *LexerModeAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.mode) return murmurFinish(h, 2) } func (l *LexerModeAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerModeAction); !ok { return false } else { return l.mode == other.(*LexerModeAction).mode } } func (l *LexerModeAction) String() string { return "mode(" + strconv.Itoa(l.mode) + ")" } // Executes a custom lexer action by calling {@link Recognizer//action} with the // rule and action indexes assigned to the custom action. The implementation of // a custom action is added to the generated code for the lexer in an override // of {@link Recognizer//action} when the grammar is compiled. // //This class may represent embedded actions created with the {...}
// syntax in ANTLR 4, as well as actions created for lexer commands where the
// command argument could not be evaluated when the grammar was compiled.
Custom actions are implemented by calling {@link Lexer//action} with the // appropriate rule and action indexes.
func (l *LexerCustomAction) execute(lexer Lexer) { lexer.Action(nil, l.ruleIndex, l.actionIndex) } func (l *LexerCustomAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.ruleIndex) h = murmurUpdate(h, l.actionIndex) return murmurFinish(h, 3) } func (l *LexerCustomAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerCustomAction); !ok { return false } else { return l.ruleIndex == other.(*LexerCustomAction).ruleIndex && l.actionIndex == other.(*LexerCustomAction).actionIndex } } // Implements the {@code channel} lexer action by calling // {@link Lexer//setChannel} with the assigned channel. // Constructs a New{@code channel} action with the specified channel value. // @param channel The channel value to pass to {@link Lexer//setChannel}. type LexerChannelAction struct { *BaseLexerAction channel int } func NewLexerChannelAction(channel int) *LexerChannelAction { l := new(LexerChannelAction) l.BaseLexerAction = NewBaseLexerAction(LexerActionTypeChannel) l.channel = channel return l } //This action is implemented by calling {@link Lexer//setChannel} with the // value provided by {@link //getChannel}.
func (l *LexerChannelAction) execute(lexer Lexer) { lexer.SetChannel(l.channel) } func (l *LexerChannelAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.channel) return murmurFinish(h, 2) } func (l *LexerChannelAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerChannelAction); !ok { return false } else { return l.channel == other.(*LexerChannelAction).channel } } func (l *LexerChannelAction) String() string { return "channel(" + strconv.Itoa(l.channel) + ")" } // This implementation of {@link LexerAction} is used for tracking input offsets // for position-dependent actions within a {@link LexerActionExecutor}. // //This action is not serialized as part of the ATN, and is only required for // position-dependent lexer actions which appear at a location other than the // end of a rule. For more information about DFA optimizations employed for // lexer actions, see {@link LexerActionExecutor//append} and // {@link LexerActionExecutor//fixOffsetBeforeMatch}.
// Constructs a Newindexed custom action by associating a character offset // with a {@link LexerAction}. // //Note: This class is only required for lexer actions for which // {@link LexerAction//isPositionDependent} returns {@code true}.
// // @param offset The offset into the input {@link CharStream}, relative to // the token start index, at which the specified lexer action should be // executed. // @param action The lexer action to execute at a particular offset in the // input {@link CharStream}. type LexerIndexedCustomAction struct { *BaseLexerAction offset int lexerAction LexerAction isPositionDependent bool } func NewLexerIndexedCustomAction(offset int, lexerAction LexerAction) *LexerIndexedCustomAction { l := new(LexerIndexedCustomAction) l.BaseLexerAction = NewBaseLexerAction(lexerAction.getActionType()) l.offset = offset l.lexerAction = lexerAction l.isPositionDependent = true return l } //This method calls {@link //execute} on the result of {@link //getAction} // using the provided {@code lexer}.
func (l *LexerIndexedCustomAction) execute(lexer Lexer) { // assume the input stream position was properly set by the calling code l.lexerAction.execute(lexer) } func (l *LexerIndexedCustomAction) hash() int { h := murmurInit(0) h = murmurUpdate(h, l.actionType) h = murmurUpdate(h, l.offset) h = murmurUpdate(h, l.lexerAction.hash()) return murmurFinish(h, 3) } func (l *LexerIndexedCustomAction) equals(other LexerAction) bool { if l == other { return true } else if _, ok := other.(*LexerIndexedCustomAction); !ok { return false } else { return l.offset == other.(*LexerIndexedCustomAction).offset && l.lexerAction == other.(*LexerIndexedCustomAction).lexerAction } } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/lexer_action_executor.go 0000664 0000000 0000000 00000014126 14102210121 0027252 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr // Represents an executor for a sequence of lexer actions which traversed during // the Matching operation of a lexer rule (token). // //The executor tracks position information for position-dependent lexer actions // efficiently, ensuring that actions appearing only at the end of the rule do // not cause bloating of the {@link DFA} created for the lexer.
type LexerActionExecutor struct { lexerActions []LexerAction cachedHash int } func NewLexerActionExecutor(lexerActions []LexerAction) *LexerActionExecutor { if lexerActions == nil { lexerActions = make([]LexerAction, 0) } l := new(LexerActionExecutor) l.lexerActions = lexerActions // Caches the result of {@link //hashCode} since the hash code is an element // of the performance-critical {@link LexerATNConfig//hashCode} operation. l.cachedHash = murmurInit(57) for _, a := range lexerActions { l.cachedHash = murmurUpdate(l.cachedHash, a.hash()) } return l } // Creates a {@link LexerActionExecutor} which executes the actions for // the input {@code lexerActionExecutor} followed by a specified // {@code lexerAction}. // // @param lexerActionExecutor The executor for actions already traversed by // the lexer while Matching a token within a particular // {@link LexerATNConfig}. If this is {@code nil}, the method behaves as // though it were an empty executor. // @param lexerAction The lexer action to execute after the actions // specified in {@code lexerActionExecutor}. // // @return A {@link LexerActionExecutor} for executing the combine actions // of {@code lexerActionExecutor} and {@code lexerAction}. func LexerActionExecutorappend(lexerActionExecutor *LexerActionExecutor, lexerAction LexerAction) *LexerActionExecutor { if lexerActionExecutor == nil { return NewLexerActionExecutor([]LexerAction{lexerAction}) } return NewLexerActionExecutor(append(lexerActionExecutor.lexerActions, lexerAction)) } // Creates a {@link LexerActionExecutor} which encodes the current offset // for position-dependent lexer actions. // //Normally, when the executor encounters lexer actions where // {@link LexerAction//isPositionDependent} returns {@code true}, it calls // {@link IntStream//seek} on the input {@link CharStream} to set the input // position to the end of the current token. This behavior provides // for efficient DFA representation of lexer actions which appear at the end // of a lexer rule, even when the lexer rule Matches a variable number of // characters.
// //Prior to traversing a Match transition in the ATN, the current offset // from the token start index is assigned to all position-dependent lexer // actions which have not already been assigned a fixed offset. By storing // the offsets relative to the token start index, the DFA representation of // lexer actions which appear in the middle of tokens remains efficient due // to sharing among tokens of the same length, regardless of their absolute // position in the input stream.
// //If the current executor already has offsets assigned to all // position-dependent lexer actions, the method returns {@code this}.
// // @param offset The current offset to assign to all position-dependent // lexer actions which do not already have offsets assigned. // // @return A {@link LexerActionExecutor} which stores input stream offsets // for all position-dependent lexer actions. // / func (l *LexerActionExecutor) fixOffsetBeforeMatch(offset int) *LexerActionExecutor { var updatedLexerActions []LexerAction for i := 0; i < len(l.lexerActions); i++ { _, ok := l.lexerActions[i].(*LexerIndexedCustomAction) if l.lexerActions[i].getIsPositionDependent() && !ok { if updatedLexerActions == nil { updatedLexerActions = make([]LexerAction, 0) for _, a := range l.lexerActions { updatedLexerActions = append(updatedLexerActions, a) } } updatedLexerActions[i] = NewLexerIndexedCustomAction(offset, l.lexerActions[i]) } } if updatedLexerActions == nil { return l } return NewLexerActionExecutor(updatedLexerActions) } // Execute the actions encapsulated by l executor within the context of a // particular {@link Lexer}. // //This method calls {@link IntStream//seek} to set the position of the // {@code input} {@link CharStream} prior to calling // {@link LexerAction//execute} on a position-dependent action. Before the // method returns, the input position will be restored to the same position // it was in when the method was invoked.
// // @param lexer The lexer instance. // @param input The input stream which is the source for the current token. // When l method is called, the current {@link IntStream//index} for // {@code input} should be the start of the following token, i.e. 1 // character past the end of the current token. // @param startIndex The token start index. This value may be passed to // {@link IntStream//seek} to set the {@code input} position to the beginning // of the token. // / func (l *LexerActionExecutor) execute(lexer Lexer, input CharStream, startIndex int) { requiresSeek := false stopIndex := input.Index() defer func() { if requiresSeek { input.Seek(stopIndex) } }() for i := 0; i < len(l.lexerActions); i++ { lexerAction := l.lexerActions[i] if la, ok := lexerAction.(*LexerIndexedCustomAction); ok { offset := la.offset input.Seek(startIndex + offset) lexerAction = la.lexerAction requiresSeek = (startIndex + offset) != stopIndex } else if lexerAction.getIsPositionDependent() { input.Seek(stopIndex) requiresSeek = false } lexerAction.execute(lexer) } } func (l *LexerActionExecutor) hash() int { if l == nil { return 61 } return l.cachedHash } func (l *LexerActionExecutor) equals(other interface{}) bool { if l == other { return true } else if _, ok := other.(*LexerActionExecutor); !ok { return false } else { return l.cachedHash == other.(*LexerActionExecutor).cachedHash && &l.lexerActions == &other.(*LexerActionExecutor).lexerActions } } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/lexer_atn_simulator.go 0000664 0000000 0000000 00000052716 14102210121 0026747 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "fmt" "strconv" ) var ( LexerATNSimulatorDebug = false LexerATNSimulatorDFADebug = false LexerATNSimulatorMinDFAEdge = 0 LexerATNSimulatorMaxDFAEdge = 127 // forces unicode to stay in ATN LexerATNSimulatorMatchCalls = 0 ) type ILexerATNSimulator interface { IATNSimulator reset() Match(input CharStream, mode int) int GetCharPositionInLine() int GetLine() int GetText(input CharStream) string Consume(input CharStream) } type LexerATNSimulator struct { *BaseATNSimulator recog Lexer predictionMode int mergeCache DoubleDict startIndex int Line int CharPositionInLine int mode int prevAccept *SimState MatchCalls int } func NewLexerATNSimulator(recog Lexer, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *LexerATNSimulator { l := new(LexerATNSimulator) l.BaseATNSimulator = NewBaseATNSimulator(atn, sharedContextCache) l.decisionToDFA = decisionToDFA l.recog = recog // The current token's starting index into the character stream. // Shared across DFA to ATN simulation in case the ATN fails and the // DFA did not have a previous accept state. In l case, we use the // ATN-generated exception object. l.startIndex = -1 // line number 1..n within the input/// l.Line = 1 // The index of the character relative to the beginning of the line // 0..n-1/// l.CharPositionInLine = 0 l.mode = LexerDefaultMode // Used during DFA/ATN exec to record the most recent accept configuration // info l.prevAccept = NewSimState() // done return l } func (l *LexerATNSimulator) copyState(simulator *LexerATNSimulator) { l.CharPositionInLine = simulator.CharPositionInLine l.Line = simulator.Line l.mode = simulator.mode l.startIndex = simulator.startIndex } func (l *LexerATNSimulator) Match(input CharStream, mode int) int { l.MatchCalls++ l.mode = mode mark := input.Mark() defer func() { input.Release(mark) }() l.startIndex = input.Index() l.prevAccept.reset() dfa := l.decisionToDFA[mode] if dfa.s0 == nil { return l.MatchATN(input) } return l.execATN(input, dfa.s0) } func (l *LexerATNSimulator) reset() { l.prevAccept.reset() l.startIndex = -1 l.Line = 1 l.CharPositionInLine = 0 l.mode = LexerDefaultMode } func (l *LexerATNSimulator) MatchATN(input CharStream) int { startState := l.atn.modeToStartState[l.mode] if LexerATNSimulatorDebug { fmt.Println("MatchATN mode " + strconv.Itoa(l.mode) + " start: " + startState.String()) } oldMode := l.mode s0Closure := l.computeStartState(input, startState) suppressEdge := s0Closure.hasSemanticContext s0Closure.hasSemanticContext = false next := l.addDFAState(s0Closure) if !suppressEdge { l.decisionToDFA[l.mode].setS0(next) } predict := l.execATN(input, next) if LexerATNSimulatorDebug { fmt.Println("DFA after MatchATN: " + l.decisionToDFA[oldMode].ToLexerString()) } return predict } func (l *LexerATNSimulator) execATN(input CharStream, ds0 *DFAState) int { if LexerATNSimulatorDebug { fmt.Println("start state closure=" + ds0.configs.String()) } if ds0.isAcceptState { // allow zero-length tokens l.captureSimState(l.prevAccept, input, ds0) } t := input.LA(1) s := ds0 // s is current/from DFA state for { // while more work if LexerATNSimulatorDebug { fmt.Println("execATN loop starting closure: " + s.configs.String()) } // As we move src->trg, src->trg, we keep track of the previous trg to // avoid looking up the DFA state again, which is expensive. // If the previous target was already part of the DFA, we might // be able to avoid doing a reach operation upon t. If s!=nil, // it means that semantic predicates didn't prevent us from // creating a DFA state. Once we know s!=nil, we check to see if // the DFA state has an edge already for t. If so, we can just reuse // it's configuration set there's no point in re-computing it. // This is kind of like doing DFA simulation within the ATN // simulation because DFA simulation is really just a way to avoid // computing reach/closure sets. Technically, once we know that // we have a previously added DFA state, we could jump over to // the DFA simulator. But, that would mean popping back and forth // a lot and making things more complicated algorithmically. // This optimization makes a lot of sense for loops within DFA. // A character will take us back to an existing DFA state // that already has lots of edges out of it. e.g., .* in comments. target := l.getExistingTargetState(s, t) if target == nil { target = l.computeTargetState(input, s, t) // print("Computed:" + str(target)) } if target == ATNSimulatorError { break } // If l is a consumable input element, make sure to consume before // capturing the accept state so the input index, line, and char // position accurately reflect the state of the interpreter at the // end of the token. if t != TokenEOF { l.Consume(input) } if target.isAcceptState { l.captureSimState(l.prevAccept, input, target) if t == TokenEOF { break } } t = input.LA(1) s = target // flip current DFA target becomes Newsrc/from state } return l.failOrAccept(l.prevAccept, input, s.configs, t) } // Get an existing target state for an edge in the DFA. If the target state // for the edge has not yet been computed or is otherwise not available, // l method returns {@code nil}. // // @param s The current DFA state // @param t The next input symbol // @return The existing target DFA state for the given input symbol // {@code t}, or {@code nil} if the target state for l edge is not // already cached func (l *LexerATNSimulator) getExistingTargetState(s *DFAState, t int) *DFAState { if s.edges == nil || t < LexerATNSimulatorMinDFAEdge || t > LexerATNSimulatorMaxDFAEdge { return nil } target := s.edges[t-LexerATNSimulatorMinDFAEdge] if LexerATNSimulatorDebug && target != nil { fmt.Println("reuse state " + strconv.Itoa(s.stateNumber) + " edge to " + strconv.Itoa(target.stateNumber)) } return target } // Compute a target state for an edge in the DFA, and attempt to add the // computed state and corresponding edge to the DFA. // // @param input The input stream // @param s The current DFA state // @param t The next input symbol // // @return The computed target DFA state for the given input symbol // {@code t}. If {@code t} does not lead to a valid DFA state, l method // returns {@link //ERROR}. func (l *LexerATNSimulator) computeTargetState(input CharStream, s *DFAState, t int) *DFAState { reach := NewOrderedATNConfigSet() // if we don't find an existing DFA state // Fill reach starting from closure, following t transitions l.getReachableConfigSet(input, s.configs, reach.BaseATNConfigSet, t) if len(reach.configs) == 0 { // we got nowhere on t from s if !reach.hasSemanticContext { // we got nowhere on t, don't panic out l knowledge it'd // cause a failover from DFA later. l.addDFAEdge(s, t, ATNSimulatorError, nil) } // stop when we can't Match any more char return ATNSimulatorError } // Add an edge from s to target DFA found/created for reach return l.addDFAEdge(s, t, nil, reach.BaseATNConfigSet) } func (l *LexerATNSimulator) failOrAccept(prevAccept *SimState, input CharStream, reach ATNConfigSet, t int) int { if l.prevAccept.dfaState != nil { lexerActionExecutor := prevAccept.dfaState.lexerActionExecutor l.accept(input, lexerActionExecutor, l.startIndex, prevAccept.index, prevAccept.line, prevAccept.column) return prevAccept.dfaState.prediction } // if no accept and EOF is first char, return EOF if t == TokenEOF && input.Index() == l.startIndex { return TokenEOF } panic(NewLexerNoViableAltException(l.recog, input, l.startIndex, reach)) } // Given a starting configuration set, figure out all ATN configurations // we can reach upon input {@code t}. Parameter {@code reach} is a return // parameter. func (l *LexerATNSimulator) getReachableConfigSet(input CharStream, closure ATNConfigSet, reach ATNConfigSet, t int) { // l is used to Skip processing for configs which have a lower priority // than a config that already reached an accept state for the same rule SkipAlt := ATNInvalidAltNumber for _, cfg := range closure.GetItems() { currentAltReachedAcceptState := (cfg.GetAlt() == SkipAlt) if currentAltReachedAcceptState && cfg.(*LexerATNConfig).passedThroughNonGreedyDecision { continue } if LexerATNSimulatorDebug { fmt.Printf("testing %s at %s\n", l.GetTokenName(t), cfg.String()) // l.recog, true)) } for _, trans := range cfg.GetState().GetTransitions() { target := l.getReachableTarget(trans, t) if target != nil { lexerActionExecutor := cfg.(*LexerATNConfig).lexerActionExecutor if lexerActionExecutor != nil { lexerActionExecutor = lexerActionExecutor.fixOffsetBeforeMatch(input.Index() - l.startIndex) } treatEOFAsEpsilon := (t == TokenEOF) config := NewLexerATNConfig3(cfg.(*LexerATNConfig), target, lexerActionExecutor) if l.closure(input, config, reach, currentAltReachedAcceptState, true, treatEOFAsEpsilon) { // any remaining configs for l alt have a lower priority // than the one that just reached an accept state. SkipAlt = cfg.GetAlt() } } } } } func (l *LexerATNSimulator) accept(input CharStream, lexerActionExecutor *LexerActionExecutor, startIndex, index, line, charPos int) { if LexerATNSimulatorDebug { fmt.Printf("ACTION %s\n", lexerActionExecutor) } // seek to after last char in token input.Seek(index) l.Line = line l.CharPositionInLine = charPos if lexerActionExecutor != nil && l.recog != nil { lexerActionExecutor.execute(l.recog, input, startIndex) } } func (l *LexerATNSimulator) getReachableTarget(trans Transition, t int) ATNState { if trans.Matches(t, 0, LexerMaxCharValue) { return trans.getTarget() } return nil } func (l *LexerATNSimulator) computeStartState(input CharStream, p ATNState) *OrderedATNConfigSet { configs := NewOrderedATNConfigSet() for i := 0; i < len(p.GetTransitions()); i++ { target := p.GetTransitions()[i].getTarget() cfg := NewLexerATNConfig6(target, i+1, BasePredictionContextEMPTY) l.closure(input, cfg, configs, false, false, false) } return configs } // Since the alternatives within any lexer decision are ordered by // preference, l method stops pursuing the closure as soon as an accept // state is reached. After the first accept state is reached by depth-first // search from {@code config}, all other (potentially reachable) states for // l rule would have a lower priority. // // @return {@code true} if an accept state is reached, otherwise // {@code false}. func (l *LexerATNSimulator) closure(input CharStream, config *LexerATNConfig, configs ATNConfigSet, currentAltReachedAcceptState, speculative, treatEOFAsEpsilon bool) bool { if LexerATNSimulatorDebug { fmt.Println("closure(" + config.String() + ")") // config.String(l.recog, true) + ")") } _, ok := config.state.(*RuleStopState) if ok { if LexerATNSimulatorDebug { if l.recog != nil { fmt.Printf("closure at %s rule stop %s\n", l.recog.GetRuleNames()[config.state.GetRuleIndex()], config) } else { fmt.Printf("closure at rule stop %s\n", config) } } if config.context == nil || config.context.hasEmptyPath() { if config.context == nil || config.context.isEmpty() { configs.Add(config, nil) return true } configs.Add(NewLexerATNConfig2(config, config.state, BasePredictionContextEMPTY), nil) currentAltReachedAcceptState = true } if config.context != nil && !config.context.isEmpty() { for i := 0; i < config.context.length(); i++ { if config.context.getReturnState(i) != BasePredictionContextEmptyReturnState { newContext := config.context.GetParent(i) // "pop" return state returnState := l.atn.states[config.context.getReturnState(i)] cfg := NewLexerATNConfig2(config, returnState, newContext) currentAltReachedAcceptState = l.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEOFAsEpsilon) } } } return currentAltReachedAcceptState } // optimization if !config.state.GetEpsilonOnlyTransitions() { if !currentAltReachedAcceptState || !config.passedThroughNonGreedyDecision { configs.Add(config, nil) } } for j := 0; j < len(config.state.GetTransitions()); j++ { trans := config.state.GetTransitions()[j] cfg := l.getEpsilonTarget(input, config, trans, configs, speculative, treatEOFAsEpsilon) if cfg != nil { currentAltReachedAcceptState = l.closure(input, cfg, configs, currentAltReachedAcceptState, speculative, treatEOFAsEpsilon) } } return currentAltReachedAcceptState } // side-effect: can alter configs.hasSemanticContext func (l *LexerATNSimulator) getEpsilonTarget(input CharStream, config *LexerATNConfig, trans Transition, configs ATNConfigSet, speculative, treatEOFAsEpsilon bool) *LexerATNConfig { var cfg *LexerATNConfig if trans.getSerializationType() == TransitionRULE { rt := trans.(*RuleTransition) newContext := SingletonBasePredictionContextCreate(config.context, rt.followState.GetStateNumber()) cfg = NewLexerATNConfig2(config, trans.getTarget(), newContext) } else if trans.getSerializationType() == TransitionPRECEDENCE { panic("Precedence predicates are not supported in lexers.") } else if trans.getSerializationType() == TransitionPREDICATE { // Track traversing semantic predicates. If we traverse, // we cannot add a DFA state for l "reach" computation // because the DFA would not test the predicate again in the // future. Rather than creating collections of semantic predicates // like v3 and testing them on prediction, v4 will test them on the // fly all the time using the ATN not the DFA. This is slower but // semantically it's not used that often. One of the key elements to // l predicate mechanism is not adding DFA states that see // predicates immediately afterwards in the ATN. For example, // a : ID {p1}? | ID {p2}? // should create the start state for rule 'a' (to save start state // competition), but should not create target of ID state. The // collection of ATN states the following ID references includes // states reached by traversing predicates. Since l is when we // test them, we cannot cash the DFA state target of ID. pt := trans.(*PredicateTransition) if LexerATNSimulatorDebug { fmt.Println("EVAL rule " + strconv.Itoa(trans.(*PredicateTransition).ruleIndex) + ":" + strconv.Itoa(pt.predIndex)) } configs.SetHasSemanticContext(true) if l.evaluatePredicate(input, pt.ruleIndex, pt.predIndex, speculative) { cfg = NewLexerATNConfig4(config, trans.getTarget()) } } else if trans.getSerializationType() == TransitionACTION { if config.context == nil || config.context.hasEmptyPath() { // execute actions anywhere in the start rule for a token. // // TODO: if the entry rule is invoked recursively, some // actions may be executed during the recursive call. The // problem can appear when hasEmptyPath() is true but // isEmpty() is false. In l case, the config needs to be // split into two contexts - one with just the empty path // and another with everything but the empty path. // Unfortunately, the current algorithm does not allow // getEpsilonTarget to return two configurations, so // additional modifications are needed before we can support // the split operation. lexerActionExecutor := LexerActionExecutorappend(config.lexerActionExecutor, l.atn.lexerActions[trans.(*ActionTransition).actionIndex]) cfg = NewLexerATNConfig3(config, trans.getTarget(), lexerActionExecutor) } else { // ignore actions in referenced rules cfg = NewLexerATNConfig4(config, trans.getTarget()) } } else if trans.getSerializationType() == TransitionEPSILON { cfg = NewLexerATNConfig4(config, trans.getTarget()) } else if trans.getSerializationType() == TransitionATOM || trans.getSerializationType() == TransitionRANGE || trans.getSerializationType() == TransitionSET { if treatEOFAsEpsilon { if trans.Matches(TokenEOF, 0, LexerMaxCharValue) { cfg = NewLexerATNConfig4(config, trans.getTarget()) } } } return cfg } // Evaluate a predicate specified in the lexer. // //If {@code speculative} is {@code true}, l method was called before // {@link //consume} for the Matched character. This method should call // {@link //consume} before evaluating the predicate to ensure position // sensitive values, including {@link Lexer//GetText}, {@link Lexer//GetLine}, // and {@link Lexer//getcolumn}, properly reflect the current // lexer state. This method should restore {@code input} and the simulator // to the original state before returning (i.e. undo the actions made by the // call to {@link //consume}.
// // @param input The input stream. // @param ruleIndex The rule containing the predicate. // @param predIndex The index of the predicate within the rule. // @param speculative {@code true} if the current index in {@code input} is // one character before the predicate's location. // // @return {@code true} if the specified predicate evaluates to // {@code true}. // / func (l *LexerATNSimulator) evaluatePredicate(input CharStream, ruleIndex, predIndex int, speculative bool) bool { // assume true if no recognizer was provided if l.recog == nil { return true } if !speculative { return l.recog.Sempred(nil, ruleIndex, predIndex) } savedcolumn := l.CharPositionInLine savedLine := l.Line index := input.Index() marker := input.Mark() defer func() { l.CharPositionInLine = savedcolumn l.Line = savedLine input.Seek(index) input.Release(marker) }() l.Consume(input) return l.recog.Sempred(nil, ruleIndex, predIndex) } func (l *LexerATNSimulator) captureSimState(settings *SimState, input CharStream, dfaState *DFAState) { settings.index = input.Index() settings.line = l.Line settings.column = l.CharPositionInLine settings.dfaState = dfaState } func (l *LexerATNSimulator) addDFAEdge(from *DFAState, tk int, to *DFAState, cfgs ATNConfigSet) *DFAState { if to == nil && cfgs != nil { // leading to l call, ATNConfigSet.hasSemanticContext is used as a // marker indicating dynamic predicate evaluation makes l edge // dependent on the specific input sequence, so the static edge in the // DFA should be omitted. The target DFAState is still created since // execATN has the ability to reSynchronize with the DFA state cache // following the predicate evaluation step. // // TJP notes: next time through the DFA, we see a pred again and eval. // If that gets us to a previously created (but dangling) DFA // state, we can continue in pure DFA mode from there. // / suppressEdge := cfgs.HasSemanticContext() cfgs.SetHasSemanticContext(false) to = l.addDFAState(cfgs) if suppressEdge { return to } } // add the edge if tk < LexerATNSimulatorMinDFAEdge || tk > LexerATNSimulatorMaxDFAEdge { // Only track edges within the DFA bounds return to } if LexerATNSimulatorDebug { fmt.Println("EDGE " + from.String() + " -> " + to.String() + " upon " + strconv.Itoa(tk)) } if from.edges == nil { // make room for tokens 1..n and -1 masquerading as index 0 from.edges = make([]*DFAState, LexerATNSimulatorMaxDFAEdge-LexerATNSimulatorMinDFAEdge+1) } from.edges[tk-LexerATNSimulatorMinDFAEdge] = to // connect return to } // Add a NewDFA state if there isn't one with l set of // configurations already. This method also detects the first // configuration containing an ATN rule stop state. Later, when // traversing the DFA, we will know which rule to accept. func (l *LexerATNSimulator) addDFAState(configs ATNConfigSet) *DFAState { proposed := NewDFAState(-1, configs) var firstConfigWithRuleStopState ATNConfig for _, cfg := range configs.GetItems() { _, ok := cfg.GetState().(*RuleStopState) if ok { firstConfigWithRuleStopState = cfg break } } if firstConfigWithRuleStopState != nil { proposed.isAcceptState = true proposed.lexerActionExecutor = firstConfigWithRuleStopState.(*LexerATNConfig).lexerActionExecutor proposed.setPrediction(l.atn.ruleToTokenType[firstConfigWithRuleStopState.GetState().GetRuleIndex()]) } hash := proposed.hash() dfa := l.decisionToDFA[l.mode] existing, ok := dfa.getState(hash) if ok { return existing } newState := proposed newState.stateNumber = dfa.numStates() configs.SetReadOnly(true) newState.configs = configs dfa.setState(hash, newState) return newState } func (l *LexerATNSimulator) getDFA(mode int) *DFA { return l.decisionToDFA[mode] } // Get the text Matched so far for the current token. func (l *LexerATNSimulator) GetText(input CharStream) string { // index is first lookahead char, don't include. return input.GetTextFromInterval(NewInterval(l.startIndex, input.Index()-1)) } func (l *LexerATNSimulator) Consume(input CharStream) { curChar := input.LA(1) if curChar == int('\n') { l.Line++ l.CharPositionInLine = 0 } else { l.CharPositionInLine++ } input.Consume() } func (l *LexerATNSimulator) GetCharPositionInLine() int { return l.CharPositionInLine } func (l *LexerATNSimulator) GetLine() int { return l.Line } func (l *LexerATNSimulator) GetTokenName(tt int) string { if tt == -1 { return "EOF" } return "'" + string(tt) + "'" } func resetSimState(sim *SimState) { sim.index = -1 sim.line = 0 sim.column = -1 sim.dfaState = nil } type SimState struct { index int line int column int dfaState *DFAState } func NewSimState() *SimState { s := new(SimState) resetSimState(s) return s } func (s *SimState) reset() { resetSimState(s) } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/ll1_analyzer.go 0000664 0000000 0000000 00000016331 14102210121 0025255 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr type LL1Analyzer struct { atn *ATN } func NewLL1Analyzer(atn *ATN) *LL1Analyzer { la := new(LL1Analyzer) la.atn = atn return la } //* Special value added to the lookahead sets to indicate that we hit // a predicate during analysis if {@code seeThruPreds==false}. /// const ( LL1AnalyzerHitPred = TokenInvalidType ) //* // Calculates the SLL(1) expected lookahead set for each outgoing transition // of an {@link ATNState}. The returned array has one element for each // outgoing transition in {@code s}. If the closure from transition // i leads to a semantic predicate before Matching a symbol, the // element at index i of the result will be {@code nil}. // // @param s the ATN state // @return the expected symbols for each outgoing transition of {@code s}. func (la *LL1Analyzer) getDecisionLookahead(s ATNState) []*IntervalSet { if s == nil { return nil } count := len(s.GetTransitions()) look := make([]*IntervalSet, count) for alt := 0; alt < count; alt++ { look[alt] = NewIntervalSet() lookBusy := NewSet(nil, nil) seeThruPreds := false // fail to get lookahead upon pred la.look1(s.GetTransitions()[alt].getTarget(), nil, BasePredictionContextEMPTY, look[alt], lookBusy, NewBitSet(), seeThruPreds, false) // Wipe out lookahead for la alternative if we found nothing // or we had a predicate when we !seeThruPreds if look[alt].length() == 0 || look[alt].contains(LL1AnalyzerHitPred) { look[alt] = nil } } return look } //* // Compute set of tokens that can follow {@code s} in the ATN in the // specified {@code ctx}. // //If {@code ctx} is {@code nil} and the end of the rule containing // {@code s} is reached, {@link Token//EPSILON} is added to the result set. // If {@code ctx} is not {@code nil} and the end of the outermost rule is // reached, {@link Token//EOF} is added to the result set.
// // @param s the ATN state // @param stopState the ATN state to stop at. This can be a // {@link BlockEndState} to detect epsilon paths through a closure. // @param ctx the complete parser context, or {@code nil} if the context // should be ignored // // @return The set of tokens that can follow {@code s} in the ATN in the // specified {@code ctx}. /// func (la *LL1Analyzer) Look(s, stopState ATNState, ctx RuleContext) *IntervalSet { r := NewIntervalSet() seeThruPreds := true // ignore preds get all lookahead var lookContext PredictionContext if ctx != nil { lookContext = predictionContextFromRuleContext(s.GetATN(), ctx) } la.look1(s, stopState, lookContext, r, NewSet(nil, nil), NewBitSet(), seeThruPreds, true) return r } //* // Compute set of tokens that can follow {@code s} in the ATN in the // specified {@code ctx}. // //If {@code ctx} is {@code nil} and {@code stopState} or the end of the // rule containing {@code s} is reached, {@link Token//EPSILON} is added to // the result set. If {@code ctx} is not {@code nil} and {@code addEOF} is // {@code true} and {@code stopState} or the end of the outermost rule is // reached, {@link Token//EOF} is added to the result set.
// // @param s the ATN state. // @param stopState the ATN state to stop at. This can be a // {@link BlockEndState} to detect epsilon paths through a closure. // @param ctx The outer context, or {@code nil} if the outer context should // not be used. // @param look The result lookahead set. // @param lookBusy A set used for preventing epsilon closures in the ATN // from causing a stack overflow. Outside code should pass // {@code NewSetIf the symbol type does not Match, // {@link ANTLRErrorStrategy//recoverInline} is called on the current error // strategy to attempt recovery. If {@link //getBuildParseTree} is // {@code true} and the token index of the symbol returned by // {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to // the parse tree by calling {@link ParserRuleContext//addErrorNode}.
// // @param ttype the token type to Match // @return the Matched symbol // @panics RecognitionException if the current input symbol did not Match // {@code ttype} and the error strategy could not recover from the // mismatched symbol func (p *BaseParser) Match(ttype int) Token { t := p.GetCurrentToken() if t.GetTokenType() == ttype { p.errHandler.ReportMatch(p) p.Consume() } else { t = p.errHandler.RecoverInline(p) if p.BuildParseTrees && t.GetTokenIndex() == -1 { // we must have conjured up a Newtoken during single token // insertion // if it's not the current symbol p.ctx.AddErrorNode(t) } } return t } // Match current input symbol as a wildcard. If the symbol type Matches // (i.e. has a value greater than 0), {@link ANTLRErrorStrategy//ReportMatch} // and {@link //consume} are called to complete the Match process. // //If the symbol type does not Match, // {@link ANTLRErrorStrategy//recoverInline} is called on the current error // strategy to attempt recovery. If {@link //getBuildParseTree} is // {@code true} and the token index of the symbol returned by // {@link ANTLRErrorStrategy//recoverInline} is -1, the symbol is added to // the parse tree by calling {@link ParserRuleContext//addErrorNode}.
// // @return the Matched symbol // @panics RecognitionException if the current input symbol did not Match // a wildcard and the error strategy could not recover from the mismatched // symbol func (p *BaseParser) MatchWildcard() Token { t := p.GetCurrentToken() if t.GetTokenType() > 0 { p.errHandler.ReportMatch(p) p.Consume() } else { t = p.errHandler.RecoverInline(p) if p.BuildParseTrees && t.GetTokenIndex() == -1 { // we must have conjured up a Newtoken during single token // insertion // if it's not the current symbol p.ctx.AddErrorNode(t) } } return t } func (p *BaseParser) GetParserRuleContext() ParserRuleContext { return p.ctx } func (p *BaseParser) SetParserRuleContext(v ParserRuleContext) { p.ctx = v } func (p *BaseParser) GetParseListeners() []ParseTreeListener { if p.parseListeners == nil { return make([]ParseTreeListener, 0) } return p.parseListeners } // Registers {@code listener} to receive events during the parsing process. // //To support output-preserving grammar transformations (including but not // limited to left-recursion removal, automated left-factoring, and // optimized code generation), calls to listener methods during the parse // may differ substantially from calls made by // {@link ParseTreeWalker//DEFAULT} used after the parse is complete. In // particular, rule entry and exit events may occur in a different order // during the parse than after the parser. In addition, calls to certain // rule entry methods may be omitted.
// //With the following specific exceptions, calls to listener events are // deterministic, i.e. for identical input the calls to listener // methods will be the same.
// //If {@code listener} is {@code nil} or has not been added as a parse // listener, p.method does nothing.
// @param listener the listener to remove // func (p *BaseParser) RemoveParseListener(listener ParseTreeListener) { if p.parseListeners != nil { idx := -1 for i, v := range p.parseListeners { if v == listener { idx = i break } } if idx == -1 { return } // remove the listener from the slice p.parseListeners = append(p.parseListeners[0:idx], p.parseListeners[idx+1:]...) if len(p.parseListeners) == 0 { p.parseListeners = nil } } } // Remove all parse listeners. func (p *BaseParser) removeParseListeners() { p.parseListeners = nil } // Notify any parse listeners of an enter rule event. func (p *BaseParser) TriggerEnterRuleEvent() { if p.parseListeners != nil { ctx := p.ctx for _, listener := range p.parseListeners { listener.EnterEveryRule(ctx) ctx.EnterRule(listener) } } } // // Notify any parse listeners of an exit rule event. // // @see //addParseListener // func (p *BaseParser) TriggerExitRuleEvent() { if p.parseListeners != nil { // reverse order walk of listeners ctx := p.ctx l := len(p.parseListeners) - 1 for i := range p.parseListeners { listener := p.parseListeners[l-i] ctx.ExitRule(listener) listener.ExitEveryRule(ctx) } } } func (p *BaseParser) GetInterpreter() *ParserATNSimulator { return p.Interpreter } func (p *BaseParser) GetATN() *ATN { return p.Interpreter.atn } func (p *BaseParser) GetTokenFactory() TokenFactory { return p.input.GetTokenSource().GetTokenFactory() } // Tell our token source and error strategy about a Newway to create tokens.// func (p *BaseParser) setTokenFactory(factory TokenFactory) { p.input.GetTokenSource().setTokenFactory(factory) } // The ATN with bypass alternatives is expensive to create so we create it // lazily. // // @panics UnsupportedOperationException if the current parser does not // implement the {@link //getSerializedATN()} method. // func (p *BaseParser) GetATNWithBypassAlts() { // TODO panic("Not implemented!") // serializedAtn := p.getSerializedATN() // if (serializedAtn == nil) { // panic("The current parser does not support an ATN with bypass alternatives.") // } // result := p.bypassAltsAtnCache[serializedAtn] // if (result == nil) { // deserializationOptions := NewATNDeserializationOptions(nil) // deserializationOptions.generateRuleBypassTransitions = true // result = NewATNDeserializer(deserializationOptions).deserialize(serializedAtn) // p.bypassAltsAtnCache[serializedAtn] = result // } // return result } // The preferred method of getting a tree pattern. For example, here's a // sample use: // //
// ParseTree t = parser.expr()
// ParseTreePattern p = parser.compileParseTreePattern("<ID>+0",
// MyParser.RULE_expr)
// ParseTreeMatch m = p.Match(t)
// String id = m.Get("ID")
//
func (p *BaseParser) compileParseTreePattern(pattern, patternRuleIndex, lexer Lexer) {
panic("NewParseTreePatternMatcher not implemented!")
//
// if (lexer == nil) {
// if (p.GetTokenStream() != nil) {
// tokenSource := p.GetTokenStream().GetTokenSource()
// if _, ok := tokenSource.(ILexer); ok {
// lexer = tokenSource
// }
// }
// }
// if (lexer == nil) {
// panic("Parser can't discover a lexer to use")
// }
// m := NewParseTreePatternMatcher(lexer, p)
// return m.compile(pattern, patternRuleIndex)
}
func (p *BaseParser) GetInputStream() IntStream {
return p.GetTokenStream()
}
func (p *BaseParser) SetInputStream(input TokenStream) {
p.SetTokenStream(input)
}
func (p *BaseParser) GetTokenStream() TokenStream {
return p.input
}
// Set the token stream and reset the parser.//
func (p *BaseParser) SetTokenStream(input TokenStream) {
p.input = nil
p.reset()
p.input = input
}
// Match needs to return the current input symbol, which gets put
// into the label for the associated token ref e.g., x=ID.
//
func (p *BaseParser) GetCurrentToken() Token {
return p.input.LT(1)
}
func (p *BaseParser) NotifyErrorListeners(msg string, offendingToken Token, err RecognitionException) {
if offendingToken == nil {
offendingToken = p.GetCurrentToken()
}
p._SyntaxErrors++
line := offendingToken.GetLine()
column := offendingToken.GetColumn()
listener := p.GetErrorListenerDispatch()
listener.SyntaxError(p, offendingToken, line, column, msg, err)
}
func (p *BaseParser) Consume() Token {
o := p.GetCurrentToken()
if o.GetTokenType() != TokenEOF {
p.GetInputStream().Consume()
}
hasListener := p.parseListeners != nil && len(p.parseListeners) > 0
if p.BuildParseTrees || hasListener {
if p.errHandler.inErrorRecoveryMode(p) {
node := p.ctx.AddErrorNode(o)
if p.parseListeners != nil {
for _, l := range p.parseListeners {
l.VisitErrorNode(node)
}
}
} else {
node := p.ctx.AddTokenNode(o)
if p.parseListeners != nil {
for _, l := range p.parseListeners {
l.VisitTerminal(node)
}
}
}
// node.invokingState = p.state
}
return o
}
func (p *BaseParser) addContextToParseTree() {
// add current context to parent if we have a parent
if p.ctx.GetParent() != nil {
p.ctx.GetParent().(ParserRuleContext).AddChild(p.ctx)
}
}
func (p *BaseParser) EnterRule(localctx ParserRuleContext, state, ruleIndex int) {
p.SetState(state)
p.ctx = localctx
p.ctx.SetStart(p.input.LT(1))
if p.BuildParseTrees {
p.addContextToParseTree()
}
if p.parseListeners != nil {
p.TriggerEnterRuleEvent()
}
}
func (p *BaseParser) ExitRule() {
p.ctx.SetStop(p.input.LT(-1))
// trigger event on ctx, before it reverts to parent
if p.parseListeners != nil {
p.TriggerExitRuleEvent()
}
p.SetState(p.ctx.GetInvokingState())
if p.ctx.GetParent() != nil {
p.ctx = p.ctx.GetParent().(ParserRuleContext)
} else {
p.ctx = nil
}
}
func (p *BaseParser) EnterOuterAlt(localctx ParserRuleContext, altNum int) {
localctx.SetAltNumber(altNum)
// if we have Newlocalctx, make sure we replace existing ctx
// that is previous child of parse tree
if p.BuildParseTrees && p.ctx != localctx {
if p.ctx.GetParent() != nil {
p.ctx.GetParent().(ParserRuleContext).RemoveLastChild()
p.ctx.GetParent().(ParserRuleContext).AddChild(localctx)
}
}
p.ctx = localctx
}
// Get the precedence level for the top-most precedence rule.
//
// @return The precedence level for the top-most precedence rule, or -1 if
// the parser context is not nested within a precedence rule.
func (p *BaseParser) GetPrecedence() int {
if len(p.precedenceStack) == 0 {
return -1
}
return p.precedenceStack[len(p.precedenceStack)-1]
}
func (p *BaseParser) EnterRecursionRule(localctx ParserRuleContext, state, ruleIndex, precedence int) {
p.SetState(state)
p.precedenceStack.Push(precedence)
p.ctx = localctx
p.ctx.SetStart(p.input.LT(1))
if p.parseListeners != nil {
p.TriggerEnterRuleEvent() // simulates rule entry for
// left-recursive rules
}
}
//
// Like {@link //EnterRule} but for recursive rules.
func (p *BaseParser) PushNewRecursionContext(localctx ParserRuleContext, state, ruleIndex int) {
previous := p.ctx
previous.SetParent(localctx)
previous.SetInvokingState(state)
previous.SetStop(p.input.LT(-1))
p.ctx = localctx
p.ctx.SetStart(previous.GetStart())
if p.BuildParseTrees {
p.ctx.AddChild(previous)
}
if p.parseListeners != nil {
p.TriggerEnterRuleEvent() // simulates rule entry for
// left-recursive rules
}
}
func (p *BaseParser) UnrollRecursionContexts(parentCtx ParserRuleContext) {
p.precedenceStack.Pop()
p.ctx.SetStop(p.input.LT(-1))
retCtx := p.ctx // save current ctx (return value)
// unroll so ctx is as it was before call to recursive method
if p.parseListeners != nil {
for p.ctx != parentCtx {
p.TriggerExitRuleEvent()
p.ctx = p.ctx.GetParent().(ParserRuleContext)
}
} else {
p.ctx = parentCtx
}
// hook into tree
retCtx.SetParent(parentCtx)
if p.BuildParseTrees && parentCtx != nil {
// add return ctx into invoking rule's tree
parentCtx.AddChild(retCtx)
}
}
func (p *BaseParser) GetInvokingContext(ruleIndex int) ParserRuleContext {
ctx := p.ctx
for ctx != nil {
if ctx.GetRuleIndex() == ruleIndex {
return ctx
}
ctx = ctx.GetParent().(ParserRuleContext)
}
return nil
}
func (p *BaseParser) Precpred(localctx RuleContext, precedence int) bool {
return precedence >= p.precedenceStack[len(p.precedenceStack)-1]
}
func (p *BaseParser) inContext(context ParserRuleContext) bool {
// TODO: useful in parser?
return false
}
//
// Checks whether or not {@code symbol} can follow the current state in the
// ATN. The behavior of p.method is equivalent to the following, but is
// implemented such that the complete context-sensitive follow set does not
// need to be explicitly constructed.
//
// // return getExpectedTokens().contains(symbol) //// // @param symbol the symbol type to check // @return {@code true} if {@code symbol} can follow the current state in // the ATN, otherwise {@code false}. func (p *BaseParser) IsExpectedToken(symbol int) bool { atn := p.Interpreter.atn ctx := p.ctx s := atn.states[p.state] following := atn.NextTokens(s, nil) if following.contains(symbol) { return true } if !following.contains(TokenEpsilon) { return false } for ctx != nil && ctx.GetInvokingState() >= 0 && following.contains(TokenEpsilon) { invokingState := atn.states[ctx.GetInvokingState()] rt := invokingState.GetTransitions()[0] following = atn.NextTokens(rt.(*RuleTransition).followState, nil) if following.contains(symbol) { return true } ctx = ctx.GetParent().(ParserRuleContext) } if following.contains(TokenEpsilon) && symbol == TokenEOF { return true } return false } // Computes the set of input symbols which could follow the current parser // state and context, as given by {@link //GetState} and {@link //GetContext}, // respectively. // // @see ATN//getExpectedTokens(int, RuleContext) // func (p *BaseParser) GetExpectedTokens() *IntervalSet { return p.Interpreter.atn.getExpectedTokens(p.state, p.ctx) } func (p *BaseParser) GetExpectedTokensWithinCurrentRule() *IntervalSet { atn := p.Interpreter.atn s := atn.states[p.state] return atn.NextTokens(s, nil) } // Get a rule's index (i.e., {@code RULE_ruleName} field) or -1 if not found.// func (p *BaseParser) GetRuleIndex(ruleName string) int { var ruleIndex, ok = p.GetRuleIndexMap()[ruleName] if ok { return ruleIndex } return -1 } // Return List<String> of the rule names in your parser instance // leading up to a call to the current rule. You could override if // you want more details such as the file/line info of where // in the ATN a rule is invoked. // // this very useful for error messages. func (p *BaseParser) GetRuleInvocationStack(c ParserRuleContext) []string { if c == nil { c = p.ctx } stack := make([]string, 0) for c != nil { // compute what follows who invoked us ruleIndex := c.GetRuleIndex() if ruleIndex < 0 { stack = append(stack, "n/a") } else { stack = append(stack, p.GetRuleNames()[ruleIndex]) } vp := c.GetParent() if vp == nil { break } c = vp.(ParserRuleContext) } return stack } // For debugging and other purposes.// func (p *BaseParser) GetDFAStrings() string { return fmt.Sprint(p.Interpreter.decisionToDFA) } // For debugging and other purposes.// func (p *BaseParser) DumpDFA() { seenOne := false for _, dfa := range p.Interpreter.decisionToDFA { if dfa.numStates() > 0 { if seenOne { fmt.Println() } fmt.Println("Decision " + strconv.Itoa(dfa.decision) + ":") fmt.Print(dfa.String(p.LiteralNames, p.SymbolicNames)) seenOne = true } } } func (p *BaseParser) GetSourceName() string { return p.GrammarFileName } // During a parse is sometimes useful to listen in on the rule entry and exit // events as well as token Matches. p.is for quick and dirty debugging. // func (p *BaseParser) SetTrace(trace *TraceListener) { if trace == nil { p.RemoveParseListener(p.tracer) p.tracer = nil } else { if p.tracer != nil { p.RemoveParseListener(p.tracer) } p.tracer = NewTraceListener(p) p.AddParseListener(p.tracer) } } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/parser_atn_simulator.go 0000664 0000000 0000000 00000151755 14102210121 0027127 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "fmt" "strconv" "strings" ) var ( ParserATNSimulatorDebug = false ParserATNSimulatorListATNDecisions = false ParserATNSimulatorDFADebug = false ParserATNSimulatorRetryDebug = false ) type ParserATNSimulator struct { *BaseATNSimulator parser Parser predictionMode int input TokenStream startIndex int dfa *DFA mergeCache *DoubleDict outerContext ParserRuleContext } func NewParserATNSimulator(parser Parser, atn *ATN, decisionToDFA []*DFA, sharedContextCache *PredictionContextCache) *ParserATNSimulator { p := new(ParserATNSimulator) p.BaseATNSimulator = NewBaseATNSimulator(atn, sharedContextCache) p.parser = parser p.decisionToDFA = decisionToDFA // SLL, LL, or LL + exact ambig detection?// p.predictionMode = PredictionModeLL // LAME globals to avoid parameters!!!!! I need these down deep in predTransition p.input = nil p.startIndex = 0 p.outerContext = nil p.dfa = nil // Each prediction operation uses a cache for merge of prediction contexts. // Don't keep around as it wastes huge amounts of memory. DoubleKeyMap // isn't Synchronized but we're ok since two threads shouldn't reuse same // parser/atnsim object because it can only handle one input at a time. // This maps graphs a and b to merged result c. (a,b)&rarrc. We can avoid // the merge if we ever see a and b again. Note that (b,a)&rarrc should // also be examined during cache lookup. // p.mergeCache = nil return p } func (p *ParserATNSimulator) GetPredictionMode() int { return p.predictionMode } func (p *ParserATNSimulator) SetPredictionMode(v int) { p.predictionMode = v } func (p *ParserATNSimulator) reset() { } func (p *ParserATNSimulator) AdaptivePredict(input TokenStream, decision int, outerContext ParserRuleContext) int { if ParserATNSimulatorDebug || ParserATNSimulatorListATNDecisions { fmt.Println("AdaptivePredict decision " + strconv.Itoa(decision) + " exec LA(1)==" + p.getLookaheadName(input) + " line " + strconv.Itoa(input.LT(1).GetLine()) + ":" + strconv.Itoa(input.LT(1).GetColumn())) } p.input = input p.startIndex = input.Index() p.outerContext = outerContext dfa := p.decisionToDFA[decision] p.dfa = dfa m := input.Mark() index := input.Index() defer func() { p.dfa = nil p.mergeCache = nil // wack cache after each prediction input.Seek(index) input.Release(m) }() // Now we are certain to have a specific decision's DFA // But, do we still need an initial state? var s0 *DFAState if dfa.precedenceDfa { // the start state for a precedence DFA depends on the current // parser precedence, and is provided by a DFA method. s0 = dfa.getPrecedenceStartState(p.parser.GetPrecedence()) } else { // the start state for a "regular" DFA is just s0 s0 = dfa.s0 } if s0 == nil { if outerContext == nil { outerContext = RuleContextEmpty } if ParserATNSimulatorDebug || ParserATNSimulatorListATNDecisions { fmt.Println("predictATN decision " + strconv.Itoa(dfa.decision) + " exec LA(1)==" + p.getLookaheadName(input) + ", outerContext=" + outerContext.String(p.parser.GetRuleNames(), nil)) } // If p is not a precedence DFA, we check the ATN start state // to determine if p ATN start state is the decision for the // closure block that determines whether a precedence rule // should continue or complete. t2 := dfa.atnStartState t, ok := t2.(*StarLoopEntryState) if !dfa.precedenceDfa && ok { if t.precedenceRuleDecision { dfa.setPrecedenceDfa(true) } } fullCtx := false s0Closure := p.computeStartState(dfa.atnStartState, RuleContextEmpty, fullCtx) if dfa.precedenceDfa { // If p is a precedence DFA, we use applyPrecedenceFilter // to convert the computed start state to a precedence start // state. We then use DFA.setPrecedenceStartState to set the // appropriate start state for the precedence level rather // than simply setting DFA.s0. // s0Closure = p.applyPrecedenceFilter(s0Closure) s0 = p.addDFAState(dfa, NewDFAState(-1, s0Closure)) dfa.setPrecedenceStartState(p.parser.GetPrecedence(), s0) } else { s0 = p.addDFAState(dfa, NewDFAState(-1, s0Closure)) dfa.s0 = s0 } } alt := p.execATN(dfa, s0, input, index, outerContext) if ParserATNSimulatorDebug { fmt.Println("DFA after predictATN: " + dfa.String(p.parser.GetLiteralNames(), nil)) } return alt } // Performs ATN simulation to compute a predicted alternative based // upon the remaining input, but also updates the DFA cache to avoid // having to traverse the ATN again for the same input sequence. // There are some key conditions we're looking for after computing a new // set of ATN configs (proposed DFA state): // if the set is empty, there is no viable alternative for current symbol // does the state uniquely predict an alternative? // does the state have a conflict that would prevent us from // putting it on the work list? // We also have some key operations to do: // add an edge from previous DFA state to potentially NewDFA state, D, // upon current symbol but only if adding to work list, which means in all // cases except no viable alternative (and possibly non-greedy decisions?) // collecting predicates and adding semantic context to DFA accept states // adding rule context to context-sensitive DFA accept states // consuming an input symbol // Reporting a conflict // Reporting an ambiguity // Reporting a context sensitivity // Reporting insufficient predicates // cover these cases: // dead end // single alt // single alt + preds // conflict // conflict + preds // func (p *ParserATNSimulator) execATN(dfa *DFA, s0 *DFAState, input TokenStream, startIndex int, outerContext ParserRuleContext) int { if ParserATNSimulatorDebug || ParserATNSimulatorListATNDecisions { fmt.Println("execATN decision " + strconv.Itoa(dfa.decision) + " exec LA(1)==" + p.getLookaheadName(input) + " line " + strconv.Itoa(input.LT(1).GetLine()) + ":" + strconv.Itoa(input.LT(1).GetColumn())) } previousD := s0 if ParserATNSimulatorDebug { fmt.Println("s0 = " + s0.String()) } t := input.LA(1) for { // for more work D := p.getExistingTargetState(previousD, t) if D == nil { D = p.computeTargetState(dfa, previousD, t) } if D == ATNSimulatorError { // if any configs in previous dipped into outer context, that // means that input up to t actually finished entry rule // at least for SLL decision. Full LL doesn't dip into outer // so don't need special case. // We will get an error no matter what so delay until after // decision better error message. Also, no reachable target // ATN states in SLL implies LL will also get nowhere. // If conflict in states that dip out, choose min since we // will get error no matter what. e := p.noViableAlt(input, outerContext, previousD.configs, startIndex) input.Seek(startIndex) alt := p.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previousD.configs, outerContext) if alt != ATNInvalidAltNumber { return alt } panic(e) } if D.requiresFullContext && p.predictionMode != PredictionModeSLL { // IF PREDS, MIGHT RESOLVE TO SINGLE ALT => SLL (or syntax error) conflictingAlts := D.configs.GetConflictingAlts() if D.predicates != nil { if ParserATNSimulatorDebug { fmt.Println("DFA state has preds in DFA sim LL failover") } conflictIndex := input.Index() if conflictIndex != startIndex { input.Seek(startIndex) } conflictingAlts = p.evalSemanticContext(D.predicates, outerContext, true) if conflictingAlts.length() == 1 { if ParserATNSimulatorDebug { fmt.Println("Full LL avoided") } return conflictingAlts.minValue() } if conflictIndex != startIndex { // restore the index so Reporting the fallback to full // context occurs with the index at the correct spot input.Seek(conflictIndex) } } if ParserATNSimulatorDFADebug { fmt.Println("ctx sensitive state " + outerContext.String(nil, nil) + " in " + D.String()) } fullCtx := true s0Closure := p.computeStartState(dfa.atnStartState, outerContext, fullCtx) p.ReportAttemptingFullContext(dfa, conflictingAlts, D.configs, startIndex, input.Index()) alt := p.execATNWithFullContext(dfa, D, s0Closure, input, startIndex, outerContext) return alt } if D.isAcceptState { if D.predicates == nil { return D.prediction } stopIndex := input.Index() input.Seek(startIndex) alts := p.evalSemanticContext(D.predicates, outerContext, true) if alts.length() == 0 { panic(p.noViableAlt(input, outerContext, D.configs, startIndex)) } else if alts.length() == 1 { return alts.minValue() } else { // Report ambiguity after predicate evaluation to make sure the correct set of ambig alts is Reported. p.ReportAmbiguity(dfa, D, startIndex, stopIndex, false, alts, D.configs) return alts.minValue() } } previousD = D if t != TokenEOF { input.Consume() t = input.LA(1) } } panic("Should not have reached p state") } // Get an existing target state for an edge in the DFA. If the target state // for the edge has not yet been computed or is otherwise not available, // p method returns {@code nil}. // // @param previousD The current DFA state // @param t The next input symbol // @return The existing target DFA state for the given input symbol // {@code t}, or {@code nil} if the target state for p edge is not // already cached func (p *ParserATNSimulator) getExistingTargetState(previousD *DFAState, t int) *DFAState { edges := previousD.edges if edges == nil { return nil } return edges[t+1] } // Compute a target state for an edge in the DFA, and attempt to add the // computed state and corresponding edge to the DFA. // // @param dfa The DFA // @param previousD The current DFA state // @param t The next input symbol // // @return The computed target DFA state for the given input symbol // {@code t}. If {@code t} does not lead to a valid DFA state, p method // returns {@link //ERROR}. func (p *ParserATNSimulator) computeTargetState(dfa *DFA, previousD *DFAState, t int) *DFAState { reach := p.computeReachSet(previousD.configs, t, false) if reach == nil { p.addDFAEdge(dfa, previousD, t, ATNSimulatorError) return ATNSimulatorError } // create Newtarget state we'll add to DFA after it's complete D := NewDFAState(-1, reach) predictedAlt := p.getUniqueAlt(reach) if ParserATNSimulatorDebug { altSubSets := PredictionModegetConflictingAltSubsets(reach) fmt.Println("SLL altSubSets=" + fmt.Sprint(altSubSets) + ", previous=" + previousD.configs.String() + ", configs=" + reach.String() + ", predict=" + strconv.Itoa(predictedAlt) + ", allSubsetsConflict=" + fmt.Sprint(PredictionModeallSubsetsConflict(altSubSets)) + ", conflictingAlts=" + p.getConflictingAlts(reach).String()) } if predictedAlt != ATNInvalidAltNumber { // NO CONFLICT, UNIQUELY PREDICTED ALT D.isAcceptState = true D.configs.SetUniqueAlt(predictedAlt) D.setPrediction(predictedAlt) } else if PredictionModehasSLLConflictTerminatingPrediction(p.predictionMode, reach) { // MORE THAN ONE VIABLE ALTERNATIVE D.configs.SetConflictingAlts(p.getConflictingAlts(reach)) D.requiresFullContext = true // in SLL-only mode, we will stop at p state and return the minimum alt D.isAcceptState = true D.setPrediction(D.configs.GetConflictingAlts().minValue()) } if D.isAcceptState && D.configs.HasSemanticContext() { p.predicateDFAState(D, p.atn.getDecisionState(dfa.decision)) if D.predicates != nil { D.setPrediction(ATNInvalidAltNumber) } } // all adds to dfa are done after we've created full D state D = p.addDFAEdge(dfa, previousD, t, D) return D } func (p *ParserATNSimulator) predicateDFAState(dfaState *DFAState, decisionState DecisionState) { // We need to test all predicates, even in DFA states that // uniquely predict alternative. nalts := len(decisionState.GetTransitions()) // Update DFA so reach becomes accept state with (predicate,alt) // pairs if preds found for conflicting alts altsToCollectPredsFrom := p.getConflictingAltsOrUniqueAlt(dfaState.configs) altToPred := p.getPredsForAmbigAlts(altsToCollectPredsFrom, dfaState.configs, nalts) if altToPred != nil { dfaState.predicates = p.getPredicatePredictions(altsToCollectPredsFrom, altToPred) dfaState.setPrediction(ATNInvalidAltNumber) // make sure we use preds } else { // There are preds in configs but they might go away // when OR'd together like {p}? || NONE == NONE. If neither // alt has preds, resolve to min alt dfaState.setPrediction(altsToCollectPredsFrom.minValue()) } } // comes back with reach.uniqueAlt set to a valid alt func (p *ParserATNSimulator) execATNWithFullContext(dfa *DFA, D *DFAState, s0 ATNConfigSet, input TokenStream, startIndex int, outerContext ParserRuleContext) int { if ParserATNSimulatorDebug || ParserATNSimulatorListATNDecisions { fmt.Println("execATNWithFullContext " + s0.String()) } fullCtx := true foundExactAmbig := false var reach ATNConfigSet previous := s0 input.Seek(startIndex) t := input.LA(1) predictedAlt := -1 for { // for more work reach = p.computeReachSet(previous, t, fullCtx) if reach == nil { // if any configs in previous dipped into outer context, that // means that input up to t actually finished entry rule // at least for LL decision. Full LL doesn't dip into outer // so don't need special case. // We will get an error no matter what so delay until after // decision better error message. Also, no reachable target // ATN states in SLL implies LL will also get nowhere. // If conflict in states that dip out, choose min since we // will get error no matter what. e := p.noViableAlt(input, outerContext, previous, startIndex) input.Seek(startIndex) alt := p.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(previous, outerContext) if alt != ATNInvalidAltNumber { return alt } panic(e) } altSubSets := PredictionModegetConflictingAltSubsets(reach) if ParserATNSimulatorDebug { fmt.Println("LL altSubSets=" + fmt.Sprint(altSubSets) + ", predict=" + strconv.Itoa(PredictionModegetUniqueAlt(altSubSets)) + ", resolvesToJustOneViableAlt=" + fmt.Sprint(PredictionModeresolvesToJustOneViableAlt(altSubSets))) } reach.SetUniqueAlt(p.getUniqueAlt(reach)) // unique prediction? if reach.GetUniqueAlt() != ATNInvalidAltNumber { predictedAlt = reach.GetUniqueAlt() break } else if p.predictionMode != PredictionModeLLExactAmbigDetection { predictedAlt = PredictionModeresolvesToJustOneViableAlt(altSubSets) if predictedAlt != ATNInvalidAltNumber { break } } else { // In exact ambiguity mode, we never try to terminate early. // Just keeps scarfing until we know what the conflict is if PredictionModeallSubsetsConflict(altSubSets) && PredictionModeallSubsetsEqual(altSubSets) { foundExactAmbig = true predictedAlt = PredictionModegetSingleViableAlt(altSubSets) break } // else there are multiple non-conflicting subsets or // we're not sure what the ambiguity is yet. // So, keep going. } previous = reach if t != TokenEOF { input.Consume() t = input.LA(1) } } // If the configuration set uniquely predicts an alternative, // without conflict, then we know that it's a full LL decision // not SLL. if reach.GetUniqueAlt() != ATNInvalidAltNumber { p.ReportContextSensitivity(dfa, predictedAlt, reach, startIndex, input.Index()) return predictedAlt } // We do not check predicates here because we have checked them // on-the-fly when doing full context prediction. // // In non-exact ambiguity detection mode, we might actually be able to // detect an exact ambiguity, but I'm not going to spend the cycles // needed to check. We only emit ambiguity warnings in exact ambiguity // mode. // // For example, we might know that we have conflicting configurations. // But, that does not mean that there is no way forward without a // conflict. It's possible to have nonconflicting alt subsets as in: // altSubSets=[{1, 2}, {1, 2}, {1}, {1, 2}] // from // // [(17,1,[5 $]), (13,1,[5 10 $]), (21,1,[5 10 $]), (11,1,[$]), // (13,2,[5 10 $]), (21,2,[5 10 $]), (11,2,[$])] // // In p case, (17,1,[5 $]) indicates there is some next sequence that // would resolve p without conflict to alternative 1. Any other viable // next sequence, however, is associated with a conflict. We stop // looking for input because no amount of further lookahead will alter // the fact that we should predict alternative 1. We just can't say for // sure that there is an ambiguity without looking further. p.ReportAmbiguity(dfa, D, startIndex, input.Index(), foundExactAmbig, nil, reach) return predictedAlt } func (p *ParserATNSimulator) computeReachSet(closure ATNConfigSet, t int, fullCtx bool) ATNConfigSet { if ParserATNSimulatorDebug { fmt.Println("in computeReachSet, starting closure: " + closure.String()) } if p.mergeCache == nil { p.mergeCache = NewDoubleDict() } intermediate := NewBaseATNConfigSet(fullCtx) // Configurations already in a rule stop state indicate reaching the end // of the decision rule (local context) or end of the start rule (full // context). Once reached, these configurations are never updated by a // closure operation, so they are handled separately for the performance // advantage of having a smaller intermediate set when calling closure. // // For full-context reach operations, separate handling is required to // ensure that the alternative Matching the longest overall sequence is // chosen when multiple such configurations can Match the input. var SkippedStopStates []*BaseATNConfig // First figure out where we can reach on input t for _, c := range closure.GetItems() { if ParserATNSimulatorDebug { fmt.Println("testing " + p.GetTokenName(t) + " at " + c.String()) } _, ok := c.GetState().(*RuleStopState) if ok { if fullCtx || t == TokenEOF { if SkippedStopStates == nil { SkippedStopStates = make([]*BaseATNConfig, 0) } SkippedStopStates = append(SkippedStopStates, c.(*BaseATNConfig)) if ParserATNSimulatorDebug { fmt.Println("added " + c.String() + " to SkippedStopStates") } } continue } for j := 0; j < len(c.GetState().GetTransitions()); j++ { trans := c.GetState().GetTransitions()[j] target := p.getReachableTarget(trans, t) if target != nil { cfg := NewBaseATNConfig4(c, target) intermediate.Add(cfg, p.mergeCache) if ParserATNSimulatorDebug { fmt.Println("added " + cfg.String() + " to intermediate") } } } } // Now figure out where the reach operation can take us... var reach ATNConfigSet // This block optimizes the reach operation for intermediate sets which // trivially indicate a termination state for the overall // AdaptivePredict operation. // // The conditions assume that intermediate // contains all configurations relevant to the reach set, but p // condition is not true when one or more configurations have been // withheld in SkippedStopStates, or when the current symbol is EOF. // if SkippedStopStates == nil && t != TokenEOF { if len(intermediate.configs) == 1 { // Don't pursue the closure if there is just one state. // It can only have one alternative just add to result // Also don't pursue the closure if there is unique alternative // among the configurations. reach = intermediate } else if p.getUniqueAlt(intermediate) != ATNInvalidAltNumber { // Also don't pursue the closure if there is unique alternative // among the configurations. reach = intermediate } } // If the reach set could not be trivially determined, perform a closure // operation on the intermediate set to compute its initial value. // if reach == nil { reach = NewBaseATNConfigSet(fullCtx) closureBusy := NewSet(nil, nil) treatEOFAsEpsilon := t == TokenEOF for k := 0; k < len(intermediate.configs); k++ { p.closure(intermediate.configs[k], reach, closureBusy, false, fullCtx, treatEOFAsEpsilon) } } if t == TokenEOF { // After consuming EOF no additional input is possible, so we are // only interested in configurations which reached the end of the // decision rule (local context) or end of the start rule (full // context). Update reach to contain only these configurations. This // handles both explicit EOF transitions in the grammar and implicit // EOF transitions following the end of the decision or start rule. // // When reach==intermediate, no closure operation was performed. In // p case, removeAllConfigsNotInRuleStopState needs to check for // reachable rule stop states as well as configurations already in // a rule stop state. // // This is handled before the configurations in SkippedStopStates, // because any configurations potentially added from that list are // already guaranteed to meet p condition whether or not it's // required. // reach = p.removeAllConfigsNotInRuleStopState(reach, reach == intermediate) } // If SkippedStopStates!=nil, then it contains at least one // configuration. For full-context reach operations, these // configurations reached the end of the start rule, in which case we // only add them back to reach if no configuration during the current // closure operation reached such a state. This ensures AdaptivePredict // chooses an alternative Matching the longest overall sequence when // multiple alternatives are viable. // if SkippedStopStates != nil && ((!fullCtx) || (!PredictionModehasConfigInRuleStopState(reach))) { for l := 0; l < len(SkippedStopStates); l++ { reach.Add(SkippedStopStates[l], p.mergeCache) } } if len(reach.GetItems()) == 0 { return nil } return reach } // // Return a configuration set containing only the configurations from // {@code configs} which are in a {@link RuleStopState}. If all // configurations in {@code configs} are already in a rule stop state, p // method simply returns {@code configs}. // //
When {@code lookToEndOfRule} is true, p method uses // {@link ATN//NextTokens} for each configuration in {@code configs} which is // not already in a rule stop state to see if a rule stop state is reachable // from the configuration via epsilon-only transitions.
// // @param configs the configuration set to update // @param lookToEndOfRule when true, p method checks for rule stop states // reachable by epsilon-only transitions from each configuration in // {@code configs}. // // @return {@code configs} if all configurations in {@code configs} are in a // rule stop state, otherwise return a Newconfiguration set containing only // the configurations from {@code configs} which are in a rule stop state // func (p *ParserATNSimulator) removeAllConfigsNotInRuleStopState(configs ATNConfigSet, lookToEndOfRule bool) ATNConfigSet { if PredictionModeallConfigsInRuleStopStates(configs) { return configs } result := NewBaseATNConfigSet(configs.FullContext()) for _, config := range configs.GetItems() { _, ok := config.GetState().(*RuleStopState) if ok { result.Add(config, p.mergeCache) continue } if lookToEndOfRule && config.GetState().GetEpsilonOnlyTransitions() { NextTokens := p.atn.NextTokens(config.GetState(), nil) if NextTokens.contains(TokenEpsilon) { endOfRuleState := p.atn.ruleToStopState[config.GetState().GetRuleIndex()] result.Add(NewBaseATNConfig4(config, endOfRuleState), p.mergeCache) } } } return result } func (p *ParserATNSimulator) computeStartState(a ATNState, ctx RuleContext, fullCtx bool) ATNConfigSet { // always at least the implicit call to start rule initialContext := predictionContextFromRuleContext(p.atn, ctx) configs := NewBaseATNConfigSet(fullCtx) for i := 0; i < len(a.GetTransitions()); i++ { target := a.GetTransitions()[i].getTarget() c := NewBaseATNConfig6(target, i+1, initialContext) closureBusy := NewSet(nil, nil) p.closure(c, configs, closureBusy, true, fullCtx, false) } return configs } // // This method transforms the start state computed by // {@link //computeStartState} to the special start state used by a // precedence DFA for a particular precedence value. The transformation // process applies the following changes to the start state's configuration // set. // //// The prediction context must be considered by p filter to address // situations like the following. //
//
//
// grammar TA
// prog: statement* EOF
// statement: letterA | statement letterA 'b'
// letterA: 'a'
//
//
// // If the above grammar, the ATN state immediately before the token // reference {@code 'a'} in {@code letterA} is reachable from the left edge // of both the primary and closure blocks of the left-recursive rule // {@code statement}. The prediction context associated with each of these // configurations distinguishes between them, and prevents the alternative // which stepped out to {@code prog} (and then back in to {@code statement} // from being eliminated by the filter. //
// // @param configs The configuration set computed by // {@link //computeStartState} as the start state for the DFA. // @return The transformed configuration set representing the start state // for a precedence DFA at a particular precedence level (determined by // calling {@link Parser//getPrecedence}). // func (p *ParserATNSimulator) applyPrecedenceFilter(configs ATNConfigSet) ATNConfigSet { statesFromAlt1 := make(map[int]PredictionContext) configSet := NewBaseATNConfigSet(configs.FullContext()) for _, config := range configs.GetItems() { // handle alt 1 first if config.GetAlt() != 1 { continue } updatedContext := config.GetSemanticContext().evalPrecedence(p.parser, p.outerContext) if updatedContext == nil { // the configuration was eliminated continue } statesFromAlt1[config.GetState().GetStateNumber()] = config.GetContext() if updatedContext != config.GetSemanticContext() { configSet.Add(NewBaseATNConfig2(config, updatedContext), p.mergeCache) } else { configSet.Add(config, p.mergeCache) } } for _, config := range configs.GetItems() { if config.GetAlt() == 1 { // already handled continue } // In the future, p elimination step could be updated to also // filter the prediction context for alternatives predicting alt>1 // (basically a graph subtraction algorithm). if !config.getPrecedenceFilterSuppressed() { context := statesFromAlt1[config.GetState().GetStateNumber()] if context != nil && context.equals(config.GetContext()) { // eliminated continue } } configSet.Add(config, p.mergeCache) } return configSet } func (p *ParserATNSimulator) getReachableTarget(trans Transition, ttype int) ATNState { if trans.Matches(ttype, 0, p.atn.maxTokenType) { return trans.getTarget() } return nil } func (p *ParserATNSimulator) getPredsForAmbigAlts(ambigAlts *BitSet, configs ATNConfigSet, nalts int) []SemanticContext { altToPred := make([]SemanticContext, nalts+1) for _, c := range configs.GetItems() { if ambigAlts.contains(c.GetAlt()) { altToPred[c.GetAlt()] = SemanticContextorContext(altToPred[c.GetAlt()], c.GetSemanticContext()) } } nPredAlts := 0 for i := 1; i < nalts+1; i++ { pred := altToPred[i] if pred == nil { altToPred[i] = SemanticContextNone } else if pred != SemanticContextNone { nPredAlts++ } } // nonambig alts are nil in altToPred if nPredAlts == 0 { altToPred = nil } if ParserATNSimulatorDebug { fmt.Println("getPredsForAmbigAlts result " + fmt.Sprint(altToPred)) } return altToPred } func (p *ParserATNSimulator) getPredicatePredictions(ambigAlts *BitSet, altToPred []SemanticContext) []*PredPrediction { pairs := make([]*PredPrediction, 0) containsPredicate := false for i := 1; i < len(altToPred); i++ { pred := altToPred[i] // unpredicated is indicated by SemanticContextNONE if ambigAlts != nil && ambigAlts.contains(i) { pairs = append(pairs, NewPredPrediction(pred, i)) } if pred != SemanticContextNone { containsPredicate = true } } if !containsPredicate { return nil } return pairs } // // This method is used to improve the localization of error messages by // choosing an alternative rather than panicing a // {@link NoViableAltException} in particular prediction scenarios where the // {@link //ERROR} state was reached during ATN simulation. // //// The default implementation of p method uses the following // algorithm to identify an ATN configuration which successfully parsed the // decision entry rule. Choosing such an alternative ensures that the // {@link ParserRuleContext} returned by the calling rule will be complete // and valid, and the syntax error will be Reported later at a more // localized location.
// //// In some scenarios, the algorithm described above could predict an // alternative which will result in a {@link FailedPredicateException} in // the parser. Specifically, p could occur if the only configuration // capable of successfully parsing to the end of the decision rule is // blocked by a semantic predicate. By choosing p alternative within // {@link //AdaptivePredict} instead of panicing a // {@link NoViableAltException}, the resulting // {@link FailedPredicateException} in the parser will identify the specific // predicate which is preventing the parser from successfully parsing the // decision rule, which helps developers identify and correct logic errors // in semantic predicates. //
// // @param configs The ATN configurations which were valid immediately before // the {@link //ERROR} state was reached // @param outerContext The is the \gamma_0 initial parser context from the paper // or the parser stack at the instant before prediction commences. // // @return The value to return from {@link //AdaptivePredict}, or // {@link ATN//INVALID_ALT_NUMBER} if a suitable alternative was not // identified and {@link //AdaptivePredict} should Report an error instead. // func (p *ParserATNSimulator) getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(configs ATNConfigSet, outerContext ParserRuleContext) int { cfgs := p.splitAccordingToSemanticValidity(configs, outerContext) semValidConfigs := cfgs[0] semInvalidConfigs := cfgs[1] alt := p.GetAltThatFinishedDecisionEntryRule(semValidConfigs) if alt != ATNInvalidAltNumber { // semantically/syntactically viable path exists return alt } // Is there a syntactically valid path with a failed pred? if len(semInvalidConfigs.GetItems()) > 0 { alt = p.GetAltThatFinishedDecisionEntryRule(semInvalidConfigs) if alt != ATNInvalidAltNumber { // syntactically viable path exists return alt } } return ATNInvalidAltNumber } func (p *ParserATNSimulator) GetAltThatFinishedDecisionEntryRule(configs ATNConfigSet) int { alts := NewIntervalSet() for _, c := range configs.GetItems() { _, ok := c.GetState().(*RuleStopState) if c.GetReachesIntoOuterContext() > 0 || (ok && c.GetContext().hasEmptyPath()) { alts.addOne(c.GetAlt()) } } if alts.length() == 0 { return ATNInvalidAltNumber } return alts.first() } // Walk the list of configurations and split them according to // those that have preds evaluating to true/false. If no pred, assume // true pred and include in succeeded set. Returns Pair of sets. // // Create a NewSet so as not to alter the incoming parameter. // // Assumption: the input stream has been restored to the starting point // prediction, which is where predicates need to evaluate. type ATNConfigSetPair struct { item0, item1 ATNConfigSet } func (p *ParserATNSimulator) splitAccordingToSemanticValidity(configs ATNConfigSet, outerContext ParserRuleContext) []ATNConfigSet { succeeded := NewBaseATNConfigSet(configs.FullContext()) failed := NewBaseATNConfigSet(configs.FullContext()) for _, c := range configs.GetItems() { if c.GetSemanticContext() != SemanticContextNone { predicateEvaluationResult := c.GetSemanticContext().evaluate(p.parser, outerContext) if predicateEvaluationResult { succeeded.Add(c, nil) } else { failed.Add(c, nil) } } else { succeeded.Add(c, nil) } } return []ATNConfigSet{succeeded, failed} } // Look through a list of predicate/alt pairs, returning alts for the // pairs that win. A {@code NONE} predicate indicates an alt containing an // unpredicated config which behaves as "always true." If !complete // then we stop at the first predicate that evaluates to true. This // includes pairs with nil predicates. // func (p *ParserATNSimulator) evalSemanticContext(predPredictions []*PredPrediction, outerContext ParserRuleContext, complete bool) *BitSet { predictions := NewBitSet() for i := 0; i < len(predPredictions); i++ { pair := predPredictions[i] if pair.pred == SemanticContextNone { predictions.add(pair.alt) if !complete { break } continue } predicateEvaluationResult := pair.pred.evaluate(p.parser, outerContext) if ParserATNSimulatorDebug || ParserATNSimulatorDFADebug { fmt.Println("eval pred " + pair.String() + "=" + fmt.Sprint(predicateEvaluationResult)) } if predicateEvaluationResult { if ParserATNSimulatorDebug || ParserATNSimulatorDFADebug { fmt.Println("PREDICT " + fmt.Sprint(pair.alt)) } predictions.add(pair.alt) if !complete { break } } } return predictions } func (p *ParserATNSimulator) closure(config ATNConfig, configs ATNConfigSet, closureBusy *Set, collectPredicates, fullCtx, treatEOFAsEpsilon bool) { initialDepth := 0 p.closureCheckingStopState(config, configs, closureBusy, collectPredicates, fullCtx, initialDepth, treatEOFAsEpsilon) } func (p *ParserATNSimulator) closureCheckingStopState(config ATNConfig, configs ATNConfigSet, closureBusy *Set, collectPredicates, fullCtx bool, depth int, treatEOFAsEpsilon bool) { if ParserATNSimulatorDebug { fmt.Println("closure(" + config.String() + ")") fmt.Println("configs(" + configs.String() + ")") if config.GetReachesIntoOuterContext() > 50 { panic("problem") } } _, ok := config.GetState().(*RuleStopState) if ok { // We hit rule end. If we have context info, use it // run thru all possible stack tops in ctx if !config.GetContext().isEmpty() { for i := 0; i < config.GetContext().length(); i++ { if config.GetContext().getReturnState(i) == BasePredictionContextEmptyReturnState { if fullCtx { configs.Add(NewBaseATNConfig1(config, config.GetState(), BasePredictionContextEMPTY), p.mergeCache) continue } else { // we have no context info, just chase follow links (if greedy) if ParserATNSimulatorDebug { fmt.Println("FALLING off rule " + p.getRuleName(config.GetState().GetRuleIndex())) } p.closureWork(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) } continue } returnState := p.atn.states[config.GetContext().getReturnState(i)] newContext := config.GetContext().GetParent(i) // "pop" return state c := NewBaseATNConfig5(returnState, config.GetAlt(), newContext, config.GetSemanticContext()) // While we have context to pop back from, we may have // gotten that context AFTER having falling off a rule. // Make sure we track that we are now out of context. c.SetReachesIntoOuterContext(config.GetReachesIntoOuterContext()) p.closureCheckingStopState(c, configs, closureBusy, collectPredicates, fullCtx, depth-1, treatEOFAsEpsilon) } return } else if fullCtx { // reached end of start rule configs.Add(config, p.mergeCache) return } else { // else if we have no context info, just chase follow links (if greedy) if ParserATNSimulatorDebug { fmt.Println("FALLING off rule " + p.getRuleName(config.GetState().GetRuleIndex())) } } } p.closureWork(config, configs, closureBusy, collectPredicates, fullCtx, depth, treatEOFAsEpsilon) } // Do the actual work of walking epsilon edges// func (p *ParserATNSimulator) closureWork(config ATNConfig, configs ATNConfigSet, closureBusy *Set, collectPredicates, fullCtx bool, depth int, treatEOFAsEpsilon bool) { state := config.GetState() // optimization if !state.GetEpsilonOnlyTransitions() { configs.Add(config, p.mergeCache) // make sure to not return here, because EOF transitions can act as // both epsilon transitions and non-epsilon transitions. } for i := 0; i < len(state.GetTransitions()); i++ { t := state.GetTransitions()[i] _, ok := t.(*ActionTransition) continueCollecting := collectPredicates && !ok c := p.getEpsilonTarget(config, t, continueCollecting, depth == 0, fullCtx, treatEOFAsEpsilon) if ci, ok := c.(*BaseATNConfig); ok && ci != nil { if !t.getIsEpsilon() && closureBusy.add(c) != c { // avoid infinite recursion for EOF* and EOF+ continue } newDepth := depth if _, ok := config.GetState().(*RuleStopState); ok { // target fell off end of rule mark resulting c as having dipped into outer context // We can't get here if incoming config was rule stop and we had context // track how far we dip into outer context. Might // come in handy and we avoid evaluating context dependent // preds if p is > 0. if closureBusy.add(c) != c { // avoid infinite recursion for right-recursive rules continue } if p.dfa != nil && p.dfa.precedenceDfa { if t.(*EpsilonTransition).outermostPrecedenceReturn == p.dfa.atnStartState.GetRuleIndex() { c.setPrecedenceFilterSuppressed(true) } } c.SetReachesIntoOuterContext(c.GetReachesIntoOuterContext() + 1) configs.SetDipsIntoOuterContext(true) // TODO: can remove? only care when we add to set per middle of p method newDepth-- if ParserATNSimulatorDebug { fmt.Println("dips into outer ctx: " + c.String()) } } else if _, ok := t.(*RuleTransition); ok { // latch when newDepth goes negative - once we step out of the entry context we can't return if newDepth >= 0 { newDepth++ } } p.closureCheckingStopState(c, configs, closureBusy, continueCollecting, fullCtx, newDepth, treatEOFAsEpsilon) } } } func (p *ParserATNSimulator) getRuleName(index int) string { if p.parser != nil && index >= 0 { return p.parser.GetRuleNames()[index] } return "If {@code to} is {@code nil}, p method returns {@code nil}. // Otherwise, p method returns the {@link DFAState} returned by calling // {@link //addDFAState} for the {@code to} state.
// // @param dfa The DFA // @param from The source state for the edge // @param t The input symbol // @param to The target state for the edge // // @return If {@code to} is {@code nil}, p method returns {@code nil} // otherwise p method returns the result of calling {@link //addDFAState} // on {@code to} // func (p *ParserATNSimulator) addDFAEdge(dfa *DFA, from *DFAState, t int, to *DFAState) *DFAState { if ParserATNSimulatorDebug { fmt.Println("EDGE " + from.String() + " -> " + to.String() + " upon " + p.GetTokenName(t)) } if to == nil { return nil } to = p.addDFAState(dfa, to) // used existing if possible not incoming if from == nil || t < -1 || t > p.atn.maxTokenType { return to } if from.edges == nil { from.edges = make([]*DFAState, p.atn.maxTokenType+1+1) } from.edges[t+1] = to // connect if ParserATNSimulatorDebug { var names []string if p.parser != nil { names = p.parser.GetLiteralNames() } fmt.Println("DFA=\n" + dfa.String(names, nil)) } return to } // // Add state {@code D} to the DFA if it is not already present, and return // the actual instance stored in the DFA. If a state equivalent to {@code D} // is already in the DFA, the existing state is returned. Otherwise p // method returns {@code D} after adding it to the DFA. // //If {@code D} is {@link //ERROR}, p method returns {@link //ERROR} and // does not change the DFA.
// // @param dfa The dfa // @param D The DFA state to add // @return The state stored in the DFA. This will be either the existing // state if {@code D} is already in the DFA, or {@code D} itself if the // state was not already present. // func (p *ParserATNSimulator) addDFAState(dfa *DFA, d *DFAState) *DFAState { if d == ATNSimulatorError { return d } hash := d.hash() existing, ok := dfa.getState(hash) if ok { return existing } d.stateNumber = dfa.numStates() if !d.configs.ReadOnly() { d.configs.OptimizeConfigs(p.BaseATNSimulator) d.configs.SetReadOnly(true) } dfa.setState(hash, d) if ParserATNSimulatorDebug { fmt.Println("adding NewDFA state: " + d.String()) } return d } func (p *ParserATNSimulator) ReportAttemptingFullContext(dfa *DFA, conflictingAlts *BitSet, configs ATNConfigSet, startIndex, stopIndex int) { if ParserATNSimulatorDebug || ParserATNSimulatorRetryDebug { interval := NewInterval(startIndex, stopIndex+1) fmt.Println("ReportAttemptingFullContext decision=" + strconv.Itoa(dfa.decision) + ":" + configs.String() + ", input=" + p.parser.GetTokenStream().GetTextFromInterval(interval)) } if p.parser != nil { p.parser.GetErrorListenerDispatch().ReportAttemptingFullContext(p.parser, dfa, startIndex, stopIndex, conflictingAlts, configs) } } func (p *ParserATNSimulator) ReportContextSensitivity(dfa *DFA, prediction int, configs ATNConfigSet, startIndex, stopIndex int) { if ParserATNSimulatorDebug || ParserATNSimulatorRetryDebug { interval := NewInterval(startIndex, stopIndex+1) fmt.Println("ReportContextSensitivity decision=" + strconv.Itoa(dfa.decision) + ":" + configs.String() + ", input=" + p.parser.GetTokenStream().GetTextFromInterval(interval)) } if p.parser != nil { p.parser.GetErrorListenerDispatch().ReportContextSensitivity(p.parser, dfa, startIndex, stopIndex, prediction, configs) } } // If context sensitive parsing, we know it's ambiguity not conflict// func (p *ParserATNSimulator) ReportAmbiguity(dfa *DFA, D *DFAState, startIndex, stopIndex int, exact bool, ambigAlts *BitSet, configs ATNConfigSet) { if ParserATNSimulatorDebug || ParserATNSimulatorRetryDebug { interval := NewInterval(startIndex, stopIndex+1) fmt.Println("ReportAmbiguity " + ambigAlts.String() + ":" + configs.String() + ", input=" + p.parser.GetTokenStream().GetTextFromInterval(interval)) } if p.parser != nil { p.parser.GetErrorListenerDispatch().ReportAmbiguity(p.parser, dfa, startIndex, stopIndex, exact, ambigAlts, configs) } } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/parser_rule_context.go 0000664 0000000 0000000 00000020133 14102210121 0026742 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "reflect" "strconv" ) type ParserRuleContext interface { RuleContext SetException(RecognitionException) AddTokenNode(token Token) *TerminalNodeImpl AddErrorNode(badToken Token) *ErrorNodeImpl EnterRule(listener ParseTreeListener) ExitRule(listener ParseTreeListener) SetStart(Token) GetStart() Token SetStop(Token) GetStop() Token AddChild(child RuleContext) RuleContext RemoveLastChild() } type BaseParserRuleContext struct { *BaseRuleContext start, stop Token exception RecognitionException children []Tree } func NewBaseParserRuleContext(parent ParserRuleContext, invokingStateNumber int) *BaseParserRuleContext { prc := new(BaseParserRuleContext) prc.BaseRuleContext = NewBaseRuleContext(parent, invokingStateNumber) prc.RuleIndex = -1 // * If we are debugging or building a parse tree for a Visitor, // we need to track all of the tokens and rule invocations associated // with prc rule's context. This is empty for parsing w/o tree constr. // operation because we don't the need to track the details about // how we parse prc rule. // / prc.children = nil prc.start = nil prc.stop = nil // The exception that forced prc rule to return. If the rule successfully // completed, prc is {@code nil}. prc.exception = nil return prc } func (prc *BaseParserRuleContext) SetException(e RecognitionException) { prc.exception = e } func (prc *BaseParserRuleContext) GetChildren() []Tree { return prc.children } func (prc *BaseParserRuleContext) CopyFrom(ctx *BaseParserRuleContext) { // from RuleContext prc.parentCtx = ctx.parentCtx prc.invokingState = ctx.invokingState prc.children = nil prc.start = ctx.start prc.stop = ctx.stop } func (prc *BaseParserRuleContext) GetText() string { if prc.GetChildCount() == 0 { return "" } var s string for _, child := range prc.children { s += child.(ParseTree).GetText() } return s } // Double dispatch methods for listeners func (prc *BaseParserRuleContext) EnterRule(listener ParseTreeListener) { } func (prc *BaseParserRuleContext) ExitRule(listener ParseTreeListener) { } // * Does not set parent link other add methods do that/// func (prc *BaseParserRuleContext) addTerminalNodeChild(child TerminalNode) TerminalNode { if prc.children == nil { prc.children = make([]Tree, 0) } if child == nil { panic("Child may not be null") } prc.children = append(prc.children, child) return child } func (prc *BaseParserRuleContext) AddChild(child RuleContext) RuleContext { if prc.children == nil { prc.children = make([]Tree, 0) } if child == nil { panic("Child may not be null") } prc.children = append(prc.children, child) return child } // * Used by EnterOuterAlt to toss out a RuleContext previously added as // we entered a rule. If we have // label, we will need to remove // generic ruleContext object. // / func (prc *BaseParserRuleContext) RemoveLastChild() { if prc.children != nil && len(prc.children) > 0 { prc.children = prc.children[0 : len(prc.children)-1] } } func (prc *BaseParserRuleContext) AddTokenNode(token Token) *TerminalNodeImpl { node := NewTerminalNodeImpl(token) prc.addTerminalNodeChild(node) node.parentCtx = prc return node } func (prc *BaseParserRuleContext) AddErrorNode(badToken Token) *ErrorNodeImpl { node := NewErrorNodeImpl(badToken) prc.addTerminalNodeChild(node) node.parentCtx = prc return node } func (prc *BaseParserRuleContext) GetChild(i int) Tree { if prc.children != nil && len(prc.children) >= i { return prc.children[i] } return nil } func (prc *BaseParserRuleContext) GetChildOfType(i int, childType reflect.Type) RuleContext { if childType == nil { return prc.GetChild(i).(RuleContext) } for j := 0; j < len(prc.children); j++ { child := prc.children[j] if reflect.TypeOf(child) == childType { if i == 0 { return child.(RuleContext) } i-- } } return nil } func (prc *BaseParserRuleContext) ToStringTree(ruleNames []string, recog Recognizer) string { return TreesStringTree(prc, ruleNames, recog) } func (prc *BaseParserRuleContext) GetRuleContext() RuleContext { return prc } func (prc *BaseParserRuleContext) Accept(visitor ParseTreeVisitor) interface{} { return visitor.VisitChildren(prc) } func (prc *BaseParserRuleContext) SetStart(t Token) { prc.start = t } func (prc *BaseParserRuleContext) GetStart() Token { return prc.start } func (prc *BaseParserRuleContext) SetStop(t Token) { prc.stop = t } func (prc *BaseParserRuleContext) GetStop() Token { return prc.stop } func (prc *BaseParserRuleContext) GetToken(ttype int, i int) TerminalNode { for j := 0; j < len(prc.children); j++ { child := prc.children[j] if c2, ok := child.(TerminalNode); ok { if c2.GetSymbol().GetTokenType() == ttype { if i == 0 { return c2 } i-- } } } return nil } func (prc *BaseParserRuleContext) GetTokens(ttype int) []TerminalNode { if prc.children == nil { return make([]TerminalNode, 0) } tokens := make([]TerminalNode, 0) for j := 0; j < len(prc.children); j++ { child := prc.children[j] if tchild, ok := child.(TerminalNode); ok { if tchild.GetSymbol().GetTokenType() == ttype { tokens = append(tokens, tchild) } } } return tokens } func (prc *BaseParserRuleContext) GetPayload() interface{} { return prc } func (prc *BaseParserRuleContext) getChild(ctxType reflect.Type, i int) RuleContext { if prc.children == nil || i < 0 || i >= len(prc.children) { return nil } j := -1 // what element have we found with ctxType? for _, o := range prc.children { childType := reflect.TypeOf(o) if childType.Implements(ctxType) { j++ if j == i { return o.(RuleContext) } } } return nil } // Go lacks generics, so it's not possible for us to return the child with the correct type, but we do // check for convertibility func (prc *BaseParserRuleContext) GetTypedRuleContext(ctxType reflect.Type, i int) RuleContext { return prc.getChild(ctxType, i) } func (prc *BaseParserRuleContext) GetTypedRuleContexts(ctxType reflect.Type) []RuleContext { if prc.children == nil { return make([]RuleContext, 0) } contexts := make([]RuleContext, 0) for _, child := range prc.children { childType := reflect.TypeOf(child) if childType.ConvertibleTo(ctxType) { contexts = append(contexts, child.(RuleContext)) } } return contexts } func (prc *BaseParserRuleContext) GetChildCount() int { if prc.children == nil { return 0 } return len(prc.children) } func (prc *BaseParserRuleContext) GetSourceInterval() *Interval { if prc.start == nil || prc.stop == nil { return TreeInvalidInterval } return NewInterval(prc.start.GetTokenIndex(), prc.stop.GetTokenIndex()) } //need to manage circular dependencies, so export now // Print out a whole tree, not just a node, in LISP format // (root child1 .. childN). Print just a node if b is a leaf. // func (prc *BaseParserRuleContext) String(ruleNames []string, stop RuleContext) string { var p ParserRuleContext = prc s := "[" for p != nil && p != stop { if ruleNames == nil { if !p.IsEmpty() { s += strconv.Itoa(p.GetInvokingState()) } } else { ri := p.GetRuleIndex() var ruleName string if ri >= 0 && ri < len(ruleNames) { ruleName = ruleNames[ri] } else { ruleName = strconv.Itoa(ri) } s += ruleName } if p.GetParent() != nil && (ruleNames != nil || !p.GetParent().(ParserRuleContext).IsEmpty()) { s += " " } pi := p.GetParent() if pi != nil { p = pi.(ParserRuleContext) } else { p = nil } } s += "]" return s } var RuleContextEmpty = NewBaseParserRuleContext(nil, -1) type InterpreterRuleContext interface { ParserRuleContext } type BaseInterpreterRuleContext struct { *BaseParserRuleContext } func NewBaseInterpreterRuleContext(parent BaseInterpreterRuleContext, invokingStateNumber, ruleIndex int) *BaseInterpreterRuleContext { prc := new(BaseInterpreterRuleContext) prc.BaseParserRuleContext = NewBaseParserRuleContext(parent, invokingStateNumber) prc.RuleIndex = ruleIndex return prc } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/prediction_context.go 0000664 0000000 0000000 00000053264 14102210121 0026572 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "strconv" ) // Represents {@code $} in local context prediction, which means wildcard. // {@code//+x =//}. // / const ( BasePredictionContextEmptyReturnState = 0x7FFFFFFF ) // Represents {@code $} in an array in full context mode, when {@code $} // doesn't mean wildcard: {@code $ + x = [$,x]}. Here, // {@code $} = {@link //EmptyReturnState}. // / var ( BasePredictionContextglobalNodeCount = 1 BasePredictionContextid = BasePredictionContextglobalNodeCount ) type PredictionContext interface { hash() int GetParent(int) PredictionContext getReturnState(int) int equals(PredictionContext) bool length() int isEmpty() bool hasEmptyPath() bool String() string } type BasePredictionContext struct { cachedHash int } func NewBasePredictionContext(cachedHash int) *BasePredictionContext { pc := new(BasePredictionContext) pc.cachedHash = cachedHash return pc } func (b *BasePredictionContext) isEmpty() bool { return false } func calculateHash(parent PredictionContext, returnState int) int { h := murmurInit(1) h = murmurUpdate(h, parent.hash()) h = murmurUpdate(h, returnState) return murmurFinish(h, 2) } func calculateEmptyHash() int { h := murmurInit(1) return murmurFinish(h, 0) } // Used to cache {@link BasePredictionContext} objects. Its used for the shared // context cash associated with contexts in DFA states. This cache // can be used for both lexers and parsers. type PredictionContextCache struct { cache map[PredictionContext]PredictionContext } func NewPredictionContextCache() *PredictionContextCache { t := new(PredictionContextCache) t.cache = make(map[PredictionContext]PredictionContext) return t } // Add a context to the cache and return it. If the context already exists, // return that one instead and do not add a Newcontext to the cache. // Protect shared cache from unsafe thread access. // func (p *PredictionContextCache) add(ctx PredictionContext) PredictionContext { if ctx == BasePredictionContextEMPTY { return BasePredictionContextEMPTY } existing := p.cache[ctx] if existing != nil { return existing } p.cache[ctx] = ctx return ctx } func (p *PredictionContextCache) Get(ctx PredictionContext) PredictionContext { return p.cache[ctx] } func (p *PredictionContextCache) length() int { return len(p.cache) } type SingletonPredictionContext interface { PredictionContext } type BaseSingletonPredictionContext struct { *BasePredictionContext parentCtx PredictionContext returnState int } func NewBaseSingletonPredictionContext(parent PredictionContext, returnState int) *BaseSingletonPredictionContext { s := new(BaseSingletonPredictionContext) s.BasePredictionContext = NewBasePredictionContext(37) if parent != nil { s.cachedHash = calculateHash(parent, returnState) } else { s.cachedHash = calculateEmptyHash() } s.parentCtx = parent s.returnState = returnState return s } func SingletonBasePredictionContextCreate(parent PredictionContext, returnState int) PredictionContext { if returnState == BasePredictionContextEmptyReturnState && parent == nil { // someone can pass in the bits of an array ctx that mean $ return BasePredictionContextEMPTY } return NewBaseSingletonPredictionContext(parent, returnState) } func (b *BaseSingletonPredictionContext) length() int { return 1 } func (b *BaseSingletonPredictionContext) GetParent(index int) PredictionContext { return b.parentCtx } func (b *BaseSingletonPredictionContext) getReturnState(index int) int { return b.returnState } func (b *BaseSingletonPredictionContext) hasEmptyPath() bool { return b.returnState == BasePredictionContextEmptyReturnState } func (b *BaseSingletonPredictionContext) equals(other PredictionContext) bool { if b == other { return true } else if _, ok := other.(*BaseSingletonPredictionContext); !ok { return false } else if b.hash() != other.hash() { return false // can't be same if hash is different } otherP := other.(*BaseSingletonPredictionContext) if b.returnState != other.getReturnState(0) { return false } else if b.parentCtx == nil { return otherP.parentCtx == nil } return b.parentCtx.equals(otherP.parentCtx) } func (b *BaseSingletonPredictionContext) hash() int { h := murmurInit(1) if b.parentCtx == nil { return murmurFinish(h, 0) } h = murmurUpdate(h, b.parentCtx.hash()) h = murmurUpdate(h, b.returnState) return murmurFinish(h, 2) } func (b *BaseSingletonPredictionContext) String() string { var up string if b.parentCtx == nil { up = "" } else { up = b.parentCtx.String() } if len(up) == 0 { if b.returnState == BasePredictionContextEmptyReturnState { return "$" } return strconv.Itoa(b.returnState) } return strconv.Itoa(b.returnState) + " " + up } var BasePredictionContextEMPTY = NewEmptyPredictionContext() type EmptyPredictionContext struct { *BaseSingletonPredictionContext } func NewEmptyPredictionContext() *EmptyPredictionContext { p := new(EmptyPredictionContext) p.BaseSingletonPredictionContext = NewBaseSingletonPredictionContext(nil, BasePredictionContextEmptyReturnState) return p } func (e *EmptyPredictionContext) isEmpty() bool { return true } func (e *EmptyPredictionContext) GetParent(index int) PredictionContext { return nil } func (e *EmptyPredictionContext) getReturnState(index int) int { return e.returnState } func (e *EmptyPredictionContext) equals(other PredictionContext) bool { return e == other } func (e *EmptyPredictionContext) String() string { return "$" } type ArrayPredictionContext struct { *BasePredictionContext parents []PredictionContext returnStates []int } func NewArrayPredictionContext(parents []PredictionContext, returnStates []int) *ArrayPredictionContext { // Parent can be nil only if full ctx mode and we make an array // from {@link //EMPTY} and non-empty. We merge {@link //EMPTY} by using // nil parent and // returnState == {@link //EmptyReturnState}. c := new(ArrayPredictionContext) c.BasePredictionContext = NewBasePredictionContext(37) for i := range parents { c.cachedHash += calculateHash(parents[i], returnStates[i]) } c.parents = parents c.returnStates = returnStates return c } func (a *ArrayPredictionContext) GetReturnStates() []int { return a.returnStates } func (a *ArrayPredictionContext) hasEmptyPath() bool { return a.getReturnState(a.length()-1) == BasePredictionContextEmptyReturnState } func (a *ArrayPredictionContext) isEmpty() bool { // since EmptyReturnState can only appear in the last position, we // don't need to verify that size==1 return a.returnStates[0] == BasePredictionContextEmptyReturnState } func (a *ArrayPredictionContext) length() int { return len(a.returnStates) } func (a *ArrayPredictionContext) GetParent(index int) PredictionContext { return a.parents[index] } func (a *ArrayPredictionContext) getReturnState(index int) int { return a.returnStates[index] } func (a *ArrayPredictionContext) equals(other PredictionContext) bool { if _, ok := other.(*ArrayPredictionContext); !ok { return false } else if a.cachedHash != other.hash() { return false // can't be same if hash is different } else { otherP := other.(*ArrayPredictionContext) return &a.returnStates == &otherP.returnStates && &a.parents == &otherP.parents } } func (a *ArrayPredictionContext) hash() int { h := murmurInit(1) for _, p := range a.parents { h = murmurUpdate(h, p.hash()) } for _, r := range a.returnStates { h = murmurUpdate(h, r) } return murmurFinish(h, 2 * len(a.parents)) } func (a *ArrayPredictionContext) String() string { if a.isEmpty() { return "[]" } s := "[" for i := 0; i < len(a.returnStates); i++ { if i > 0 { s = s + ", " } if a.returnStates[i] == BasePredictionContextEmptyReturnState { s = s + "$" continue } s = s + strconv.Itoa(a.returnStates[i]) if a.parents[i] != nil { s = s + " " + a.parents[i].String() } else { s = s + "nil" } } return s + "]" } // Convert a {@link RuleContext} tree to a {@link BasePredictionContext} graph. // Return {@link //EMPTY} if {@code outerContext} is empty or nil. // / func predictionContextFromRuleContext(a *ATN, outerContext RuleContext) PredictionContext { if outerContext == nil { outerContext = RuleContextEmpty } // if we are in RuleContext of start rule, s, then BasePredictionContext // is EMPTY. Nobody called us. (if we are empty, return empty) if outerContext.GetParent() == nil || outerContext == RuleContextEmpty { return BasePredictionContextEMPTY } // If we have a parent, convert it to a BasePredictionContext graph parent := predictionContextFromRuleContext(a, outerContext.GetParent().(RuleContext)) state := a.states[outerContext.GetInvokingState()] transition := state.GetTransitions()[0] return SingletonBasePredictionContextCreate(parent, transition.(*RuleTransition).followState.GetStateNumber()) } func merge(a, b PredictionContext, rootIsWildcard bool, mergeCache *DoubleDict) PredictionContext { // share same graph if both same if a == b { return a } ac, ok1 := a.(*BaseSingletonPredictionContext) bc, ok2 := b.(*BaseSingletonPredictionContext) if ok1 && ok2 { return mergeSingletons(ac, bc, rootIsWildcard, mergeCache) } // At least one of a or b is array // If one is $ and rootIsWildcard, return $ as// wildcard if rootIsWildcard { if _, ok := a.(*EmptyPredictionContext); ok { return a } if _, ok := b.(*EmptyPredictionContext); ok { return b } } // convert singleton so both are arrays to normalize if _, ok := a.(*BaseSingletonPredictionContext); ok { a = NewArrayPredictionContext([]PredictionContext{a.GetParent(0)}, []int{a.getReturnState(0)}) } if _, ok := b.(*BaseSingletonPredictionContext); ok { b = NewArrayPredictionContext([]PredictionContext{b.GetParent(0)}, []int{b.getReturnState(0)}) } return mergeArrays(a.(*ArrayPredictionContext), b.(*ArrayPredictionContext), rootIsWildcard, mergeCache) } // // Merge two {@link SingletonBasePredictionContext} instances. // //Stack tops equal, parents merge is same return left graph.
//
Same stack top, parents differ merge parents giving array node, then
// remainders of those graphs. A Newroot node is created to point to the
// merged parents.
//
Different stack tops pointing to same parent. Make array node for the
// root where both element in the root point to the same (original)
// parent.
//
Different stack tops pointing to different parents. Make array node for
// the root where each element points to the corresponding original
// parent.
//
These local-context merge operations are used when {@code rootIsWildcard} // is true.
// //{@link //EMPTY} is superset of any graph return {@link //EMPTY}.
//
{@link //EMPTY} and anything is {@code //EMPTY}, so merged parent is
// {@code //EMPTY} return left graph.
//
Special case of last merge if local context.
//
These full-context merge operations are used when {@code rootIsWildcard} // is false.
// // // //Must keep all contexts {@link //EMPTY} in array is a special value (and
// nil parent).
//
Different tops, different parents.
//
Shared top, same parents.
//
Shared top, different parents.
//
Shared top, all shared parents.
//
Equal tops, merge parents and reduce top to
// {@link SingletonBasePredictionContext}.
//
// When using this prediction mode, the parser will either return a correct // parse tree (i.e. the same parse tree that would be returned with the // {@link //LL} prediction mode), or it will Report a syntax error. If a // syntax error is encountered when using the {@link //SLL} prediction mode, // it may be due to either an actual syntax error in the input or indicate // that the particular combination of grammar and input requires the more // powerful {@link //LL} prediction abilities to complete successfully.
// //// This prediction mode does not provide any guarantees for prediction // behavior for syntactically-incorrect inputs.
// PredictionModeSLL = 0 // // The LL(*) prediction mode. This prediction mode allows the current parser // context to be used for resolving SLL conflicts that occur during // prediction. This is the fastest prediction mode that guarantees correct // parse results for all combinations of grammars with syntactically correct // inputs. // //// When using this prediction mode, the parser will make correct decisions // for all syntactically-correct grammar and input combinations. However, in // cases where the grammar is truly ambiguous this prediction mode might not // Report a precise answer for exactly which alternatives are // ambiguous.
// //// This prediction mode does not provide any guarantees for prediction // behavior for syntactically-incorrect inputs.
// PredictionModeLL = 1 // // The LL(*) prediction mode with exact ambiguity detection. In addition to // the correctness guarantees provided by the {@link //LL} prediction mode, // this prediction mode instructs the prediction algorithm to determine the // complete and exact set of ambiguous alternatives for every ambiguous // decision encountered while parsing. // //// This prediction mode may be used for diagnosing ambiguities during // grammar development. Due to the performance overhead of calculating sets // of ambiguous alternatives, this prediction mode should be avoided when // the exact results are not necessary.
// //// This prediction mode does not provide any guarantees for prediction // behavior for syntactically-incorrect inputs.
// PredictionModeLLExactAmbigDetection = 2 ) // // Computes the SLL prediction termination condition. // //// This method computes the SLL prediction termination condition for both of // the following cases.
// //COMBINED SLL+LL PARSING
// //When LL-fallback is enabled upon SLL conflict, correct predictions are // ensured regardless of how the termination condition is computed by this // method. Due to the substantially higher cost of LL prediction, the // prediction should only fall back to LL when the additional lookahead // cannot lead to a unique SLL prediction.
// //Assuming combined SLL+LL parsing, an SLL configuration set with only // conflicting subsets should fall back to full LL, even if the // configuration sets don't resolve to the same alternative (e.g. // {@code {1,2}} and {@code {3,4}}. If there is at least one non-conflicting // configuration, SLL could continue with the hopes that more lookahead will // resolve via one of those non-conflicting configurations.
// //Here's the prediction termination rule them: SLL (for SLL+LL parsing) // stops when it sees only conflicting configuration subsets. In contrast, // full LL keeps going when there is uncertainty.
// //HEURISTIC
// //As a heuristic, we stop prediction when we see any conflicting subset // unless we see a state that only has one alternative associated with it. // The single-alt-state thing lets prediction continue upon rules like // (otherwise, it would admit defeat too soon):
// //{@code [12|1|[], 6|2|[], 12|2|[]]. s : (ID | ID ID?) '' }
// //When the ATN simulation reaches the state before {@code ''}, it has a // DFA state that looks like: {@code [12|1|[], 6|2|[], 12|2|[]]}. Naturally // {@code 12|1|[]} and {@code 12|2|[]} conflict, but we cannot stop // processing this node because alternative to has another way to continue, // via {@code [6|2|[]]}.
// //It also let's us continue for this rule:
// //{@code [1|1|[], 1|2|[], 8|3|[]] a : A | A | A B }
// //After Matching input A, we reach the stop state for rule A, state 1. // State 8 is the state right before B. Clearly alternatives 1 and 2 // conflict and no amount of further lookahead will separate the two. // However, alternative 3 will be able to continue and so we do not stop // working on this state. In the previous example, we're concerned with // states associated with the conflicting alternatives. Here alt 3 is not // associated with the conflicting configs, but since we can continue // looking for input reasonably, don't declare the state done.
// //PURE SLL PARSING
// //To handle pure SLL parsing, all we have to do is make sure that we // combine stack contexts for configurations that differ only by semantic // predicate. From there, we can do the usual SLL termination heuristic.
// //PREDICATES IN SLL+LL PARSING
// //SLL decisions don't evaluate predicates until after they reach DFA stop // states because they need to create the DFA cache that works in all // semantic situations. In contrast, full LL evaluates predicates collected // during start state computation so it can ignore predicates thereafter. // This means that SLL termination detection can totally ignore semantic // predicates.
// //Implementation-wise, {@link ATNConfigSet} combines stack contexts but not // semantic predicate contexts so we might see two configurations like the // following.
// //{@code (s, 1, x, {}), (s, 1, x', {p})}
// //Before testing these configurations against others, we have to merge // {@code x} and {@code x'} (without modifying the existing configurations). // For example, we test {@code (x+x')==x''} when looking for conflicts in // the following configurations.
// //{@code (s, 1, x, {}), (s, 1, x', {p}), (s, 2, x'', {})}
// //If the configuration set has predicates (as indicated by // {@link ATNConfigSet//hasSemanticContext}), this algorithm makes a copy of // the configurations to strip out all of the predicates so that a standard // {@link ATNConfigSet} will merge everything ignoring predicates.
// func PredictionModehasSLLConflictTerminatingPrediction(mode int, configs ATNConfigSet) bool { // Configs in rule stop states indicate reaching the end of the decision // rule (local context) or end of start rule (full context). If all // configs meet this condition, then none of the configurations is able // to Match additional input so we terminate prediction. // if PredictionModeallConfigsInRuleStopStates(configs) { return true } // pure SLL mode parsing if mode == PredictionModeSLL { // Don't bother with combining configs from different semantic // contexts if we can fail over to full LL costs more time // since we'll often fail over anyway. if configs.HasSemanticContext() { // dup configs, tossing out semantic predicates dup := NewBaseATNConfigSet(false) for _, c := range configs.GetItems() { // NewBaseATNConfig({semanticContext:}, c) c = NewBaseATNConfig2(c, SemanticContextNone) dup.Add(c, nil) } configs = dup } // now we have combined contexts for configs with dissimilar preds } // pure SLL or combined SLL+LL mode parsing altsets := PredictionModegetConflictingAltSubsets(configs) return PredictionModehasConflictingAltSet(altsets) && !PredictionModehasStateAssociatedWithOneAlt(configs) } // Checks if any configuration in {@code configs} is in a // {@link RuleStopState}. Configurations meeting this condition have reached // the end of the decision rule (local context) or end of start rule (full // context). // // @param configs the configuration set to test // @return {@code true} if any configuration in {@code configs} is in a // {@link RuleStopState}, otherwise {@code false} func PredictionModehasConfigInRuleStopState(configs ATNConfigSet) bool { for _, c := range configs.GetItems() { if _, ok := c.GetState().(*RuleStopState); ok { return true } } return false } // Checks if all configurations in {@code configs} are in a // {@link RuleStopState}. Configurations meeting this condition have reached // the end of the decision rule (local context) or end of start rule (full // context). // // @param configs the configuration set to test // @return {@code true} if all configurations in {@code configs} are in a // {@link RuleStopState}, otherwise {@code false} func PredictionModeallConfigsInRuleStopStates(configs ATNConfigSet) bool { for _, c := range configs.GetItems() { if _, ok := c.GetState().(*RuleStopState); !ok { return false } } return true } // // Full LL prediction termination. // //Can we stop looking ahead during ATN simulation or is there some // uncertainty as to which alternative we will ultimately pick, after // consuming more input? Even if there are partial conflicts, we might know // that everything is going to resolve to the same minimum alternative. That // means we can stop since no more lookahead will change that fact. On the // other hand, there might be multiple conflicts that resolve to different // minimums. That means we need more look ahead to decide which of those // alternatives we should predict.
// //The basic idea is to split the set of configurations {@code C}, into // conflicting subsets {@code (s, _, ctx, _)} and singleton subsets with // non-conflicting configurations. Two configurations conflict if they have // identical {@link ATNConfig//state} and {@link ATNConfig//context} values // but different {@link ATNConfig//alt} value, e.g. {@code (s, i, ctx, _)} // and {@code (s, j, ctx, _)} for {@code i!=j}.
// //Reduce these configuration subsets to the set of possible alternatives. // You can compute the alternative subsets in one pass as follows:
// //{@code A_s,ctx = {i | (s, i, ctx, _)}} for each configuration in // {@code C} holding {@code s} and {@code ctx} fixed.
// //Or in pseudo-code, for each configuration {@code c} in {@code C}:
// //
// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
// alt and not pred
//
//
// The values in {@code map} are the set of {@code A_s,ctx} sets.
// //If {@code |A_s,ctx|=1} then there is no conflict associated with // {@code s} and {@code ctx}.
// //Reduce the subsets to singletons by choosing a minimum of each subset. If // the union of these alternative subsets is a singleton, then no amount of // more lookahead will help us. We will always pick that alternative. If, // however, there is more than one alternative, then we are uncertain which // alternative to predict and must continue looking for resolution. We may // or may not discover an ambiguity in the future, even if there are no // conflicting subsets this round.
// //The biggest sin is to terminate early because it means we've made a // decision but were uncertain as to the eventual outcome. We haven't used // enough lookahead. On the other hand, announcing a conflict too late is no // big deal you will still have the conflict. It's just inefficient. It // might even look until the end of file.
// //No special consideration for semantic predicates is required because // predicates are evaluated on-the-fly for full LL prediction, ensuring that // no configuration contains a semantic context during the termination // check.
// //CONFLICTING CONFIGS
// //Two configurations {@code (s, i, x)} and {@code (s, j, x')}, conflict // when {@code i!=j} but {@code x=x'}. Because we merge all // {@code (s, i, _)} configurations together, that means that there are at // most {@code n} configurations associated with state {@code s} for // {@code n} possible alternatives in the decision. The merged stacks // complicate the comparison of configuration contexts {@code x} and // {@code x'}. Sam checks to see if one is a subset of the other by calling // merge and checking to see if the merged result is either {@code x} or // {@code x'}. If the {@code x} associated with lowest alternative {@code i} // is the superset, then {@code i} is the only possible prediction since the // others resolve to {@code min(i)} as well. However, if {@code x} is // associated with {@code j>i} then at least one stack configuration for // {@code j} is not in conflict with alternative {@code i}. The algorithm // should keep going, looking for more lookahead due to the uncertainty.
// //For simplicity, I'm doing a equality check between {@code x} and // {@code x'} that lets the algorithm continue to consume lookahead longer // than necessary. The reason I like the equality is of course the // simplicity but also because that is the test you need to detect the // alternatives that are actually in conflict.
// //CONTINUE/STOP RULE
// //Continue if union of resolved alternative sets from non-conflicting and // conflicting alternative subsets has more than one alternative. We are // uncertain about which alternative to predict.
// //The complete set of alternatives, {@code [i for (_,i,_)]}, tells us which // alternatives are still in the running for the amount of input we've // consumed at this point. The conflicting sets let us to strip away // configurations that won't lead to more states because we resolve // conflicts to the configuration with a minimum alternate for the // conflicting set.
// //CASES
// //EXACT AMBIGUITY DETECTION
// //If all states Report the same conflicting set of alternatives, then we // know we have the exact ambiguity set.
// //|A_i|>1 and
// A_i = A_j for all i, j.
In other words, we continue examining lookahead until all {@code A_i} // have more than one alternative and all {@code A_i} are the same. If // {@code A={{1,2}, {1,3}}}, then regular LL prediction would terminate // because the resolved set is {@code {1}}. To determine what the real // ambiguity is, we have to know whether the ambiguity is between one and // two or one and three so we keep going. We can only stop prediction when // we need exact ambiguity detection when the sets look like // {@code A={{1,2}}} or {@code {{1,2},{1,2}}}, etc...
// func PredictionModeresolvesToJustOneViableAlt(altsets []*BitSet) int { return PredictionModegetSingleViableAlt(altsets) } // // Determines if every alternative subset in {@code altsets} contains more // than one alternative. // // @param altsets a collection of alternative subsets // @return {@code true} if every {@link BitSet} in {@code altsets} has // {@link BitSet//cardinality cardinality} > 1, otherwise {@code false} // func PredictionModeallSubsetsConflict(altsets []*BitSet) bool { return !PredictionModehasNonConflictingAltSet(altsets) } // // Determines if any single alternative subset in {@code altsets} contains // exactly one alternative. // // @param altsets a collection of alternative subsets // @return {@code true} if {@code altsets} contains a {@link BitSet} with // {@link BitSet//cardinality cardinality} 1, otherwise {@code false} // func PredictionModehasNonConflictingAltSet(altsets []*BitSet) bool { for i := 0; i < len(altsets); i++ { alts := altsets[i] if alts.length() == 1 { return true } } return false } // // Determines if any single alternative subset in {@code altsets} contains // more than one alternative. // // @param altsets a collection of alternative subsets // @return {@code true} if {@code altsets} contains a {@link BitSet} with // {@link BitSet//cardinality cardinality} > 1, otherwise {@code false} // func PredictionModehasConflictingAltSet(altsets []*BitSet) bool { for i := 0; i < len(altsets); i++ { alts := altsets[i] if alts.length() > 1 { return true } } return false } // // Determines if every alternative subset in {@code altsets} is equivalent. // // @param altsets a collection of alternative subsets // @return {@code true} if every member of {@code altsets} is equal to the // others, otherwise {@code false} // func PredictionModeallSubsetsEqual(altsets []*BitSet) bool { var first *BitSet for i := 0; i < len(altsets); i++ { alts := altsets[i] if first == nil { first = alts } else if alts != first { return false } } return true } // // Returns the unique alternative predicted by all alternative subsets in // {@code altsets}. If no such alternative exists, this method returns // {@link ATN//INVALID_ALT_NUMBER}. // // @param altsets a collection of alternative subsets // func PredictionModegetUniqueAlt(altsets []*BitSet) int { all := PredictionModeGetAlts(altsets) if all.length() == 1 { return all.minValue() } return ATNInvalidAltNumber } // Gets the complete set of represented alternatives for a collection of // alternative subsets. This method returns the union of each {@link BitSet} // in {@code altsets}. // // @param altsets a collection of alternative subsets // @return the set of represented alternatives in {@code altsets} // func PredictionModeGetAlts(altsets []*BitSet) *BitSet { all := NewBitSet() for _, alts := range altsets { all.or(alts) } return all } // // This func gets the conflicting alt subsets from a configuration set. // For each configuration {@code c} in {@code configs}: // //
// map[c] U= c.{@link ATNConfig//alt alt} // map hash/equals uses s and x, not
// alt and not pred
//
//
func PredictionModegetConflictingAltSubsets(configs ATNConfigSet) []*BitSet {
configToAlts := make(map[int]*BitSet)
for _, c := range configs.GetItems() {
key := 31 * c.GetState().GetStateNumber() + c.GetContext().hash()
alts, ok := configToAlts[key]
if !ok {
alts = NewBitSet()
configToAlts[key] = alts
}
alts.add(c.GetAlt())
}
values := make([]*BitSet, 0, 10)
for _, v := range configToAlts {
values = append(values, v)
}
return values
}
//
// Get a map from state to alt subset from a configuration set. For each
// configuration {@code c} in {@code configs}:
//
//
// map[c.{@link ATNConfig//state state}] U= c.{@link ATNConfig//alt alt}
//
//
func PredictionModeGetStateToAltMap(configs ATNConfigSet) *AltDict {
m := NewAltDict()
for _, c := range configs.GetItems() {
alts := m.Get(c.GetState().String())
if alts == nil {
alts = NewBitSet()
m.put(c.GetState().String(), alts)
}
alts.(*BitSet).add(c.GetAlt())
}
return m
}
func PredictionModehasStateAssociatedWithOneAlt(configs ATNConfigSet) bool {
values := PredictionModeGetStateToAltMap(configs).values()
for i := 0; i < len(values); i++ {
if values[i].(*BitSet).length() == 1 {
return true
}
}
return false
}
func PredictionModegetSingleViableAlt(altsets []*BitSet) int {
result := ATNInvalidAltNumber
for i := 0; i < len(altsets); i++ {
alts := altsets[i]
minAlt := alts.minValue()
if result == ATNInvalidAltNumber {
result = minAlt
} else if result != minAlt { // more than 1 viable alt
return ATNInvalidAltNumber
}
}
return result
}
golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/recognizer.go 0000664 0000000 0000000 00000014036 14102210121 0025027 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
// Use of this file is governed by the BSD 3-clause license that
// can be found in the LICENSE.txt file in the project root.
package antlr
import (
"fmt"
"strings"
"strconv"
)
type Recognizer interface {
GetLiteralNames() []string
GetSymbolicNames() []string
GetRuleNames() []string
Sempred(RuleContext, int, int) bool
Precpred(RuleContext, int) bool
GetState() int
SetState(int)
Action(RuleContext, int, int)
AddErrorListener(ErrorListener)
RemoveErrorListeners()
GetATN() *ATN
GetErrorListenerDispatch() ErrorListener
}
type BaseRecognizer struct {
listeners []ErrorListener
state int
RuleNames []string
LiteralNames []string
SymbolicNames []string
GrammarFileName string
}
func NewBaseRecognizer() *BaseRecognizer {
rec := new(BaseRecognizer)
rec.listeners = []ErrorListener{ConsoleErrorListenerINSTANCE}
rec.state = -1
return rec
}
var tokenTypeMapCache = make(map[string]int)
var ruleIndexMapCache = make(map[string]int)
func (b *BaseRecognizer) checkVersion(toolVersion string) {
runtimeVersion := "4.7.2"
if runtimeVersion != toolVersion {
fmt.Println("ANTLR runtime and generated code versions disagree: " + runtimeVersion + "!=" + toolVersion)
}
}
func (b *BaseRecognizer) Action(context RuleContext, ruleIndex, actionIndex int) {
panic("action not implemented on Recognizer!")
}
func (b *BaseRecognizer) AddErrorListener(listener ErrorListener) {
b.listeners = append(b.listeners, listener)
}
func (b *BaseRecognizer) RemoveErrorListeners() {
b.listeners = make([]ErrorListener, 0)
}
func (b *BaseRecognizer) GetRuleNames() []string {
return b.RuleNames
}
func (b *BaseRecognizer) GetTokenNames() []string {
return b.LiteralNames
}
func (b *BaseRecognizer) GetSymbolicNames() []string {
return b.SymbolicNames
}
func (b *BaseRecognizer) GetLiteralNames() []string {
return b.LiteralNames
}
func (b *BaseRecognizer) GetState() int {
return b.state
}
func (b *BaseRecognizer) SetState(v int) {
b.state = v
}
//func (b *Recognizer) GetTokenTypeMap() {
// var tokenNames = b.GetTokenNames()
// if (tokenNames==nil) {
// panic("The current recognizer does not provide a list of token names.")
// }
// var result = tokenTypeMapCache[tokenNames]
// if(result==nil) {
// result = tokenNames.reduce(function(o, k, i) { o[k] = i })
// result.EOF = TokenEOF
// tokenTypeMapCache[tokenNames] = result
// }
// return result
//}
// Get a map from rule names to rule indexes.
//
// Used for XPath and tree pattern compilation.
// func (b *BaseRecognizer) GetRuleIndexMap() map[string]int { panic("Method not defined!") // var ruleNames = b.GetRuleNames() // if (ruleNames==nil) { // panic("The current recognizer does not provide a list of rule names.") // } // // var result = ruleIndexMapCache[ruleNames] // if(result==nil) { // result = ruleNames.reduce(function(o, k, i) { o[k] = i }) // ruleIndexMapCache[ruleNames] = result // } // return result } func (b *BaseRecognizer) GetTokenType(tokenName string) int { panic("Method not defined!") // var ttype = b.GetTokenTypeMap()[tokenName] // if (ttype !=nil) { // return ttype // } else { // return TokenInvalidType // } } //func (b *Recognizer) GetTokenTypeMap() map[string]int { // Vocabulary vocabulary = getVocabulary() // // Synchronized (tokenTypeMapCache) { // Map// Since tokens on hidden channels (e.g. whitespace or comments) are not // added to the parse trees, they will not appear in the output of b // method. // func (b *BaseRuleContext) GetParent() Tree { return b.parentCtx } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/semantic_context.go 0000664 0000000 0000000 00000022745 14102210121 0026235 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "fmt" "strconv" ) // A tree structure used to record the semantic context in which // an ATN configuration is valid. It's either a single predicate, // a conjunction {@code p1&&p2}, or a sum of products {@code p1||p2}. // //
I have scoped the {@link AND}, {@link OR}, and {@link Predicate} subclasses of // {@link SemanticContext} within the scope of this outer class.
// type SemanticContext interface { comparable evaluate(parser Recognizer, outerContext RuleContext) bool evalPrecedence(parser Recognizer, outerContext RuleContext) SemanticContext hash() int String() string } func SemanticContextandContext(a, b SemanticContext) SemanticContext { if a == nil || a == SemanticContextNone { return b } if b == nil || b == SemanticContextNone { return a } result := NewAND(a, b) if len(result.opnds) == 1 { return result.opnds[0] } return result } func SemanticContextorContext(a, b SemanticContext) SemanticContext { if a == nil { return b } if b == nil { return a } if a == SemanticContextNone || b == SemanticContextNone { return SemanticContextNone } result := NewOR(a, b) if len(result.opnds) == 1 { return result.opnds[0] } return result } type Predicate struct { ruleIndex int predIndex int isCtxDependent bool } func NewPredicate(ruleIndex, predIndex int, isCtxDependent bool) *Predicate { p := new(Predicate) p.ruleIndex = ruleIndex p.predIndex = predIndex p.isCtxDependent = isCtxDependent // e.g., $i ref in pred return p } //The default {@link SemanticContext}, which is semantically equivalent to //a predicate of the form {@code {true}?}. var SemanticContextNone SemanticContext = NewPredicate(-1, -1, false) func (p *Predicate) evalPrecedence(parser Recognizer, outerContext RuleContext) SemanticContext { return p } func (p *Predicate) evaluate(parser Recognizer, outerContext RuleContext) bool { var localctx RuleContext if p.isCtxDependent { localctx = outerContext } return parser.Sempred(localctx, p.ruleIndex, p.predIndex) } func (p *Predicate) equals(other interface{}) bool { if p == other { return true } else if _, ok := other.(*Predicate); !ok { return false } else { return p.ruleIndex == other.(*Predicate).ruleIndex && p.predIndex == other.(*Predicate).predIndex && p.isCtxDependent == other.(*Predicate).isCtxDependent } } func (p *Predicate) hash() int { return p.ruleIndex*43 + p.predIndex*47 } func (p *Predicate) String() string { return "{" + strconv.Itoa(p.ruleIndex) + ":" + strconv.Itoa(p.predIndex) + "}?" } type PrecedencePredicate struct { precedence int } func NewPrecedencePredicate(precedence int) *PrecedencePredicate { p := new(PrecedencePredicate) p.precedence = precedence return p } func (p *PrecedencePredicate) evaluate(parser Recognizer, outerContext RuleContext) bool { return parser.Precpred(outerContext, p.precedence) } func (p *PrecedencePredicate) evalPrecedence(parser Recognizer, outerContext RuleContext) SemanticContext { if parser.Precpred(outerContext, p.precedence) { return SemanticContextNone } return nil } func (p *PrecedencePredicate) compareTo(other *PrecedencePredicate) int { return p.precedence - other.precedence } func (p *PrecedencePredicate) equals(other interface{}) bool { if p == other { return true } else if _, ok := other.(*PrecedencePredicate); !ok { return false } else { return p.precedence == other.(*PrecedencePredicate).precedence } } func (p *PrecedencePredicate) hash() int { return p.precedence * 51 } func (p *PrecedencePredicate) String() string { return "{" + strconv.Itoa(p.precedence) + ">=prec}?" } func PrecedencePredicatefilterPrecedencePredicates(set *Set) []*PrecedencePredicate { result := make([]*PrecedencePredicate, 0) for _, v := range set.values() { if c2, ok := v.(*PrecedencePredicate); ok { result = append(result, c2) } } return result } // A semantic context which is true whenever none of the contained contexts // is false.` type AND struct { opnds []SemanticContext } func NewAND(a, b SemanticContext) *AND { operands := NewSet(nil, nil) if aa, ok := a.(*AND); ok { for _, o := range aa.opnds { operands.add(o) } } else { operands.add(a) } if ba, ok := b.(*AND); ok { for _, o := range ba.opnds { operands.add(o) } } else { operands.add(b) } precedencePredicates := PrecedencePredicatefilterPrecedencePredicates(operands) if len(precedencePredicates) > 0 { // interested in the transition with the lowest precedence var reduced *PrecedencePredicate for _, p := range precedencePredicates { if reduced == nil || p.precedence < reduced.precedence { reduced = p } } operands.add(reduced) } vs := operands.values() opnds := make([]SemanticContext, len(vs)) for i, v := range vs { opnds[i] = v.(SemanticContext) } and := new(AND) and.opnds = opnds return and } func (a *AND) equals(other interface{}) bool { if a == other { return true } else if _, ok := other.(*AND); !ok { return false } else { for i, v := range other.(*AND).opnds { if !a.opnds[i].equals(v) { return false } } return true } } // // {@inheritDoc} // //// The evaluation of predicates by a context is short-circuiting, but // unordered.
// func (a *AND) evaluate(parser Recognizer, outerContext RuleContext) bool { for i := 0; i < len(a.opnds); i++ { if !a.opnds[i].evaluate(parser, outerContext) { return false } } return true } func (a *AND) evalPrecedence(parser Recognizer, outerContext RuleContext) SemanticContext { differs := false operands := make([]SemanticContext, 0) for i := 0; i < len(a.opnds); i++ { context := a.opnds[i] evaluated := context.evalPrecedence(parser, outerContext) differs = differs || (evaluated != context) if evaluated == nil { // The AND context is false if any element is false return nil } else if evaluated != SemanticContextNone { // Reduce the result by Skipping true elements operands = append(operands, evaluated) } } if !differs { return a } if len(operands) == 0 { // all elements were true, so the AND context is true return SemanticContextNone } var result SemanticContext for _, o := range operands { if result == nil { result = o } else { result = SemanticContextandContext(result, o) } } return result } func (a *AND) hash() int { h := murmurInit(37) // Init with a value different from OR for _, op := range a.opnds { h = murmurUpdate(h, op.hash()) } return murmurFinish(h, len(a.opnds)) } func (a *OR) hash() int { h := murmurInit(41) // Init with a value different from AND for _, op := range a.opnds { h = murmurUpdate(h, op.hash()) } return murmurFinish(h, len(a.opnds)) } func (a *AND) String() string { s := "" for _, o := range a.opnds { s += "&& " + fmt.Sprint(o) } if len(s) > 3 { return s[0:3] } return s } // // A semantic context which is true whenever at least one of the contained // contexts is true. // type OR struct { opnds []SemanticContext } func NewOR(a, b SemanticContext) *OR { operands := NewSet(nil, nil) if aa, ok := a.(*OR); ok { for _, o := range aa.opnds { operands.add(o) } } else { operands.add(a) } if ba, ok := b.(*OR); ok { for _, o := range ba.opnds { operands.add(o) } } else { operands.add(b) } precedencePredicates := PrecedencePredicatefilterPrecedencePredicates(operands) if len(precedencePredicates) > 0 { // interested in the transition with the lowest precedence var reduced *PrecedencePredicate for _, p := range precedencePredicates { if reduced == nil || p.precedence > reduced.precedence { reduced = p } } operands.add(reduced) } vs := operands.values() opnds := make([]SemanticContext, len(vs)) for i, v := range vs { opnds[i] = v.(SemanticContext) } o := new(OR) o.opnds = opnds return o } func (o *OR) equals(other interface{}) bool { if o == other { return true } else if _, ok := other.(*OR); !ok { return false } else { for i, v := range other.(*OR).opnds { if !o.opnds[i].equals(v) { return false } } return true } } //// The evaluation of predicates by o context is short-circuiting, but // unordered.
// func (o *OR) evaluate(parser Recognizer, outerContext RuleContext) bool { for i := 0; i < len(o.opnds); i++ { if o.opnds[i].evaluate(parser, outerContext) { return true } } return false } func (o *OR) evalPrecedence(parser Recognizer, outerContext RuleContext) SemanticContext { differs := false operands := make([]SemanticContext, 0) for i := 0; i < len(o.opnds); i++ { context := o.opnds[i] evaluated := context.evalPrecedence(parser, outerContext) differs = differs || (evaluated != context) if evaluated == SemanticContextNone { // The OR context is true if any element is true return SemanticContextNone } else if evaluated != nil { // Reduce the result by Skipping false elements operands = append(operands, evaluated) } } if !differs { return o } if len(operands) == 0 { // all elements were false, so the OR context is false return nil } var result SemanticContext for _, o := range operands { if result == nil { result = o } else { result = SemanticContextorContext(result, o) } } return result } func (o *OR) String() string { s := "" for _, o := range o.opnds { s += "|| " + fmt.Sprint(o) } if len(s) > 3 { return s[0:3] } return s } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/testing_assert_test.go 0000664 0000000 0000000 00000004156 14102210121 0026757 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. // These assert functions are borrowed from https://github.com/stretchr/testify/ (MIT License) package antlr import ( "fmt" "reflect" "testing" ) type assert struct { t *testing.T } func assertNew(t *testing.T) *assert { return &assert{ t: t, } } func (a *assert) Equal(expected, actual interface{}) bool { if !objectsAreEqual(expected, actual) { return a.Fail(fmt.Sprintf("Not equal:\n"+ "expected: %#v\n"+ " actual: %#v\n", expected, actual)) } return true } func objectsAreEqual(expected, actual interface{}) bool { if expected == nil || actual == nil { return expected == actual } return reflect.DeepEqual(expected, actual) } func (a *assert) Nil(object interface{}) bool { if isNil(object) { return true } return a.Fail(fmt.Sprintf("Expected nil, but got: %#v", object)) } func (a *assert) NotNil(object interface{}) bool { if !isNil(object) { return true } return a.Fail("Expected value not to be nil.") } // isNil checks if a specified object is nil or not, without Failing. func isNil(object interface{}) bool { if object == nil { return true } value := reflect.ValueOf(object) kind := value.Kind() if kind >= reflect.Chan && kind <= reflect.Slice && value.IsNil() { return true } return false } func (a *assert) Panics(f func()) bool { if funcDidPanic, panicValue := didPanic(f); !funcDidPanic { return a.Fail(fmt.Sprintf("func %#v should panic\n\r\tPanic value:\t%v", f, panicValue)) } return true } // Fail reports a failure through func (a *assert) Fail(failureMessage string) bool { a.t.Errorf("%s", failureMessage) return false } // didPanic returns true if the function passed to it panics. Otherwise, it returns false. func didPanic(f func()) (bool, interface{}) { didPanic := false var message interface{} func() { defer func() { if message = recover(); message != nil { didPanic = true } }() // call the target function f() }() return didPanic, message } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/testing_lexer_b_test.go 0000664 0000000 0000000 00000006235 14102210121 0027076 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr /* LexerB is a lexer for testing purpose. This file is generated from this grammer. lexer grammar LexerB; ID : 'a'..'z'+; INT : '0'..'9'+; SEMI : ';'; ASSIGN : '='; PLUS : '+'; MULT : '*'; WS : ' '+; */ var lexerB_serializedLexerAtn = []uint16{ 3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 9, 40, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 3, 2, 6, 2, 19, 10, 2, 13, 2, 14, 2, 20, 3, 3, 6, 3, 24, 10, 3, 13, 3, 14, 3, 25, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 8, 6, 8, 37, 10, 8, 13, 8, 14, 8, 38, 2, 2, 9, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 3, 2, 2, 2, 42, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 3, 18, 3, 2, 2, 2, 5, 23, 3, 2, 2, 2, 7, 27, 3, 2, 2, 2, 9, 29, 3, 2, 2, 2, 11, 31, 3, 2, 2, 2, 13, 33, 3, 2, 2, 2, 15, 36, 3, 2, 2, 2, 17, 19, 4, 99, 124, 2, 18, 17, 3, 2, 2, 2, 19, 20, 3, 2, 2, 2, 20, 18, 3, 2, 2, 2, 20, 21, 3, 2, 2, 2, 21, 4, 3, 2, 2, 2, 22, 24, 4, 50, 59, 2, 23, 22, 3, 2, 2, 2, 24, 25, 3, 2, 2, 2, 25, 23, 3, 2, 2, 2, 25, 26, 3, 2, 2, 2, 26, 6, 3, 2, 2, 2, 27, 28, 7, 61, 2, 2, 28, 8, 3, 2, 2, 2, 29, 30, 7, 63, 2, 2, 30, 10, 3, 2, 2, 2, 31, 32, 7, 45, 2, 2, 32, 12, 3, 2, 2, 2, 33, 34, 7, 44, 2, 2, 34, 14, 3, 2, 2, 2, 35, 37, 7, 34, 2, 2, 36, 35, 3, 2, 2, 2, 37, 38, 3, 2, 2, 2, 38, 36, 3, 2, 2, 2, 38, 39, 3, 2, 2, 2, 39, 16, 3, 2, 2, 2, 6, 2, 20, 25, 38, 2, } var lexerB_lexerDeserializer = NewATNDeserializer(nil) var lexerB_lexerAtn = lexerB_lexerDeserializer.DeserializeFromUInt16(lexerB_serializedLexerAtn) var lexerB_lexerChannelNames = []string{ "DEFAULT_TOKEN_CHANNEL", "HIDDEN", } var lexerB_lexerModeNames = []string{ "DEFAULT_MODE", } var lexerB_lexerLiteralNames = []string{ "", "", "", "';'", "'='", "'+'", "'*'", } var lexerB_lexerSymbolicNames = []string{ "", "ID", "INT", "SEMI", "ASSIGN", "PLUS", "MULT", "WS", } var lexerB_lexerRuleNames = []string{ "ID", "INT", "SEMI", "ASSIGN", "PLUS", "MULT", "WS", } type LexerB struct { *BaseLexer channelNames []string modeNames []string // TODO: EOF string } var lexerB_lexerDecisionToDFA = make([]*DFA, len(lexerB_lexerAtn.DecisionToState)) func init() { for index, ds := range lexerB_lexerAtn.DecisionToState { lexerB_lexerDecisionToDFA[index] = NewDFA(ds, index) } } func NewLexerB(input CharStream) *LexerB { l := new(LexerB) l.BaseLexer = NewBaseLexer(input) l.Interpreter = NewLexerATNSimulator(l, lexerB_lexerAtn, lexerB_lexerDecisionToDFA, NewPredictionContextCache()) l.channelNames = lexerB_lexerChannelNames l.modeNames = lexerB_lexerModeNames l.RuleNames = lexerB_lexerRuleNames l.LiteralNames = lexerB_lexerLiteralNames l.SymbolicNames = lexerB_lexerSymbolicNames l.GrammarFileName = "LexerB.g4" // TODO: l.EOF = TokenEOF return l } // LexerB tokens. const ( LexerBID = 1 LexerBINT = 2 LexerBSEMI = 3 LexerBASSIGN = 4 LexerBPLUS = 5 LexerBMULT = 6 LexerBWS = 7 ) golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/testing_util_test.go 0000664 0000000 0000000 00000001216 14102210121 0026425 0 ustar 00root root 0000000 0000000 package antlr import ( "fmt" "strings" ) // newTestCommonToken create common token with tokentype, text and channel // notice: test purpose only func newTestCommonToken(tokenType int, text string, channel int) *CommonToken { t := new(CommonToken) t.BaseToken = new(BaseToken) t.tokenType = tokenType t.channel = channel t.text = text t.line = 0 t.column = -1 return t } // tokensToString returnes []Tokens string // notice: test purpose only func tokensToString(tokens []Token) string { buf := make([]string, len(tokens)) for i, token := range tokens { buf[i] = fmt.Sprintf("%v", token) } return "[" + strings.Join(buf, ", ") + "]" } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/token.go 0000664 0000000 0000000 00000011674 14102210121 0024005 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr import ( "strconv" "strings" ) type TokenSourceCharStreamPair struct { tokenSource TokenSource charStream CharStream } // A token has properties: text, type, line, character position in the line // (so we can ignore tabs), token channel, index, and source from which // we obtained this token. type Token interface { GetSource() *TokenSourceCharStreamPair GetTokenType() int GetChannel() int GetStart() int GetStop() int GetLine() int GetColumn() int GetText() string SetText(s string) GetTokenIndex() int SetTokenIndex(v int) GetTokenSource() TokenSource GetInputStream() CharStream } type BaseToken struct { source *TokenSourceCharStreamPair tokenType int // token type of the token channel int // The parser ignores everything not on DEFAULT_CHANNEL start int // optional return -1 if not implemented. stop int // optional return -1 if not implemented. tokenIndex int // from 0..n-1 of the token object in the input stream line int // line=1..n of the 1st character column int // beginning of the line at which it occurs, 0..n-1 text string // text of the token. readOnly bool } const ( TokenInvalidType = 0 // During lookahead operations, this "token" signifies we hit rule end ATN state // and did not follow it despite needing to. TokenEpsilon = -2 TokenMinUserTokenType = 1 TokenEOF = -1 // All tokens go to the parser (unless Skip() is called in that rule) // on a particular "channel". The parser tunes to a particular channel // so that whitespace etc... can go to the parser on a "hidden" channel. TokenDefaultChannel = 0 // Anything on different channel than DEFAULT_CHANNEL is not parsed // by parser. TokenHiddenChannel = 1 ) func (b *BaseToken) GetChannel() int { return b.channel } func (b *BaseToken) GetStart() int { return b.start } func (b *BaseToken) GetStop() int { return b.stop } func (b *BaseToken) GetLine() int { return b.line } func (b *BaseToken) GetColumn() int { return b.column } func (b *BaseToken) GetTokenType() int { return b.tokenType } func (b *BaseToken) GetSource() *TokenSourceCharStreamPair { return b.source } func (b *BaseToken) GetTokenIndex() int { return b.tokenIndex } func (b *BaseToken) SetTokenIndex(v int) { b.tokenIndex = v } func (b *BaseToken) GetTokenSource() TokenSource { return b.source.tokenSource } func (b *BaseToken) GetInputStream() CharStream { return b.source.charStream } type CommonToken struct { *BaseToken } func NewCommonToken(source *TokenSourceCharStreamPair, tokenType, channel, start, stop int) *CommonToken { t := new(CommonToken) t.BaseToken = new(BaseToken) t.source = source t.tokenType = tokenType t.channel = channel t.start = start t.stop = stop t.tokenIndex = -1 if t.source.tokenSource != nil { t.line = source.tokenSource.GetLine() t.column = source.tokenSource.GetCharPositionInLine() } else { t.column = -1 } return t } // An empty {@link Pair} which is used as the default value of // {@link //source} for tokens that do not have a source. //CommonToken.EMPTY_SOURCE = [ nil, nil ] // Constructs a New{@link CommonToken} as a copy of another {@link Token}. // //// If {@code oldToken} is also a {@link CommonToken} instance, the newly // constructed token will share a reference to the {@link //text} field and // the {@link Pair} stored in {@link //source}. Otherwise, {@link //text} will // be assigned the result of calling {@link //GetText}, and {@link //source} // will be constructed from the result of {@link Token//GetTokenSource} and // {@link Token//GetInputStream}.
// // @param oldToken The token to copy. // func (c *CommonToken) clone() *CommonToken { t := NewCommonToken(c.source, c.tokenType, c.channel, c.start, c.stop) t.tokenIndex = c.GetTokenIndex() t.line = c.GetLine() t.column = c.GetColumn() t.text = c.GetText() return t } func (c *CommonToken) GetText() string { if c.text != "" { return c.text } input := c.GetInputStream() if input == nil { return "" } n := input.Size() if c.start < n && c.stop < n { return input.GetTextFromInterval(NewInterval(c.start, c.stop)) } return "// You can insert stuff, replace, and delete chunks. Note that the operations // are done lazily--only if you convert the buffer to a {@link String} with // {@link TokenStream#getText()}. This is very efficient because you are not // moving data around all the time. As the buffer of tokens is converted to // strings, the {@link #getText()} method(s) scan the input token stream and // check to see if there is an operation at the current index. If so, the // operation is done and then normal {@link String} rendering continues on the // buffer. This is like having multiple Turing machine instruction streams // (programs) operating on a single input tape. :)
//// This rewriter makes no modifications to the token stream. It does not ask the // stream to fill itself up nor does it advance the input cursor. The token // stream {@link TokenStream#index()} will return the same value before and // after any {@link #getText()} call.
//// The rewriter only works on tokens that you have in the buffer and ignores the // current input cursor. If you are buffering tokens on-demand, calling // {@link #getText()} halfway through the input will only do rewrites for those // tokens in the first half of the file.
//// Since the operations are done lazily at {@link #getText}-time, operations do // not screw up the token index values. That is, an insert operation at token // index {@code i} does not change the index values for tokens // {@code i}+1..n-1.
//// Because operations never actually alter the buffer, you may always get the // original token stream back without undoing anything. Since the instructions // are queued up, you can easily simulate transactions and roll back any changes // if there is an error just by removing instructions. For example,
//
// CharStream input = new ANTLRFileStream("input");
// TLexer lex = new TLexer(input);
// CommonTokenStream tokens = new CommonTokenStream(lex);
// T parser = new T(tokens);
// TokenStreamRewriter rewriter = new TokenStreamRewriter(tokens);
// parser.startRule();
//
// // Then in the rules, you can execute (assuming rewriter is visible):
//// Token t,u; // ... // rewriter.insertAfter(t, "text to put after t");} // rewriter.insertAfter(u, "text after u");} // System.out.println(rewriter.getText()); ////
// You can also have multiple "instruction streams" and get multiple rewrites // from a single pass over the input. Just name the instruction streams and use // that name again when printing the buffer. This could be useful for generating // a C file and also its header file--all from the same buffer:
//
// rewriter.insertAfter("pass1", t, "text to put after t");}
// rewriter.insertAfter("pass2", u, "text after u");}
// System.out.println(rewriter.getText("pass1"));
// System.out.println(rewriter.getText("pass2"));
//
// // If you don't use named rewrite streams, a "default" stream is used as the // first example shows.
const( Default_Program_Name = "default" Program_Init_Size = 100 Min_Token_Index = 0 ) // Define the rewrite operation hierarchy type RewriteOperation interface { // Execute the rewrite operation by possibly adding to the buffer. // Return the index of the next token to operate on. Execute(buffer *bytes.Buffer) int String() string GetInstructionIndex() int GetIndex() int GetText() string GetOpName() string GetTokens() TokenStream SetInstructionIndex(val int) SetIndex(int) SetText(string) SetOpName(string) SetTokens(TokenStream) } type BaseRewriteOperation struct { //Current index of rewrites list instruction_index int //Token buffer index index int //Substitution text text string //Actual operation name op_name string //Pointer to token steam tokens TokenStream } func (op *BaseRewriteOperation)GetInstructionIndex() int{ return op.instruction_index } func (op *BaseRewriteOperation)GetIndex() int{ return op.index } func (op *BaseRewriteOperation)GetText() string{ return op.text } func (op *BaseRewriteOperation)GetOpName() string{ return op.op_name } func (op *BaseRewriteOperation)GetTokens() TokenStream{ return op.tokens } func (op *BaseRewriteOperation)SetInstructionIndex(val int){ op.instruction_index = val } func (op *BaseRewriteOperation)SetIndex(val int) { op.index = val } func (op *BaseRewriteOperation)SetText(val string){ op.text = val } func (op *BaseRewriteOperation)SetOpName(val string){ op.op_name = val } func (op *BaseRewriteOperation)SetTokens(val TokenStream) { op.tokens = val } func (op *BaseRewriteOperation) Execute(buffer *bytes.Buffer) int{ return op.index } func (op *BaseRewriteOperation) String() string { return fmt.Sprintf("<%s@%d:\"%s\">", op.op_name, op.tokens.Get(op.GetIndex()), op.text, ) } type InsertBeforeOp struct { BaseRewriteOperation } func NewInsertBeforeOp(index int, text string, stream TokenStream) *InsertBeforeOp{ return &InsertBeforeOp{BaseRewriteOperation:BaseRewriteOperation{ index:index, text:text, op_name:"InsertBeforeOp", tokens:stream, }} } func (op *InsertBeforeOp) Execute(buffer *bytes.Buffer) int{ buffer.WriteString(op.text) if op.tokens.Get(op.index).GetTokenType() != TokenEOF{ buffer.WriteString(op.tokens.Get(op.index).GetText()) } return op.index+1 } func (op *InsertBeforeOp) String() string { return op.BaseRewriteOperation.String() } // Distinguish between insert after/before to do the "insert afters" // first and then the "insert befores" at same index. Implementation // of "insert after" is "insert before index+1". type InsertAfterOp struct { BaseRewriteOperation } func NewInsertAfterOp(index int, text string, stream TokenStream) *InsertAfterOp{ return &InsertAfterOp{BaseRewriteOperation:BaseRewriteOperation{ index:index+1, text:text, tokens:stream, }} } func (op *InsertAfterOp) Execute(buffer *bytes.Buffer) int { buffer.WriteString(op.text) if op.tokens.Get(op.index).GetTokenType() != TokenEOF{ buffer.WriteString(op.tokens.Get(op.index).GetText()) } return op.index+1 } func (op *InsertAfterOp) String() string { return op.BaseRewriteOperation.String() } // I'm going to try replacing range from x..y with (y-x)+1 ReplaceOp // instructions. type ReplaceOp struct{ BaseRewriteOperation LastIndex int } func NewReplaceOp(from, to int, text string, stream TokenStream)*ReplaceOp { return &ReplaceOp{ BaseRewriteOperation:BaseRewriteOperation{ index:from, text:text, op_name:"ReplaceOp", tokens:stream, }, LastIndex:to, } } func (op *ReplaceOp)Execute(buffer *bytes.Buffer) int{ if op.text != ""{ buffer.WriteString(op.text) } return op.LastIndex +1 } func (op *ReplaceOp) String() string { if op.text == "" { return fmt.Sprintf("a
a", "DistinguishBetweenInsertAfterAndInsertBeforeToPreserverOrder2", func(r *TokenStreamRewriter){ r.InsertBeforeDefault(0, "") r.InsertBeforeDefault(0, "") r.InsertAfterDefault(0, "
") r.InsertAfterDefault(0, "") r.InsertBeforeDefault(1, "") r.InsertAfterDefault(1,"") }), NewLexerTest("ab", "a
")
r.InsertBeforeDefault(0, "")
r.InsertBeforeDefault(0, "
This is a one way link. It emanates from a state (usually via a list of // transitions) and has a target state.
// //Since we never have to change the ATN transitions once we construct it, // the states. We'll use the term Edge for the DFA to distinguish them from // ATN transitions.
type Transition interface { getTarget() ATNState setTarget(ATNState) getIsEpsilon() bool getLabel() *IntervalSet getSerializationType() int Matches(int, int, int) bool } type BaseTransition struct { target ATNState isEpsilon bool label int intervalSet *IntervalSet serializationType int } func NewBaseTransition(target ATNState) *BaseTransition { if target == nil { panic("target cannot be nil.") } t := new(BaseTransition) t.target = target // Are we epsilon, action, sempred? t.isEpsilon = false t.intervalSet = nil return t } func (t *BaseTransition) getTarget() ATNState { return t.target } func (t *BaseTransition) setTarget(s ATNState) { t.target = s } func (t *BaseTransition) getIsEpsilon() bool { return t.isEpsilon } func (t *BaseTransition) getLabel() *IntervalSet { return t.intervalSet } func (t *BaseTransition) getSerializationType() int { return t.serializationType } func (t *BaseTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { panic("Not implemented") } const ( TransitionEPSILON = 1 TransitionRANGE = 2 TransitionRULE = 3 TransitionPREDICATE = 4 // e.g., {isType(input.LT(1))}? TransitionATOM = 5 TransitionACTION = 6 TransitionSET = 7 // ~(A|B) or ~atom, wildcard, which convert to next 2 TransitionNOTSET = 8 TransitionWILDCARD = 9 TransitionPRECEDENCE = 10 ) var TransitionserializationNames = []string{ "INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE", } //var TransitionserializationTypes struct { // EpsilonTransition int // RangeTransition int // RuleTransition int // PredicateTransition int // AtomTransition int // ActionTransition int // SetTransition int // NotSetTransition int // WildcardTransition int // PrecedencePredicateTransition int //}{ // TransitionEPSILON, // TransitionRANGE, // TransitionRULE, // TransitionPREDICATE, // TransitionATOM, // TransitionACTION, // TransitionSET, // TransitionNOTSET, // TransitionWILDCARD, // TransitionPRECEDENCE //} // TODO: make all transitions sets? no, should remove set edges type AtomTransition struct { *BaseTransition } func NewAtomTransition(target ATNState, intervalSet int) *AtomTransition { t := new(AtomTransition) t.BaseTransition = NewBaseTransition(target) t.label = intervalSet // The token type or character value or, signifies special intervalSet. t.intervalSet = t.makeLabel() t.serializationType = TransitionATOM return t } func (t *AtomTransition) makeLabel() *IntervalSet { s := NewIntervalSet() s.addOne(t.label) return s } func (t *AtomTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return t.label == symbol } func (t *AtomTransition) String() string { return strconv.Itoa(t.label) } type RuleTransition struct { *BaseTransition followState ATNState ruleIndex, precedence int } func NewRuleTransition(ruleStart ATNState, ruleIndex, precedence int, followState ATNState) *RuleTransition { t := new(RuleTransition) t.BaseTransition = NewBaseTransition(ruleStart) t.ruleIndex = ruleIndex t.precedence = precedence t.followState = followState t.serializationType = TransitionRULE t.isEpsilon = true return t } func (t *RuleTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return false } type EpsilonTransition struct { *BaseTransition outermostPrecedenceReturn int } func NewEpsilonTransition(target ATNState, outermostPrecedenceReturn int) *EpsilonTransition { t := new(EpsilonTransition) t.BaseTransition = NewBaseTransition(target) t.serializationType = TransitionEPSILON t.isEpsilon = true t.outermostPrecedenceReturn = outermostPrecedenceReturn return t } func (t *EpsilonTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return false } func (t *EpsilonTransition) String() string { return "epsilon" } type RangeTransition struct { *BaseTransition start, stop int } func NewRangeTransition(target ATNState, start, stop int) *RangeTransition { t := new(RangeTransition) t.BaseTransition = NewBaseTransition(target) t.serializationType = TransitionRANGE t.start = start t.stop = stop t.intervalSet = t.makeLabel() return t } func (t *RangeTransition) makeLabel() *IntervalSet { s := NewIntervalSet() s.addRange(t.start, t.stop) return s } func (t *RangeTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return symbol >= t.start && symbol <= t.stop } func (t *RangeTransition) String() string { return "'" + string(t.start) + "'..'" + string(t.stop) + "'" } type AbstractPredicateTransition interface { Transition IAbstractPredicateTransitionFoo() } type BaseAbstractPredicateTransition struct { *BaseTransition } func NewBasePredicateTransition(target ATNState) *BaseAbstractPredicateTransition { t := new(BaseAbstractPredicateTransition) t.BaseTransition = NewBaseTransition(target) return t } func (a *BaseAbstractPredicateTransition) IAbstractPredicateTransitionFoo() {} type PredicateTransition struct { *BaseAbstractPredicateTransition isCtxDependent bool ruleIndex, predIndex int } func NewPredicateTransition(target ATNState, ruleIndex, predIndex int, isCtxDependent bool) *PredicateTransition { t := new(PredicateTransition) t.BaseAbstractPredicateTransition = NewBasePredicateTransition(target) t.serializationType = TransitionPREDICATE t.ruleIndex = ruleIndex t.predIndex = predIndex t.isCtxDependent = isCtxDependent // e.g., $i ref in pred t.isEpsilon = true return t } func (t *PredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return false } func (t *PredicateTransition) getPredicate() *Predicate { return NewPredicate(t.ruleIndex, t.predIndex, t.isCtxDependent) } func (t *PredicateTransition) String() string { return "pred_" + strconv.Itoa(t.ruleIndex) + ":" + strconv.Itoa(t.predIndex) } type ActionTransition struct { *BaseTransition isCtxDependent bool ruleIndex, actionIndex, predIndex int } func NewActionTransition(target ATNState, ruleIndex, actionIndex int, isCtxDependent bool) *ActionTransition { t := new(ActionTransition) t.BaseTransition = NewBaseTransition(target) t.serializationType = TransitionACTION t.ruleIndex = ruleIndex t.actionIndex = actionIndex t.isCtxDependent = isCtxDependent // e.g., $i ref in pred t.isEpsilon = true return t } func (t *ActionTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return false } func (t *ActionTransition) String() string { return "action_" + strconv.Itoa(t.ruleIndex) + ":" + strconv.Itoa(t.actionIndex) } type SetTransition struct { *BaseTransition } func NewSetTransition(target ATNState, set *IntervalSet) *SetTransition { t := new(SetTransition) t.BaseTransition = NewBaseTransition(target) t.serializationType = TransitionSET if set != nil { t.intervalSet = set } else { t.intervalSet = NewIntervalSet() t.intervalSet.addOne(TokenInvalidType) } return t } func (t *SetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return t.intervalSet.contains(symbol) } func (t *SetTransition) String() string { return t.intervalSet.String() } type NotSetTransition struct { *SetTransition } func NewNotSetTransition(target ATNState, set *IntervalSet) *NotSetTransition { t := new(NotSetTransition) t.SetTransition = NewSetTransition(target, set) t.serializationType = TransitionNOTSET return t } func (t *NotSetTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return symbol >= minVocabSymbol && symbol <= maxVocabSymbol && !t.intervalSet.contains(symbol) } func (t *NotSetTransition) String() string { return "~" + t.intervalSet.String() } type WildcardTransition struct { *BaseTransition } func NewWildcardTransition(target ATNState) *WildcardTransition { t := new(WildcardTransition) t.BaseTransition = NewBaseTransition(target) t.serializationType = TransitionWILDCARD return t } func (t *WildcardTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return symbol >= minVocabSymbol && symbol <= maxVocabSymbol } func (t *WildcardTransition) String() string { return "." } type PrecedencePredicateTransition struct { *BaseAbstractPredicateTransition precedence int } func NewPrecedencePredicateTransition(target ATNState, precedence int) *PrecedencePredicateTransition { t := new(PrecedencePredicateTransition) t.BaseAbstractPredicateTransition = NewBasePredicateTransition(target) t.serializationType = TransitionPRECEDENCE t.precedence = precedence t.isEpsilon = true return t } func (t *PrecedencePredicateTransition) Matches(symbol, minVocabSymbol, maxVocabSymbol int) bool { return false } func (t *PrecedencePredicateTransition) getPredicate() *PrecedencePredicate { return NewPrecedencePredicate(t.precedence) } func (t *PrecedencePredicateTransition) String() string { return fmt.Sprint(t.precedence) + " >= _p" } golang-github-antlr-antlr4-4.7.2+ds/runtime/Go/antlr/tree.go 0000664 0000000 0000000 00000013560 14102210121 0023620 0 ustar 00root root 0000000 0000000 // Copyright (c) 2012-2017 The ANTLR Project. All rights reserved. // Use of this file is governed by the BSD 3-clause license that // can be found in the LICENSE.txt file in the project root. package antlr // The basic notion of a tree has a parent, a payload, and a list of children. // It is the most abstract interface for all the trees used by ANTLR. /// var TreeInvalidInterval = NewInterval(-1, -2) type Tree interface { GetParent() Tree SetParent(Tree) GetPayload() interface{} GetChild(i int) Tree GetChildCount() int GetChildren() []Tree } type SyntaxTree interface { Tree GetSourceInterval() *Interval } type ParseTree interface { SyntaxTree Accept(Visitor ParseTreeVisitor) interface{} GetText() string ToStringTree([]string, Recognizer) string } type RuleNode interface { ParseTree GetRuleContext() RuleContext GetBaseRuleContext() *BaseRuleContext } type TerminalNode interface { ParseTree GetSymbol() Token } type ErrorNode interface { TerminalNode errorNode() } type ParseTreeVisitor interface { Visit(tree ParseTree) interface{} VisitChildren(node RuleNode) interface{} VisitTerminal(node TerminalNode) interface{} VisitErrorNode(node ErrorNode) interface{} } type BaseParseTreeVisitor struct{} var _ ParseTreeVisitor = &BaseParseTreeVisitor{} func (v *BaseParseTreeVisitor) Visit(tree ParseTree) interface{} { return nil } func (v *BaseParseTreeVisitor) VisitChildren(node RuleNode) interface{} { return nil } func (v *BaseParseTreeVisitor) VisitTerminal(node TerminalNode) interface{} { return nil } func (v *BaseParseTreeVisitor) VisitErrorNode(node ErrorNode) interface{} { return nil } // TODO //func (this ParseTreeVisitor) Visit(ctx) { // if (Utils.isArray(ctx)) { // self := this // return ctx.map(function(child) { return VisitAtom(self, child)}) // } else { // return VisitAtom(this, ctx) // } //} // //func VisitAtom(Visitor, ctx) { // if (ctx.parser == nil) { //is terminal // return // } // // name := ctx.parser.ruleNames[ctx.ruleIndex] // funcName := "Visit" + Utils.titleCase(name) // // return Visitor[funcName](ctx) //} type ParseTreeListener interface { VisitTerminal(node TerminalNode) VisitErrorNode(node ErrorNode) EnterEveryRule(ctx ParserRuleContext) ExitEveryRule(ctx ParserRuleContext) } type BaseParseTreeListener struct{} var _ ParseTreeListener = &BaseParseTreeListener{} func (l *BaseParseTreeListener) VisitTerminal(node TerminalNode) {} func (l *BaseParseTreeListener) VisitErrorNode(node ErrorNode) {} func (l *BaseParseTreeListener) EnterEveryRule(ctx ParserRuleContext) {} func (l *BaseParseTreeListener) ExitEveryRule(ctx ParserRuleContext) {} type TerminalNodeImpl struct { parentCtx RuleContext symbol Token } var _ TerminalNode = &TerminalNodeImpl{} func NewTerminalNodeImpl(symbol Token) *TerminalNodeImpl { tn := new(TerminalNodeImpl) tn.parentCtx = nil tn.symbol = symbol return tn } func (t *TerminalNodeImpl) GetChild(i int) Tree { return nil } func (t *TerminalNodeImpl) GetChildren() []Tree { return nil } func (t *TerminalNodeImpl) SetChildren(tree []Tree) { panic("Cannot set children on terminal node") } func (t *TerminalNodeImpl) GetSymbol() Token { return t.symbol } func (t *TerminalNodeImpl) GetParent() Tree { return t.parentCtx } func (t *TerminalNodeImpl) SetParent(tree Tree) { t.parentCtx = tree.(RuleContext) } func (t *TerminalNodeImpl) GetPayload() interface{} { return t.symbol } func (t *TerminalNodeImpl) GetSourceInterval() *Interval { if t.symbol == nil { return TreeInvalidInterval } tokenIndex := t.symbol.GetTokenIndex() return NewInterval(tokenIndex, tokenIndex) } func (t *TerminalNodeImpl) GetChildCount() int { return 0 } func (t *TerminalNodeImpl) Accept(v ParseTreeVisitor) interface{} { return v.VisitTerminal(t) } func (t *TerminalNodeImpl) GetText() string { return t.symbol.GetText() } func (t *TerminalNodeImpl) String() string { if t.symbol.GetTokenType() == TokenEOF { return "