org.jactr.io.compiler.DefaultCompiler.java Source code

Introduction

Here is the source code for org.jactr.io.compiler.DefaultCompiler.java

Source

/*
 * Copyright (C) 2001-5, Anthony Harrison anh23@pitt.edu This library is free
 * software; you can redistribute it and/or modify it under the terms of the GNU
 * Lesser General Public License as published by the Free Software Foundation;
 * either version 2.1 of the License, or (at your option) any later version.
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details. You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * Created on Apr 21, 2005 by developer
 */

package org.jactr.io.compiler;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

import org.antlr.runtime.tree.CommonTree;
import org.antlr.runtime.tree.CommonTreeNodeStream;
import org.antlr.runtime.tree.TreeNodeStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jactr.io.antlr3.compiler.CompilationWarning;
import org.jactr.io.antlr3.compiler.JACTRCompiler;
import org.jactr.io.parser.CanceledException;

/**
 * @author developer TODO To change the template for this generated type comment
 *         go to Window - Preferences - Java - Code Style - Code Templates
 */
public class DefaultCompiler {
    /**
     * Logger definition
     */

    static private transient Log LOGGER = LogFactory.getLog(DefaultCompiler.class);

    private Map<Integer, Collection<IUnitCompiler>> _unitCompilerMap;

    /**
     * 
     */
    public DefaultCompiler() {
        super();
        _unitCompilerMap = new HashMap<Integer, Collection<IUnitCompiler>>();
        installDefaultCompilers();
    }

    protected void installDefaultCompilers() {
        addCompiler(new ClassVerifyingUnitCompiler());
    }

    public void addCompiler(IUnitCompiler compiler) {
        Collection<Integer> relevantTypes = compiler.getRelevantTypes();
        for (Integer i : relevantTypes) {
            Collection<IUnitCompiler> compilers = _unitCompilerMap.get(i);
            if (compilers == null) {
                compilers = new ArrayList<IUnitCompiler>();
                _unitCompilerMap.put(i, compilers);
            }
            compilers.add(compiler);
        }
    }

    public Collection<IUnitCompiler> getCompilers() {
        Collection<IUnitCompiler> compilers = new HashSet<IUnitCompiler>();
        for (Collection<IUnitCompiler> comps : _unitCompilerMap.values())
            compilers.addAll(comps);
        return compilers;
    }

    public void removeCompiler(IUnitCompiler compiler) {
        Collection<Integer> relevantTypes = compiler.getRelevantTypes();
        for (Integer i : relevantTypes) {
            Collection<IUnitCompiler> compilers = _unitCompilerMap.get(i);
            if (compilers != null)
                compilers.remove(compiler);
        }
    }

    public boolean compile(CommonTree modelTree, Collection<Exception> info, Collection<Exception> warnings,
            Collection<Exception> errors) {
        return compile(modelTree, info, warnings, errors, new CommonTreeNodeStream(modelTree));
    }

    public boolean compile(CommonTree modelTree, Collection<Exception> info, Collection<Exception> warnings,
            Collection<Exception> errors, TreeNodeStream stream) {
        boolean compiled = false;
        JACTRCompiler compiler = null;

        for (IUnitCompiler comp : getCompilers())
            comp.preCompile();

        try {
            compiler = new JACTRCompiler(stream);
            compiler.setUnitCompilerMap(_unitCompilerMap);
            compiler.model();
        } catch (CompilationWarning cw) {
            warnings.add(cw);
        } catch (CanceledException ce) {
            throw ce;
        } catch (Exception e) {
            errors.add(e);
        } finally {
            Collection<Exception> newErrors = compiler.getErrors();
            if (newErrors.size() == 0)
                compiled = true;
            errors.addAll(newErrors);
            warnings.addAll(compiler.getWarnings());

            for (IUnitCompiler comp : getCompilers())
                comp.postCompile();
        }

        return compiled;
    }
}