import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
/** Walk ancestors of this node until we find ALT with
 *  alt!=null or leftRecursiveAltInfo!=null. Then grab label if any.
 *  If not a rule element, just returns null.
 */
public String getAltLabel() {
	List<? extends Tree> ancestors = this.getAncestors();
	if ( ancestors==null ) return null;
	for (int i=ancestors.size()-1; i>=0; i--) {
		GrammarAST p = (GrammarAST)ancestors.get(i);
		if ( p.getType()== ANTLRParser.ALT ) {
			AltAST a = (AltAST)p;
			if ( a.altLabel!=null ) return a.altLabel.getText();
			if ( a.leftRecursiveAltInfo!=null ) {
				return a.leftRecursiveAltInfo.altLabel;
			}
		}
	}
	return null;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public LabelElementPair(Grammar g, GrammarAST label, GrammarAST element, int labelOp) {
    this.label = label;
    this.element = element;
    // compute general case for label type
    if ( element.getFirstDescendantWithType(tokenTypeForTokens)!=null ) {
        if ( labelOp==ANTLRParser.ASSIGN ) type = LabelType.TOKEN_LABEL;
        else type = LabelType.TOKEN_LIST_LABEL;
    }
    else if ( element.getFirstDescendantWithType(ANTLRParser.RULE_REF)!=null ) {
        if ( labelOp==ANTLRParser.ASSIGN ) type = LabelType.RULE_LABEL;
        else type = LabelType.RULE_LIST_LABEL;
    }

    // now reset if lexer and string
    if ( g.isLexer() ) {
        if ( element.getFirstDescendantWithType(ANTLRParser.STRING_LITERAL)!=null ) {
            if ( labelOp==ANTLRParser.ASSIGN ) type = LabelType.LEXER_STRING_LABEL;
        }
    }
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
protected void _createATN(Collection<Rule> rules) {
	createRuleStartAndStopATNStates();

	GrammarASTAdaptor adaptor = new GrammarASTAdaptor();
	for (Rule r : rules) {
		// find rule's block
		GrammarAST blk = (GrammarAST)r.ast.getFirstChildWithType(ANTLRParser.BLOCK);
		CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk);
		ATNBuilder b = new ATNBuilder(nodes,this);
		try {
			setCurrentRuleName(r.name);
			Handle h = b.ruleBlock(null);
			rule(r.ast, r.name, h);
		}
		catch (RecognitionException re) {
			ErrorManager.fatalInternalError("bad grammar AST structure", re);
		}
	}
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public List<SrcOp> set(GrammarAST setAST, GrammarAST labelAST, boolean invert) {
	MatchSet matchOp;
	if ( invert ) matchOp = new MatchNotSet(this, setAST);
	else matchOp = new MatchSet(this, setAST);
	if ( labelAST!=null ) {
		String label = labelAST.getText();
		RuleFunction rf = getCurrentRuleFunction();
		if ( labelAST.parent.getType() == ANTLRParser.PLUS_ASSIGN ) {
			defineImplicitLabel(setAST, matchOp);
			TokenListDecl l = getTokenListLabelDecl(label);
			rf.addContextDecl(setAST.getAltLabel(), l);
		}
		else {
			Decl d = getTokenLabelDecl(label);
			matchOp.labels.add(d);
			rf.addContextDecl(setAST.getAltLabel(), d);
		}
	}
	if ( controller.needsImplicitLabel(setAST, matchOp) ) defineImplicitLabel(setAST, matchOp);
	AddToLabelList listLabelOp = getAddToListOpIfListLabelPresent(matchOp, labelAST);
	return list(matchOp, listLabelOp);
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public List<SrcOp> wildcard(GrammarAST ast, GrammarAST labelAST) {
	Wildcard wild = new Wildcard(this, ast);
	// TODO: dup with tokenRef
	if ( labelAST!=null ) {
		String label = labelAST.getText();
		Decl d = getTokenLabelDecl(label);
		wild.labels.add(d);
		getCurrentRuleFunction().addContextDecl(ast.getAltLabel(), d);
		if ( labelAST.parent.getType() == ANTLRParser.PLUS_ASSIGN ) {
			TokenListDecl l = getTokenListLabelDecl(label);
			getCurrentRuleFunction().addContextDecl(ast.getAltLabel(), l);
		}
	}
	if ( controller.needsImplicitLabel(ast, wild) ) defineImplicitLabel(ast, wild);
	AddToLabelList listLabelOp = getAddToListOpIfListLabelPresent(wild, labelAST);
	return list(wild, listLabelOp);
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public Choice getChoiceBlock(BlockAST blkAST, List<CodeBlockForAlt> alts, GrammarAST labelAST) {
	int decision = ((DecisionState)blkAST.atnState).decision;
	Choice c;
	if ( !g.tool.force_atn && AnalysisPipeline.disjoint(g.decisionLOOK.get(decision)) ) {
		c = getLL1ChoiceBlock(blkAST, alts);
	}
	else {
		c = getComplexChoiceBlock(blkAST, alts);
	}

	if ( labelAST!=null ) { // for x=(...), define x or x_list
		String label = labelAST.getText();
		Decl d = getTokenLabelDecl(label);
		c.label = d;
		getCurrentRuleFunction().addContextDecl(labelAST.getAltLabel(), d);
		if ( labelAST.parent.getType() == ANTLRParser.PLUS_ASSIGN  ) {
			String listLabel = gen.getTarget().getListLabel(label);
			TokenListDecl l = new TokenListDecl(this, listLabel);
			getCurrentRuleFunction().addContextDecl(labelAST.getAltLabel(), l);
		}
	}

	return c;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public Choice getEBNFBlock(GrammarAST ebnfRoot, List<CodeBlockForAlt> alts) {
	if (!g.tool.force_atn) {
		int decision;
		if ( ebnfRoot.getType()==ANTLRParser.POSITIVE_CLOSURE ) {
			decision = ((PlusLoopbackState)ebnfRoot.atnState).decision;
		}
		else if ( ebnfRoot.getType()==ANTLRParser.CLOSURE ) {
			decision = ((StarLoopEntryState)ebnfRoot.atnState).decision;
		}
		else {
			decision = ((DecisionState)ebnfRoot.atnState).decision;
		}

		if ( AnalysisPipeline.disjoint(g.decisionLOOK.get(decision)) ) {
			return getLL1EBNFBlock(ebnfRoot, alts);
		}
	}

	return getComplexEBNFBlock(ebnfRoot, alts);
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public Choice getLL1EBNFBlock(GrammarAST ebnfRoot, List<CodeBlockForAlt> alts) {
	int ebnf = 0;
	if ( ebnfRoot!=null ) ebnf = ebnfRoot.getType();
	Choice c = null;
	switch ( ebnf ) {
		case ANTLRParser.OPTIONAL :
			if ( alts.size()==1 ) c = new LL1OptionalBlockSingleAlt(this, ebnfRoot, alts);
			else c = new LL1OptionalBlock(this, ebnfRoot, alts);
			break;
		case ANTLRParser.CLOSURE :
			if ( alts.size()==1 ) c = new LL1StarBlockSingleAlt(this, ebnfRoot, alts);
			else c = getComplexEBNFBlock(ebnfRoot, alts);
			break;
		case ANTLRParser.POSITIVE_CLOSURE :
			if ( alts.size()==1 ) c = new LL1PlusBlockSingleAlt(this, ebnfRoot, alts);
			else c = getComplexEBNFBlock(ebnfRoot, alts);
			break;
	}
	return c;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public Choice getComplexEBNFBlock(GrammarAST ebnfRoot, List<CodeBlockForAlt> alts) {
	int ebnf = 0;
	if ( ebnfRoot!=null ) ebnf = ebnfRoot.getType();
	Choice c = null;
	switch ( ebnf ) {
		case ANTLRParser.OPTIONAL :
			c = new OptionalBlock(this, ebnfRoot, alts);
			break;
		case ANTLRParser.CLOSURE :
			c = new StarBlock(this, ebnfRoot, alts);
			break;
		case ANTLRParser.POSITIVE_CLOSURE :
			c = new PlusBlock(this, ebnfRoot, alts);
			break;
	}
	return c;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public void buildNormalRuleFunction(Rule r, RuleFunction function) {
	CodeGenerator gen = delegate.getGenerator();
	// TRIGGER factory functions for rule alts, elements
	GrammarASTAdaptor adaptor = new GrammarASTAdaptor(r.ast.token.getInputStream());
	GrammarAST blk = (GrammarAST)r.ast.getFirstChildWithType(ANTLRParser.BLOCK);
	CommonTreeNodeStream nodes = new CommonTreeNodeStream(adaptor,blk);
	walker = new SourceGenTriggers(nodes, this);
	try {
		// walk AST of rule alts/elements
		function.code = DefaultOutputModelFactory.list(walker.block(null, null));
		function.hasLookaheadBlock = walker.hasLookaheadBlock;
	}
	catch (org.antlr.runtime.RecognitionException e){
		e.printStackTrace(System.err);
	}

	function.ctxType = gen.getTarget().getRuleFunctionContextStructName(function);

	function.postamble = rulePostamble(function, r);
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public static Map<Rule, Set<Rule>> getRuleDependencies(Grammar g, Collection<Rule> rules) {
	Map<Rule, Set<Rule>> dependencies = new HashMap<Rule, Set<Rule>>();

	for (Rule r : rules) {
		List<GrammarAST> tokenRefs = r.ast.getNodesWithType(ANTLRParser.TOKEN_REF);
		for (GrammarAST tref : tokenRefs) {
			Set<Rule> calls = dependencies.get(r);
			if ( calls==null ) {
				calls = new HashSet<Rule>();
				dependencies.put(r, calls);
			}
			calls.add(g.getRule(tref.getText()));
		}
	}

	return dependencies;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public void discoverLexerRule(RuleAST rule, GrammarAST ID, List<GrammarAST> modifiers,
							  GrammarAST block)
{
	checkInvalidRuleDef(ID.token);

	if (modifiers != null) {
		for (GrammarAST tree : modifiers) {
			if (tree.getType() == ANTLRParser.FRAGMENT) {
				inFragmentRule = true;
			}
		}
	}

	if (!inFragmentRule) {
		nonFragmentRuleCount++;
	}
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
void checkImport(Token importID) {
	Grammar delegate = g.getImportedGrammar(importID.getText());
	if ( delegate==null ) return;
	List<Integer> validDelegators = validImportTypes.get(delegate.getType());
	if ( validDelegators!=null && !validDelegators.contains(g.getType()) ) {
		g.tool.errMgr.grammarError(ErrorType.INVALID_IMPORT,
								   g.fileName,
								   importID,
								   g, delegate);
	}
	if ( g.isCombined() &&
		 (delegate.name.equals(g.name+Grammar.getGrammarTypeToFileNameSuffix(ANTLRParser.LEXER))||
		  delegate.name.equals(g.name+Grammar.getGrammarTypeToFileNameSuffix(ANTLRParser.PARSER))) )
	{
		g.tool.errMgr.grammarError(ErrorType.IMPORT_NAME_CLASH,
								   g.fileName,
								   importID,
								   g, delegate);
	}
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public void checkRuleArgs(Grammar g, List<GrammarAST> rulerefs) {
	if ( rulerefs==null ) return;
	for (GrammarAST ref : rulerefs) {
		String ruleName = ref.getText();
		Rule r = g.getRule(ruleName);
		GrammarAST arg = (GrammarAST)ref.getFirstChildWithType(ANTLRParser.ARG_ACTION);
		if ( arg!=null && (r==null || r.args==null) ) {
			errMgr.grammarError(ErrorType.RULE_HAS_NO_ARGS,
									  g.fileName, ref.token, ruleName);

		}
		else if ( arg==null && (r!=null&&r.args!=null) ) {
			errMgr.grammarError(ErrorType.MISSING_RULE_ARGS,
									  g.fileName, ref.token, ruleName);
		}
	}
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public static Map<String,GrammarAST> getUnusedParserRules(Grammar g) {
		if ( g.ast==null || g.isLexer() ) return null;
		List<GrammarAST> ruleNodes = g.ast.getNodesWithTypePreorderDFS(IntervalSet.of(ANTLRParser.RULE_REF));
		// in case of errors, we walk AST ourselves
		// ANTLR's Grammar object might have bailed on rule defs etc...
		Set<String> ruleRefs = new HashSet<String>();
		Map<String,GrammarAST> ruleDefs = new HashMap<String,GrammarAST>();
		for (GrammarAST x : ruleNodes) {
			if ( x.getParent().getType()==ANTLRParser.RULE ) {
//				System.out.println("def "+x);
				ruleDefs.put(x.getText(), x);
			}
			else if ( x instanceof RuleRefAST ) {
				RuleRefAST r = (RuleRefAST) x;
//				System.out.println("ref "+r);
				ruleRefs.add(r.getText());
			}
		}
		ruleDefs.keySet().removeAll(ruleRefs);
		return ruleDefs;
	}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
@Override
public Grammar createGrammar(GrammarRootAST ast) {
    final Grammar g;

    LOGGER.debug("ast " + ast.getGrammarName());

    if (ast.grammarType == ANTLRParser.LEXER) {
        g = new InmemantlrLexerGrammar(this, ast);
    } else {
        g = new InmemantlrGrammar(this, ast);
    }
    // ensure each node has pointer to surrounding grammar
    GrammarTransformPipeline.setGrammarPtr(g, ast);
    return g;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
/** Manually get option node from tree; return null if no defined. */
public static GrammarAST findOptionValueAST(GrammarRootAST root, String option) {
	GrammarAST options = (GrammarAST)root.getFirstChildWithType(ANTLRParser.OPTIONS);
	if ( options!=null && options.getChildCount() > 0 ) {
		for (Object o : options.getChildren()) {
			GrammarAST c = (GrammarAST)o;
			if ( c.getType() == ANTLRParser.ASSIGN &&
				 c.getChild(0).getText().equals(option) )
			{
				return (GrammarAST)c.getChild(1);
			}
		}
	}
	return null;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public static void augmentTokensWithOriginalPosition(final Grammar g, GrammarAST tree) {
	if ( tree==null ) return;

	List<GrammarAST> optionsSubTrees = tree.getNodesWithType(ANTLRParser.ELEMENT_OPTIONS);
	for (int i = 0; i < optionsSubTrees.size(); i++) {
		GrammarAST t = optionsSubTrees.get(i);
		CommonTree elWithOpt = t.parent;
		if ( elWithOpt instanceof GrammarASTWithOptions ) {
			Map<String, GrammarAST> options = ((GrammarASTWithOptions) elWithOpt).getOptions();
			if ( options.containsKey(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME) ) {
				GrammarToken newTok = new GrammarToken(g, elWithOpt.getToken());
				newTok.originalTokenIndex = Integer.valueOf(options.get(LeftRecursiveRuleTransformer.TOKENINDEX_OPTION_NAME).getText());
				elWithOpt.token = newTok;

				GrammarAST originalNode = g.ast.getNodeWithTokenIndex(newTok.getTokenIndex());
				if (originalNode != null) {
					// update the AST node start/stop index to match the values
					// of the corresponding node in the original parse tree.
					elWithOpt.setTokenStartIndex(originalNode.getTokenStartIndex());
					elWithOpt.setTokenStopIndex(originalNode.getTokenStopIndex());
				}
				else {
					// the original AST node could not be located by index;
					// make sure to assign valid values for the start/stop
					// index so toTokenString will not throw exceptions.
					elWithOpt.setTokenStartIndex(newTok.getTokenIndex());
					elWithOpt.setTokenStopIndex(newTok.getTokenIndex());
				}
			}
		}
	}
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
public ActionAST getLexerAction() {
	Tree blk = getFirstChildWithType(ANTLRParser.BLOCK);
	if ( blk.getChildCount()==1 ) {
		Tree onlyAlt = blk.getChild(0);
		Tree lastChild = onlyAlt.getChild(onlyAlt.getChildCount()-1);
		if ( lastChild.getType()==ANTLRParser.ACTION ) {
			return (ActionAST)lastChild;
		}
	}
	return null;
}
 

import org.antlr.v4.parse.ANTLRParser; //导入依赖的package包/类
/** Given a grammar type, what should be the default action scope?
 *  If I say @members in a COMBINED grammar, for example, the
 *  default scope should be "parser".
 */
public String getDefaultActionScope() {
    switch ( getType() ) {
        case ANTLRParser.LEXER :
            return "lexer";
        case ANTLRParser.PARSER :
        case ANTLRParser.COMBINED :
            return "parser";
    }
    return null;
}