source: trunk/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag @ 13781

/*
    Copyright (C) 2009-2017 Modelon AB

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, version 3 of the License.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.lang.InterruptedException;
import java.lang.StringBuilder;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Pattern;
import java.util.zip.ZipOutputStream;
import java.util.zip.ZipEntry;
import java.util.Set;
import java.util.Iterator;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;

import org.jmodelica.util.logging.ModelicaLogger;
import org.jmodelica.util.logging.MemoryLogger;
import org.jmodelica.util.logging.Level;
import org.jmodelica.common.options.AbstractOptionRegistry;
import org.jmodelica.common.options.AbstractOptionRegistry.UnknownOptionException;
import org.jmodelica.util.Arguments;
import org.jmodelica.util.SymbolValueFixer;
import org.jmodelica.util.EnvironmentUtils;
import org.jmodelica.util.exceptions.ModelicaException;
import org.jmodelica.util.exceptions.InternalCompilerError;
import org.jmodelica.util.MemorySpider;
import org.jmodelica.util.exceptions.CompilerException;
import org.jmodelica.util.exceptions.IllegalCompilerArgumentException;
import org.jmodelica.util.exceptions.ModelicaClassNotFoundException;
import org.jmodelica.util.exceptions.JModelicaHomeNotFoundException;
import org.jmodelica.util.exceptions.PackingFailedException;
import org.jmodelica.util.exceptions.CcodeCompilationException;
import org.jmodelica.util.problemHandling.ProblemProducer;
import org.jmodelica.util.PassAndForget;
import org.jmodelica.util.logging.IllegalLogStringException;
import org.jmodelica.util.ErrorCheckType;
import org.jmodelica.util.streams.*;
import org.jmodelica.util.files.*;
import org.jmodelica.util.ccompiler.CCompilerArguments;
import org.jmodelica.util.ccompiler.CCompilerDelegator;
import org.jmodelica.util.ccompiler.CCompilerDelegator.Creator;
import org.jmodelica.util.ccompiler.CCompilerTarget;
import org.jmodelica.util.ccompiler.GccCompilerDelegator;
import org.jmodelica.common.LogContainer;
import org.jmodelica.modelica.compiler.generated.OptionRegistry;

import org.xml.sax.SAXException;

aspect ModelicaCompilerMain {
 
/**
 * 
 * Main compiler class which bundles the tasks needed to compile a Modelica
 * model.
 * <p>
 * There are two usages with this class:
 * -# Compile in one step either from the command line or by calling the static 
 * method <compileModel> in your own class.
 * -# Split compilation into several steps by calling the static methods
 * in your own class.
 * <p>
 * Use (1) for a simple and compact way of compiling a Modelica model. As a
 * minimum, provide the modelfile name and class name as command line arguments.
 * Optional arguments are XML template and c template files which are needed for
 * code generation. If any of these are ommitted no code generation will be
 * performed.
 * <p>
 * Command line example without code generation:<br>
 * <code>org.jmodelica.applications.ModelicaCompiler myModels/models.mo models.model1</code>
 * <p>
 * Command line example with code generation: <br>
 * <code>org.jmodelica.applications.ModelicaCompiler myModels/models.mo models.model1
 * XMLtemplate1.xml XMLtemplate2.xml cppTemplate.cpp</code>
 * <p>
 * Logging can be set with the optional argument -log=d, v, i, w or e where:
 * <p>
 *  - d : log debug, verbose, info, warning and error messages
 *  - v : log verbose, info, warning and error messages
 *  - i : log info, warning and error messages
 *  - w : log warning and error messages
 *  - e : log error messages only (default if the log option is not used)
 * <p>
 * Example with log level set to INFO: <br>
 * <code>org.jmodelica.applications.ModelicaCompiler -log=i myModels/models.mo 
 * models.model1</code>
 * <p>
 * The logs will be printed to standard out.
 * <p>
 * 
 * For method (2), the compilation steps are divided into 4 tasks which can be
 * used via the methods:
 * -# parseModel (source code -> attributed source representation)
 * -# instantiateModel (source representation -> instance model) 
 * -# flattenModel (instance model -> flattened model) 
 * -# generateCode (flattened model -> c code and XML code)
 * <p>
 * They must be called in this order. Use provided methods to get/set logging
 * level.
 * 
 */
public class ModelicaCompiler implements LogContainer {
    
    public static final Level DEFAULT_LEVEL = Level.ERROR;
    protected static ModelicaLogger log = new StreamingLogger(ModelicaCompiler.DEFAULT_LEVEL, System.out);
    
    private CCompilerDelegator delegator = null;
    private String delegator_name = null;
    private OptionRegistry options = null;
    private DiagnosticsGenerator diagGenerator = null;
    
    protected boolean dumpMemoryUse = false;
    protected int dumpMemoryUseMinSize = 2 * 1024;
    protected boolean findFlatToInstanceLinks = false;
    
    // If true, assume that JMODELICA_HOME points to the source folder - for easier debugging while developing
    protected boolean debugSrcIsHome = false;
    public void setDebugSrcIsHome(boolean b) {
        debugSrcIsHome = b;
    }
    
    protected static LinkedList<CompilationHooks> globalHooksList = new LinkedList<>();
    protected LinkedList<CompilationHooks> hooksList = new LinkedList<>(globalHooksList);

    protected static LinkedList<CompilationStartListener> compilationStartListeners = new LinkedList<>();
    
    protected File tempDir = null;
    protected File outDir = null;
    protected File sourceDir = null;
    protected File resourceDir = null;
    
    protected String[] targetPlatforms = null;
    protected Collection<Problem> warnings = new ArrayList<Problem>();

    private static final String OPTION_EXPORT_TEMPLATE = "==OPTIONS-LIST==";
    
    /**
     * Basic export of all known problem types
     */
    public static class ProblemExporter {
        public static void main(String ... args) {
            ASTNode node = new ASTNode(); // Dummy read to initialize all of the producers
            ProblemProducer.exportXML(new PrintStream(System.out));
        }
    }

    public static OptionRegistry createOptions() {
        return OptionRegistry.buildOptions();
    }

    public static ModulesSettings createModulesSettings(OptionRegistry options) {
       return new ModulesSettings(options);
    }

    public ModelicaCompiler(OptionRegistry options) {
        this.options = options;
    }

    protected ModelicaCompiler() {}

    public CCompilerDelegator getCCompiler() {
        String c_compiler = options.getStringOption(CCompilerDelegator.OPTION);
        if (delegator == null || !c_compiler.equals(delegator_name)) {
            delegator_name = c_compiler;
            delegator = CCompilerDelegator.delegatorFor(c_compiler);
        }
        return delegator;
    }
    
    public static <T extends CompilationHooks> T addGlobalCompilationHooks(T hooks) {
        globalHooksList.add(hooks);
        return hooks;
    }
    
    public static void removeGlobalCompilationHooks(CompilationHooks hooks) {
        globalHooksList.remove(hooks);
    }
    
    public <T extends CompilationHooks> T addCompilationHooks(T hooks) {
        hooksList.add(hooks);
        return hooks;
    }
    
    public void removeCompilationHooks(CompilationHooks hooks) {
        hooksList.remove(hooks);
    }

    public static <T extends CompilationStartListener> T addCompilationStartListener(T listener) {
        compilationStartListeners.add(listener);
        return listener;
    }

    protected IErrorHandler errorHandler = null;
    
    /**
     * Set the error handler to use for collection errors.
     * Passing <code>null</code> resets to default.
     */
    public void setErrorHandler(IErrorHandler eh) {
        errorHandler = eh;
    }
    
    public IErrorHandler getErrorHandler() {
        return errorHandler;
    }

    /**
     * Notifies compilation start listeners that compilation will start.
     */
    protected static void notifyCompilationStart(ModelicaCompiler mc) {
        for (CompilationStartListener listener : compilationStartListeners) {
            listener.onCompileStart(mc);
        }
    }

    /**
     * Throws a {@link CompilationAbortedException} if any hooks class signals an abort.
     */
    private void hookCheckAbort() {
        for (CompilationHooks hooks : hooksList) {
            if (hooks.shouldAbort(this)) {
                log.info("Compilation aborted.");
                throw new CompilationAbortedException();
            }
        }
    }
    
    /**
     * Calls the hook to be called after the supplied code files are parsed.
     */
    private void hookFilesParsed(SourceRoot sr) {
        for (CompilationHooks hooks : hooksList) {
            hooks.filesParsed(this, sr);
        }
    }
    
    /**
     * Calls the hook to be called after the error checks on the instantiated 
     * model are finished without errors.
     */
    private void hookModelInstantiated(InstClassDecl icd) {
        for (CompilationHooks hooks : hooksList) {
            hooks.modelInstantiated(this, icd);
        }
        icd.root().getUtilInterface().modelInstantiated(icd);
    }
    
    /**
     * Calls the hook to be called after the model is flattened.
     */
    private void hookModelFlattened(FClass fc) {
        for (CompilationHooks hooks : hooksList) {
            hooks.modelFlattened(this, fc);
        }
    }
    
    /**
     * Calls the hook to be called after transformations are applied to the model.
     */
    private void hookModelTransformed(FClass fc) {
        for (CompilationHooks hooks : hooksList) {
            hooks.modelTransformed(this, fc);
        }
    }
    
    /**
     * Calls the hook to be called after error checks of the flat model are 
     * finished without errors.
     */
    private void hookFlatModelChecked(FClass fc) {
        for (CompilationHooks hooks : hooksList) {
            hooks.flatModelChecked(this, fc);
        }
    }
    
    /**
     * Calls the hook to be called after a code generator is created.
     */
    private void hookCodeGeneratorCreated(AbstractGenerator gen) {
        for (CompilationHooks hooks : hooksList) {
            hooks.codeGeneratorCreated(this, gen);
        }
    }
    
    /**
     * Calls the hook to be called after output code is generated.
     */
    private void hookCodeGenerated(FClass fc, File dir) {
        for (CompilationHooks hooks : hooksList) {
            hooks.codeGenerated(this, fc, dir);
        }
    }
    
    /**
     * Calls the hook to be called after the generated C code is compiled.
     */
    private void hookCodeCompiled() {
        for (CompilationHooks hooks : hooksList) {
            hooks.codeCompiled(this);
        }
    }

    /**
     * Calls the hook to be called before the FMU is packed.
     * @param fc the source FClass
     * @param dir the temporary FMU directory
     */
    private void hookPackFmu(FClass fc, File dir) {
        for (CompilationHooks hooks : hooksList) {
            hooks.packFmu(this, fc, dir);
        }
        fc.root().getUtilInterface().packFmu(fc, dir.toPath());
    }
    
    /**
     * Calls the hook to be called after the FMU is packed.
     */
    private void hookFmuPacked(FClass fc, File path) {
        for (CompilationHooks hooks : hooksList) {
            hooks.fmuPacked(this, fc, path);
        }
        fc.root().getUtilInterface().fmuPacked(fc, path.toPath());
    }
    
    public String getStringOption(String key) throws UnknownOptionException {
        return options.getStringOption(key);
    }
    
    public void setStringOption(String key, String value) throws UnknownOptionException {
        options.setStringOption(key,value);
    }
    
    public int getIntegerOption(String key) throws UnknownOptionException {
        return options.getIntegerOption(key);
    }
    
    public void setIntegerOption(String key, int value) throws UnknownOptionException {
        options.setIntegerOption(key, value);
    }
    
    public double getRealOption(String key) throws UnknownOptionException {
        return options.getRealOption(key);
    }
    
    public void setRealOption(String key, double value) throws UnknownOptionException {
        options.setRealOption(key, value);
    }
    
    public boolean getBooleanOption(String key) throws UnknownOptionException{
        return options.getBooleanOption(key);
    }
    
    public void setBooleanOption(String key, boolean value) throws UnknownOptionException {
        options.setBooleanOption(key, value);
    }

    public void setDiagnosticsGenerator(DiagnosticsGenerator diagGenerator) {
        this.diagGenerator = diagGenerator;
    }

    public DiagnosticsGenerator getDiagnosticsGenerator() {
        return this.diagGenerator;
    }
    
    public String getOptionDescription(String key) throws UnknownOptionException {
        return options.getDescription(key);
    }
    
    public boolean willDumpMemoryUse() {
        return dumpMemoryUse;
    }

    public void setDumpMemoryUse(boolean dump) {
        dumpMemoryUse = dump;
    }

    public void setDumpMemoryUse(boolean dump, int minSize) {
        dumpMemoryUse = dump;
        dumpMemoryUseMinSize = minSize;
    }

    public void setDumpMemoryUse(boolean dump, String minSize) {
        if (minSize == null || minSize.isEmpty())
            setDumpMemoryUse(dump);
        else
            setDumpMemoryUse(dump, (int) ASTNode.parseMem(minSize));
    }
    
    public boolean willFindFlatToInstanceLinks() {
        return findFlatToInstanceLinks;
    }

    public void setFindFlatToInstanceLinks(boolean find) {
        findFlatToInstanceLinks = find;
    }

    /**
     * Returns the modelicapath attribute set for this compiler instance.
     * 
     * @return Reference to the modelicapath attribute. 
     * 
     */
    public String getModelicapath() {
        return options.getStringOption("MODELICAPATH");
    }
    
    /**
     * Set the modelicapath attribute.
     * 
     * @param path The new modelicapath.
     */
    public void setModelicapath(String path) {
        options.setStringOption("MODELICAPATH", path);
    }

    protected final static int NUM_USED_MEMORY_SLOTS = 6;
    protected long[] usedMem = new long[NUM_USED_MEMORY_SLOTS];
    protected int numUsedMemFilled;
    protected long timeCompilationStarted;

    /**
     * Initilize vars gathering debug information about compilation.
     * 
     * Should be called before compilation process begins.
     */
    protected void resetCompilationInfo() {
        timeCompilationStarted = System.currentTimeMillis();
        numUsedMemFilled = 0;
    }
    
    /**
     * Log debug information about compilation.
     * 
     * Should be called after compilation process ends.
     */
    protected void logCompilationInfo() {
        long time = System.currentTimeMillis() - timeCompilationStarted;
        double time2 = Math.round(time / 10.0) / 100.0;
        log.debug("Compilation took " + time2 + " s");
        
        noteUsedMemory();  // Needed if an exception occurred
        int numFinishedSteps = numUsedMemFilled / 2;
        if (numFinishedSteps > 0) {
            log.debug("Changes in memory use:");
            logMemoryUseForStep("parseModel", 0);
        }
        if (numFinishedSteps > 1)
            logMemoryUseForStep("instantiateModel", 1);
        if (numFinishedSteps > 2)
            logMemoryUseForStep("flattenModel", 2);
    }
    
    /**
     * Log memory change for a single compilation step.
     * 
     * Called by {@link #logCompilationInfo()}.
     * 
     * @param name   the name of the step
     * @param index  the index of the step (0-2)
     */
    protected void logMemoryUseForStep(String name, int index) {
        String mem = ASTNode.formatMem((int) (usedMem[2 * index + 1] - usedMem[2 * index]));
        log.debug(String.format(" %-19s %8s", name + "():", mem));
    }
    
    /**
     * Saves away the current amount of memory used.
     */
    protected void noteUsedMemory() {
        if (numUsedMemFilled < NUM_USED_MEMORY_SLOTS)
            usedMem[numUsedMemFilled++] = getUsedMemory();
    }
    
    private static final Runtime RUNTIME = Runtime.getRuntime();
    
    /**
     * Get the amount of memory currently used.
     * 
     * This includes objects that are no longer reachable but not yet garbage collected.
     */
    public static long getUsedMemory() {
        return RUNTIME.totalMemory() - RUNTIME.freeMemory();
    }

    /**
     * Save a dump of the memory use of an AST.
     * 
     * The dump will be saved in a file named <code>"size_" + type + ".txt"</code>.
     * 
     * @param root   the root of the AST to dump memory use for
     * @param type   a one-word description of the tree to dump
     * @param count  it node counts should also be generated
     */
    protected void dumpMemoryUseFile(ASTNode root, String type, boolean count) throws FileNotFoundException {
        dumpMemoryUseFile(root, type, type, count);
    }

    /**
     * Save a dump of the memory use of an AST.
     * 
     * The dump will be saved in a file named <code>"size_" + name + ".txt"</code>.
     * 
     * @param root   the root of the AST to dump memory use for
     * @param type   a short description of the tree to dump
     * @param name   the variable part of the file name
     * @param count  it node counts should also be generated
     */
    protected void dumpMemoryUseFile(ASTNode root, String type, String name, boolean count) 
            throws FileNotFoundException {
        if (dumpMemoryUse) {
            String file = "size_" + name + ".txt";
            log.debug("Dumping " + type + " tree to '" + file + "'...");
            long time = System.currentTimeMillis();
            root.dumpMemoryUse(file, true, -1, dumpMemoryUseMinSize);
            time = Math.round((System.currentTimeMillis() - time) / 1000.0);
            if (count)
                root.buildNodeCount();
            log.debug(" Dumped tree in " + time + "s");
        }
    }

    /**
     * Save a dump of the node class counts of an AST (or several).
     * 
     * The dump will be saved in a file named <code>"node_count.txt"</code>.
     */
    protected void dumpNodeCountFile() 
            throws IOException {
        if (dumpMemoryUse) {
            String file = "node_count.txt";
            log.debug("Dumping node counts to '" + file + "'...");
            ASTNode.dumpNodeCount(file);
        }
    }

    /**
     * Find any links from the flat tree to the instance tree.
     */
    protected void findFlatToInstanceLinks(FClass fc) {
        if (findFlatToInstanceLinks) {
            log.warning("Searching memory graph for flat tree for links to instance tree...");
            new MemorySpider(new MemorySpider.ClassFilteredVisitor<InstRoot>(InstRoot.class) {
                protected void visitFiltered(InstRoot ir, Stack<MemorySpider.Frame> path) {
                    Root root = null;
                    int first = -1;
                    int last = -1;
                    for (int i = 0; last < 0 && i < path.size(); i++) {
                        Object obj = path.get(i).getObject();
                        if (obj instanceof BaseNode) {
                            BaseNode n = (BaseNode) obj;
                            try {
                                if (first < 0) {
                                    root = n.root();
                                    first = i;
                                } else if (root != n.root()) {
                                    last = i;
                                } else {
                                    first = i;
                                }
                            } catch (Exception e) {}
                        }
                    }
                    log.error("Found link to instance tree, starting at: " + path.get(first).name());
                    for (int i = first + 1; i <= last; i++)
                        log.error("  " + path.get(i));
                    throw new IllegalArgumentException();
                }
            }).traverse(fc);
            log.warning("Done.");
        }
    }
    
    private static Path[] stringsToPaths(String[] s) {
        Path paths[] = new Path[s.length];
        for (int i = 0; i < s.length; i++) {
            paths[i] = Paths.get(s[i]);
        }
        return paths;
    }
    
    /**
     * Creates a target object.
     * 
     * @param target The type of target: me, cs, ect. Use nocodegen for a NOCODEGEN target.
     * @param version The version in case of an fmu. Use null for a NOCODEGEN.
     */
    public TargetObject createTargetObject(String target, String version) {
        return TargetObject.getTarget(target, version);
    }

    /**
     * Compiles a model and creates an FMU, convenience method for compileUnit that uses default version.
     * <p>
     * Compiles a model (parsing, instantiating, flattening, code generation and 
     * binary file compilation) and packs the result in an FMU.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param target    the compiler target. Valid options are 'me' or 'cs'.
     * @param compileTo specify location of the compiled FMU. If a file is specified, the model will be renamed to this
     *                  name during the compilation. If directory is specified, the model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     * @deprecated      Use {@link #compileFMU(String, Path[], String, Path)} instead
     */
    @Deprecated
    public CompiledUnit compileFMU(String className, String fileName[], String target, String compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        return compileFMU(className, stringsToPaths(fileName), target, compileTo == null ? null : Paths.get(compileTo));
    }
    
    /**
     * Compiles a model and creates an FMU, convenience method for compileUnit that uses default version.
     * <p>
     * Compiles a model (parsing, instantiating, flattening, code generation and 
     * binary file compilation) and packs the result in an FMU.
     * 
     * @param className name of model class in the model file to compile.
     * @param paths     array of model file or library paths.
     * @param target    the compiler target. Valid options are 'me' or 'cs'.
     * @param compileTo specify location of the compiled FMU. If a file is specified, the model will be renamed to this
     *                  name during the compilation. If directory is specified, the model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     * @deprecated      Use {@link #compileFMU(String, Path[], String, Path)} instead
     */
    public CompiledUnit compileFMU(String className, Path paths[], String target, Path compileTo)
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    
        return compileUnit(className, paths, target, "1.0" , compileTo);
    }

    /**
     * Compiles a model and creates an FMUX, convenience method for compileUnit.
     * <p>
     * Compiles a model (parsing, instantiating, flattening and XML code 
     * generation) and packs the result in an FMUX.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param compileTo specify location of the compiled FMUX. If a file is specified, the model will be renamed to this
     *                  name during the compilation. If directory, the  model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     * @deprecated      Use {@link #compileFMUX(String, Path[], Path)} instead
     */
    @Deprecated
    public CompiledUnit compileFMUX(String className, String fileName[], String compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        return compileFMUX(className, stringsToPaths(fileName), compileTo == null ? null : Paths.get(compileTo));
    }

    /**
     * Compiles a model and creates an FMUX, convenience method for compileUnit.
     * <p>
     * Compiles a model (parsing, instantiating, flattening and XML code 
     * generation) and packs the result in an FMUX.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param compileTo specify location of the compiled FMUX. If a file is specified, the model will be renamed to this
     *                  name during the compilation. If directory, the  model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     */
    public CompiledUnit compileFMUX(String className, Path fileName[], Path compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        return compileUnit(className, fileName, "fmux", null , compileTo);
    }
    /**
     * Compiles an FMU or FMUX. Is a wrapper.
     * <p>
     * Compiles a model (parsing, instantiating, flattening, code generation and 
     * binary file compilation) and packs the result in an FMU/FMUX.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param target    the compiler target. Valid options are 'me' or 'cs'.
     * @param version   the FMI version. Valid options are '1.0' or '2.0'.
     * @param compileTo specify location of the compiled FMU/FMUX. If a file is specified, the model will be renamed to
     *                  this name during the compilation. If directory, the  model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     * @deprecated      Use {@link #compileUnit(String, Path[], String, String, String)} instead.
     */
    @Deprecated
    public CompiledUnit compileUnit(String className, String fileName[], String target, String version, String compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        return compileUnit(className, stringsToPaths(fileName), target, version, compileTo == null ? null : Paths.get(compileTo));
    }
    
    /**
     * Compiles an FMU or FMUX. Is a wrapper.
     * <p>
     * Compiles a model (parsing, instantiating, flattening, code generation and 
     * binary file compilation) and packs the result in an FMU/FMUX.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param target    the compiler target. Valid options are 'me' or 'cs'.
     * @param version   the FMI version. Valid options are '1.0' or '2.0'.
     * @param compileTo specify location of the compiled FMU/FMUX. If a file is specified, the model will be renamed to
     *                  this name during the compilation. If directory, the  model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     */
    public CompiledUnit compileUnit(String className, Path fileName[], String target, String version, Path compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        TargetObject targetObject = TargetObject.getTarget(target, version);
        return compileUnit(className, fileName, targetObject, compileTo);
    }

    /**
     * Compiles an FMU or FMUX.
     * 
     * @param className name of model class in the model file to compile.
     * @param fileName  array of model file or library paths.
     * @param target    target object, contains information about the target, its unit suffix for example.
     * @param compileTo specify location of the compiled FMU/FMUX. If a file is specified, the model will be renamed to
     *                  this name during the compilation. If directory, the  model will keep its original name.
     * @return          a {@link CompiledUnit} result object.
     */
    protected CompiledUnit compileUnit(String className, Path fileName[], TargetObject target, Path compileTo) 
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        /*
         * Always set certain options when compiling.
         * First save these options in the temporary options' registry to reset when compiling has finished.
         */
        OptionRegistry tempOptions = options.copy();

        /*
         * Set options for the target.
         */
        target.setDefaultOptions(options);

        boolean doTearDown = true;
        try {
            doTearDown = trySetUp();
            return doCompileUnit(className, fileName, target, compileTo);
        } finally {
            deleteOutDir();
            tryTearDown(doTearDown);

            /*
             * Reset all options.
             */
            options.copyAllOptions(tempOptions);
        }
    }

    protected CompiledUnit doCompileUnit(String className, Path fileName[], TargetObject target, Path compileTo) 
        throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {

        CompiledUnit unit = null;
        try {
            StepInfo.GC_BEFORE_MEM = options.getBooleanOption("debug_invoke_gc");

            if (outDir == null) {
                setRandomOutDir();
            }

            if (target.getMakeFileFlag() != null) {
                // Might be used by constant evaluation.
                CCompilerDelegator ccompiler = getCCompiler();
                ccompiler.setTargetPlatforms(targetPlatforms);

                // Get loadable module settings.
                ModulesSettings modulesSettings = createModulesSettings(options);
                ccompiler.setModuleLibraryNames(modulesSettings.getLibraryNames());
            }

            /*
             * Compile mo-file and generate code for all templates that are not null.
             */
            FClass fc = compileModel(fileName, className, target, compileTo);

            if (!target.getCodeGenFlag()) {
                /*
                 * No code has been generated.
                 */
                return null;
            }

            /*
             * Compile C code if the Makefile flag is not null.
             */
            hookCheckAbort();
            doCompileCCode(target, fc);

            /*
             * Package unit.
             */
            ASTNode.beginStep("packUnit()");
            Path unitPath = packUnit(className, target, fc);
            unit = log.logCompiledUnit(unitPath, warnings, fc.numberOfComponents());
            ASTNode.endStep("packUnit()");

        } finally {
            log.debug("Time usage and memory usage change during compilation steps:");
            ASTNode.getStepInfo().logReport();
            if (options.getBooleanOption("debug_csv_step_info"))
                ASTNode.getStepInfo().writeCSVFile(new File(FClass.removeModifiersFromClassName(className) + ".csv"));
        }
        
        return unit;
    }

    protected void parseFiles(Path[] paths) throws IOException {
        StepInfo.TimeItem time = new StepInfo.TimeItem();
        time.begin();
        parseFiles(Arrays.asList(paths), true);
        time.end();
        log.info("Total time: " + time);
    }

    private void parseFiles(Iterable<Path> files, boolean all) throws IOException {
        for (Path file : files) {
            if (Files.isDirectory(file)) {
                try(DirectoryStream<Path> ds = Files.newDirectoryStream(file)) { 
                    parseFiles(ds, false);
                }
            } else {
                String path = file.toString();
                try {
                    if (all || hasModelicaFileExt(path)) {
                        parseModel(file);
                        log.info(file + " parsed OK.");
                    }
                } catch (CompilerException e) {
                    log.logCompilerException(e);
                } catch (FileNotFoundException e) {
                    log.error("Could not find file: " + e.getMessage());
                } catch (IOException e) {
                    log.error("Error opening file: " + e.getMessage());
                } catch (Exception e) {
                    log.error("Parser thew an exception on file " + path + ":\n" + e);
                }
            }
        }
    }
    
    public boolean hasModelicaFileExt(String file) {
        return file.endsWith(".mo");
    }

    private static final int ZIP_BUFFER_SIZE = 2048;
    

    /**
     * Write all files in a directory and its subdirectories to a zip stream.
     * 
     * @param dir     directory to zip
     * @param out     zip stream to write to
     */
    protected void zipDir(File dir, ZipOutputStream out) {
        zipDir(dir, out, null);
    }

    /**
     * Write all files in a directory and its subdirectories to a zip stream.
     * 
     * @param dir     directory to zip
     * @param out     zip stream to write to
     * @param zipDir  directory within the zip file to write to, or <code>null</code> for the root
     */
    protected void zipDir(File dir, ZipOutputStream out, File zipDir) {
        zipDir(dir, out, zipDir, new byte[ZIP_BUFFER_SIZE]);
    }
    
    /**
     * Write all files in a directory and its subdirectories to a zip stream.
     * 
     * @param dir     directory to zip
     * @param out     zip stream to write to
     * @param zipDir  directory within the zip file to write to, or <code>null</code> for the root
     * @param buffer  buffer to use when writing files
     */
    private void zipDir(File dir, ZipOutputStream out, File zipDir, byte[] buffer) {
        for (File f : dir.listFiles()) {
            File fz = new File(zipDir, f.getName());
            try {
                if (f.isDirectory()) {
                    out.putNextEntry(new ZipEntry(fz.getPath() + "/"));
                    zipDir(f, out, fz, buffer);
                } else {
                    FileInputStream in = new FileInputStream(f);
                    out.putNextEntry(new ZipEntry(fz.getPath()));
                    for (int n; (n = in.read(buffer, 0, buffer.length)) != -1; ) 
                        out.write(buffer, 0, n);
                    in.close();
                }
            } catch (FileNotFoundException e) {
                // Should only occur in weird cases - ignore and skip this file
            } catch (IOException e) {
                // TODO: this should result in an error message about failing to zip file
                e.printStackTrace();
            }
        }
    }

    /**
     * Parses a model and returns a reference to the root of the source tree.
     * Options related to the compilation are also loaded here and added to the
     * source tree representation.
     * 
     * @param name
     *            The name of the model file.
     *
     * @return The root of the source tree.
     * 
     * @throws beaver.Parser.Exception
     *             If there was an Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing.
     * @throws FileNotFoundException
     *             If the model file can not be found.
     * @throws IOException
     *             If there was an error reading the model file. (Beaver exception.)
     */
    private SourceRoot parseModel(Path name) 
      throws FileNotFoundException, IOException, beaver.Parser.Exception, CompilerException{
        return parserHandler.parseModel(createUtilInterface(), LoadInfo.create(name));
    }

    /**
     * 
     * Parses a set of files and returns a reference to the root of a source tree
     * where the content of all files is contained. Each file is parsed using
     * the parseModel method.
     * 
     * @param files
     *            An array of file names.
     *
     * @return The root of the source tree.
     * 
     * @throws beaver.Parser.Exception
     *             If there was a Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing.
     * @throws FileNotFoundException
     *             If any of the model files could not be found.
     * @throws IOException
     *             If there was an error reading any of the model files. (Beaver exception.)
     * @deprecated use {@link #parseModelFromPaths(Path[])} instead
     */
    @Deprecated
    public SourceRoot parseModel(String[] files)
      throws FileNotFoundException, IOException, beaver.Parser.Exception, CompilerException {
        // NB: This method is called by compile_wrappers.py! It may not be deleted!
        return parseModelFromPaths(stringsToPaths(files));
    }

    /**
     * Parses a set of files and returns a reference to the root of a source tree
     * where the content of all files is contained. Each file is parsed using
     * the {@link #doParseModel}.
     * 
     * @param files
     *            An array of file paths.
     *
     * @return The root of the source tree.
     * 
     * @throws beaver.Parser.Exception
     *             If there was a Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing.
     * @throws FileNotFoundException
     *             If any of the model files could not be found.
     * @throws IOException
     *             If there was an error reading any of the model files. (Beaver exception.)
     */
    public SourceRoot parseModelFromPaths(Path[] files)
      throws FileNotFoundException, IOException, beaver.Parser.Exception, CompilerException {
        hookCheckAbort();
        boolean doTearDown = true;
        try {
            doTearDown = trySetUp();
            Collection<LoadInfo> loadInfos = new ArrayList<>();
            for (Path path : files) {
                loadInfos.add(LoadInfo.create(path));
            }
            return doParseModel(loadInfos);
        } finally {
            tryTearDown(doTearDown);
        }
    }

    /**
     * Parses a string and returns a reference to the root of the source tree. 
     * Options related to the compilation are also loaded here and added to the 
     * source tree representation.
     * 
     * @param code
     *            Modelica code to parse.
     * @param name
     *            The filename (or other description) to use when reporting errors.
     *
     * @return The root of the source tree.
     * 
     * @throws beaver.Parser.Exception
     *             If there was an Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing.
     * @throws IOException
     *             If there was an error reading the model file. (Beaver exception.)
     */
    public SourceRoot parseString(String code, String name) 
      throws IOException, beaver.Parser.Exception, CompilerException {
        checkSetUp();
        return parserHandler.parseString(createUtilInterface(), code, LoadInfo.create(name));
    }

    public SourceRoot doParseModel(Collection<LoadInfo> loadInfos) 
      throws FileNotFoundException, IOException, beaver.Parser.Exception, CompilerException {
        checkSetUp();
        notifyCompilationStart(this);
        ASTNode.getStepInfo().reset();
        ASTNode.beginStep("parseModel()");
        SourceRoot sr = parserHandler.parseModel(createUtilInterface(), loadInfos);
        hookFilesParsed(sr);
        ASTNode.endStep("parseModel()");
        
        return sr;
    }
    
    /**
     * Parses and instantiated the model <code>cl</code> from the source files <code>name</code>.
     * 
     * @param paths
     *            Array of model file or library paths.
     * @param cl
     *            The name of the class in the model file to compile.
     * @param target
     *            The model represenation type the model should be compiled to.
     * 
     * @throws ModelicaException
     *             If errors have been found during the parsing, instantiation
     *             or flattening.
     * @throws FileNotFoundException
     *             If the model file can not be found.
     * @throws IOException
     *             If there was an error creating the .mof file.
     * @throws beaver.Parser.Exception
     *             If there was an Beaver parsing exception.
     */
    private InstClassDecl instantiateModel(Path[] paths, String cl, TargetObject target)
            throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
        // build source tree
        SourceRoot sr = parseModelFromPaths(paths);
        dumpMemoryUseFile(sr, "source", false);

        if (options.getBooleanOption("generate_html_diagnostics")) {
            setDiagnosticsGenerator(new DiagnosticsGenerator(cl, options));
        }

        // compute instance tree
        InstClassDecl icl = instantiateModel(sr, cl, target);
        
        dumpMemoryUseFile(sr, "source and instance", "instance", true);
        
        return icl;
    }

    /**
     * Computes a model instance tree from a source tree. Some error checks such
     * as type checking is performed during the computation.
     * 
     * @param sr
     *            The reference to the model source root.
     * @param cl
     *            The name of the class in the model file to compile.
     * @param target
     *            The model represenation type the model should be compiled to.
     * 
     * @return The instance node corresponding to the instantiated model.
     * 
     * @throws CompilerException
     *             If errors have been found during the instantiation.
     * @throws ModelicaClassNotFoundException
     *             If the Modelica class to instantiate is not found.
     */
    public InstClassDecl instantiateModel(SourceRoot sr, String cl, TargetObject target) 
        throws ModelicaClassNotFoundException, CompilerException {
        hookCheckAbort();
        boolean doTearDown = true;
        try {
            doTearDown = trySetUp(sr.getErrorHandler());
            return doInstantiateModel(sr, cl, target);
        } finally {
            tryTearDown(doTearDown);
        }
    }
    
    public InstClassDecl doInstantiateModel(SourceRoot sr, String cl, TargetObject target) 
        throws ModelicaClassNotFoundException, CompilerException {
        
        ASTNode.beginStep("instantiateModel()");
        
        InstProgramRoot ipr = sr.getProgram().getInstProgramRoot();
        
        log.info("Checking for errors...");
        InstClassDecl icd = ipr.instantiateModel(cl);
        try {
            icd.checkErrorsInModelInstance(cl, target.getCheckType());
        } finally {
            handleCompilerWarnings(sr.collectWarnings());
        }
        
        hookModelInstantiated(icd);
        ASTNode.endStep("instantiateModel()");
        
        return icd;
    }

    protected void handleCompilerWarnings(Collection<Problem> warnings) throws CompilerException {
        if (options.getBooleanOption("generate_html_diagnostics") && getDiagnosticsGenerator() != null) 
            getDiagnosticsGenerator().writeProblems(warnings);
        
        if (!warnings.isEmpty()) {
            log.logProblems(warnings);
            this.warnings.addAll(warnings);
        }
    }
    
    /**
     * Retrieves a list of warnings and clear the internal list.
    */
    public Problem[] retrieveAndClearWarnings() {
        Problem[] oldWarnings = warnings.toArray(new Problem[warnings.size()]);
        warnings = new ArrayList<Problem>();
        return oldWarnings;
    }

    /**
     * Please use the correctly spelled version!
     */
    @Deprecated
    public Problem[] retreiveAndClearWarnings() {
        return retrieveAndClearWarnings();
    }

    /**
     * Computes the flattened model representation from a model instance.
     * 
     * @param icd
     *            A reference to the model instance node.
     * @param target
     *            The model represenation type the model should be compiled to.
     * @param flatName
     *            Name of the unit/flat model supplied by the user, if any.
     * 
     * @return FClass object representing the flattened model.
     * 
     * @throws CompilerException
     *             If errors have been found during the flattening.
     * @throws IOException
     *             If there was an error creating the .mof file.
     * @throws ModelicaClassNotFoundException
     *             If the Modelica class to flatten is not found.
     */
    public FClass flattenModel(InstClassDecl icd, TargetObject target, String flatName) 
            throws CompilerException, ModelicaClassNotFoundException, IOException {
        hookCheckAbort();
        boolean doTearDown = true;
        try {
            doTearDown = trySetUp(icd.root().getErrorHandler());
            PassAndForget<InstClassDecl> buf = new PassAndForget<InstClassDecl>(icd);
            icd = null;
            return doFlattenModel(buf.pass(), target, flatName);
        } finally {
            tryTearDown(doTearDown);
        }
    }
    
    public FClass doFlattenModel(InstClassDecl icd, TargetObject target, String flatName) 
            throws CompilerException, ModelicaClassNotFoundException, IOException {
        ASTNode.beginStep("flattenModel()");
        
        String instName = icd.qualifiedName();
        File flatFile = new File(sourceDir, (flatName == null ? instName : flatName) + ".mof");
        final FClass fc = FClass.create(icd, flatName);
        
        ASTNode.beginStep("flatten()");
        log.info("Flattening model...");
        icd.flattenInstClassDecl(fc);
        dumpMemoryUseFile(fc, "flat", true);
        dumpNodeCountFile();
        icd = null;
        ASTNode.endStep("flatten()");
        
        findFlatToInstanceLinks(fc);
        hookModelFlattened(fc);
        hookCheckAbort();

        OptionRegistry options = fc.myOptions();
        
        // Output the untransformed flattened model
        ASTNode.beginStep("prettyPrintRawFlat()");
        if (options.getBooleanOption("generate_mof_files")) {
            log.debug("Creating raw .mof file...");
            CodeStream out = new CodeStream(flatFile);
            fc.prettyPrint_MC(out, "");
            out.close();
            log.debug("... raw .mof file created.");
        }

        log.verbose("Raw flattened model:");
        log.verbose(fc);
        ASTNode.endStep("prettyPrintRawFlat()");

        if (options.getBooleanOption("generate_html_diagnostics") && getDiagnosticsGenerator()!=null) {
            ASTNode.beginStep("htmlDiagnostics()");
            getDiagnosticsGenerator().writeRawFlattenedModel(fc);
            getDiagnosticsGenerator().setModelDiagnosticsBeforeTransform(fc.modelDiagnostics());
            ASTNode.endStep("htmlDiagnostics()");
        }
        
        fc.transformCanonical();
        
        /* Temporary fix to problems with long compilation times due to later evaluations */
        getExternalFunctionCache().tearDown();
        options.external_constant_evaluation.setValue(0);
        
        hookModelTransformed(fc);
        hookCheckAbort();
        
        ASTNode.beginStep("prettyPrintFlat()");
        if (options.getBooleanOption("generate_mof_files")) {
            log.debug("Creating transformed .mof file...");
            CodeStream out = new CodeStream(new File(sourceDir, instName + "_transformed.mof"));
            fc.prettyPrint_MC(out, "");
            out.close();
            log.debug("... transformed .mof file created.");
        }
        
        log.verbose("Diagnostics for transformed flattened model:");
        log.verbose(new Object() {
            public String toString() {
                return fc.diagnostics();
            };
        });
        
        log.verbose("Transformed flattened model:");
        log.verbose(fc);
        
        ASTNode.endStep("prettyPrintFlat()");
        
        dumpMemoryUseFile(fc, "transformed", false);
        
        if (options.getBooleanOption("write_iteration_variables_to_file")) {
            ASTNode.beginStep("writeIterationVariables()");
            if (!fc.onlyInitBLT())
                fc.getDAEBLT().writeIterationVariablesToFile(new File(resourceDir, instName + "_iteration_variables.txt"));
            fc.getDAEInitBLT().writeIterationVariablesToFile(new File(resourceDir, instName + "_initial_system_iteration_variables.txt"));
            ASTNode.endStep("writeIterationVariables()");
        }

        if (options.getBooleanOption("write_tearing_pairs_to_file")) {
            ASTNode.beginStep("writeIterationVariables()");
            if (!fc.onlyInitBLT())
                fc.getDAEBLT().writeTearingPairsToFile(new File(instName + "_tearing_pairs.txt"));
            fc.getDAEInitBLT().writeTearingPairsToFile(new File(instName + "_initial_system_tearing_pairs.txt"));
            ASTNode.endStep("writeIterationVariables()");
        }

        fc.errorCheck(target.getCheckType());
        handleCompilerWarnings(fc.collectWarnings());

        if (options.getBooleanOption("generate_html_diagnostics") && getDiagnosticsGenerator()!=null) {
            ASTNode.beginStep("htmlDiagnostics()");
            getDiagnosticsGenerator().writeTransformedFlattenedModel(fc);
            getDiagnosticsGenerator().writeDiagnostics(fc);
            ASTNode.endStep("htmlDiagnostics()");
        }

        hookFlatModelChecked(fc);
        ASTNode.endStep("flattenModel()");

        return fc;
    }

    /**
     * Create a new CGenerator object.
     * 
     * Override for subclasses needing another subclass of CGenerator.
     */
    protected CGenerator createCGenerator(FClass fc) {
        return new CGenerator(ASTNode.prettyPrinter, '$', fc);
    }

    protected ExternCEvalGenerator createCGenerator(FExternalStmt ext) {
        CodeGenContext cgc = new CodeGenContext().createProxy();
        Map<String,String> tempMap = new HashMap<String,String>();
        return new ExternCEvalGenerator(ASTNode.prettyPrinter, '$', null, ext, cgc, tempMap);
    }

    /**
     * 
     * Generates XML and c code for a flattened model represented as an instance
     * of FClass using template files. The XML variables, XML values and c files
     * are given the default names <modelname>.xml, <modelname>_values.xml and 
     * <modelname>.c respectively.
     * 
     * @param fc
     *            The FClass instance for which the code generation should be
     *            computed.
     * @param target
     *            The target object for the compiler.
     * @throws FileNotFoundException
     *             If either of the three template files can not be found.
     */
    public void generateCode(FClass fc, TargetObject target) throws FileNotFoundException {
        boolean doTearDown = true;
        try {
            doTearDown = trySetUp(fc.root().getErrorHandler());
            doGenerateCode(fc, target);
        } finally {
            tryTearDown(doTearDown);
        }
    }
    
    public void doGenerateCode(FClass fc, TargetObject target) throws FileNotFoundException {
        ASTNode.beginStep("generateCode()");
        log.info("Generating code...");
        
        String name = fc.nameUnderscore();
        Templates templates = target.getTemplates(getOptions());
        
        generateAllFiles(fc, target, templates, name);
        hookCodeGenerated(fc, outDir);
        
        fc.guidManager().setSourceFile(new File(outDir, "modelDescription.xml"));
        fc.guidManager().processDependentFiles();
        
        log.debug("... code generated.");
        ASTNode.endStep("generateCode()");
    }
    
    /**
     * Set the default logger and default level.
     */
    public void setDefaultLogger() {
        try {
            setLogger(DEFAULT_LEVEL + "|stdout");
        } catch (IllegalLogStringException e) {
            e.printStackTrace(); // Should never happen unless someone made major bobo!
        }
    }
    
    /**
     * Configure logging according to <code>logString</code>.
     */
    public void setLogger(String logString) throws IllegalLogStringException {
        setLogger(ModelicaLogger.createModelicaLoggersFromLogString(logString));
    }
    
    /**
     * Change logger to <code>logger</code>
     */
    public void setLogger(ModelicaLogger logger) {
        log.close();
        log = logger;
        ASTNode.log = log;
    }
    
    public ModelicaLogger log() {
        return log;
    }
    
    /**
     * Close and disconnect all loggers.
     */
    public void closeLogger() {
        log.close();
    }

    private void setOptions(Arguments programarguments) {
        // Create option registry
        options = createOptions();
        String opts = programarguments.get("opt");
        if (opts != null) {
            for (String opt : opts.split(",")) {
                String[] parts = opt.split(":", 2);
                if (parts.length == 1)
                    options.setBooleanOption(parts[0], true);
                else
                    options.setOption(parts[0], parts[1]);
            }
        }
        
        //add modelicapath to optionregistry
        String modelicapath = programarguments.get("modelicapath");
        if (modelicapath == null) {
            //modelicapath was not set in program arguments -> check envir variable or via JMODELICA_HOME
            if (System.getenv("MODELICAPATH") != null) 
                modelicapath = System.getenv("MODELICAPATH");
            else
                modelicapath = EnvironmentUtils.getThirdPartyMSL().toString();
        }
        options.setStringOption("MODELICAPATH", modelicapath);
    }
    
    public OptionRegistry getOptions() {
        return options;
    }

    public static final String COMPILER_VERSION = Version.parseVersion();

    protected void setArguments(Arguments programarguments) {
        
        int arg = 0;
        String modelicapath = null;
        
        //log option
        try {
            String logString = programarguments.get("log");
            setLogger(logString);
        } catch (IllegalLogStringException e) {
            setLogger(e.getLogger());
            log.error(e);
            closeLogger();
            System.exit(1);
        }
        
        setDumpMemoryUse(programarguments.containsKey("dumpmemuse"), programarguments.get("dumpmemuse"));
        setFindFlatToInstanceLinks(programarguments.containsKey("findflatinst"));
        
        if (programarguments.containsKey("debugSrcIsHome")) 
            setDebugSrcIsHome(true);
        
        // platform argument
        String platforms = programarguments.get("platform");
        if (platforms != null) {
            setTargetPlatforms(platforms.split(","));
        }
        
        // set options
        this.setOptions(programarguments);
        
        // Log compilation command
        log.info("Compiler arguments:\n  "        + programarguments.line());
        log.info("Current working directory:\n  " + currentWorkingDirecory());
        log.info("Compiler version: "             + COMPILER_VERSION);
        log.info("Java version: "                 + System.getProperty("java.version"));
        log.info("OS name: "                      + System.getProperty("os.name"));
        log.info("OS architecture: "              + System.getProperty("os.arch"));
        logEnvironment("MODELICAPATH", "JAVA_HOME", "JMODELICA_HOME");
    }

    public static void main(String ... args) {
        // create an empty compiler
        ModelicaCompiler mc = new ModelicaCompiler();
        try {
            // set arguments
            Arguments arguments = new Arguments("ModelicaCompiler", args);
            mc.setArguments(arguments);
            // Compile model
            mc.compileModelFromCommandLine(args, arguments);
        } catch(Throwable e) {
            log.error(e);
            log.close();
            System.exit(1);
        }
    }

    /**
     * Compile model given on command line options and print any error messages.
     */
    protected void compileModelFromCommandLine(String[] args, Arguments programarguments) {
        // Get files and class
        // TODO: move this into arguments class
        String[] files = splitFiles(programarguments.libraryPath());
        String className = programarguments.className();
        String compileTo = programarguments.out();
        
        // Compile model
        try {
            String targetType = programarguments.get("target");
            if (targetType == null || targetType.equals("fmume")) {
                targetType = "me";
            } else if (targetType.equals("fmucs")) {
                targetType = "cs";
            }
            
            //Compile
            compileUnit(className, files, targetType, programarguments.get("version"), compileTo);
            
        } catch (CompilerException ce) {
            if (options.getBooleanOption("generate_html_diagnostics") && getDiagnosticsGenerator() != null) 
                getDiagnosticsGenerator().writeProblems(ce.getProblems());
            log.logCompilerException(ce);
            closeLogger();
            System.exit(1);
        } catch (Throwable e) {
            log.error(e);
            closeLogger();
            System.exit(1);
        } finally {
            closeLogger();
        }
    }

    /**
     * Split the argument containing the list of files into an array of filenames.
     */
    protected String[] splitFiles(String arg) {
        ArrayList<String> res = new ArrayList<String>();
        for (String part : arg.split(","))
            if (!part.equals(""))
                res.add(part);
        return res.toArray(new String[res.size()]);
    }

    /**
     * Get the current working directory.
     */
    protected String currentWorkingDirecory() {
        try {
            return new File(".").getCanonicalPath();
        } catch (IOException e) {
            return "< could not get current working directory >";
        }
    }

    /**
     * Write environment variables to logger.
     */
    protected void logEnvironment(String... names) {
        for (String name : names) {
            String val = System.getenv(name);
            log.info("%-15s = %s", name, (val == null) ? "" : val);
        }
    }

    public enum TargetType {
        FMUME10, FMUME20, FMUCS10, FMUCS20, FMUMECS20, FMUX, CEVAL, NULL
    }
    
    /**
    * Target object, contains all information related to which target is compiled.
    * 
    * The target is an enum that represents all different targets, the templates are in a separate class.
    */
    public enum TargetObject implements CCompilerTarget {
        
        FMUME10   (TargetType.FMUME10,   "fmume10",   "fmu",  XMLGeneratorHolder.FMI1),
        FMUME20   (TargetType.FMUME20,   "fmume20",   "fmu",  XMLGeneratorHolder.FMI2),
        FMUCS10   (TargetType.FMUCS10,   "fmucs10",   "fmu",  XMLGeneratorHolder.FMI1),
        FMUCS20   (TargetType.FMUCS20,   "fmucs20",   "fmu",  XMLGeneratorHolder.FMI2),
        FMUMECS20 (TargetType.FMUMECS20, "fmumecs20", "fmu",  XMLGeneratorHolder.FMI2), 
        FMUX      (TargetType.FMUX,      null,        "fmux", XMLGeneratorHolder.FMIX),
        CHECK     (TargetType.NULL,      null,        null,   XMLGeneratorHolder.NULL, ErrorCheckType.CHECK, false),
        PARSE     (TargetType.NULL,      null,        null,   XMLGeneratorHolder.NULL, ErrorCheckType.CHECK, false),
        NOCODEGEN (TargetType.NULL,      null,        null,   XMLGeneratorHolder.NULL, ErrorCheckType.COMPILE, false),
        CEVAL     (TargetType.CEVAL,     "ceval",     null  , null);

        private final TargetType type;
        private final String makeFileFlag;
        private final String suffix;
        private final XMLGeneratorHolder xmlGenerator;
        private final ErrorCheckType checkType;
        private final boolean codeGen;

        private TargetObject(TargetType type, String makeFileFlag, String suffix, XMLGeneratorHolder xmlGenerator, ErrorCheckType checkType, boolean codeGen) {
            this.type = type;
            this.makeFileFlag = makeFileFlag;
            this.suffix = suffix;
            this.checkType = checkType;
            this.codeGen = codeGen;
            this.xmlGenerator = xmlGenerator;
        }

        private TargetObject(TargetType type, String makeFileFlag, String suffix, XMLGeneratorHolder xmlGenerator, ErrorCheckType checkType) {
            this(type, makeFileFlag, suffix, xmlGenerator, checkType, true);
        }
        
        private TargetObject(TargetType type, String makeFileFlag, String suffix, XMLGeneratorHolder xmlGenerator) {
            this(type, makeFileFlag, suffix, xmlGenerator, ErrorCheckType.COMPILE);
        }
        
        public Templates getTemplates(OptionRegistry options) {
            return new Templates(type, options);
        }
        
        public String createExtraCFlagsString(AbstractOptionRegistry abstractOptions, String fileName) {
            OptionRegistry options = (OptionRegistry) abstractOptions;
            
            if (suffix == null) {
                return "";
            }
            
            return getTemplates(options).createExtraCFlagsString(options, fileName);
        }
        
        /**
        * Returns an enum of the target that contains all relevant information for the target.
        * 
        * @param targetType  The compiler target.
        * @param version     The FMI version.
        */
        public static TargetObject getTarget(String targetType, String version)
                throws IllegalCompilerArgumentException {
            
            if (targetType.equals("nocodegen")) {
                return NOCODEGEN;
            } else if (targetType.equals("me")) {
                if (version == null || version.equals("1.0")) {
                    return FMUME10;
                } else if (version.equals("2.0")) {
                    return FMUME20;
                } else {
                    throw new IllegalCompilerArgumentException("Unknown version '" + version + "' for target '" + targetType + "'. Use 1.0 or 2.0."); 
                }
            } else if (targetType.equals("cs")) {
                if (version == null || version.equals("1.0")) {
                    return FMUCS10;
                } else if (version.equals("2.0")) {
                    return FMUCS20;
                } else {
                    throw new IllegalCompilerArgumentException("Unknown version '" + version + "' for target '" + targetType + "'. Use 1.0 or 2.0."); 
                }
            } else if (targetType.equals("me+cs")) {
                if (version == null || version.equals("2.0")) {
                    return FMUMECS20;
                } else {
                    throw new IllegalCompilerArgumentException("Unknown version '" + version + "' for target '" + targetType + "'. Use 2.0.");
                }
            } else if (targetType.equals("fmux")) {
                return FMUX;
            } else if (targetType.equals("ceval")){
                return CEVAL;
            } else if (targetType.equals("parse")) {
                return PARSE;
            } else if (targetType.equals("check")) {
                return CHECK;
            } else {
                throw new IllegalCompilerArgumentException("Unknown target '" + targetType + "'. Use me or cs to compile an FMU or fmux to compile an FMUX."); 
            }
        }
        
        /**
         * Create a new XMLGenerator object.
         * 
         * Override for subclasses needing another subclass of XMLGenerator.
         */
        public GenericXMLGenerator getXMLGenerator(FClass fc) {
            return xmlGenerator.getXMLGenerator(fc);
        }
        
        /**
         * get the flag should be used in the Makefile.
         * 
         * @return The flag for the Makefile. 
         * 
         */
        public String getMakeFileFlag() {
            return makeFileFlag;
        }
        
        /**
         * Gets the file suffix for a the target object. 
         */
        public String getUnitSuffix() {
            return suffix;
        }
        
        /**
         * Get the check type to use when error checking.
         */
        public ErrorCheckType getCheckType() {
            return checkType;
        }
        
        /**
         * Get a flag that determines if there should be any code-generation.
         */
        public boolean getCodeGenFlag() {
            return codeGen;
        }

        /**
         * Sets the default options that should be used for this target object. 
         */
        public void setDefaultOptions(AbstractOptionRegistry options) {
            for (TargetOptionContributor contributor :
                    TargetOptionContributor.TARGET_DEFAULT_OPTION_CONTRIBUTORS.values()) {

                contributor.setOptions(this, options);
            }
        }

    }

    public static TargetOptionContributor addTargetOptionContributor(TargetOptionContributor contributor) {
        Map<String, TargetOptionContributor> contributors = TargetOptionContributor.TARGET_DEFAULT_OPTION_CONTRIBUTORS;
        String identity = contributor.identity();

        if (contributors.containsKey(identity)) {
            return contributors.get(identity);
        }

        contributors.put(identity, contributor);
        return contributor;
    }

    private static final TargetOptionContributor TARGET_DEFAULT_BASE_CONTRIBUTOR = addTargetOptionContributor(
                    new ModelicaCompiler.TargetOptionContributor() {

                        @Override
                        public void setOptions(TargetObject object, AbstractOptionRegistry options) {
                            switch (object) {
                                case FMUME10:
                                    options.setStringOption("fmu_type", "FMUME10");
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", true);
                                    options.setBooleanOption("generate_fmi_cs_xml", false);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case FMUME20:
                                    options.setStringOption("fmu_type", "FMUME20");
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", true);
                                    options.setBooleanOption("generate_fmi_cs_xml", false);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case CHECK:
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", true);
                                    options.setBooleanOption("generate_fmi_cs_xml", false);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case FMUCS10:
                                    options.setStringOption("fmu_type", "FMUCS10");
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", false);
                                    options.setBooleanOption("generate_fmi_cs_xml", true);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case FMUCS20:
                                    options.setStringOption("fmu_type", "FMUCS20");
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", false);
                                    options.setBooleanOption("generate_fmi_cs_xml", true);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case FMUMECS20:
                                    options.setStringOption("fmu_type", "FMUME20;FMUCS20");
                                    options.setBooleanOption("generate_ode", true);
                                    options.setBooleanOption("generate_dae", false);
                                    options.setBooleanOption("equation_sorting", true);
                                    options.setBooleanOption("generate_fmi_me_xml", true);
                                    options.setBooleanOption("generate_fmi_cs_xml", true);
                                    options.setBooleanOption("generate_xml_equations", false);
                                    break;
                                case FMUX:
                                    options.setBooleanOption("generate_ode", false);
                                    options.setBooleanOption("generate_dae", true);
                                    options.setBooleanOption("equation_sorting", false);
                                    options.setBooleanOption("generate_fmi_me_xml", false);
                                    options.setBooleanOption("generate_fmi_cs_xml", false);
                                    options.setBooleanOption("generate_xml_equations", true);
                                    break;
                                case NOCODEGEN:
                                    options.setBooleanOption("unroll_functions", true);
                                    break;
                                default:
                                    break;
                                }
                            options.setStringOption("compiler_version", ModelicaCompiler.COMPILER_VERSION);
                        }

                        @Override
                        public String identity() {
                            return "org.jmodelica.modelica.compiler.ModelicaCompiler.TARGET_DEFAULT_BASE_CONTRIBUTOR";
                        }
                    });

    private static final TargetOptionContributor TARGET_FMI_VERSION_CONTRIBUTOR = addTargetOptionContributor(
                    new ModelicaCompiler.TargetOptionContributor() {

                        @Override
                        public void setOptions(TargetObject object, AbstractOptionRegistry options) {
                            switch (object) {
                                case FMUME10:
                                case FMUCS10:
                                    options.setStringOption("fmi_version", OptionRegistry.FMIVersion.FMI10);
                                    break;
                                case FMUME20:
                                case FMUCS20:
                                case FMUMECS20:
                                    options.setStringOption("fmi_version", OptionRegistry.FMIVersion.FMI20);
                                    break;
                                default:
                                    break;
                            }
                        }

                        @Override
                        public String identity() {
                            return "org.jmodelica.modelica.compiler.ModelicaCompiler.TARGET_FMI_VERSION_CONTRIBUTOR";
                        }
                    });

    /**
     * Contributor class for additional default options dependent on compilation target.
     */
    public static abstract class TargetOptionContributor implements Comparable<TargetOptionContributor> {

        private static final Map<String, TargetOptionContributor> TARGET_DEFAULT_OPTION_CONTRIBUTORS =
            new HashMap<String, TargetOptionContributor>();

        protected abstract String identity();
        protected abstract void setOptions(TargetObject object, AbstractOptionRegistry options);

        @Override
        public int compareTo(TargetOptionContributor other) {
            return identity().compareTo(other.identity());
        }

        @Override
        public boolean equals(Object other) {
            if (!(other instanceof TargetOptionContributor)) {
                return false;
            }
            return compareTo((TargetOptionContributor) other) == 0;
        }

    }

}

    /**
     * Retrieves the target platforms.
     * 
     * @return  the target platforms.
     */
    public String[] ModelicaCompiler.getTargetPlatforms() {
        return targetPlatforms;
    }

    /**
     * Sets the target platforms.
     * 
     * @param platforms the platforms to set as compilation targets.
     */
    public void ModelicaCompiler.setTargetPlatforms(String... platforms) {
        this.targetPlatforms = platforms;
    }

    /**
     * Sets the directory new temporary files are created in. 
     * The default value is <code>null</code>, and is interpreted as the current working directory.
     */
    public void ModelicaCompiler.setTempFileDir(File temp) {
        tempDir = temp;
    }

    public void ModelicaCompiler.setOutDir(File out) {
        outDir = out;
        sourceDir = new File(outDir, "sources");
        resourceDir = new File(outDir, "resources");
        sourceDir.mkdirs();
        resourceDir.mkdir();
    }

    public void ModelicaCompiler.setSubOutDir(String out) {
        setOutDir(new File(tempDir, out));
    }

    public void ModelicaCompiler.setRandomOutDir() {
        try {
            File out = File.createTempFile("jmc", "out", tempDir);
            out.delete();
            setOutDir(out);
        } catch (IOException e) {
            throw new ModelicaException("Unable to create temporary directory with prefix 'jmc', suffix 'out' and " +
                    "temp base directory '" + tempDir + "'! java.io.tmpdir: '" + System.getProperty("java.io.tmpdir") + 
                    "'. TMP: '" + System.getenv("TMP") + "'. TEMP: '" + System.getenv("TEMP") + "'.", e);
        }
    }

    /**
     * Deletes the temporary out directory.
     */
    private void ModelicaCompiler.deleteOutDir() {
        if (outDir != null) {
            FileUtil.recursiveDelete(outDir);
        }
        outDir = null;
        sourceDir = null;
        resourceDir = null;
    }

    /**
     * Compiles a Modelica model. A model file name and class must be provided.
     * Prints an error and returns without completion if, for example, a file 
     * can not be found or if the parsing fails. Supports multiple model files.
     * 
     * @param files
     *            Array of model file or library paths.
     * @param cl
     *            The name of the class in the model file to compile.
     * @param target
     *            The target object for the compiler.
     * 
     * @return A flat representation of the class specified by <code>cl</code>.
     *            Returns null for some targets.
     * 
     * @throws beaver.Parser.Exception
     *             If there was an Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing, instantiation
     *             or flattening.
     * @throws FileNotFoundException
     *             If the model file can not be found.
     * @throws IOException
     *             If there was an error reading the model file. (Beaver
     *             exception.)
     * @throws IOException
     *             If there was an error creating the .mof file.
     * @throws ModelicaClassNotFoundException
     *             If the Modelica class to parse, instantiate or flatten is not
     *             found.
     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
     */
    public FClass ModelicaCompiler.compileModel(String files[], String cl, TargetObject target, String compileTo)
          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
        return compileModel(stringsToPaths(files), cl, target, compileTo == null ? null : Paths.get(compileTo));
    }
    
    /**
     * Compiles a Modelica model. A model file name and class must be provided.
     * Prints an error and returns without completion if, for example, a file 
     * can not be found or if the parsing fails. Supports multiple model files.
     * 
     * @param files
     *            Array of model file or library paths.
     * @param cl
     *            The name of the class in the model file to compile.
     * @param target
     *            The target object for the compiler.
     * 
     * @return A flat representation of the class specified by <code>cl</code>.
     *            Returns null for some targets.
     * 
     * @throws beaver.Parser.Exception
     *             If there was an Beaver parsing exception.
     * @throws CompilerException
     *             If errors have been found during the parsing, instantiation
     *             or flattening.
     * @throws FileNotFoundException
     *             If the model file can not be found.
     * @throws IOException
     *             If there was an error reading the model file. (Beaver
     *             exception.)
     * @throws IOException
     *             If there was an error creating the .mof file.
     * @throws ModelicaClassNotFoundException
     *             If the Modelica class to parse, instantiate or flatten is not
     *             found.
     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
     */
     public FClass ModelicaCompiler.compileModel(Path files[], String cl, TargetObject target, Path compileTo)
          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
        boolean doTearDown = true;
        try {
            doTearDown = trySetUp();
            return doCompileModel(files, cl, target, compileTo);
        } finally {
            tryTearDown(doTearDown);
        }
    }
    
    
    public FClass ModelicaCompiler.doCompileModel(Path name[], String cl, TargetObject target, Path compileTo)
          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
        if (target.equals(TargetObject.PARSE)) {
            parseFiles(name);
            return null;
        } else if (target.equals(TargetObject.CHECK)) {
            try {
                instantiateModel(name, cl, target);
            } finally {
                if (outDir != null) {
                    deleteOutDir();
                }
            }
            return null;
        }
        
        log.info("======= Compiling model =======");
        resetCompilationInfo();
        
        FClass fc = null;
        try {
            // compute instance tree
            InstClassDecl icl = instantiateModel(name, cl, target);
            UtilInterface util = icl.root().getUtilInterface();
            String flatName = null;
            if (compileTo != null) {
                Path unitFile = makePackagingDirs(cl, compileTo, target);
                util.setCompilationOutputPath(unitFile);
                flatName = computeFlatName(compileTo, util);
            }
            
            // flattening
            // Throw away source and instance trees when they are not needed any more
            PassAndForget<InstClassDecl> buf = new PassAndForget<InstClassDecl>(icl);
            icl = null;
            fc = flattenModel(buf.pass(), target, flatName);
            
            // Generate code 
            if (target.getCodeGenFlag()) {
                generateCode(fc, target);
                dumpMemoryUseFile(fc, "generated", false);
            }
            
            fc.loadResources(new File(outDir, "resources"));
            
        } finally {
        }
        
        if (options.getBooleanOption("generate_html_diagnostics"))
            setDiagnosticsGenerator(null);
        
        log.info("====== Model compiled successfully =======");
        
        return fc;
    }
    
    /**
     * If true, the compiler has been set up.
     */
    protected boolean ModelicaCompiler.isSetUp = false;
    
    /**
     * If the compiler has not been set up yet, do so and return true. If it
     * has been return false. It is the callers responsibility to call 
     * {@link #tryTearDown(boolean)}.
     */
    protected boolean ModelicaCompiler.trySetUp() {
        return trySetUp(null);
    }
    
    /**
     *@see #trySetUp()
     */
    protected boolean ModelicaCompiler.trySetUp(IErrorHandler eh) {
        if (!isSetUp) {
            setUp(eh);
            return true;
        }
        return false;
    }
    
    /**
     * Set up the compiler. It is the callers responsibility to call
     * {@link #tearDown()}.
     * 
     *@param IErrorHandler The error handler to use when compiling. If null the
     *                     default will be used.
     */
    public void ModelicaCompiler.setUp() {
        setUp(null);
    }
    protected void ModelicaCompiler.setUp(IErrorHandler eh) {
        if (isSetUp) {
            throw new InternalCompilerError("Compiler setup can only be performed once");
        }
        if (eh == null) {
            eh = new DefaultErrorHandler(options.getBooleanOption("halt_on_warning"));
            if (options.getBooleanOption("compliance_as_warning")) {
                eh = new ComplianceWarnErrorHandler(eh);
            }
        }
        setErrorHandler(eh);
        isSetUp = true;
    }
    
    public void ModelicaCompiler.checkSetUp() {
        if (!isSetUp) {
            throw new InternalCompilerError("Compiler setup not performed. Use ModelicaCompiler.setUp()");
        }
    }
    
    /**
     *@param doTearDown If true, run tear down.
     */
    protected void ModelicaCompiler.tryTearDown(boolean doTearDown) {
        if (doTearDown) {
            tearDown();
        }
    }
    
    /**
     * Tear down the compiler. Undo the work done in {@link #setUp(IErrorHandler)}.
     */
    public void ModelicaCompiler.tearDown() {
        createUtilInterface().tearDown();
        setErrorHandler(null);
        isSetUp = false;
    }
    
    protected void ModelicaCompiler.warning(String message) {
        errorHandler.problem(Problem.createProblem(null, ProblemSeverity.WARNING, ProblemKind.OTHER, message));
    }
    
    protected void ModelicaCompiler.error(String message) {
        errorHandler.problem(Problem.createProblem(null, ProblemSeverity.ERROR, ProblemKind.OTHER, message));
    }

    /**
     * Generate an output file.
     * 
     * @param fc    the FClass to generate code for
     * @param tmpl  the path to the template
     * @param gen   the code generator to use 
     * @param dir   the directory to put the output file in
     * @param name  the name of the output file
     */
    SplitFilesCodeStream ModelicaCompiler.generateFile(FClass fc, String tmpl, AbstractGenerator gen, File dir, String name, String header) 
            throws FileNotFoundException {

        if (tmpl != null || gen instanceof GenericXMLGenerator) {
            hookCheckAbort();
            hookCodeGeneratorCreated(gen);
            File outFile = new File(dir, name);
            boolean debugGen = options.getBooleanOption("debug_duplicate_generated");
            SplitFilesCodeStream stream = new SplitFilesCodeStream(outFile, debugGen, header);
            gen.generate(tmpl, stream, header);
            for (File file : stream.files()) {
                log.debug("Generated file '" + file + "'.");
                if (fc != null) {
                    fc.guidManager().addDependentFile(file);
                }
            }
            return stream;
        }
        return null;
    }

    /**
     * Packs an FMU (helper function for {@link #compileUnit()}).
     */
    protected Path ModelicaCompiler.packUnit(String className,
            TargetObject target, FClass fClass) throws PackingFailedException {
        Path unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
        
        hookPackFmu(fClass, outDir);
        hookCheckAbort();
        packUnit(className, target, fClass, unitFile);
        hookFmuPacked(fClass, unitFile.toAbsolutePath().toFile());
        
        return unitFile;
    }
    
    private void ModelicaCompiler.packUnit(String className, TargetObject target, FClass fClass, Path unitFile) {
        try {
            copySourceFiles(fClass, sourceDir, outDir);
            try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(unitFile)))) {
                out.setMethod(ZipOutputStream.DEFLATED);
                zipDir(outDir, out);
            }
        } catch (Exception e) {
            throw new PackingFailedException(String.format("Could not write to '%s'.", unitFile), e);
        }
    }

    /**
     * Copies source files.
     *
     * @param fClass        the flat tree for which the source code was compiled.
     * @param rootDir       the root directory that contains the sources.
     * @param destination   the destination to which to copy the source files.
     * @throws IOException  if there was any error copying or reading files.
     */
    private void ModelicaCompiler.copySourceFiles(FClass fClass, File rootDir, File destination) {
        if(!options.getBooleanOption("copy_source_files_to_fmu")) {
            FileUtil.recursiveDelete(sourceDir);
            sourceDir = null;
        }
    }

    private void ModelicaCompiler.doCompileCCode(TargetObject target,  FClass fc) {
        if (target.getMakeFileFlag() != null) {
                ASTNode.beginStep("compileCCode()");
                String cFileName = fc.nameUnderscore();
                CCompilerDelegator ccompiler = getCCompiler();
                CCompilerArguments ccArgs = new CCompilerArguments(cFileName, fc.myOptions(), target, fc.externalLibraries(), fc.externalLibraryDirectories(), 
                        fc.externalIncludeDirectories());
                ccompiler.compileCCode(ModelicaCompiler.log, ccArgs, outDir);
                ccompiler.copySharedLibs(outDir, ccArgs.getExternalLibraries());
                ASTNode.endStep("compileCCode()");
        }
        hookCodeCompiled();
     }

    /**
     * Calculates the destination directory for a packaged unit. If the specified destination is a file its directory
     * is chosen as destination. If the destination does not exist, it is created (using {@link Filed#createDirectories()}).
     * 
     * @param className
     *          The qualified name of the class for to create a unit for.
     * @param destination
     *          The path where to put the packaged unit.
     * @param target
     *          A {@link TargetObject} containing information about the target.
     * @return
     *          the path to the destination file of the packaged unit.
     */ 
    private Path ModelicaCompiler.makePackagingDirs(String className, Path destination, TargetObject target)
            throws IOException {
        Path dest = destination.toAbsolutePath();
        if (Files.isDirectory(dest)) { 
            String mangledName = FClass.convertClassNameToUnderscore(className);
            dest = dest.resolve(mangledName + "." + target.getUnitSuffix());
        } else {
            Path destDir = dest.getParent();
            if (destDir != null && !Files.isDirectory(destDir)) {
                Files.createDirectories(dest.getParent());
            }
        }
        return dest;
    }
    
    private void ModelicaCompiler.generateAllFiles(FClass fc, TargetObject target, Templates templates, String name)
            throws FileNotFoundException {
        templates.generateCFiles(this, fc, createCGenerator(fc), sourceDir, name);
        templates.generateXMLFiles(this, fc, target.getXMLGenerator(fc), outDir, "modelDescription");
    }
    
    private String ModelicaCompiler.computeFlatName(Path compileTo, UtilInterface util) {
        String flatName = null;
        if (!Files.isDirectory(compileTo)) {
            flatName = compileTo.getFileName().toString();
            int i = flatName.lastIndexOf('.');
            if (i > 0) {
                flatName = flatName.substring(0, i);
            }
        }
        return flatName;
    }

}


aspect CompilationHelpers {


syn boolean SourceRoot.isFileInLibrary() = findOutermostLibraryDir() != null;

syn lazy Path SourceRoot.findOutermostLibraryDir() {
    if (getProgram().getNumUnstructuredEntity() != 1) 
        return null;
    else
        return getProgram().getUnstructuredEntity(0).findOutermostLibraryDir();
}

syn Path SrcStoredDefinition.findOutermostLibraryDir() {
    if (!hasSrcWithin() || !getSrcWithin().hasPackageName()) {
        return null;
    }
    Path me = Paths.get(fileName()).toAbsolutePath();
    if (SrcLibNode.isPackageFile(me)) {
        me = me.getParent();
    }
    Path lib = getSrcWithin().getPackageName().findOutermostLibraryDirForWithin(me);
    return (lib != null) ? lib : null;
}

syn Path SrcAccess.findOutermostLibraryDirForWithin(Path f) = null;
eq SrcDot.findOutermostLibraryDirForWithin(Path f) {
    for (int i = getNumSrcNamedAccess() - 1; i >= 0 && f != null; i--)
        f = getSrcNamedAccess(i).findOutermostLibraryDirForWithin(f);
    return f;
}
eq SrcNamedAccess.findOutermostLibraryDirForWithin(Path f) {
    f = f.getParent();
    if (f != null && f.getFileName().toString().equals(getID()) && SrcLibNode.isStructuredLib(f))
        return f;
    else 
        return null;
}


/**
 * Class for all templates.
 * 
 * Support class for the target enum. Contains all templates, when creating
 * an instance templates are specified with a number.
 */

public class Templates {
    
    private static final int XML = 0;
    private static final int C   = 1;
    
    private ModelicaCompiler.TargetType type;
    
    private String[] templates;
    private String templatePathPrefix;
    private boolean fmuTemplate;
    
    protected static final String[] DEBUG_TEMPLATE_IN_SRC = new String[] {
        "Compiler/ModelicaCBackEnd/templates",
        "Compiler/ModelicaFMUXBackEnd/templates",
        "Compiler/OptimicaFMUXBackEnd/templates",
    };


    public Templates(ModelicaCompiler.TargetType type, OptionRegistry options) {
        switch (type) {
        case FMUME10:
            templates = new String[] { null, "fmi1_me_modelica_template.c" };
            fmuTemplate = true;
            break;
        case FMUCS10:
            templates = new String[] { null, "fmi1_cs_modelica_template.c" };
            fmuTemplate = true;
            break;
        case FMUME20:
        case FMUCS20:
        case FMUMECS20:
            templates = new String[] { null, "fmi2_master_modelica_template.c" };
            fmuTemplate = true;
            break;
        case FMUX:
            templates = new String[] { "jmodelica_model_description.tpl" };
            break;
        case CEVAL:
            templates = new String[] { null, "ceval_external_template.c" };
            break;
        case NULL:
            templates = null;
            break;
        }
        
        this.type = type;
        
        if (CONTRIBUTORS != null) {
            for (TemplateContributor contributor : CONTRIBUTORS) {
                contributor.addTemplates(this, options);
            }
        }
    }

    private String template(int i) {
        return (i < templates.length) ? templates[i] : null;
    }
    
    private String templatePath(String fileName, boolean debugSrcIsHome) {
        if (fileName == null) {
            return null;
        }
        
        File home = EnvironmentUtils.getJModelicaHome();
        if (debugSrcIsHome) {
            for (String dir : DEBUG_TEMPLATE_IN_SRC) {
                File f = new File(new File(home, dir), fileName);
                if (f.exists())
                    return f.getAbsolutePath();
            }
        } 
        return new File(templateDir(), fileName).getAbsolutePath();
    }
    
    private File templateDir() {
        return new File(EnvironmentUtils.getJModelicaHome(), "CodeGenTemplates");
    }
    
    public void generateXMLFiles(ModelicaCompiler mc, FClass fc, AbstractGenerator gen, File sourceDir, String name)
            throws FileNotFoundException {
        mc.generateFile(fc, templatePath(getXMLTemplateName(fc), mc.debugSrcIsHome), gen, sourceDir, name + ".xml", "");
    }
    
    public void generateCFiles(ModelicaCompiler mc, FClass fc, AbstractGenerator gen, File sourceDir, String name)
            throws FileNotFoundException {
        String header = "";
        
        if (fmuTemplate) {
            if (C_HEADER_TEMPLATES != null) {
                for (String tpl : C_HEADER_TEMPLATES) {
                    header = header + "#include \"" + name + "_" + tpl + ".h\"\n";
                }
            }
        }
        
        generateCFiles(mc, fc, gen, sourceDir, name, header);
        
        if (fmuTemplate) {
            if (C_HEADER_TEMPLATES != null) {
                for (String tpl : C_HEADER_TEMPLATES) {
                    String filename = tpl + ".h";
                    String path = new File("FMIBase", filename).toString();
                    
                    mc.generateFile(fc, templatePath(path, mc.debugSrcIsHome), gen, sourceDir, name + "_" + filename, "");
                }
            }

            if (C_SOURCE_TEMPLATES != null) { 
                for (String tpl : C_SOURCE_TEMPLATES) {
                    String filename = tpl + ".c";
                    String path = new File("FMIBase", filename).toString();
                    
                    mc.generateFile(fc, templatePath(path, mc.debugSrcIsHome), gen, sourceDir, name + "_" + filename, header);
                }
            }
        }
    }
    
    public String createExtraCFlagsString(AbstractOptionRegistry options, String name) {
        
        if (C_SOURCE_TEMPLATES == null) {
            return "";
        }
        
        String applies_to = options.getStringOption("cc_extra_flags_applies_to");
        String flags = options.getStringOption("cc_extra_flags");
        StringBuilder sb = new StringBuilder();
        if (applies_to.equals(OptionRegistry.CCompilerFiles.ALL)) {
            sb.append("%");
            sb.append(flags);
        } else if (applies_to.equals(OptionRegistry.CCompilerFiles.FUNCTIONS)) {
            sb.append(name);
            sb.append("_");
            sb.append("funcs");
            sb.append(flags);
        }
        return sb.toString();
    }
    
    private void generateCFiles(ModelicaCompiler mc, FClass fc, AbstractGenerator gen, File sourceDir, String name, String header)
            throws FileNotFoundException {
        mc.generateFile(fc, templatePath(getCTemplateName(fc), mc.debugSrcIsHome), gen, sourceDir, name + ".c", header);
    }
   
    private static ArrayList<TemplateContributor> CONTRIBUTORS;
    private static LinkedHashSet<String> XML_TEMPLATES;
    private static LinkedHashSet<String> C_HEADER_TEMPLATES;
    private static LinkedHashSet<String> C_SOURCE_TEMPLATES;    
    
    public abstract static class TemplateContributor {
        public void addTemplates(Templates templates, OptionRegistry options) { }
    }

    public static <T extends TemplateContributor> T addContributor(T contributor) {
        if (CONTRIBUTORS == null) { CONTRIBUTORS = new ArrayList<TemplateContributor>(); }
        
        CONTRIBUTORS.add(contributor);
        
        return contributor;
    }
    
    public void addXMLTemplates(String ...template) {
        if (XML_TEMPLATES == null) { XML_TEMPLATES = new LinkedHashSet<String>(); }
        
        for (String tmpl : template) {
            XML_TEMPLATES.add(tmpl);
        }
    }
    
    public void addCSourceTemplates(String ...template) {
        if (C_SOURCE_TEMPLATES == null) { C_SOURCE_TEMPLATES = new LinkedHashSet<String>(); }
        
        for (String tmpl : template) {
            C_SOURCE_TEMPLATES.add(tmpl);
        }
    }
    
    public void addCHeaderTemplates(String ...template) {
        if (C_HEADER_TEMPLATES == null) { C_HEADER_TEMPLATES = new LinkedHashSet<String>(); }
        
        for (String tmpl : template) {
            C_HEADER_TEMPLATES.add(tmpl);
        }
    }
}
    
private String Templates.getCTemplateName(FClass fc) {
    return template(C);
}

private String Templates.getXMLTemplateName(FClass fc) {
    return template(XML);
}

private static final Templates.TemplateContributor ModelicaCompiler.BASIC_TEMPLATES =
    Templates.addContributor(new Templates.TemplateContributor() {

        @Override
        public void addTemplates(Templates templates, OptionRegistry options) {
            templates.addCHeaderTemplates("base");
            templates.addCSourceTemplates("base", "init_independent", "init_dependent", "equ_init", "equ", "funcs");
        }
    });

public class XMLGeneratorHolder {

    public static final XMLGeneratorHolder NULL  = new XMLGeneratorHolder();
    public static final XMLGeneratorHolder FMI1  = new XMLGeneratorHolder(Fmi1XMLGenerator.CREATOR);
    public static final XMLGeneratorHolder FMI2  = new XMLGeneratorHolder(Fmi2XMLGenerator.CREATOR);
    public static final XMLGeneratorHolder JMI   = new XMLGeneratorHolder(XMLGenerator.CREATOR);
    public static final XMLGeneratorHolder FMIX  = new XMLGeneratorHolder(XMLGenerator.CREATOR);

    private final GenericXMLGenerator.Creator xmlGen;

    private XMLGeneratorHolder(GenericXMLGenerator.Creator xmlGen) {
        this.xmlGen = xmlGen;
    }

    private XMLGeneratorHolder() {
        this.xmlGen = null;
    }
}

public GenericXMLGenerator XMLGeneratorHolder.getXMLGenerator(FClass fc) {
    if (xmlGen == null) {
        return null;
    }
    
    return (GenericXMLGenerator) xmlGen.create(ASTNode.prettyPrinter, '$', fc);
}

public enum Module { GET_SET }

public class ModulesSettings {
    
    public ModulesSettings(OptionRegistry options) {
        /* Add default modules */
        addLibrary(Module.GET_SET, "jmi_get_set_default");
        
        for (ModuleContributor contributor : CONTRIBUTORS) {
            contributor.addModule(this, options);
        }
    }
     
    public void addLibrary(Module module, String name) {
        libraryNames.put(module,  name);
    }
    
    public java.util.List<String> getLibraryNames() {
        return new ArrayList(libraryNames.values());
    }
    
    private static ArrayList<ModuleContributor> CONTRIBUTORS = new ArrayList<>();
    private static HashMap<Module, String> libraryNames = new HashMap<>();
    
    public abstract static class ModuleContributor {
        public void addModule(ModulesSettings settings, OptionRegistry options) { }
    }
    
    public static <T extends ModuleContributor> T addContributor(T contributor) {
        CONTRIBUTORS.add(contributor);
        
        return contributor;
    }
}

/**
 * Interface for hooking into the compilation process.
 * 
 * Trees passed as arguments may be altered, but implementer must take care 
 * not to break compilation in this way.
 */
public interface CompilationHooks {
    /**
     * Returns <code>true</code> if the compilation should be aborted.
     * 
     * May be called at any time, and is guaranteed to be called before each 
     * compilation step with a separate method in this interface.
     * 
     * If compilation is aborted before it is finished, a 
     * {@link CompilationAbortedException} is thrown.
     */
    boolean shouldAbort(ModelicaCompiler instance);
    
    /**
     * Called after the supplied code files are parsed.
     */
    void filesParsed(ModelicaCompiler instance, SourceRoot sr);
    
    /**
     * Called after the error checks on the instantiated model are finished without errors.
     * 
     * Since the instance tree is built lazily, this step can not be broken up.
     */
    void modelInstantiated(ModelicaCompiler instance, InstClassDecl icd);
    
    /**
     * Called after the model is flattened.
     */
    void modelFlattened(ModelicaCompiler instance, FClass fc);
    
    /**
     * Called after transformations are applied to the flat model.
     */
    void modelTransformed(ModelicaCompiler instance, FClass fc);
    
    /**
     * Called after error checks of the flat model are finished without errors.
     */
    void flatModelChecked(ModelicaCompiler instance, FClass fc);
    
    /**
     * Called after a code generator is created.
     * 
     * Normally called three times.
     */
    void codeGeneratorCreated(ModelicaCompiler instance, AbstractGenerator gen);
    
    /**
     * Called after output code is generated.
     */
    void codeGenerated(ModelicaCompiler instance, FClass fc, File dir);
    
    /**
     * Called after the generated C code is compiled.
     */
    void codeCompiled(ModelicaCompiler instance);

    /**
     * Called before the FMU is packed.
     *
     * @param instance compiler instance calling this hook
     * @param fc the source FClass
     * @param dir the temporary directory containing files to be packed in the FMU
     */
    public void packFmu(ModelicaCompiler instance, FClass fc, File dir);

    /**
     * Called after the FMU is packed.
     */
    void fmuPacked(ModelicaCompiler instance, FClass fc, File path);
}

/**
 * Functional interface for callbacks that should run before compilation starts.
 */
public interface CompilationStartListener {
    /**
     * Called before compiling ({@link ModelicaCompiler#compileUnit()}).
     * @param mc the ModelicaCompiler instance that will start compiling.
     */
    void onCompileStart(ModelicaCompiler mc);
}

public abstract class CompilationHooksImpl implements CompilationHooks {
    @Override
    public boolean shouldAbort(ModelicaCompiler instance) { return false; }
    @Override
    public void modelTransformed(ModelicaCompiler instance, FClass fc) {}
    @Override
    public void modelInstantiated(ModelicaCompiler instance, InstClassDecl icd) {}
    @Override
    public void modelFlattened(ModelicaCompiler instance, FClass fc) {}
    @Override
    public void packFmu(ModelicaCompiler instance, FClass fc, File dir) {}
    @Override
    public void fmuPacked(ModelicaCompiler instance, FClass fc, File path) {}
    @Override
    public void flatModelChecked(ModelicaCompiler instance, FClass fc) {}
    @Override
    public void filesParsed(ModelicaCompiler instance, SourceRoot sr) {}
    @Override
    public void codeGeneratorCreated(ModelicaCompiler instance, AbstractGenerator gen) {}
    @Override
    public void codeGenerated(ModelicaCompiler instance, FClass fc, File dir) {}
    @Override
    public void codeCompiled(ModelicaCompiler instance) {}
}

/**
 * Thrown when a compilation is aborted through a CompilationHooks.
 */
public class CompilationAbortedException extends RuntimeException {
    public CompilationAbortedException() {
    }
    public CompilationAbortedException(String msg) {
        super(msg);
    }
}

    public class ModelicaCompiler {
        static {
            // Ensures that we load the class when this class is loaded!
            GccCompilerDelegator.CREATOR.getClass();
        }
    }
}

aspect Version {
    public class Version {
        public static String parseVersion() {
            String version   = "unknown";
            String jmhome = System.getenv("JMODELICA_HOME");
            if (jmhome != null) {
                File versionFile = new File(jmhome, "version.txt");
                try {
                    BufferedReader is = new BufferedReader(new InputStreamReader(new FileInputStream(versionFile)));
                    StringBuilder sb = new StringBuilder();
                    String line;
                    while ((line = is.readLine()) != null)
                        sb.append(line);
                    version = sb.toString();
                } catch (IOException e) {
                    
                }
            }
            return version;
        }
        
        public static void main(String ... args) {
            System.out.println(parseVersion());
        }
    }
}