Examples with GrammarRootAST org.antlr.v4.tool.ast.GrammarRootAST used on opensource projects

Example 6 with GrammarRootAST

use of org.antlr.v4.tool.ast.GrammarRootAST in project antlr4 by antlr.

the class Tool method loadGrammar.

/** Convenience method to load and process an ANTLR grammar. Useful
	 *  when creating interpreters.  If you need to access to the lexer
	 *  grammar created while processing a combined grammar, use
	 *  getImplicitLexer() on returned grammar.
	 */
public Grammar loadGrammar(String fileName) {
    GrammarRootAST grammarRootAST = parseGrammar(fileName);
    final Grammar g = createGrammar(grammarRootAST);
    g.fileName = fileName;
    process(g, false);
    return g;
}

Example 7 with GrammarRootAST

use of org.antlr.v4.tool.ast.GrammarRootAST in project antlr4 by antlr.

the class Tool method sortGrammarByTokenVocab.

public List<GrammarRootAST> sortGrammarByTokenVocab(List<String> fileNames) {
    //		System.out.println(fileNames);
    Graph<String> g = new Graph<String>();
    List<GrammarRootAST> roots = new ArrayList<GrammarRootAST>();
    for (String fileName : fileNames) {
        GrammarAST t = parseGrammar(fileName);
        // came back as error node
        if (t == null || t instanceof GrammarASTErrorNode)
            continue;
        if (((GrammarRootAST) t).hasErrors)
            continue;
        GrammarRootAST root = (GrammarRootAST) t;
        roots.add(root);
        root.fileName = fileName;
        String grammarName = root.getChild(0).getText();
        GrammarAST tokenVocabNode = findOptionValueAST(root, "tokenVocab");
        // Make grammars depend on any tokenVocab options
        if (tokenVocabNode != null) {
            String vocabName = tokenVocabNode.getText();
            // Strip quote characters if any
            int len = vocabName.length();
            int firstChar = vocabName.charAt(0);
            int lastChar = vocabName.charAt(len - 1);
            if (len >= 2 && firstChar == '\'' && lastChar == '\'') {
                vocabName = vocabName.substring(1, len - 1);
            }
            // If the name contains a path delimited by forward slashes,
            // use only the part after the last slash as the name
            int lastSlash = vocabName.lastIndexOf('/');
            if (lastSlash >= 0) {
                vocabName = vocabName.substring(lastSlash + 1);
            }
            g.addEdge(grammarName, vocabName);
        }
        // add cycle to graph so we always process a grammar if no error
        // even if no dependency
        g.addEdge(grammarName, grammarName);
    }
    List<String> sortedGrammarNames = g.sort();
    //		System.out.println("sortedGrammarNames="+sortedGrammarNames);
    List<GrammarRootAST> sortedRoots = new ArrayList<GrammarRootAST>();
    for (String grammarName : sortedGrammarNames) {
        for (GrammarRootAST root : roots) {
            if (root.getGrammarName().equals(grammarName)) {
                sortedRoots.add(root);
                break;
            }
        }
    }
    return sortedRoots;
}

Example 8 with GrammarRootAST

use of org.antlr.v4.tool.ast.GrammarRootAST in project antlr4 by antlr.

the class Tool method processGrammarsOnCommandLine.

public void processGrammarsOnCommandLine() {
    List<GrammarRootAST> sortedGrammars = sortGrammarByTokenVocab(grammarFiles);
    for (GrammarRootAST t : sortedGrammars) {
        final Grammar g = createGrammar(t);
        g.fileName = t.fileName;
        if (gen_dependencies) {
            BuildDependencyGenerator dep = new BuildDependencyGenerator(this, g);
            /*
					List outputFiles = dep.getGeneratedFileList();
					List dependents = dep.getDependenciesFileList();
					System.out.println("output: "+outputFiles);
					System.out.println("dependents: "+dependents);
					 */
            System.out.println(dep.getDependencies().render());
        } else if (errMgr.getNumErrors() == 0) {
            process(g, true);
        }
    }
}

Example 9 with GrammarRootAST

use of org.antlr.v4.tool.ast.GrammarRootAST in project antlr4 by antlr.

the class Tool method parse.

public GrammarRootAST parse(String fileName, CharStream in) {
    try {
        GrammarASTAdaptor adaptor = new GrammarASTAdaptor(in);
        ToolANTLRLexer lexer = new ToolANTLRLexer(in, this);
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        lexer.tokens = tokens;
        ToolANTLRParser p = new ToolANTLRParser(tokens, this);
        p.setTreeAdaptor(adaptor);
        try {
            ParserRuleReturnScope r = p.grammarSpec();
            GrammarAST root = (GrammarAST) r.getTree();
            if (root instanceof GrammarRootAST) {
                ((GrammarRootAST) root).hasErrors = lexer.getNumberOfSyntaxErrors() > 0 || p.getNumberOfSyntaxErrors() > 0;
                assert ((GrammarRootAST) root).tokenStream == tokens;
                if (grammarOptions != null) {
                    ((GrammarRootAST) root).cmdLineOptions = grammarOptions;
                }
                return ((GrammarRootAST) root);
            }
        } catch (v3TreeGrammarException e) {
            errMgr.grammarError(ErrorType.V3_TREE_GRAMMAR, fileName, e.location);
        }
        return null;
    } catch (RecognitionException re) {
        // TODO: do we gen errors now?
        ErrorManager.internalError("can't generate this message at moment; antlr recovers");
    }
    return null;
}

Example 10 with GrammarRootAST

use of org.antlr.v4.tool.ast.GrammarRootAST in project antlr4 by antlr.

the class Tool method process.

/** To process a grammar, we load all of its imported grammars into
		subordinate grammar objects. Then we merge the imported rules
		into the root grammar. If a root grammar is a combined grammar,
		we have to extract the implicit lexer. Once all this is done, we
		process the lexer first, if present, and then the parser grammar
	 */
public void process(Grammar g, boolean gencode) {
    g.loadImportedGrammars();
    GrammarTransformPipeline transform = new GrammarTransformPipeline(g, this);
    transform.process();
    LexerGrammar lexerg;
    GrammarRootAST lexerAST;
    if (g.ast != null && g.ast.grammarType == ANTLRParser.COMBINED && !g.ast.hasErrors) {
        // alters g.ast
        lexerAST = transform.extractImplicitLexer(g);
        if (lexerAST != null) {
            if (grammarOptions != null) {
                lexerAST.cmdLineOptions = grammarOptions;
            }
            lexerg = new LexerGrammar(this, lexerAST);
            lexerg.fileName = g.fileName;
            lexerg.originalGrammar = g;
            g.implicitLexer = lexerg;
            lexerg.implicitLexerOwner = g;
            processNonCombinedGrammar(lexerg, gencode);
        //				System.out.println("lexer tokens="+lexerg.tokenNameToTypeMap);
        //				System.out.println("lexer strings="+lexerg.stringLiteralToTypeMap);
        }
    }
    if (g.implicitLexer != null)
        g.importVocab(g.implicitLexer);
    //		System.out.println("tokens="+g.tokenNameToTypeMap);
    //		System.out.println("strings="+g.stringLiteralToTypeMap);
    processNonCombinedGrammar(g, gencode);
}