org.antlr.v4.Tool Java Examples

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();
  }
 

@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 = ConfigANTLRPerGrammar.getDialogForm(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());
	}
}
 

public static GrammarRootAST parseGrammar(Project project, Tool antlr, VirtualFile grammarFile) {
	try {
		Document document = FileDocumentManager.getInstance().getDocument(grammarFile);
		String grammarText = document != null ? document.getText() : new String(grammarFile.contentsToByteArray());

		ANTLRStringStream in = new ANTLRStringStream(grammarText);
		in.name = grammarFile.getPath();
		return antlr.parse(grammarFile.getPath(), in);
	}
	catch (IOException ioe) {
		antlr.errMgr.toolError(ErrorType.CANNOT_OPEN_FILE, ioe, grammarFile);
	}
	return null;
}
 

@Nullable
private static Grammar loadGrammar(VirtualFile grammarFile, Project project, Tool antlr) {
	// basically here I am mimicking the loadGrammar() method from Tool
	// so that I can check for an empty AST coming back.
	GrammarRootAST grammarRootAST = parseGrammar(project, antlr, grammarFile);
	if ( grammarRootAST==null ) {
		return null;
	}

	// Create a grammar from the AST so we can figure out what type it is
	Grammar g = antlr.createGrammar(grammarRootAST);
	g.fileName = grammarFile.getPath();

	return g;
}
 

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;
}
 

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();
}
 

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;
}
 

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;
  }
 

public OutputModelWalker(Tool tool,
						 STGroup templates)
{
	this.tool = tool;
	this.templates = templates;
}
 

public RunANTLRListener(Tool tool, ConsoleView console) {
	this.tool = tool;
	this.console = console;
}
 

public PluginIgnoreMissingTokensFileErrorManager(Tool tool) {
	super(tool);
}
 

private Antlr4ToolFacade( Tool tool, Output.Readable buffer )
{
    this.tool = tool;
    this.buffer = buffer;
}
 

public static void assertGeneratesValidParser( String resource ) throws Exception
{
    Output.Readable buffer = stringBuilder();
    Tool antlr = new Tool();
    Antlr4ToolFacade facade = new Antlr4ToolFacade( antlr, buffer );
    try
    {
        Antlr4.write( Fixture.grammarResource( Antlr4.class, resource ), buffer );
    }
    catch ( Throwable e )
    {
        try
        {
            facade.reportFailureIn( "generating grammar" );
        }
        catch ( AssertionError x )
        {
            throw e;
        }
    }
    antlr.addListener( facade );
    GrammarRootAST ast = antlr.parse( resource, new ANTLRReaderStream( buffer.reader() ) );
    if ( ast.hasErrors )
    {
        RuleAST lastGood = lastGoodRule( ast );
        if ( lastGood == null )
        {
            facade.reportFailureIn( "parsing grammar" );
        }
        else
        {
            facade.reportFailureIn(
                    "parsing grammar, after " + lastGood.getRuleName() + " on line " + lastGood.getLine() );
        }
    }
    antlr.process( antlr.createGrammar( ast ), false );
    if ( facade.hasErrors() )
    {
        facade.reportFailureIn( "processing grammar" );
    }
}
 

public CodeGenerator(Tool tool, Grammar g, String language) {
	this.g = g;
	this.tool = tool;
	this.language = language != null ? language : DEFAULT_LANGUAGE;
}
 

public BuildDependencyGenerator(Tool tool, Grammar g) {
      this.tool = tool;
this.g = g;
String language = g.getOptionString("language");
generator = new CodeGenerator(tool, g, language);
  }
 

public ToolANTLRParser(TokenStream input, Tool tool) {
	super(input);
	this.tool = tool;
}
 

public ToolANTLRLexer(CharStream input, Tool tool) {
	super(input);
	this.tool = tool;
}
 

/** convenience method for Tool.loadGrammar() */
public static Grammar load(String fileName) {
	Tool antlr = new Tool();
	return antlr.loadGrammar(fileName);
}
 

public LexerGrammar(Tool tool, GrammarRootAST ast) {
	super(tool, ast);
}
 

public ErrorManager(Tool tool) {
	this.tool = tool;
}
 

public GrammarTransformPipeline(Grammar g, Tool tool) {
	this.g = g;
	this.tool = tool;
}
 

public static void main(String args[]) throws MojoFailureException, MojoExecutionException {

        String userDir = System.getProperty("user.dir");

        String grammarName = userDir + "\\src\\main\\antlr4\\org\\ethereum\\serpent\\Serpent.g4";

        String options[] = {grammarName, "-visitor",  "-package", "org.ethereum.serpent"};
        Tool tool = new Tool(options);
        tool.outputDirectory = userDir + "\\src\\main\\java\\org\\ethereum\\serpent\\";
        tool.processGrammarsOnCommandLine();

//        org.antlr.Tool.main(new String[]{userDir + "\\src\\main\\antlr4\\org\\ethereum\\serpent\\Serpent.g4"});
    }
 

public LoadGrammarsToolListener(Tool tool) { super(tool); } 

public DefaultToolListener(Tool tool) { this.tool = tool; }