Example usage for org.antlr.v4.runtime CommonTokenStream CommonTokenStream

Introduction

In this page you can find the example usage for org.antlr.v4.runtime CommonTokenStream CommonTokenStream.

Prototype

public CommonTokenStream(TokenSource tokenSource)

Source Link

Document

Constructs a new CommonTokenStream using the specified token source and the default token channel ( Token#DEFAULT_CHANNEL ).

Usage

From source file:de.dfki.resc28.ole.resources.Repository.java

License:Open Source License

public Response createAsset(
        @HeaderParam(HttpHeaders.ACCEPT) @DefaultValue(Constants.CT_TEXT_TURTLE) final String acceptType,
        String fileUri) {//www .  ja v a2 s. c  o m
    try {
        @SuppressWarnings("resource")
        CloseableHttpClient http = ProxyConfigurator.createHttpClient();
        HttpGet request = new HttpGet(fileUri);

        request.setHeader("Accept", "text/plain"); // TODO: set accept-header from inputFormat!
        HttpResponse response = (HttpResponse) http.execute(request);

        if (response.getStatusLine().getStatusCode() == 200) {
            DataInputStream input = new DataInputStream(
                    new BufferedInputStream(response.getEntity().getContent()));
            String ID = UUID.randomUUID().toString();
            AssetListener assetListener = new AssetListener(ID, fileUri);
            DistributionListener distributionListener = new DistributionListener(ID, fileUri);

            LDrawLexer lexer = new LDrawLexer(new ANTLRInputStream(input));
            LDrawParser parser = new LDrawParser(new CommonTokenStream(lexer));
            ParseTreeWalker walker = new ParseTreeWalker();
            ParseTree tree = parser.file();
            walker.walk(assetListener, tree);
            walker.walk(distributionListener, tree);

            Model assetModel = assetListener.getModel();
            fGraphStore.addToNamedGraph(Util.joinPath(Server.fAssetBaseUri, ID), assetModel);

            Model distributionModel = distributionListener.getModel();
            fGraphStore.addToNamedGraph(Util.joinPath(Server.fDistributionBaseUri, ID), distributionModel);

            final Model repoModel = ModelFactory.createDefaultModel();//fGraphStore.getNamedGraph(Util.joinPath(Server.fBaseURI, "repo"));
            Resource repo = repoModel.getResource(Util.joinPath(Server.fBaseURI, "repo"));
            Resource asset = repoModel.createResource(Util.joinPath(Server.fBaseURI, "repo/assets/", ID));
            repoModel.add(repo, DCAT.dataset, asset);
            fGraphStore.addToNamedGraph(Util.joinPath(Server.fBaseURI, "repo"), repoModel);

            return Response.ok().status(Status.CREATED).contentLocation(new URI(asset.getURI())).build();

        } else {
            return Response.status(Status.INTERNAL_SERVER_ERROR).build();
        }
    } catch (Exception e) {
        throw new WebApplicationException();
    }
}

From source file:de.epdv.plugin.netbeans.lang.go.parser.GLParser.java

@Override
public void parse(Snapshot snapshot, Task task, SourceModificationEvent event) {
    this.snapshot = snapshot;
    ANTLRInputStream input = new ANTLRInputStream(snapshot.getText().toString());
    Lexer lexer = new GolangLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    goParser = new GolangParser(tokens);
    goParser.removeErrorListeners();/*from ww w  .  j  a v a 2s.  co m*/
    errors = new CollectingErrorsListener(snapshot.getSource().getFileObject());
    goParser.addErrorListener(errors);
    try {
        goParser.sourceFile();
    } catch (RuntimeException ex) {
        Exceptions.printStackTrace(ex);
    }
}

From source file:de.huberlin.cuneiform.dag.CuneiformDag.java

License:Apache License

private void addInputStream(CharStream stream) {

    CuneiformLexer lexer;//from   w  ww.ja v a  2  s .c om
    CuneiformParser parser;
    String declare;
    DefTaskNode defTaskNode;
    DefTask defTask;

    if (stream == null)
        throw new NullPointerException("Input string must not be null.");

    // parse input file
    lexer = new CuneiformLexer(stream);
    parser = new CuneiformParser(new CommonTokenStream(lexer));
    parser.script();

    if (parser.hasError())
        throw new RuntimeException("Parser returned with errors.");

    declare = parser.getDeclare();
    if (declare == null)
        throw new NullPointerException("Declare must not be null.");

    wfNameSet.add(declare);

    // add junctions for tasks
    for (String deftaskName : parser.getDefTaskNameSet()) {

        if (deftaskName == null)
            throw new NullPointerException("Deftask name must not be null.");

        defTask = parser.getDefTask(deftaskName);

        // create new deftask junction
        defTaskNode = new DefTaskNode(declare, defTask, parser.getDefTaskBody(deftaskName));

        // add the DefTaskJunction to the set of workflow elements
        elementSet.add(defTaskNode);
    }

    // connect assignments
    for (Assign assign : parser.getAssignList()) {

        if (assign == null)
            throw new NullPointerException("Assignment must not be null.");

        resolveAssign(parser, assign);
    }

    // mark workflow targets as terminals
    for (String varName : parser.getTargetSet()) {

        if (varName == null)
            throw new NullPointerException("Target variable name must not be null.");

        terminalSet.add(getNamedJunction(varName));
    }

}

From source file:de.huberlin.cuneiform.dax.repl.DaxRepl.java

License:Apache License

public static DaxSemanticModelListener process(String input) {

    ANTLRInputStream instream;/*from w w  w  . j  a v  a  2 s . c om*/
    DaxLexer lexer;
    CommonTokenStream tokenStream;
    DaxParser parser;
    ParseTree tree;
    ParseTreeWalker walker;
    DaxSemanticModelListener adag;

    walker = new ParseTreeWalker();

    // parse original content
    instream = new ANTLRInputStream(input);

    lexer = new DaxLexer(instream);
    lexer.removeErrorListeners();

    tokenStream = new CommonTokenStream(lexer);

    parser = new DaxParser(tokenStream);
    parser.removeErrorListeners();

    adag = new DaxSemanticModelListener();
    lexer.addErrorListener(adag);
    parser.addErrorListener(adag);

    tree = parser.adag();

    walker.walk(adag, tree);

    return adag;
}

From source file:de.huberlin.cuneiform.language.BaseCuneiformParser.java

License:Apache License

protected void importFile(String id) throws IOException {

    ANTLRFileStream stream;/*w ww .  j  a  v  a2 s  .  co  m*/
    CuneiformLexer lexer;
    CuneiformParser parser;
    String s;

    try {
        // create parser
        stream = new ANTLRFileStream(id);
        lexer = new CuneiformLexer(stream);
        parser = new CuneiformParser(new CommonTokenStream(lexer));

        // copy everything that is relevant into the new parser
        parser.addLabel(labelMap);
        parser.addBlackListItem(blackList);
        parser.addDefTask(defTaskMap);
        parser.addAssign(assignList);
        parser.addDefMacro(defMacroMap);
        parser.addExtend(extendList);

        // run it
        parser.script();

        if (parser.hasError()) {

            s = parser.getDeclare();
            if (s == null)
                s = id;

            reportError(ERROR_IMPORT, "Errors persist in '" + s + "'");
            return;
        }

        // merge models
        labelMap = parser.getModifiableLabelMap();
        blackList = parser.getModifiableBlackList();
        defTaskMap = parser.getModifiableDefTaskMap();
        assignList = parser.getModifiableAssignList();
        defMacroMap = parser.getModifiableDefMacroMap();
        extendList = parser.getModifiableExtendList();
    } catch (DuplicateParseException e) {
        // Suppressing duplicate parse
    }

}

From source file:de.huberlin.wbi.cfjava.cuneiform.Workflow.java

License:Apache License

public static Workflow createWorkflow(final String script) {

    ANTLRInputStream input;//from  ww w  . j  av  a  2  s .c o m
    CuneiformLexer lexer;
    CuneiformParser parser;
    CommonTokenStream tokenStream;
    ParseTree tree;
    int nerr;
    WorkflowListener asv;
    ParseTreeWalker walker;

    try (StringReader reader = new StringReader(script)) {

        input = new ANTLRInputStream(reader);
        lexer = new CuneiformLexer(input);
        tokenStream = new CommonTokenStream(lexer);
        parser = new CuneiformParser(tokenStream);
        asv = new WorkflowListener();
        walker = new ParseTreeWalker();

        tree = parser.script();

        nerr = parser.getNumberOfSyntaxErrors();
        if (nerr > 0)
            throw new RuntimeException("Encountered " + nerr + " syntax errors.");

        walker.walk(asv, tree);

        return new LazyWorkflow(asv.getQuery(), asv.getRho(), asv.getGamma());
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

From source file:de.huberlin.wbi.cuneiform.cfide.editor.SyntaxListener.java

License:Apache License

public static void process(JTextPane textPane, StyleConf conf) {

    ANTLRInputStream instream;/* www  .  j  a v a  2s . c  o  m*/
    CuneiformLexer lexer;
    TokenStream tokenStream;
    CuneiformParser parser;
    ParseTree tree;
    SyntaxListener syntaxListener;
    ParseTreeWalker walker;

    walker = new ParseTreeWalker();

    // parse content
    instream = new ANTLRInputStream(textPane.getText());

    lexer = new CuneiformLexer(instream);
    lexer.removeErrorListeners();

    tokenStream = new CommonTokenStream(lexer);

    parser = new CuneiformParser(tokenStream);
    parser.removeErrorListeners();

    syntaxListener = new SyntaxListener(textPane, conf);

    tree = parser.script();
    walker.walk(syntaxListener, tree);
}

From source file:de.huberlin.wbi.cuneiform.core.preprocess.ChannelListener.java

License:Apache License

public static String process(String input) {

    ANTLRInputStream instream;/*from ww  w  . j  a va  2 s  .  c om*/
    CuneiformLexer lexer;
    CommonTokenStream tokenStream;
    CuneiformParser parser;
    ParseTree tree;
    ParseTreeWalker walker;
    ChannelListener channelListener;

    walker = new ParseTreeWalker();

    // parse original content
    instream = new ANTLRInputStream(input);

    lexer = new CuneiformLexer(instream);
    lexer.removeErrorListeners();

    tokenStream = new CommonTokenStream(lexer);

    parser = new CuneiformParser(tokenStream);
    parser.removeErrorListeners();

    channelListener = new ChannelListener(tokenStream);
    lexer.addErrorListener(channelListener);
    parser.addErrorListener(channelListener);

    tree = parser.script();

    walker.walk(channelListener, tree);

    return channelListener.getRewrittenText();
}

From source file:de.huberlin.wbi.cuneiform.core.preprocess.PreListener.java

License:Apache License

public static String process(String input) {

    ANTLRInputStream instream;/*w w w  .jav a  2s  . c  o m*/
    CuneiformLexer lexer;
    CommonTokenStream tokenStream;
    CuneiformParser parser;
    ParseTree tree;
    ParseTreeWalker walker;
    PreListener preListener;

    walker = new ParseTreeWalker();

    // parse original content
    instream = new ANTLRInputStream(input);

    lexer = new CuneiformLexer(instream);
    lexer.removeErrorListeners();

    tokenStream = new CommonTokenStream(lexer);

    parser = new CuneiformParser(tokenStream);
    parser.removeErrorListeners();

    preListener = new PreListener(tokenStream);
    lexer.addErrorListener(preListener);
    parser.addErrorListener(preListener);

    tree = parser.script();

    walker.walk(preListener, tree);

    return preListener.getRewrittenText();
}

From source file:de.huberlin.wbi.cuneiform.core.repl.BaseRepl.java

License:Apache License

public int interpret(String input) {

    String afterPre, afterChannel;
    CuneiformLexer lexer;/*  w  w w  . j  av  a 2  s .co m*/
    CuneiformParser parser;
    TopLevelContext tlc;

    if (input == null)
        throw new NullPointerException("Input string must not be null.");

    // pre-step
    afterPre = PreListener.process(input);

    // channel-step
    afterChannel = ChannelListener.process(afterPre);

    // create lexer
    lexer = new CuneiformLexer(new ANTLRInputStream(afterChannel));
    lexer.removeErrorListeners();
    lexer.addErrorListener(state);

    // create parser
    parser = new CuneiformParser(new CommonTokenStream(lexer));
    parser.removeErrorListeners();
    parser.addErrorListener(state);

    // visit parsed script
    tlc = (TopLevelContext) state.visit(parser.script());

    return interpret(tlc);
}