org.antlr.v4.runtime.atn.ATN Java Examples

public ATN checkAndClear() {
    if (!shouldClearDfaCache()) {
        return atn;
    }

    if (0 != counter.incrementAndGet() % DFA_CACHE_THRESHOLD) {
        return atn;
    }

    WRITE_LOCK.lock();
    try {
        atn.clearDFA();
    } finally {
        WRITE_LOCK.unlock();
    }

    return atn;
}
 

private static void optimizeStates(ATN atn) {
//		System.out.println(atn.states);
		List<ATNState> compressed = new ArrayList<ATNState>();
		int i = 0; // new state number
		for (ATNState s : atn.states) {
			if ( s!=null ) {
				compressed.add(s);
				s.stateNumber = i; // reset state number as we shift to new position
				i++;
			}
		}
//		System.out.println(compressed);
//		System.out.println("ATN optimizer removed " + (atn.states.size() - compressed.size()) + " null states.");
		atn.states.clear();
		atn.states.addAll(compressed);
	}
 

@Override
public ATN createATN() {
	_createATN(g.rules.values());
	assert atn.maxTokenType == g.getMaxTokenType();
       addRuleFollowLinks();
	addEOFTransitionToStartRules();
	ATNOptimizer.optimize(g, atn);

	for (Triple<Rule, ATNState, ATNState> pair : preventEpsilonClosureBlocks) {
		LL1Analyzer analyzer = new LL1Analyzer(atn);
		if (analyzer.LOOK(pair.b, pair.c, null).contains(org.antlr.v4.runtime.Token.EPSILON)) {
			ErrorType errorType = pair.a instanceof LeftRecursiveRule ? ErrorType.EPSILON_LR_FOLLOW : ErrorType.EPSILON_CLOSURE;
			g.tool.errMgr.grammarError(errorType, g.fileName, ((GrammarAST)pair.a.ast.getChild(0)).getToken(), pair.a.name);
		}
	}

	optionalCheck:
	for (Triple<Rule, ATNState, ATNState> pair : preventEpsilonOptionalBlocks) {
		int bypassCount = 0;
		for (int i = 0; i < pair.b.getNumberOfTransitions(); i++) {
			ATNState startState = pair.b.transition(i).target;
			if (startState == pair.c) {
				bypassCount++;
				continue;
			}

			LL1Analyzer analyzer = new LL1Analyzer(atn);
			if (analyzer.LOOK(startState, pair.c, null).contains(org.antlr.v4.runtime.Token.EPSILON)) {
				g.tool.errMgr.grammarError(ErrorType.EPSILON_OPTIONAL, g.fileName, ((GrammarAST)pair.a.ast.getChild(0)).getToken(), pair.a.name);
				continue optionalCheck;
			}
		}

		if (bypassCount != 1) {
			throw new UnsupportedOperationException("Expected optional block with exactly 1 bypass alternative.");
		}
	}

	return atn;
}
 

public final AnywordContext anyword() throws RecognitionException {
	AnywordContext _localctx = new AnywordContext(_ctx, getState());
	enterRule(_localctx, 22, RULE_anyword);
	try {
		int _alt;
		enterOuterAlt(_localctx, 1);
		{
			setState(86);
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1: {
					{
						setState(85);
						match(ANYCHAR);
					}
				}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(88);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input, 8, _ctx);
			} while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
		}
	} catch (RecognitionException re) {
		_localctx.exception = re;
		_errHandler.reportError(this, re);
		_errHandler.recover(this, re);
	} finally {
		exitRule();
	}
	return _localctx;
}
 

/** @since 4.5.1 */
public GrammarParserInterpreter createGrammarParserInterpreter(TokenStream tokenStream) {
	if (this.isLexer()) {
		throw new IllegalStateException("A parser interpreter can only be created for a parser or combined grammar.");
	}
	char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
	ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
	return new GrammarParserInterpreter(this, deserialized, tokenStream);
}
 

public ParserInterpreter createParserInterpreter(TokenStream tokenStream) {
	if (this.isLexer()) {
		throw new IllegalStateException("A parser interpreter can only be created for a parser or combined grammar.");
	}

	char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
	ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
	return new ParserInterpreter(fileName, getVocabulary(), Arrays.asList(getRuleNames()), deserialized, tokenStream);
}
 

public LexerInterpreter createLexerInterpreter(CharStream input) {
	if (this.isParser()) {
		throw new IllegalStateException("A lexer interpreter can only be created for a lexer or combined grammar.");
	}

	if (this.isCombined()) {
		return implicitLexer.createLexerInterpreter(input);
	}

	char[] serializedAtn = ATNSerializer.getSerializedAsChars(atn);
	ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
	return new LexerInterpreter(fileName, getVocabulary(), Arrays.asList(getRuleNames()), ((LexerGrammar)this).modes.keySet(), deserialized, input);
}
 

public final ObjectPrefixContext objectPrefix() throws RecognitionException {
	ObjectPrefixContext _localctx = new ObjectPrefixContext(_ctx, getState());
	enterRule(_localctx, 16, RULE_objectPrefix);
	try {
		int _alt;
		enterOuterAlt(_localctx, 1);
		{
			setState(73);
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1: {
					{
						setState(71);
						match(NAME);
						setState(72);
						match(DOT);
					}
				}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(75);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input, 7, _ctx);
			} while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER);
		}
	} catch (RecognitionException re) {
		_localctx.exception = re;
		_errHandler.reportError(this, re);
		_errHandler.recover(this, re);
	} finally {
		exitRule();
	}
	return _localctx;
}
 

public final FieldListContext fieldList() throws RecognitionException {
	FieldListContext _localctx = new FieldListContext(_ctx, getState());
	enterRule(_localctx, 8, RULE_fieldList);
	try {
		int _alt;
		enterOuterAlt(_localctx, 1);
		{
			setState(45);
			field();
			setState(50);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input, 3, _ctx);
			while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) {
				if (_alt == 1) {
					{
						{
							setState(46);
							match(COMMA);
							setState(47);
							field();
						}
					}
				}
				setState(52);
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input, 3, _ctx);
			}
		}
	} catch (RecognitionException re) {
		_localctx.exception = re;
		_errHandler.reportError(this, re);
		_errHandler.recover(this, re);
	} finally {
		exitRule();
	}
	return _localctx;
}
 

public ParserATNFactory(Grammar g) {
	if (g == null) {
		throw new NullPointerException("g");
	}

	this.g = g;

	ATNType atnType = g instanceof LexerGrammar ? ATNType.LEXER : ATNType.PARSER;
	int maxTokenType = g.getMaxTokenType();
	this.atn = new ATN(atnType, maxTokenType);
}
 

public GrammarParserInterpreter(Grammar g,
								String grammarFileName,
								Vocabulary vocabulary,
								Collection<String> ruleNames,
								ATN atn,
								TokenStream input) {
	super(grammarFileName, vocabulary, ruleNames, atn, input);
	this.g = g;
}
 

public SerializedATN(OutputModelFactory factory, ATN atn) {
		super(factory);
		IntegerList data = ATNSerializer.getSerialized(atn);
		serialized = new ArrayList<String>(data.size());
		for (int c : data.toArray()) {
			String encoded = factory.getGenerator().getTarget().encodeIntAsCharEscape(c == -1 ? Character.MAX_VALUE : c);
			serialized.add(encoded);
		}
//		System.out.println(ATNSerializer.getDecoded(factory.getGrammar(), atn));
	}
 

public GrammarParserInterpreter(Grammar g, ATN atn, TokenStream input) {
	super(g.fileName, g.getVocabulary(),
		  Arrays.asList(g.getRuleNames()),
		  atn, // must run ATN through serializer to set some state flags
		  input);
	this.g = g;
	decisionStatesThatSetOuterAltNumInContext = findOuterMostDecisionStates();
	stateToAltsMap = new int[g.atn.states.size()][];
}
 

/** Derive a new parser from an old one that has knowledge of the grammar.
 *  The Grammar object is used to correctly compute outer alternative
 *  numbers for parse tree nodes. A parser of the same type is created
 *  for subclasses of {@link ParserInterpreter}.
 */
public static ParserInterpreter deriveTempParserInterpreter(Grammar g, Parser originalParser, TokenStream tokens) {
	ParserInterpreter parser;
	if (originalParser instanceof ParserInterpreter) {
		Class<? extends ParserInterpreter> c = originalParser.getClass().asSubclass(ParserInterpreter.class);
		try {
			Constructor<? extends ParserInterpreter> ctor = c.getConstructor(Grammar.class, ATN.class, TokenStream.class);
			parser = ctor.newInstance(g, originalParser.getATN(), originalParser.getTokenStream());
		}
		catch (Exception e) {
			throw new IllegalArgumentException("can't create parser to match incoming "+originalParser.getClass().getSimpleName(), e);
		}
	}
	else { // must've been a generated parser
		char[] serializedAtn = ATNSerializer.getSerializedAsChars(originalParser.getATN());
		ATN deserialized = new ATNDeserializer().deserialize(serializedAtn);
		parser = new ParserInterpreter(originalParser.getGrammarFileName(),
									   originalParser.getVocabulary(),
									   Arrays.asList(originalParser.getRuleNames()),
									   deserialized,
									   tokens);
	}

	parser.setInputStream(tokens);

	// Make sure that we don't get any error messages from using this temporary parser
	parser.setErrorHandler(new BailErrorStrategy());
	parser.removeErrorListeners();
	parser.removeParseListeners();
	parser.getInterpreter().setPredictionMode(PredictionMode.LL_EXACT_AMBIG_DETECTION);
	return parser;
}
 

private static DFA[] createDecisionToDFA(ATN atn)
{
    DFA[] decisionToDFA = new DFA[atn.getNumberOfDecisions()];
    for (int i = 0; i < decisionToDFA.length; i++) {
        decisionToDFA[i] = new DFA(atn.getDecisionState(i), i);
    }
    return decisionToDFA;
}
 

public ATN getATN() {
	if ( atn==null ) {
		ParserATNFactory factory = new ParserATNFactory(this);
		atn = factory.createATN();
	}
	return atn;
}
 

@Override
public ATN getATN() {
  return _ATN;
}
 

public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn, DFA[] decisionToDFA, PredictionContextCache sharedContextCache) {
    super(recog, atn, decisionToDFA, sharedContextCache);
}
 

@Override
public ATN getATN() { return _ATN; }
 

@Override
public ATN getATN() { return _ATN; }
 

@Override
public ATN getATN() {
  return _ATN;
}
 

public final MergeStatementContext mergeStatement() throws RecognitionException {
	MergeStatementContext _localctx = new MergeStatementContext(_ctx, getState());
	enterRule(_localctx, 10, RULE_mergeStatement);
	int _la;
	try {
		int _alt;
		enterOuterAlt(_localctx, 1);
		{
		setState(108);
		match(MERGE);
		setState(109);
		match(INTO);
		setState(110);
		tableName();
		setState(114);
		_errHandler.sync(this);
		_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
		while ( _alt!=1 && _alt!= ATN.INVALID_ALT_NUMBER ) {
			if ( _alt==1+1 ) {
				{
				{
				setState(111);
				matchWildcard();
				}
				} 
			}
			setState(116);
			_errHandler.sync(this);
			_alt = getInterpreter().adaptivePredict(_input,14,_ctx);
		}
		setState(118);
		_errHandler.sync(this);
		_la = _input.LA(1);
		if (_la==RETURNING) {
			{
			setState(117);
			returningClause();
			}
		}

		setState(121);
		_errHandler.sync(this);
		_la = _input.LA(1);
		if (_la==T__0) {
			{
			setState(120);
			match(T__0);
			}
		}


		                statementModel.setStatementType(JaybirdStatementModel.MERGE_TYPE);
		            
		}
	}
	catch (RecognitionException re) {
		_localctx.exception = re;
		_errHandler.reportError(this, re);
		_errHandler.recover(this, re);
	}
	finally {
		exitRule();
	}
	return _localctx;
}
 

public AtnWrapper(ATN atn) {
    this.atn = atn;
}
 

@Override
public ATN getATN() {
	return _ATN;
}
 

/** {@inheritDoc} */
@Override public ATN getATN() {
    return _ATN;
}
 

/** {@inheritDoc} */
@Override public ATN getATN() {
    return _ATN;
}
 

@Override
public ATN getATN() {
    return _ATN;
}
 

@Override
public ATN getATN() {
    return _ATN;
}
 

public PositionAdjustingLexerATNSimulator(Lexer recog, ATN atn) {
    super(recog, atn);
}
 

public LeftRecursionDetector(Grammar g, ATN atn) {
	this.g = g;
	this.atn = atn;
}