mbtarranger.languages.arrange.Glue.java Source code

Introduction

Here is the source code for mbtarranger.languages.arrange.Glue.java

Source

/*******************************************************************************
 * Copyright (c) 2013, 2014 ETAS GmbH.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 * Dennis Eder (ETAS GmbH) - initial API and implementation and/or initial documentation
 *******************************************************************************/
package mbtarranger.languages.arrange;

import java.io.File;
import java.io.IOException;

import mbtarranger.MbtArrangerRuntimeException;
import mbtarranger.languages.arrange.ast1.AST;
import mbtarranger.languages.arrange.gen.ArrangeLexer;
import mbtarranger.languages.arrange.gen.ArrangeParser;

import org.antlr.v4.runtime.ANTLRFileStream;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.ParserRuleContext;
import org.antlr.v4.runtime.tree.ParseTree;
import org.antlr.v4.runtime.tree.ParseTreeListener;
import org.antlr.v4.runtime.tree.ParseTreeVisitor;

public class Glue {
    protected static <T_Pass extends ParseTreeListener> T_Pass extractSinglePass(File osPath, Class<T_Pass> cls) {
        ArrangeLexer lexer;
        try {
            lexer = new ArrangeLexer(new ANTLRFileStream(osPath.getAbsolutePath()));

            lexer.removeErrorListeners();
            ErrorListener errListener = new ErrorListener(osPath);
            lexer.addErrorListener(errListener);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            ArrangeParser parser = new ArrangeParser(tokens);
            parser.setBuildParseTree(true);
            parser.removeErrorListeners();
            parser.addErrorListener(errListener);
            T_Pass pass1;
            try {
                pass1 = cls.newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                throw new MbtArrangerRuntimeException("misdesigned generics using reflection to type instantiation",
                        e);
            }
            parser.setBuildParseTree(true);
            parser.addParseListener(pass1);
            try {
                parser.root();
            } catch (NullPointerException nulex) {
                throw new MbtArrangerRuntimeException(
                        /*
                         * NullPointerExceptions caught here mean, that the parser needs
                         * additional logic to handle grammar robustly
                         */
                        "ARRANGE parser failed", nulex);
            }
            return pass1;
        } catch (IOException e1) {
            throw new MbtArrangerRuntimeException(e1);
        }
    }

    protected static <T_Pass extends ParseTreeVisitor<AST<ParserRuleContext>>> T_Pass extractSinglePassVisiting(
            File osPath, Class<T_Pass> cls) {
        ArrangeLexer lexer;
        try {
            lexer = new ArrangeLexer(new ANTLRFileStream(osPath.getAbsolutePath()));

            lexer.removeErrorListeners();
            ErrorListener errListener = new ErrorListener(osPath);
            lexer.addErrorListener(errListener);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            ArrangeParser parser = new ArrangeParser(tokens);
            parser.setBuildParseTree(true);
            parser.removeErrorListeners();
            parser.addErrorListener(errListener);
            T_Pass pass1;
            try {
                pass1 = cls.newInstance();
            } catch (InstantiationException | IllegalAccessException e) {
                throw new MbtArrangerRuntimeException("misdesigned generics using reflection to type instantiation",
                        e);
            }
            parser.setBuildParseTree(true);
            try {
                ParseTree tree = parser.root();
                pass1.visit(tree);
            } catch (NullPointerException nulex) {
                throw new MbtArrangerRuntimeException(
                        /*
                         * NullPointerExceptions caught here mean, that the parser needs
                         * additional logic to handle grammar robustly
                         */
                        "ARRANGE parser failed", nulex);
            }
            return pass1;
        } catch (IOException e1) {
            throw new MbtArrangerRuntimeException(e1);
        }
    }

    // --------- AST extractions -------

    public static ExtractArrange extractArrange(File osPath) {
        return extractSinglePassVisiting(osPath, ExtractArrange.class);
    }

    // --------- Referencings extractions -------

    public static ExtractTest2LtlReferencings_Pass1 extractTest2LtlReferencings(File osPath) {
        return extractSinglePass(osPath, ExtractTest2LtlReferencings_Pass1.class);
    }

    public static ExtractTest2TraceReferencings_Pass1 extractTest2TraceReferencings(File osPath) {
        return extractSinglePass(osPath, ExtractTest2TraceReferencings_Pass1.class);
    }

}