import org.antlr.v4.Tool; //导入依赖的package包/类
public Grammar(Tool tool, GrammarRootAST ast) {
if ( ast==null ) {
	throw new NullPointerException("ast");
}

if (ast.tokenStream == null) {
	throw new IllegalArgumentException("ast must have a token stream");
}

      this.tool = tool;
      this.ast = ast;
      this.name = (ast.getChild(0)).getText();
this.tokenStream = ast.tokenStream;
this.originalTokenStream = this.tokenStream;

initTokenSymbolTables();
  }
 

import org.antlr.v4.Tool; //导入依赖的package包/类
@Override
public void actionPerformed(AnActionEvent e) {
	if ( e.getProject()==null ) {
		LOG.error("actionPerformed no project for "+e);
		return; // whoa!
	}
	VirtualFile grammarFile = MyActionUtils.getGrammarFileFromEvent(e);
	if ( grammarFile==null ) return;
	LOG.info("actionPerformed "+grammarFile);

	ConfigANTLRPerGrammar configDialog = new ConfigANTLRPerGrammar(e.getProject(), grammarFile.getPath());
	configDialog.getPeer().setTitle("Configure ANTLR Tool "+ Tool.VERSION+" for "+ grammarFile.getName());

	configDialog.show();

	if ( configDialog.getExitCode()==DialogWrapper.OK_EXIT_CODE ) {
		configDialog.saveValues(e.getProject(), grammarFile.getPath());
	}
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public LeftRecursiveRuleAnalyzer(GrammarAST ruleAST,
								 Tool tool, String ruleName, String language)
{
	super(new CommonTreeNodeStream(new GrammarASTAdaptor(ruleAST.token.getInputStream()), ruleAST));
	this.tool = tool;
	this.ruleName = ruleName;
	this.language = language;
	this.tokenStream = ruleAST.g.tokenStream;
	if (this.tokenStream == null) {
		throw new NullPointerException("grammar must have a token stream");
	}

	loadPrecRuleTemplates();
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public STGroup getTemplates() {
	if (templates == null) {
		String version = getVersion();
		if ( version==null ||
			 !RuntimeMetaData.getMajorMinorVersion(version).equals(RuntimeMetaData.getMajorMinorVersion(Tool.VERSION)))
		{
			gen.tool.errMgr.toolError(ErrorType.INCOMPATIBLE_TOOL_AND_TEMPLATES, version, Tool.VERSION, language);
		}
		templates = loadTemplates();
	}

	return templates;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public OutputFile(OutputModelFactory factory, String fileName) {
      super(factory);
      this.fileName = fileName;
      Grammar g = factory.getGrammar();
grammarFileName = g.fileName;
ANTLRVersion = Tool.VERSION;
      TokenLabelType = g.getOptionString("TokenLabelType");
      InputSymbolType = TokenLabelType;
  }
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public String getFilenameFromFirstLineOfGrammar(String line) {
	String fileName = "A" + Tool.GRAMMAR_EXTENSION;
	int grIndex = line.lastIndexOf("grammar");
	int semi = line.lastIndexOf(';');
	if ( grIndex>=0 && semi>=0 ) {
		int space = line.indexOf(' ', grIndex);
		fileName = line.substring(space+1, semi)+Tool.GRAMMAR_EXTENSION;
	}
	if ( fileName.length()==Tool.GRAMMAR_EXTENSION.length() ) fileName = "A" + Tool.GRAMMAR_EXTENSION;
	return fileName;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
/**
 * Writes ANTLR grammar to a temporary folder and generates java classes which are later compiled
 * @param path location of the temporary folder created in compile method.
 * @param grammar grammar which is saved as .g4 file and from which .java file is generated
 * @throws IOException usually thrown when not enough rights at the given location.
 */
private void createSource(Path path, String grammar) throws IOException{
	String tempPath = path.toString();
	
	//Writing .g4 file to temp directory
	Writer writer = null;
       try{
       	Logger.log("Attempting to write grammar to temp directory "+tempPath+".");
       	writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(tempPath + File.separator+"RuntimeGrammar.g4"), "utf-8"));
       	writer.write(grammar);
       }		
       catch (Exception e){
		Logger.log("Could not access temp directory.");
		System.exit(1);
	}finally{
		writer.close();
	}
       
       Logger.log("Finished without errors.\n");
       
       //Add a package name to each class so we would not have issues with naming
       String packageString = "LaTeXEE"+Integer.toString(packageIncrement);
       String[] args2 = {"-o",tempPath+File.separator+packageString,"-encoding","UTF-8","-package",packageString,tempPath+File.separator+"RuntimeGrammar.g4"};
	Tool antlr = new Tool(args2);
	
	//Generate .java files
	antlr.processGrammarsOnCommandLine();
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public static ParserInterpreterData buildFromSnapshot(DocumentSnapshot snapshot) {
    LexerInterpreterData lexerInterpreterData = LexerInterpreterData.buildFromSnapshot(snapshot);
    if (lexerInterpreterData == null) {
        return null;
    }

    List<SyntaxError> syntaxErrors = new ArrayList<>();
    Tool tool = new CustomTool(snapshot);
    tool.errMgr = new CustomErrorManager(tool);
    tool.addListener(new ErrorListener(snapshot, tool, syntaxErrors));
    tool.libDirectory = new File(snapshot.getVersionedDocument().getFileObject().getPath()).getParent();

    ANTLRStringStream stream = new ANTLRStringStream(snapshot.getText());
    stream.name = snapshot.getVersionedDocument().getFileObject().getNameExt();
    GrammarRootAST ast = tool.parse(stream.name, stream);
    Grammar grammar = tool.createGrammar(ast);
    if (grammar instanceof LexerGrammar) {
        return null;
    }

    tool.process(grammar, false);

    ParserInterpreterData data = new ParserInterpreterData();

    // start by filling in the lexer data
    data.lexerInterpreterData = lexerInterpreterData;

    // then fill in the parser data
    data.grammarFileName = grammar.fileName;
    data.serializedAtn = ATNSerializer.getSerializedAsString(grammar.atn, Arrays.asList(grammar.getRuleNames()));
    data.vocabulary = grammar.getVocabulary();
    data.ruleNames = new ArrayList<>(grammar.rules.keySet());

    return data;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public ErrorListener(@NonNull DocumentSnapshot snapshot, @NonNull Tool tool, @NonNull List<SyntaxError> syntaxErrors) {
    Parameters.notNull("snapshot", snapshot);
    Parameters.notNull("tool", tool);
    Parameters.notNull("syntaxErrors", syntaxErrors);

    this.snapshot = snapshot;
    this.tool = tool;
    this.syntaxErrors = syntaxErrors;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
/** Same as loadGrammar(fileName) except import vocab from existing lexer */
private Grammar loadGrammar(final Tool tool, final String fileName,
    final LexerGrammar lexerGrammar) {
  GrammarRootAST grammarRootAST = tool.parseGrammar(fileName);
  final Grammar g = tool.createGrammar(grammarRootAST);
  g.fileName = fileName;
  if (lexerGrammar != null) {
    g.importVocab(lexerGrammar);
  }
  tool.process(g, false);
  return g;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public static Tool createANTLRToolForLoadingGrammars() {
	Tool antlr = new Tool();
	antlr.errMgr = new PluginIgnoreMissingTokensFileErrorManager(antlr);
	antlr.errMgr.setFormat("antlr");
	LoadGrammarsToolListener listener = new LoadGrammarsToolListener(antlr);
	antlr.removeListeners();
	antlr.addListener(listener);
	return antlr;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public static GrammarRootAST parseGrammar(Project project, Tool antlr, String grammarFileName) {
	try {
		String encoding = ConfigANTLRPerGrammar.getProp(project, grammarFileName, ConfigANTLRPerGrammar.PROP_ENCODING, "UTF-8");
		char[] grammarText = Utils.readFile(grammarFileName, encoding);
		String grammarTextS = new String(grammarText).replaceAll("\\r", "");
		ANTLRStringStream in = new ANTLRStringStream(grammarTextS);
		GrammarRootAST t = antlr.parse(grammarFileName, in);
		return t;
	}
	catch (IOException ioe) {
		antlr.errMgr.toolError(ErrorType.CANNOT_OPEN_FILE, ioe, grammarFileName);
	}
	return null;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public InmemantlrGrammar(Tool tool, GrammarRootAST ast) {
    super(tool, ast);
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public InmemantlrLexerGrammar(Tool tool, GrammarRootAST ast) {
    super(tool, ast);
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public BuildDependencyGenerator(Tool tool, Grammar g) {
      this.tool = tool;
this.g = g;
String language = g.getOptionString("language");
generator = new CodeGenerator(tool, g, language);
  }
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public GrammarTransformPipeline(Grammar g, Tool tool) {
	this.g = g;
	this.tool = tool;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public ErrorManager(Tool tool) {
	this.tool = tool;
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public LexerGrammar(Tool tool, GrammarRootAST ast) {
	super(tool, ast);
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
/** convenience method for Tool.loadGrammar() */
public static Grammar load(String fileName) {
	Tool antlr = new Tool();
	return antlr.loadGrammar(fileName);
}
 

import org.antlr.v4.Tool; //导入依赖的package包/类
public ToolANTLRLexer(CharStream input, Tool tool) {
	super(input);
	this.tool = tool;
}