OMCompiler/Compiler/Script/CevalScriptBackend.mo - Linux GNU 11.4.0 Code Coverage Report

Directory:	./
Coverage:	low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
	Coverage	Exec / Excl / Total
Lines:	47.9%	1256 / 0 / 2624
Functions:	-%	0 / 1 / 1
Branches:	39.3%	659 / 0 / 1676
    OMCompiler/Compiler/Script/CevalScriptBackend.mo
    
        Line
        Branch
        Exec
        Source
      
        /*
      
         * This file is part of OpenModelica.
      
         *
      
         * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC),
      
         * c/o Linköpings universitet, Department of Computer and Information Science,
      
         * SE-58183 Linköping, Sweden.
      
         *
      
         * All rights reserved.
      
         *
      
         * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF AGPL VERSION 3 LICENSE OR
      
         * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8.
      
         * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
      
         * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GNU AGPL
      
         * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
      
         *
      
         * The OpenModelica software and the OSMC (Open Source Modelica Consortium)
      
         * Public License (OSMC-PL) are obtained from OSMC, either from the above
      
         * address, from the URLs:
      
         * http://www.openmodelica.org or
      
         * https://github.com/OpenModelica/ or
      
         * http://www.ida.liu.se/projects/OpenModelica,
      
         * and in the OpenModelica distribution.
      
         *
      
         * GNU AGPL version 3 is obtained from:
      
         * https://www.gnu.org/licenses/licenses.html#GPL
      
         *
      
         * This program is distributed WITHOUT ANY WARRANTY; without
      
         * even the implied warranty of MERCHANTABILITY or FITNESS
      
         * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
      
         * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
      
         *
      
         * See the full OSMC Public License conditions for more details.
      
         *
      
         */
      
        encapsulated package CevalScriptBackend
      
        "
      
          This module handles constant propagation of expressions for scripting
      
          functions. This module contains the parts not needed for the
      
          bootstrapping.
      
        "
      
        // public imports
      
        import Absyn;
      
        import ProgramUtil;
      
        import AbsynUtil;
      
        import AbsynJLDumpTpl;
      
        import BackendDAE;
      
        import Ceval;
      
        import DAE;
      
        import FCore;
      
        import Interactive;
      
        import InteractiveTypes;
      
        import Interactive.Access;
      
        import InteractiveUtil;
      
        import Values;
      
        import SimCode;
      
        import UnitAbsyn;
      
        // protected imports
      
        protected
      
        import AbsynToJulia;
      
        import AbsynToSCode;
      
        import Autoconf;
      
        import BackendDAECreate;
      
        import BackendDAEOptimize;
      
        import BackendDAEUtil;
      
        import BackendDump;
      
        import BackendEquation;
      
        import BackendVariable;
      
        import Binding;
      
        import BlockCallRewrite;
      
        import CevalScript;
      
        import CodegenWasmJit;
      
        import CodegenWasmJitFunctions;
      
        import CheckModel;
      
        import ClassInf;
      
        import ClockIndexes;
      
        import CodegenFMU;
      
        import ComponentReference;
      
        protected import ComponentReferenceBasics;
      
        import Config;
      
        import Conversion;
      
        import DAEDump;
      
        import DAEQuery;
      
        import DAEUtil;
      
        import Debug;
      
        import DiffAlgorithm;
      
        import ContainerImage;
      
        import Dump;
      
        import Error;
      
        import ErrorExt;
      
        import ExecStat;
      
        import Expression;
      
        protected import ExpressionBasics;
      
        import FBuiltin;
      
        import FGraph;
      
        import Figaro;
      
        import FindZeroCrossings;
      
        import FInst;
      
        import Flags;
      
        import FlagsUtil;
      
        import FlatModel = NFFlatModel;
      
        import FMI;
      
        import FMIExt;
      
        import FunctionTree = NFFlatten.FunctionTree;
      
        import GCExt;
      
        import GlobalScript;
      
        import Graph;
      
        import InnerOuter;
      
        import Inst;
      
        import LexerModelicaDiff;
      
        import List;
      
        import Lookup;
      
        import NFApi;
      
        import NFConvertDAE;
      
        import NFFlatModel;
      
        import NFFlatten;
      
        import NFInst;
      
        import NFSCodeEnv;
      
        import NFSCodeFlatten;
      
        import NFSCodeLookup;
      
        import NFClassDiagram;
      
        import NFDefUseChains;
      
        import NFUsedElements;
      
        import Obfuscate;
      
        import OMGraphics;
      
        import PackageManagement;
      
        import Parser;
      
        import Print;
      
        import Refactor;
      
        import ReverseLookup;
      
        import RewriteRules;
      
        import SCode;
      
        import SCodeDump;
      
        import SCodeUtil;
      
        import SemanticVersion;
      
        import Settings;
      
        import SimCodeMain;
      
        import SimCodeFunction;
      
        import SimCodeFunctionUtil;
      
        import SimCodeUtil;
      
        import StateMachineFlatten;
      
        import SimpleModelicaParser;
      
        import SimulationResults;
      
        import StaticScript;
      
        import StringUtil;
      
        import SymbolicJacobian;
      
        import SymbolTable;
      
        import System;
      
        import TaskGraphResults;
      
        import TotalModelDebug;
      
        import Tpl;
      
        import Types;
      
        import Uncertainties;
      
        import UnitAbsynBuilder;
      
        import UnitParserExt;
      
        import UnorderedSet;
      
        import Util;
      
        import ValuesDump;
      
        import ValuesMake;
      
        import ValuesUtil;
      
        import XMLDump;
      
        protected constant DAE.Type simulationResultType_rtest = DAE.T_COMPLEX(ClassInf.RECORD(Absyn.IDENT("SimulationResult")),{
      
          DAE.TYPES_VAR("resultFile",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("simulationOptions",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("messages",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE())
      
          },NONE(), false);
      
        protected constant DAE.Type simulationResultType_full = DAE.T_COMPLEX(ClassInf.RECORD(Absyn.IDENT("SimulationResult")),{
      
          DAE.TYPES_VAR("resultFile",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("simulationOptions",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("messages",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeFrontend",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeBackend",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeSimCode",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeTemplates",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeCompile",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeSimulation",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("timeTotal",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE())
      
          },NONE(), false);
      
        protected constant DAE.Type simulationResultType_drModelica = DAE.T_COMPLEX(ClassInf.RECORD(Absyn.IDENT("SimulationResult")),{
      
          DAE.TYPES_VAR("messages",DAE.dummyAttrVar,DAE.T_STRING_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("flatteningTime",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE()),
      
          DAE.TYPES_VAR("simulationTime",DAE.dummyAttrVar,DAE.T_REAL_DEFAULT,DAE.UNBOUND(),false,NONE())
      
          },NONE(), false);
      
        //these are in reversed order than above
      
        protected constant list<tuple<String,Values.Value>> zeroAdditionalSimulationResultValues =
      
          { ("timeTotal",      Values.REAL(0.0)),
      
            ("timeSimulation", Values.REAL(0.0)),
      
            ("timeCompile",    Values.REAL(0.0)),
      
            ("timeTemplates",  Values.REAL(0.0)),
      
            ("timeSimCode",    Values.REAL(0.0)),
      
            ("timeBackend",    Values.REAL(0.0)),
      
            ("timeFrontend",   Values.REAL(0.0))
      
          };
      
        // The build-phase times only (reversed order), for paths that skip translate/
      
        // build (resimulateExecutable) but still run the model: createSimulationResult-
      
        // FromcallModelExecutable adds the real timeTotal/timeSimulation, and these keep
      
        // the result a complete SimulationResult record (0.0 for the phases not run)
      
        // instead of a truncated one missing fields.
      
        protected constant list<tuple<String,Values.Value>> zeroBuildPhaseResultValues =
      
          { ("timeCompile",    Values.REAL(0.0)),
      
            ("timeTemplates",  Values.REAL(0.0)),
      
            ("timeSimCode",    Values.REAL(0.0)),
      
            ("timeBackend",    Values.REAL(0.0)),
      
            ("timeFrontend",   Values.REAL(0.0))
      
          };
      
        protected constant DAE.Exp defaultStartTime         = DAE.RCONST(0.0)     "default startTime";
      
        protected constant DAE.Exp defaultStopTime          = DAE.RCONST(1.0)     "default stopTime";
      
        protected constant DAE.Exp defaultNumberOfIntervals = DAE.ICONST(500)     "default numberOfIntervals";
      
        protected constant DAE.Exp defaultStepSize          = DAE.RCONST(0.002)   "default stepSize";
      
        protected constant DAE.Exp defaultTolerance         = DAE.RCONST(1e-6)    "default tolerance";
      
        protected constant DAE.Exp defaultMethod            = DAE.SCONST("dassl") "default method";
      
        protected constant DAE.Exp defaultFileNamePrefix    = DAE.SCONST("")      "default fileNamePrefix";
      
        protected constant DAE.Exp defaultOptions           = DAE.SCONST("")      "default options";
      
        protected constant DAE.Exp defaultOutputFormat      = DAE.SCONST("mat")   "default outputFormat";
      
        protected constant DAE.Exp defaultVariableFilter    = DAE.SCONST(".*")    "default variableFilter; does whole string matching, i.e. it becomes ^.*$ in the runtime";
      
        protected constant DAE.Exp defaultCflags            = DAE.SCONST("")      "default compiler flags";
      
        protected constant DAE.Exp defaultSimflags          = DAE.SCONST("")      "default simulation flags";
      
        protected constant InteractiveTypes.SimulationOptions defaultSimulationOptions =
      
          InteractiveTypes.SIMULATION_OPTIONS(
      
            defaultStartTime,
      
            defaultStopTime,
      
            defaultNumberOfIntervals,
      
            defaultStepSize,
      
            defaultTolerance,
      
            defaultMethod,
      
            defaultFileNamePrefix,
      
            defaultOptions,
      
            defaultOutputFormat,
      
            defaultVariableFilter,
      
            defaultCflags,
      
            defaultSimflags
      
            ) "default simulation options";
      
        protected constant list<String> simulationOptionsNames =
      
          {
      
            "startTime",
      
            "stopTime",
      
            "numberOfIntervals",
      
            "tolerance",
      
            "method",
      
            "fileNamePrefix",
      
            "options",
      
            "outputFormat",
      
            "variableFilter",
      
            "cflags",
      
            "simflags"
      
          } "names of simulation options";
      
        public function getSimulationResultType
      
          output DAE.Type t;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1211 times.

        1211
          t := if Testsuite.isRunning() then simulationResultType_rtest else simulationResultType_full;
      
        end getSimulationResultType;
      
        public function getDrModelicaSimulationResultType
      
          output DAE.Type t;
      
        algorithm
      
        ✗
          t := if Testsuite.isRunning() then simulationResultType_rtest else simulationResultType_drModelica;
      
        end getDrModelicaSimulationResultType;
      
        public function createSimulationResult
      
          input String resultFile;
      
          input String options;
      
          input String message;
      
          input list<tuple<String,Values.Value>> inAddResultValues "additional values in reversed order; expected values see in CevalScript.simulationResultType_full";
      
          output Values.Value res;
      
        protected
      
          list<tuple<String,Values.Value>> resultValues;
      
          list<Values.Value> vals;
      
          list<String> fields;
      
          Boolean notest;
      
        algorithm
      
        1211
          resultValues := listReverse(inAddResultValues);
      
          //TODO: maybe we should test if the fields are the ones in simulationResultType_full
      
        1211
          notest := not Testsuite.isRunning();
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1211 times.

        1211
          fields := if notest then List.map(resultValues, Util.tuple21) else {};
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1211 times.

        1211
          vals := if notest then List.map(resultValues, Util.tuple22) else {};
      
        2422
          res := Values.RECORD(Absyn.IDENT("SimulationResult"),
      
            Values.STRING(resultFile)::Values.STRING(options)::Values.STRING(message)::vals,
      
            "resultFile"::"simulationOptions"::"messages"::fields,-1);
      
        end createSimulationResult;
      
        public function createSimulationResultFailure
      
          input String message;
      
          input String options;
      
          output Values.Value res;
      
        protected
      
        algorithm
      
        15
          res := createSimulationResult("", options, message, zeroAdditionalSimulationResultValues);
      
        end createSimulationResultFailure;
      
        protected function buildCurrentSimulationResultExp
      
          output DAE.Exp outExp;
      
        protected
      
          DAE.ComponentRef cref;
      
        algorithm
      
        2422
          cref := ComponentReferenceBasics.makeCrefIdent("currentSimulationResult",DAE.T_UNKNOWN_DEFAULT,{});
      
        2422
          outExp := Expression.makeCrefExp(cref,DAE.T_UNKNOWN_DEFAULT);
      
        end buildCurrentSimulationResultExp;
      
        protected function cevalCurrentSimulationResultExp
      
          input FCore.Cache inCache;
      
          input FCore.Graph env;
      
          input String inputFilename;
      
          input Absyn.Msg msg;
      
          output FCore.Cache outCache;
      
          output String filename;
      
        algorithm
      
          (outCache,filename) := match (inCache, inputFilename)
      
            local FCore.Cache cache;
      
            case (cache, "<default>")
      
              algorithm
      
        ✗
                (cache,Values.STRING(filename)) := Ceval.ceval(cache,env,buildCurrentSimulationResultExp(),true,msg,0);
      
              then (cache,filename);
      
            else (inCache,inputFilename);
      
          end match;
      
        end cevalCurrentSimulationResultExp;
      
        public function convertSimulationOptionsToSimCode "converts SimulationOptions to SimCode.SimulationSettings"
      
          input InteractiveTypes.SimulationOptions opts;
      
          output SimCode.SimulationSettings settings;
      
        algorithm
      
          settings := match opts
      
          local
      
            Real startTime,stopTime,stepSize,tolerance;
      
            Integer nIntervals;
      
            String method,format,varFilter,cflags,options,simflags;
      
            case InteractiveTypes.SIMULATION_OPTIONS(
      
              DAE.RCONST(startTime),
      
              DAE.RCONST(stopTime),
      
              DAE.ICONST(nIntervals),
      
              DAE.RCONST(stepSize),
      
              DAE.RCONST(tolerance),
      
              DAE.SCONST(method),
      
              _, /* fileNamePrefix*/
      
              _, /* options */
      
              DAE.SCONST(format),
      
              DAE.SCONST(varFilter),
      
              DAE.SCONST(cflags),
      
              DAE.SCONST(simflags)) algorithm
      
                options := "";
      
        1353
            then SimCode.SIMULATION_SETTINGS(startTime,stopTime,nIntervals,stepSize,tolerance,method,options,format,varFilter,cflags,simflags);
      
          end match;
      
        end convertSimulationOptionsToSimCode;
      
        public function buildSimulationOptions
      
        "@author: adrpo
      
          builds a SimulationOptions record from the given input"
      
          input DAE.Exp startTime "start time, default 0.0";
      
          input DAE.Exp stopTime "stop time, default 1.0";
      
          input DAE.Exp numberOfIntervals "number of intervals, default 500";
      
          input DAE.Exp stepSize "stepSize, default (stopTime-startTime)/numberOfIntervals";
      
          input DAE.Exp tolerance "tolerance, default 1e-6";
      
          input DAE.Exp method "method, default 'dassl'";
      
          input DAE.Exp fileNamePrefix "file name prefix, default ''";
      
          input DAE.Exp options "options, default ''";
      
          input DAE.Exp outputFormat "output format, default 'plt'";
      
          input DAE.Exp variableFilter;
      
          input DAE.Exp cflags;
      
          input DAE.Exp simflags;
      
          output InteractiveTypes.SimulationOptions outSimulationOptions;
      
        algorithm
      
        ✗
          outSimulationOptions :=
      
            InteractiveTypes.SIMULATION_OPTIONS(
      
            startTime,
      
            stopTime,
      
            numberOfIntervals,
      
            stepSize,
      
            tolerance,
      
            method,
      
            fileNamePrefix,
      
            options,
      
            outputFormat,
      
            variableFilter,
      
            cflags,
      
            simflags
      
          );
      
        end buildSimulationOptions;
      
        public function getSimulationOption
      
        "@author: adrpo
      
          get the value from simulation option"
      
          input InteractiveTypes.SimulationOptions inSimOpt;
      
          input String optionName;
      
          output DAE.Exp outOptionValue;
      
        algorithm
      
          outOptionValue := match(inSimOpt, optionName)
      
            local
      
              DAE.Exp e;
      
              String name, msg;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(startTime = e),         "startTime")         then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(stopTime = e),          "stopTime")          then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(numberOfIntervals = e), "numberOfIntervals") then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(stepSize = e),          "stepSize")          then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(tolerance = e),         "tolerance")         then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(method = e),            "method")            then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(fileNamePrefix = e),    "fileNamePrefix")    then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(options = e),           "options")           then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(outputFormat = e),      "outputFormat")      then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(variableFilter = e),    "variableFilter")    then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(cflags = e),            "cflags")            then e;
      
            case (InteractiveTypes.SIMULATION_OPTIONS(simflags = e),          "simflags")          then e;
      
            case (_,                                         name)
      
              algorithm
      
        ✗
                msg := "Unknown simulation option: " + name;
      
        ✗
                Error.addCompilerWarning(msg);
      
        ✗
              then
      
                fail();
      
          end match;
      
        end getSimulationOption;
      
        public function buildSimulationOptionsFromModelExperimentAnnotation
      
        "@author: adrpo
      
          retrieve annotation(experiment(....)) values and build a SimulationOptions object to return"
      
          input Absyn.Path inModelPath;
      
          input String inFileNamePrefix;
      
          input Option<InteractiveTypes.SimulationOptions> defaultOption;
      
          output InteractiveTypes.SimulationOptions outSimOpt;
      
        algorithm
      
          outSimOpt := matchcontinue defaultOption
      
            local
      
              InteractiveTypes.SimulationOptions defaults, simOpt;
      
              String experimentAnnotationStr;
      
              list<Absyn.NamedArg> named;
      
              Option<Absyn.Modification> experiment_ann;
      
            // search inside annotation(experiment(...))
      
            case _
      
              algorithm
      
        2648
                loadProgram(inModelPath);
      
        2648
                defaults := Util.getOptionOrDefault(defaultOption, setFileNamePrefixInSimulationOptions(defaultSimulationOptions, inFileNamePrefix));
      
        2648
                experiment_ann := InteractiveUtil.getInheritedAnnotation(inModelPath, "experiment", SymbolTable.getAbsyn());
      
                // TODO: Get the values from the modifier directly instead of this mess.
      
        2647
                experimentAnnotationStr := Interactive.getExperimentAnnotationString(experiment_ann);
      
                // parse the string we get back, either {} or {StopTime=5, Tolerance = 0.10};
      
                // jump to next case if the annotation is empty
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 449 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        449
                false := stringEq(experimentAnnotationStr, "{}");
      
                // get rid of '{' and '}'
      
        449
                experimentAnnotationStr := System.stringReplace(experimentAnnotationStr, "{", "");
      
        449
                experimentAnnotationStr := System.stringReplace(experimentAnnotationStr, "}", "");
      
          5/10✗ Branch 3 not taken.
✓ Branch 4 taken 449 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 449 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 449 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 449 times.
✗ Branch 11 not taken.
✓ Branch 12 taken 449 times.

        449
                GlobalScript.ISTMTS({GlobalScript.IEXP(exp = Absyn.CALL(functionArgs = Absyn.FUNCTIONARGS(_, named)))}, _)
      
                := Parser.parsestringexp("experiment(" + experimentAnnotationStr + ");\n", "<experiment>");
      
        449
                simOpt := populateSimulationOptions(defaults, named);
      
              then
      
                simOpt;
      
            // if we fail, just use the defaults
      
            else
      
              algorithm
      
        2199
                defaults := setFileNamePrefixInSimulationOptions(defaultSimulationOptions, inFileNamePrefix);
      
              then defaults;
      
          end matchcontinue;
      
        end buildSimulationOptionsFromModelExperimentAnnotation;
      
        protected function setFileNamePrefixInSimulationOptions
      
          input  InteractiveTypes.SimulationOptions inSimOpt;
      
          input  String inFileNamePrefix;
      
          output InteractiveTypes.SimulationOptions outSimOpt;
      
        protected
      
          DAE.Exp startTime, stopTime, numberOfIntervals, stepSize, tolerance, method, options, outputFormat, variableFilter, cflags, simflags;
      
          Boolean UseOtimica;
      
        algorithm
      
          4/4✓ Branch 1 taken 4805 times.
✓ Branch 2 taken 42 times.
✓ Branch 4 taken 24 times.
✓ Branch 5 taken 4781 times.

        4847
          UseOtimica := Config.acceptOptimicaGrammar() or Flags.getConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM);
      
        4847
          InteractiveTypes.SIMULATION_OPTIONS(startTime, stopTime, numberOfIntervals, stepSize, tolerance, method, _, options, outputFormat, variableFilter, cflags, simflags) := inSimOpt;
      
          2/2✓ Branch 0 taken 4781 times.
✓ Branch 1 taken 66 times.

        4847
          if UseOtimica then
      
            method := DAE.SCONST("optimization");
      
          elseif  Flags.getConfigBool(Flags.DAE_MODE) then
      
            method := DAE.SCONST("ida");
      
          end if;
      
          2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 4781 times.

        4847
          numberOfIntervals := if UseOtimica then DAE.ICONST(50) else numberOfIntervals;
      
        4847
          outSimOpt := InteractiveTypes.SIMULATION_OPTIONS(startTime, stopTime, numberOfIntervals, stepSize, tolerance, method, DAE.SCONST(inFileNamePrefix), options, outputFormat, variableFilter, cflags, simflags);
      
        end setFileNamePrefixInSimulationOptions;
      
        protected function getConst
      
        "@author: adrpo
      
          Tranform a literal Absyn.Exp to DAE.Exp with the given DAE.Type"
      
          input  Absyn.Exp inAbsynExp;
      
          input DAE.Type inExpType;
      
          output DAE.Exp outExp;
      
        algorithm
      
          outExp := matchcontinue(inAbsynExp, inExpType)
      
            local
      
              Integer i;
      
              Real r;
      
              Absyn.Exp exp;
      
              String str;
      
            case (Absyn.UNARY(Absyn.UMINUS(),exp), _)
      
              algorithm
      
          1/2✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.

        2
                DAE.ICONST(i) := getConst(exp, inExpType);
      
        ✗
                i := intNeg(i);
      
        ✗
              then
      
                DAE.ICONST(i);
      
            case (Absyn.UNARY(Absyn.UMINUS(),exp), _)
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

        2
                DAE.RCONST(r) := getConst(exp, inExpType);
      
        2
                r := realNeg(r);
      
        2
              then
      
                DAE.RCONST(r);
      
        49
            case (Absyn.INTEGER(i), DAE.T_INTEGER())  then DAE.ICONST(i);
      
        328
            case (Absyn.REAL(str),    DAE.T_REAL()) algorithm r := stringReal(str); then DAE.RCONST(r);
      
        397
            case (Absyn.INTEGER(i), DAE.T_REAL()) algorithm r := intReal(i); then DAE.RCONST(r);
      
            else
      
              algorithm
      
        ✗
                str := "CevalScript.getConst: experiment annotation contains unsupported expression: " + Dump.printExpStr(inAbsynExp) + " of type " + TypesDump.unparseType(inExpType) + "\n";
      
        ✗
                Error.addCompilerError(str);
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
        end getConst;
      
        protected function populateSimulationOptions
      
          input output InteractiveTypes.SimulationOptions options;
      
          input list<Absyn.NamedArg> args;
      
        protected
      
          String name;
      
          Absyn.Exp value;
      
          Option<DAE.Exp> interval = NONE();
      
        algorithm
      
          2/2✓ Branch 0 taken 781 times.
✓ Branch 1 taken 449 times.

        1230
          for arg in args loop
      
        781
            Absyn.NAMEDARG(argName = name, argValue = value) := arg;
      
            () := match name
      
        95
              case "Tolerance"         algorithm options.tolerance := getConst(value, DAE.T_REAL_DEFAULT);            then ();
      
        88
              case "StartTime"         algorithm options.startTime := getConst(value, DAE.T_REAL_DEFAULT);            then ();
      
        448
              case "StopTime"          algorithm options.stopTime := getConst(value, DAE.T_REAL_DEFAULT);             then ();
      
        49
              case "NumberOfIntervals" algorithm options.numberOfIntervals := getConst(value, DAE.T_INTEGER_DEFAULT); then ();
      
        92
              case "Interval"          algorithm interval := SOME(getConst(value, DAE.T_REAL_DEFAULT));               then ();
      
              else
      
                algorithm
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 6 times.

        9
                  if not StringUtil.startsWith(name, "__") then
      
        3
                    Error.addCompilerWarning("Ignoring unknown experiment annotation option: " +
      
                      name + " = " + Dump.printExpStr(value));
      
                  end if;
      
                then
      
                  ();
      
            end match;
      
          end for;
      
          // Interval needs to be handled last since it depends on the start and stop time.
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 449 times.
✓ Branch 2 taken 357 times.
✓ Branch 3 taken 92 times.

        449
          if isSome(interval) then
      
        92
            options := setSimulationOptionsInterval(options, Expression.toReal(Util.getOption(interval)));
      
          else
      
            /*fix issue 12070, set proper default value of stepSize when Interval annotation is not provided
      
              stepSize = (StopTime-StartTime)/500
      
            */
      
        714
            options.stepSize := DAE.RCONST((Expression.toReal(options.stopTime) - Expression.toReal(options.startTime)) / 500);
      
          end if;
      
        end populateSimulationOptions;
      
        function setSimulationOptionsInterval
      
          input output InteractiveTypes.SimulationOptions options;
      
          input Real interval;
      
        protected
      
          Real start_time, stop_time;
      
        algorithm
      
        92
          start_time := Expression.toReal(options.startTime);
      
        92
          stop_time := Expression.toReal(options.stopTime);
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 92 times.

        92
          options.stepSize := DAE.RCONST(interval);
      
          // Round to nearest integer
      
          options.numberOfIntervals := DAE.ICONST(realInt((stop_time - start_time) / interval + 0.5));
      
        end setSimulationOptionsInterval;
      
        protected function simOptionsAsString
      
        "@author: adrpo
      
          Gets the simulation options as string"
      
          input list<Values.Value> vals;
      
          output String str;
      
        algorithm
      
          str := matchcontinue vals
      
            local
      
              list<String> simOptsValues;
      
              list<Values.Value> lst;
      
            case _::lst
      
              algorithm
      
                // build a list with the values
      
        1211
                simOptsValues := List.map(lst, ValuesDump.valString);
      
                // trim " from strings!
      
        1211
                simOptsValues := List.map2(simOptsValues, System.stringReplace, "\"", "\'");
      
        1211
                str := Util.buildMapStr(simulationOptionsNames, simOptsValues, " = ", ", ");
      
              then
      
                str;
      
            // on failure
      
            case _::lst
      
              algorithm
      
                // build a list with the values
      
        ✗
                simOptsValues := List.map(lst, ValuesDump.valString);
      
                // trim " from strings!
      
        ✗
                simOptsValues := List.map2(simOptsValues, System.stringReplace, "\"", "\'");
      
        ✗
                str := stringDelimitList(simOptsValues, ", ");
      
              then
      
                str;
      
          end matchcontinue;
      
        end simOptionsAsString;
      
        protected function diffSanityCheckEqual
      
          "Sanity check for the Modelica source diff/merge: returns true when s1 and
      
           s2 represent the same Modelica program. Code tokens are compared strictly
      
           (ignoring whitespace), while comments are compared as a multiset so the
      
           merge step is free to relocate them."
      
          input String s1;
      
          input String s2;
      
          output Boolean b;
      
        protected
      
          import LexerModelicaDiff.{Token,tokenContent,scanString,isLineComment,isBlockComment,blockCommentCanonical,modelicaDiffTokenWhitespace};
      
          list<Token> ts1, ts2;
      
          list<String> comments1, comments2;
      
        algorithm
      
        46
          (ts1, _) := scanString(s1);
      
        46
          (ts2, _) := scanString(s2);
      
          14/16✓ Branch 1 taken 746 times.
✓ Branch 2 taken 1083 times.
✓ Branch 3 taken 1829 times.
✓ Branch 4 taken 46 times.
✓ Branch 5 taken 1083 times.
✓ Branch 6 taken 46 times.
✓ Branch 9 taken 746 times.
✓ Branch 10 taken 1083 times.
✓ Branch 11 taken 1829 times.
✓ Branch 12 taken 46 times.
✓ Branch 13 taken 1083 times.
✓ Branch 14 taken 46 times.
✓ Branch 18 taken 46 times.
✗ Branch 19 not taken.
✗ Branch 23 not taken.
✓ Branch 24 taken 46 times.

        3704
          if stringAppendList(list(tokenContent(t) for t guard not modelicaDiffTokenWhitespace(t) in ts1)) <>
      
             stringAppendList(list(tokenContent(t) for t guard not modelicaDiffTokenWhitespace(t) in ts2)) then
      
            b := false;
      
        ✗
            return;
      
          end if;
      
          8/8✓ Branch 1 taken 1821 times.
✓ Branch 2 taken 8 times.
✓ Branch 4 taken 1809 times.
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 1829 times.
✓ Branch 7 taken 46 times.
✓ Branch 8 taken 20 times.
✓ Branch 9 taken 46 times.

        1875
          comments1 := List.sort(list(diffSanityCheckCommentStr(t)
      
                                      for t guard isLineComment(t) or isBlockComment(t) in ts1),
      
                                 Util.strcmpBool);
      
          8/8✓ Branch 1 taken 1821 times.
✓ Branch 2 taken 8 times.
✓ Branch 4 taken 1809 times.
✓ Branch 5 taken 12 times.
✓ Branch 6 taken 1829 times.
✓ Branch 7 taken 46 times.
✓ Branch 8 taken 20 times.
✓ Branch 9 taken 46 times.

        1875
          comments2 := List.sort(list(diffSanityCheckCommentStr(t)
      
                                      for t guard isLineComment(t) or isBlockComment(t) in ts2),
      
                                 Util.strcmpBool);
      
        46
          b := List.isEqualOnTrue(comments1, comments2, stringEq);
      
        end diffSanityCheckEqual;
      
        protected function diffSanityCheckCommentStr
      
          "Canonical string form of a comment token. Block comments are normalised by
      
           trimming each line, so that re-indented block comments compare equal."
      
          input LexerModelicaDiff.Token t;
      
          output String s;
      
        protected
      
          import LexerModelicaDiff.{tokenContent,isBlockComment,blockCommentCanonical};
      
        algorithm
      
          2/2✓ Branch 1 taken 24 times.
✓ Branch 2 taken 16 times.

        40
          s := if isBlockComment(t) then stringDelimitList(blockCommentCanonical(t), "\n")
      
                                    else tokenContent(t);
      
        end diffSanityCheckCommentStr;
      
        public function cevalInteractiveFunctions3
      
        "defined in the interactive environment."
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input String inFunctionName;
      
          input list<Values.Value> inVals;
      
          input Absyn.Msg msg;
      
          output FCore.Cache outCache = inCache;
      
          output Values.Value outValue;
      
        protected
      
          import LexerModelicaDiff.{Token,TokenId,tokenContent,scanString,reportErrors,filterModelicaDiff,modelicaDiffTokenEq,modelicaDiffTokenWhitespace};
      
          import DiffAlgorithm.{Diff,diff,printActual,printDiffTerminalColor,printDiffXml};
      
        algorithm
      
          outValue := matchcontinue (inFunctionName,inVals)
      
            local
      
              String simflags,s1,s2,s3,s4,s5,str,str1,str2,str3,str4,executable,
      
                     outputFormat_str,initfilename,pd,executableSuffixedExe,sim_call,result_file,filename_1,filename,
      
                     name,errMsg, res,workdir,filenameprefix,compileDir,exeDir, logFile, outputFile,
      
                     strlinearizeTime, modeldescriptionfilename, tmpDir, tmpFile, bom, description, resimulateExecutable;
      
              list<Values.Value> vals;
      
              Absyn.Path path,classpath,className;
      
              SCode.Program sp;
      
              FCore.Graph env;
      
              Absyn.Program p,pnew;
      
              Absyn.Class absynClass;
      
              Absyn.Element elem;
      
              Absyn.Exp aexp;
      
              DAE.DAElist dae;
      
              BackendDAE.BackendDAE daelow;
      
              BackendDAE.Variables vars;
      
              BackendDAE.EquationArray eqnarr;
      
              array<list<Integer>> m;
      
              Option<list<tuple<Integer, Integer, BackendDAE.Equation>>> jac;
      
              Values.Value ret_val,simValue,v,v1,v2;
      
              SimCode.SimulationSettings simSettings;
      
              Integer i,i1,resI;
      
              Option<Integer> fmiContext, fmiInstance, fmiModelVariablesInstance; /* void* implementation: DO NOT UNBOX THE POINTER AS THAT MIGHT CHANGE IT. Just treat this as an opaque type. */
      
              Integer fmiLogLevel, direction;
      
              list<Integer> is;
      
              list<FMI.TypeDefinitions> fmiTypeDefinitionsList;
      
              list<FMI.ModelVariables> fmiModelVariablesList;
      
              FMI.ExperimentAnnotation fmiExperimentAnnotation;
      
              FMI.Info fmiInfo;
      
              list<String> strs,strs1,strs2;
      
              Real timeTotal,timeSimulation,linearizeTime,offset,offset1,offset2,scaleFactor,scaleFactor1,scaleFactor2;
      
              Boolean bval, b, b1, b2, b3, b4, b5, showProtected, inputConnectors, outputConnectors, sanityCheckFailed, lineEndingIsCRLF;
      
              list<tuple<String,Values.Value>> resultValues;
      
              list<Values.Value> cvars;
      
              list<Absyn.Path> paths;
      
              list<Absyn.Class> classes;
      
              list<Absyn.ElementArg> eltargs;
      
              Absyn.Within within_;
      
              BackendDAE.EqSystem syst;
      
              BackendDAE.Shared shared;
      
              Boolean dumpExtractionSteps;
      
              list<Boolean> blst;
      
              UnitAbsyn.Unit u1,u2;
      
              list<Token> tokens1, tokens2, errorTokens;
      
              list<SimpleModelicaParser.ParseTree> parseTree1, parseTree2;
      
              //list<tuple<Diff, list<Token>>> diffs;
      
              list<tuple<Diff, list<SimpleModelicaParser.ParseTree>>> treeDiffs;
      
              SymbolTable forkedSymbolTable;
      
              SimCode.SimulationSettings simSettings;
      
            case ("runScriptParallel",{Values.ARRAY(valueLst=vals),Values.INTEGER(i),Values.BOOL(true)})
      
              algorithm
      
        ✗
                strs := List.map(vals,ValuesUtil.extractValueString);
      
                /* One of the few times we can allow to directly manipulate the symbol table
      
                 * Each thread will get a copy of the symbol table and the results will not
      
                 * be stored in the parent.
      
                 */
      
        ✗
                forkedSymbolTable := SymbolTable.get();
      
        ✗
                blst := System.launchParallelTasks(i, List.map1(strs, Util.makeTuple, forkedSymbolTable), Interactive.evaluateFork);
      
        ✗
                v := ValuesMake.makeArray(List.map(blst, ValuesMake.makeBoolean));
      
        ✗
                SymbolTable.update(forkedSymbolTable);
      
              then
      
                v;
      
            case ("runScriptParallel",{Values.ARRAY(valueLst=vals),Values.INTEGER(i),Values.BOOL(false)})
      
              algorithm
      
        ✗
                strs := List.map(vals,ValuesUtil.extractValueString);
      
        ✗
                strs := List.map1r(strs, stringAppend, stringAppend(Settings.getInstallationDirectoryPath(),"/bin/omc "));
      
        ✗
                is := System.systemCallParallel(strs,i);
      
        ✗
              then
      
                ValuesMake.makeArray(List.map(List.map1(is,intEq,0), ValuesMake.makeBoolean));
      
            case ("runScriptParallel",{Values.ARRAY(valueLst=vals),_,_})
      
        ✗
              then ValuesMake.makeArray(List.fill(Values.BOOL(false), listLength(vals)));
      
            case ("setClassComment",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str)})
      
              algorithm
      
        2
                (p,b) := Interactive.setClassComment(path, str, SymbolTable.getAbsyn());
      
        2
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

        2
              then
      
                Values.BOOL(b);
      
            case ("isShortDefinition", {Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                b := isShortDefinition(path, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("getUsedClassNames",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                sp := SymbolTable.getSCode();
      
        ✗
                (sp, _) := NFSCodeFlatten.flattenClassInProgram(path, sp);
      
        ✗
                sp := SCodeUtil.removeBuiltinsFromTopScope(sp);
      
        ✗
                paths := Interactive.getSCodeClassNamesRecursive(sp);
      
                // paths = bcallret2(sort, List.sort, paths, AbsynUtil.pathGe, paths);
      
        ✗
              then
      
                ValuesMake.makeCodeTypeNameArray(paths);
      
            case ("getUsedClassNames",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getClassComment",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                elem := InteractiveUtil.getPathedElementInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := System.unescapedString(getClassElementComment(elem));
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getClassComment",{Values.CODE(Absyn.C_TYPENAME(_))})
      
              then
      
                Values.STRING("");
      
            case ("getPackages",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("AllLoadedClasses")))})
      
              algorithm
      
        ✗
                paths := Interactive.getTopPackages(SymbolTable.getAbsyn());
      
        ✗
              then
      
                ValuesMake.makeCodeTypeNameArray(paths);
      
            case ("getPackages",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                paths := Interactive.getPackagesInPath(path, SymbolTable.getAbsyn());
      
        ✗
              then
      
                ValuesMake.makeCodeTypeNameArray(paths);
      
            case ("convertUnits",{Values.STRING(str1),Values.STRING(str2)})
      
              algorithm
      
        14
                Error.clearMessages() "Clear messages";
      
        14
                UnitParserExt.initSIUnits();
      
        14
                (u1,scaleFactor1,offset1) := UnitAbsynBuilder.str2unitWithScaleFactor(str1,NONE());
      
        14
                (u2,scaleFactor2,offset2) := UnitAbsynBuilder.str2unitWithScaleFactor(str2,NONE());
      
        13
                b := valueEq(u1,u2);
      
                /* How to calculate the final scale factor and offset:
      
                F = C*1.8 + 32
      
                C = (F - 32)/1.8 = F/1.8 - 32/1.8
      
                */
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.

        13
                scaleFactor := realDiv(scaleFactor2, scaleFactor1);
      
        13
                offset := realDiv(realSub(offset2, offset1), scaleFactor1);
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 12 times.

        27
              then
      
                Values.TUPLE({Values.BOOL(b),Values.REAL(scaleFactor),Values.REAL(offset)});
      
            case ("convertUnits",{Values.STRING(_),Values.STRING(_)})
      
              then Values.TUPLE({Values.BOOL(false),Values.REAL(1.0),Values.REAL(0.0)});
      
            case ("getDerivedUnits",{Values.STRING(str1)})
      
              algorithm
      
        4
                Error.clearMessages() "Clear messages";
      
        4
                UnitParserExt.initSIUnits();
      
        4
                u1 := UnitAbsynBuilder.str2unit(str1, NONE());
      
        3
                strs := UnitAbsynBuilder.getDerivedUnits(u1, str1);
      
        3
              then
      
                ValuesMake.makeArray(List.map(strs, ValuesMake.makeString));
      
            case ("getDerivedUnits",{Values.STRING(_)})
      
        1
              then ValuesMake.makeArray({});
      
            case ("getClassInformation",{Values.CODE(Absyn.C_TYPENAME(className))})
      
        6
              then getClassInformation(className, SymbolTable.getAbsyn());
      
            case ("getClassInformation",_)
      
              then Values.TUPLE({Values.STRING(""),Values.STRING(""),Values.BOOL(false),Values.BOOL(false),Values.BOOL(false),Values.STRING(""),
      
                                        Values.BOOL(false),Values.INTEGER(0),Values.INTEGER(0),Values.INTEGER(0),Values.INTEGER(0),Values.ARRAY({},{0}),
      
                                        Values.BOOL(false),Values.BOOL(false),Values.STRING(""),Values.STRING(""),Values.BOOL(false),Values.STRING("")});
      
            case ("getTransitions",{Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
          1/2✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.

        4
                false := Interactive.existClass(className, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getTransitions",{Values.CODE(Absyn.C_TYPENAME(className))})
      
        4
              then getTransitions(className, SymbolTable.getAbsyn());
      
            case ("getTransitions",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("addTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.STRING(_), Values.STRING(_),
      
                                   Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_), Values.CODE(Absyn.C_EXPRESSION(_))})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("addTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.STRING(_), Values.STRING(_),
      
                                   Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_),
      
                                   Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("addTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3),
      
                                   Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.INTEGER(i), Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        2
                (bval, p) := Interactive.addTransition(AbsynUtil.pathToCref(classpath), str1, str2, str3, b, b1, b2, i, Absyn.NAMEDARG("annotate",aexp)::{}, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("addTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3),
      
                                   Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.INTEGER(i),
      
                                   Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=eltargs,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                (bval, p) := Interactive.addTransitionWithAnnotation(AbsynUtil.pathToCref(classpath), str1, str2, str3, b, b1, b2, i, Absyn.ANNOTATION(eltargs), SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(bval);
      
            case ("addTransition",{_,_,_,_,_,_,_,_,_})
      
              then Values.BOOL(false);
      
            case ("deleteTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.STRING(_), Values.STRING(_),
      
                                      Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_)})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("deleteTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3),
      
                                      Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.INTEGER(i)})
      
              algorithm
      
        1
                (bval, p) := Interactive.deleteTransition(AbsynUtil.pathToCref(classpath), str1, str2, str3, b, b1, b2, i, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("deleteTransition",{_,_,_,_,_,_,_,_})
      
              then
      
                Values.BOOL(false);
      
            case ("updateTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.STRING(_), Values.STRING(_),
      
                                      Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_), Values.STRING(_),
      
                                      Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_), Values.CODE(Absyn.C_EXPRESSION(_))})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("updateTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.STRING(_), Values.STRING(_),
      
                                      Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_), Values.STRING(_),
      
                                      Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.INTEGER(_),
      
                                      Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("updateTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3),
      
                                      Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.INTEGER(i), Values.STRING(str4),
      
                                      Values.BOOL(b3), Values.BOOL(b4), Values.BOOL(b5), Values.INTEGER(i1), Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        1
                (bval, p) := Interactive.deleteTransition(AbsynUtil.pathToCref(classpath), str1, str2, str3, b, b1, b2, i, SymbolTable.getAbsyn());
      
        2
                (bval, p) := Interactive.addTransition(AbsynUtil.pathToCref(classpath), str1, str2, str4, b3, b4, b5, i1, Absyn.NAMEDARG("annotate",aexp)::{}, p);
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("updateTransition",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3),
      
                                      Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.INTEGER(i), Values.STRING(str4),
      
                                      Values.BOOL(b3), Values.BOOL(b4), Values.BOOL(b5), Values.INTEGER(i1),
      
                                      Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=eltargs,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                (bval, p) := Interactive.deleteTransition(AbsynUtil.pathToCref(classpath), str1, str2, str3, b, b1, b2, i, SymbolTable.getAbsyn());
      
        ✗
                (bval, p) := Interactive.addTransitionWithAnnotation(AbsynUtil.pathToCref(classpath), str1, str2, str4, b3, b4, b5, i1, Absyn.ANNOTATION(eltargs), p);
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(bval);
      
            case ("updateTransition",_)
      
              then
      
                Values.BOOL(false);
      
            case ("getInitialStates",{Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(className, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
        ✗
              then
      
                ValuesMake.makeArray({});
      
            case ("getInitialStates",{Values.CODE(Absyn.C_TYPENAME(className))})
      
        1
              then getInitialStates(className, SymbolTable.getAbsyn());
      
            case ("getInitialStates",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("addInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.CODE(Absyn.C_EXPRESSION(_))})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("addInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_),
      
                                     Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("addInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        2
                (bval, p) := addInitialState(classpath, str1, Absyn.NAMEDARG("annotate",aexp)::{}, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("addInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1),
      
                                     Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=eltargs,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                (bval, p) := addInitialStateWithAnnotation(classpath, str1, Absyn.ANNOTATION(eltargs), SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(bval);
      
            case ("deleteInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_)})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("deleteInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1)})
      
              algorithm
      
        1
                (bval, p) := deleteInitialState(classpath, str1, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("deleteInitialState",_)
      
              then
      
                Values.BOOL(false);
      
            case ("updateInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_), Values.CODE(Absyn.C_EXPRESSION(_))})
      
              algorithm
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("updateInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(_),
      
                                        Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                false := Interactive.existClass(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {str,"<TOP>"});
      
              then
      
                Values.BOOL(false);
      
            case ("updateInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1), Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        1
                (bval, p) := deleteInitialState(classpath, str1, SymbolTable.getAbsyn());
      
        2
                (bval, p) := addInitialState(classpath, str1, Absyn.NAMEDARG("annotate",aexp)::{}, p);
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(bval);
      
            case ("updateInitialState",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str1),
      
                                        Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=eltargs,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                (bval, p) := deleteInitialState(classpath, str1, SymbolTable.getAbsyn());
      
        ✗
                (bval, p) := addInitialStateWithAnnotation(classpath, str1, Absyn.ANNOTATION(eltargs), p);
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(bval);
      
            case ("updateInitialState",_)
      
              then Values.BOOL(false);
      
            case ("diffModelicaFileListings",{Values.STRING(s1),Values.STRING(s2),Values.ENUM_LITERAL(name=path),Values.BOOL(b)})
      
              algorithm
      
        46
                ExecStat.execStatReset();
      
        46
                (s1, bom) := StringUtil.stripBOM(s1);
      
                // Work internally with LF line endings only, so that lines coming from
      
                // the original file (s1) and lines produced by the listing (s2, always LF)
      
                // compare and merge uniformly. Remember the original (s1) convention and
      
                // restore it on output, so we do not rewrite every line ending of a file
      
                // that uses CRLF (e.g. on Windows checkouts). See #13447.
      
          2/4✓ Branch 1 taken 46 times.
✗ Branch 2 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 46 times.

        46
                lineEndingIsCRLF := s1 <> System.stringReplace(s1, "\r\n", "\n"); // removing CRLF changed s1 => it originally contained CRLF
      
        46
                s1 := System.stringReplace(s1, "\r\n", "\n");
      
        46
                s1 := System.stringReplace(s1, "\r", "\n"); // also fold any remaining lone CR (old Mac) to LF
      
        46
                (tokens1, errorTokens) := scanString(s1);
      
        46
                reportErrors(errorTokens);
      
                if false and s1<>stringAppendList(list(tokenContent(t) for t in tokens1)) then
      
                  // Debugging code. Make sure the scanner works before debugging the diff.
      
                  System.writeFile("string.before", s1);
      
                  System.writeFile("string.after", stringAppendList(list(tokenContent(t) for t in tokens1)));
      
                  Error.terminate("Lexed string does not match the original. See files string.before and string.after", sourceInfo());
      
                  fail();
      
                end if;
      
        46
                ExecStat.execStat("diffModelicaFileListings scan string 1");
      
        46
                (_,parseTree1) := SimpleModelicaParser.stored_definition(tokens1, {});
      
        46
                ExecStat.execStat("diffModelicaFileListings parse string 1");
      
                if false and s1<>SimpleModelicaParser.parseTreeStr(parseTree1) then
      
                  // Debugging code. Make sure the parser works before debugging the diff.
      
                  System.writeFile("string.before", s1);
      
                  System.writeFile("string.after", SimpleModelicaParser.parseTreeStr(parseTree1));
      
                  Error.terminate("Parsed string does not match the original. See files string.before and string.after", sourceInfo());
      
                  fail();
      
                end if;
      
        46
                (s2, bom) := StringUtil.stripBOM(s2);
      
        46
                s2 := System.stringReplace(s2, "\r\n", "\n");
      
        46
                s2 := System.stringReplace(s2, "\r", "\n");
      
        46
                (tokens2, errorTokens) := scanString(s2);
      
        46
                reportErrors(errorTokens);
      
        46
                ExecStat.execStat("diffModelicaFileListings scan string 2");
      
        46
                (_,parseTree2) := SimpleModelicaParser.stored_definition(tokens2, {});
      
        46
                ExecStat.execStat("diffModelicaFileListings parse string 2");
      
                if false and s2<>SimpleModelicaParser.parseTreeStr(parseTree2) then
      
                  // Debugging code. Make sure the parser works before debugging the diff.
      
                  System.writeFile("string.before", s2);
      
                  System.writeFile("string.after", SimpleModelicaParser.parseTreeStr(parseTree2));
      
                  Error.terminate("Parsed string does not match the original. See files string.before and string.after", sourceInfo());
      
                  fail();
      
                end if;
      
        46
                treeDiffs := SimpleModelicaParser.treeDiff(parseTree1, parseTree2, max(listLength(tokens1),listLength(tokens2)));
      
        46
                ExecStat.execStat("treeDiff");
      
        46
                sanityCheckFailed := false;
      
                if true then
      
                  // Do a sanity check
      
        46
                  s3 := Dump.unparseStr(Parser.parsestring(s2));
      
        46
                  ExecStat.execStat("sanity parsestring(s2)");
      
        46
                  s5 := printActual(treeDiffs, SimpleModelicaParser.parseTreeNodeStr);
      
                  try
      
        46
                    s4 := Dump.unparseStr(Parser.parsestring(s5));
      
        46
                    ExecStat.execStat("sanity parsestring(s5)");
      
                  else
      
        ✗
                    System.writeFile("SanityCheckFail.mo", s5);
      
        ✗
                    Error.addInternalError("Failed to parse merged string (see generated file SanityCheckFail.mo)\n", sourceInfo());
      
        ✗
                    fail();
      
                  end try;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 46 times.

        46
                  if not diffSanityCheckEqual(s3, s4) then
      
        ✗
                    System.writeFile("SanityCheckFailBefore.mo", s3);
      
        ✗
                    System.writeFile("SanityCheckFailAfter.mo", s4);
      
        ✗
                    if b then
      
        ✗
                      Error.addInternalError("After merging the strings, the semantics changed for some reason (see generated files SanityCheckFailBefore.mo SanityCheckFailAfter.mo). Will return the empty string:\ns1:\n"+s1+"\ns2:\n"+s2+"\ns3:\n"+s3+"\ns4:\n"+s4+"\ns5:\n"+s5+"\nparseTree2:"+SimpleModelicaParser.parseTreeStr(parseTree2), sourceInfo());
      
        ✗
                      fail();
      
                    else
      
        ✗
                      Error.addInternalError("After merging the strings, the semantics changed for some reason (see generated files SanityCheckFailBefore.mo SanityCheckFailAfter.mo). Will return s2:\ns1:\n"+s1+"\ns2:\n"+s2+"\ns3:\n"+s3+"\ns4:\n"+s4+"\ns5:\n"+s5, sourceInfo());
      
                    end if;
      
                    sanityCheckFailed := true;
      
                  end if;
      
                end if;
      
                /*
      
                diffs := diff(tokens1, tokens2, modelicaDiffTokenEq, modelicaDiffTokenWhitespace, tokenContent);
      
                ExecStat.execStat("diffModelicaFileListings diff 1");
      
                // print("Before filtering:\n"+printDiffTerminalColor(diffs, tokenContent)+"\n");
      
                diffs := filterModelicaDiff(diffs,removeWhitespace=false);
      
                ExecStat.execStat("diffModelicaFileListings filter diff 1");
      
                // Scan a second time, with comments filtered into place
      
                str := printActual(diffs, tokenContent);
      
                // print("Intermediate string:\n"+printDiffTerminalColor(diffs, tokenContent)+"\n");
      
                tokens2 := scanString(str);
      
                ExecStat.execStat("diffModelicaFileListings prepare pass 2");
      
                diffs := diff(tokens1, tokens2, modelicaDiffTokenEq, modelicaDiffTokenWhitespace, tokenContent);
      
                ExecStat.execStat("diffModelicaFileListings diff 2");
      
                // print("Before filtering (2):\n"+printDiffTerminalColor(diffs, tokenContent)+"\n");
      
                diffs := filterModelicaDiff(diffs);
      
                ExecStat.execStat("diffModelicaFileListings filter diff 2");
      
                */
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.

        46
                str := if sanityCheckFailed then s2 else matchcontinue AbsynUtil.pathLastIdent(path)
      
        19
                  case "plain" then printActual(treeDiffs, SimpleModelicaParser.parseTreeNodeStr);
      
        17
                  case "color" then printDiffTerminalColor(treeDiffs, SimpleModelicaParser.parseTreeNodeStr);
      
        10
                  case "xml" then printDiffXml(treeDiffs, SimpleModelicaParser.parseTreeNodeStr);
      
                  else
      
                    algorithm
      
        ✗
                      Error.addInternalError("Unknown diffModelicaFileListings choice", sourceInfo());
      
        ✗
                    then fail();
      
                end matchcontinue;
      
                // Restore the original file's line-ending convention (we processed as LF above).
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 46 times.

        46
                str := if lineEndingIsCRLF then System.stringReplace(str, "\n", "\r\n") else str;
      
        46
              then
      
                Values.STRING(bom + str);
      
            case ("diffModelicaFileListings",_) then Values.STRING("");
      
            // exportToFigaro cases added by Alexander Carlqvist
      
            case ("exportToFigaro", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(s1), Values.STRING(str), Values.STRING(str1), Values.STRING(str2), Values.STRING(str3)})
      
              algorithm
      
        ✗
                sp := SymbolTable.getSCode();
      
                /* The following line of code should be commented out when building from trunk.
      
                Uncomment when bootstrapping. */
      
        ✗
                Figaro.run(sp, path, s1, str, str1, str2, str3);
      
              then
      
                Values.BOOL(true);
      
            case ("exportToFigaro", _) then Values.BOOL(false);
      
            case ("inferBindings", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
               algorithm
      
        ✗
                pnew := Binding.inferBindings(classpath, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(pnew);
      
              then
      
                 Values.BOOL(true);
      
            case ("inferBindings", _)
      
              algorithm
      
        ✗
                print("failed inferBindings\n");
      
              then
      
                Values.BOOL(false);
      
             case ("generateVerificationScenarios", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
               algorithm
      
        1
                pnew := Binding.generateVerificationScenarios(classpath, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(pnew);
      
              then
      
                Values.BOOL(true);
      
            case ("generateVerificationScenarios", _)
      
              algorithm
      
        ✗
                print("failed to generateVerificationScenarios\n");
      
              then
      
                Values.BOOL(false);
      
            case ("rewriteBlockCall",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                p := SymbolTable.getAbsyn();
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, p);
      
                classes := {absynClass};
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, p);
      
        ✗
                within_ := ProgramUtil.buildWithin(classpath);
      
        ✗
                pnew := BlockCallRewrite.rewriteBlockCall(Absyn.PROGRAM({absynClass}, within_), Absyn.PROGRAM(classes, within_));
      
        ✗
                pnew := ProgramUtil.updateProgram(pnew, p);
      
        ✗
                SymbolTable.setAbsyn(pnew);
      
        ✗
                outCache := FCore.emptyCache();
      
              then
      
                Values.BOOL(true);
      
            case ("rewriteBlockCall", _)
      
              then Values.BOOL(false);
      
            case ("jacobian",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                (outCache, env, SOME(dae), _) := runFrontEnd(outCache, inEnv, path, true, transform = true);
      
        ✗
                filenameprefix := AbsynUtil.pathString(path);
      
        ✗
                description := DAEUtil.daeDescription(dae);
      
        ✗
                daelow := BackendDAECreate.lower(dae,outCache,env,BackendDAE.EXTRA_INFO(description,filenameprefix,NONE()));
      
        ✗
                BackendDAE.DAE({syst},shared) := BackendDAEUtil.preOptimizeBackendDAE(daelow,NONE());
      
        ✗
                (syst,m,_) := BackendDAEUtil.getAdjacencyMatrixfromOption(syst,BackendDAE.NORMAL(),NONE(),BackendDAEUtil.isInitializationDAE(shared));
      
        ✗
                vars := BackendVariable.daeVars(syst);
      
        ✗
                eqnarr := BackendEquation.getEqnsFromEqSystem(syst);
      
        ✗
                (jac, _) := SymbolicJacobian.calculateJacobian(vars, eqnarr, m, false,shared);
      
        ✗
                res := BackendDump.dumpJacobianStr(jac);
      
        ✗
              then
      
                Values.STRING(res);
      
            case ("translateModel",vals as {Values.CODE(Absyn.C_TYPENAME(className)),_,_,_,_,_,Values.STRING(filenameprefix),_,_,_,_,_})
      
              algorithm
      
        24
                (outCache,simSettings) := calculateSimulationSettings(outCache, vals);
      
        24
                (b,outCache) := translateModel(outCache, inEnv, className, filenameprefix, true, true, SOME(simSettings));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.

        22
              then
      
                Values.BOOL(b);
      
            case ("translateModel",_)
      
              then Values.BOOL(false);
      
            case ("modelEquationsUC",{Values.CODE(Absyn.C_TYPENAME(className)),Values.STRING(outputFile),Values.BOOL(dumpExtractionSteps)})
      
              algorithm
      
        14
                (outCache, ret_val) := Uncertainties.modelEquationsUC(outCache, inEnv, className, outputFile,dumpExtractionSteps);
      
        14
              then
      
                ret_val;
      
            case ("modelEquationsUC",_)
      
              then Values.STRING("There were errors during extraction of uncertainty equations. Use getErrorString() to see them.");
      
            case ("translateModelFMU", Values.CODE(Absyn.C_TYPENAME(className))::Values.STRING(str1)::Values.STRING(str2)::Values.STRING(filenameprefix)::Values.ARRAY(valueLst=cvars)::_)
      
              algorithm
      
          4/4✓ Branch 0 taken 1 time.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 1 time.

        2
                (b, outCache,_) := translateModelFMU(outCache, inEnv, className, str1, str2, filenameprefix, true, list(ValuesUtil.extractValueString(vv) for vv in cvars));
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("translateModelFMU", _)
      
              then Values.STRING("");
      
            case ("buildModelFMU", Values.CODE(Absyn.C_TYPENAME(className))::Values.STRING(str1)::Values.STRING(str2)::Values.STRING(filenameprefix)::Values.ARRAY(valueLst=cvars)::Values.BOOL(_)::Values.STRING(str3)::_)
      
              algorithm
      
        88
                simSettings := fmuSimulationSettings(className, filenameprefix, str3);
      
          4/4✓ Branch 0 taken 88 times.
✓ Branch 1 taken 88 times.
✓ Branch 2 taken 88 times.
✓ Branch 3 taken 88 times.

        176
                (outCache, ret_val) := buildModelFMU(outCache, inEnv, className, str1, str2, filenameprefix, true, list(ValuesUtil.extractValueString(vv) for vv in cvars), SOME(simSettings), str3);
      
        88
              then
      
                ret_val;
      
            case ("buildModelFMU", _)
      
              then Values.STRING("");
      
            case ("buildEncryptedPackage", {Values.CODE(Absyn.C_TYPENAME(className)),Values.BOOL(b)})
      
              algorithm
      
        1
                p := SymbolTable.getAbsyn();
      
        1
                b1 := buildEncryptedPackage(className, b, p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b1);
      
            case ("buildEncryptedPackage",_)
      
              then Values.BOOL(false);
      
            case ("translateModelXML",{Values.CODE(Absyn.C_TYPENAME(className)),Values.STRING(filenameprefix)})
      
              algorithm
      
        ✗
                filenameprefix := Util.stringReplaceChar(filenameprefix,".","_");
      
        ✗
                (outCache, ret_val) := translateModelXML(outCache, inEnv, className, filenameprefix, true, NONE());
      
        ✗
              then
      
                ret_val;
      
            case ("exportDAEtoMatlab",{Values.CODE(Absyn.C_TYPENAME(className)),Values.STRING(filenameprefix)})
      
              algorithm
      
        ✗
                (outCache, ret_val, _) := getAdjacencyMatrix(outCache, inEnv, className, msg, filenameprefix);
      
        ✗
              then
      
                ret_val;
      
            case ("checkModel",{Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
        85
                FlagsUtil.setConfigBool(Flags.CHECK_MODEL, true);
      
        85
                (outCache, ret_val) := checkModel(outCache, inEnv, className, msg);
      
        85
                FlagsUtil.setConfigBool(Flags.CHECK_MODEL, false);
      
        85
              then
      
                ret_val;
      
            case ("checkAllModelsRecursive",{Values.CODE(Absyn.C_TYPENAME(className)),Values.BOOL(showProtected)})
      
              algorithm
      
        ✗
                (outCache, ret_val) := checkAllModelsRecursive(outCache, inEnv, className, showProtected, msg);
      
        ✗
              then
      
                ret_val;
      
            case ("translateGraphics",{Values.CODE(Absyn.C_TYPENAME(className))})
      
        ✗
              then translateGraphics(className, msg);
      
            case ("getLoadedLibraries",{})
      
              algorithm
      
        ✗
                p := SymbolTable.getAbsyn();
      
        ✗
              then
      
                ValuesMake.makeArray(List.fold(p.classes,makeLoadLibrariesEntryAbsyn,{}));
      
            case ("OpenModelica_uriToFilename",{Values.STRING(s1)})
      
              algorithm
      
        ✗
                res := OpenModelica.Scripting.uriToFilename(s1);
      
        ✗
                if Flags.getConfigBool(Flags.BUILDING_FMU) then
      
        ✗
                  print("The following path is a loaded resource... "+res+"\n");
      
        ✗
                  fail();
      
                end if;
      
        ✗
              then
      
                Values.STRING(res);
      
             /* Note: Only evaluate uriToFilename during scripting. We need simulations to be able to report URI not found */
      
            case ("OpenModelica_uriToFilename",_)
      
              guard not Flags.getConfigBool(Flags.BUILDING_MODEL)
      
              then Values.STRING("");
      
            case ("getAnnotationVersion",{})
      
              algorithm
      
        4
                res := Config.getAnnotationVersion();
      
        4
              then
      
                Values.STRING(res);
      
            case ("getNoSimplify",{})
      
              algorithm
      
        ✗
                b := Config.getNoSimplify();
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("setNoSimplify",{Values.BOOL(b)})
      
              algorithm
      
        ✗
                Config.setNoSimplify(b);
      
              then
      
                Values.BOOL(true);
      
            case ("getShowAnnotations",{})
      
              algorithm
      
        ✗
                b := Config.showAnnotations();
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("setShowAnnotations",{Values.BOOL(b)})
      
              algorithm
      
        ✗
                Config.setShowAnnotations(b);
      
              then
      
                Values.BOOL(true);
      
            case ("getVectorizationLimit",{})
      
              algorithm
      
        ✗
                i := Config.vectorizationLimit();
      
        ✗
              then
      
                Values.INTEGER(i);
      
            case ("getOrderConnections",{})
      
              algorithm
      
        ✗
                b := Config.orderConnections();
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("buildModel", vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        58
                List.map_0(ClockIndexes.buildModelClocks,System.realtimeClear);
      
        58
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        58
                (b,outCache,compileDir,executable,_,_,initfilename,_,_,vals,_) := buildModel(outCache, inEnv, vals, msg);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 57 times.

        57
                executable := if not Testsuite.isRunning() then compileDir + executable else executable;
      
          1/2✓ Branch 0 taken 57 times.
✗ Branch 1 not taken.

        114
              then
      
                ValuesMake.makeArray(if b then {Values.STRING(executable),Values.STRING(initfilename)} else {Values.STRING(""),Values.STRING("")});
      
            case ("buildModel",_) /* failing build_model */
      
        1
              then ValuesMake.makeArray({Values.STRING(""),Values.STRING("")});
      
            case ("buildLabel",vals)
      
              algorithm
      
        ✗
                FlagsUtil.setConfigBool(Flags.GENERATE_LABELED_SIMCODE, true);
      
                //FlagsUtil.set(Flags.WRITE_TO_BUFFER,true);
      
        ✗
                List.map_0(ClockIndexes.buildModelClocks,System.realtimeClear);
      
        ✗
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        ✗
                (b,outCache,_,executable,_,_,initfilename,_,_,vals,_) := buildModel(outCache,inEnv, vals, msg);
      
        ✗
              then
      
                ValuesMake.makeArray(if b then {Values.STRING(executable),Values.STRING(initfilename)} else {Values.STRING(""),Values.STRING("")});
      
             case ("reduceTerms",vals)
      
              algorithm
      
        ✗
                FlagsUtil.setConfigBool(Flags.REDUCE_TERMS, true);
      
                // FlagsUtil.setConfigBool(Flags.DISABLE_EXTRA_LABELING, true);
      
        ✗
                FlagsUtil.setConfigBool(Flags.GENERATE_LABELED_SIMCODE, false);
      
        ✗
                FlagsUtil.disableDebug(Flags.WRITE_TO_BUFFER);
      
        ✗
                List.map_0(ClockIndexes.buildModelClocks,System.realtimeClear);
      
        ✗
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        ✗
                if listLength(vals)<>13 then
      
        ✗
                  Error.addInternalError("reduceTerms expected 13 arguments", sourceInfo());
      
                end if;
      
        ✗
                listGet(vals,13);
      
        ✗
                vals:=listDelete(vals,13);
      
                /* labelstoCancel; doesn't do anything */
      
        ✗
                (b,outCache,_,executable,_,_,initfilename,_,_,_) := buildModel(outCache,inEnv, vals, msg);
      
        ✗
              then
      
                ValuesMake.makeArray(if b then {Values.STRING(executable),Values.STRING(initfilename)} else {Values.STRING(""),Values.STRING("")});
      
            case ("simulate",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        1164
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
                // resimulateExecutable is the last (new) argument; pull it off so the rest
      
                // of the pipeline sees the original simulate() argument list.
      
                resimulateExecutable := match List.last(vals) case Values.STRING(str) then str; else ""; end match;
      
        1164
                vals := List.stripLast(vals);
      
          3/4✓ Branch 0 taken 1055 times.
✓ Branch 1 taken 109 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1055 times.

        1164
                if resimulateExecutable <> "" then
      
                  // Skip translation and build; simulate the already-built model directly.
      
        109
                  b := true;
      
        109
                  executable := resimulateExecutable;
      
        109
                  compileDir := System.pwd() + Autoconf.pathDelimiter;
      
                  simflags := match List.last(vals) case Values.STRING(str) then str; else ""; end match;
      
        109
                  resultValues := zeroBuildPhaseResultValues;
      
                else
      
        1055
                  (b,outCache,compileDir,executable,_,outputFormat_str,_,simflags,resultValues,vals,_) := buildModel(outCache,inEnv,vals,msg);
      
                end if;
      
          2/2✓ Branch 0 taken 1148 times.
✓ Branch 1 taken 1 time.

        1149
                if b then
      
        1148
                   exeDir := compileDir;
      
        1148
                   (outCache,simSettings) := calculateSimulationSettings(outCache, vals);
      
        1148
                   SimCode.SIMULATION_SETTINGS(outputFormat = outputFormat_str) := simSettings;
      
        1148
                   result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str}));
      
                    // result file might have been set by simflags (-r ...)
      
        1148
                   result_file := selectResultFile(result_file, simflags);
      
        1148
                   executableSuffixedExe := stringAppend(executable, getSimulationExtension(Config.simCodeTarget(),Autoconf.platform));
      
        1148
                   logFile := stringAppend(executable,".log");
      
                   // adrpo: log file is deleted by buildModel! do NOT DELETE IT AGAIN!
      
                   // we should really have different log files for simulation/compilation!
      
                   // as the buildModel log file will be deleted here and that gives less information to the user!
      
          1/2✓ Branch 1 taken 1148 times.
✗ Branch 2 not taken.

        1148
                   if System.regularFileExists(logFile) then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1148 times.

        1148
                     0 := System.removeFile(logFile);
      
                   end if;
      
        2296
                   sim_call := stringAppendList({"\"",exeDir,executableSuffixedExe,"\""," ",simflags});
      
        1148
                   System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
        1148
                   SimulationResults.close() "Windows cannot handle reading and writing to the same file from different processes like any real OS :(";
      
                   // The wasm-jit target runs the JIT-compiled model in-process and
      
                   // writes the result file directly, instead of spawning an executable;
      
                   // the wasm target runs the standalone module in a wasmtime subprocess.
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 1148 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        1148
                   if Config.simCodeTarget() == "wasm-jit" then
      
        ✗
                     resI := CodegenWasmJit.runSimulation(executable, result_file, simflags);
      
                   elseif Config.simCodeTarget() == "wasm" then
      
        ✗
                     resI := CodegenWasmJit.runSimulationWasmtime(executable, result_file, simflags);
      
                   else
      
        1148
                     resI := System.systemCallRestrictedEnv(sim_call, logFile);
      
                   end if;
      
        1148
                   timeSimulation := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
                 else
      
                   result_file := "";
      
                   resI := 1;
      
                   timeSimulation := 0.0;
      
                   logFile := "";
      
                 end if;
      
        1149
                timeTotal := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        1149
                (outCache,simValue) := createSimulationResultFromcallModelExecutable(b,resI,timeTotal,timeSimulation,resultValues,outCache,className,vals,result_file,logFile);
      
        1149
              then
      
                simValue;
      
            case ("simulate",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        15
                Settings.getInstallationDirectoryPath() "simulation fail for some other reason than OPENMODELICAHOME not being set." ;
      
        15
                str := AbsynUtil.pathString(className);
      
        15
                res := "Failed to build model: " + str;
      
        15
              then
      
                createSimulationResultFailure(res, simOptionsAsString(List.stripLast(vals)));
      
            case ("simulate",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
              then
      
                createSimulationResultFailure(
      
                  "Simulation failed for model: " + str +
      
                  "\nEnvironment variable OPENMODELICAHOME not set.",
      
                  simOptionsAsString(List.stripLast(vals)));
      
            case ("moveClass", {Values.CODE(Absyn.C_TYPENAME(className)),
      
                                Values.INTEGER(direction)})
      
              algorithm
      
        1
                (p, b) := moveClass(className, direction, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("moveClass", _) then Values.BOOL(false);
      
            case ("moveClassToTop", {Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
        ✗
                (p, b) := moveClassToTop(className, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("moveClassToTop", _) then Values.BOOL(false);
      
            case ("moveClassToBottom", {Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
        ✗
                (p, b) := moveClassToBottom(className, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("moveClassToBottom", _) then Values.BOOL(false);
      
            case ("copyClass",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(name), Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        6
                p := SymbolTable.getAbsyn();
      
        6
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, p);
      
        6
                within_ := InteractiveUtil.parseWithinPath(path);
      
        6
                p := copyClass(absynClass, name, within_, classpath, p);
      
                absynClass := ProgramUtil.getPathedClassInProgram(
      
        6
                  match within_ case Absyn.WITHIN() then ProgramUtil.joinPaths(name, within_.path); else Absyn.IDENT(name); end match, p);
      
        6
                SymbolTable.setAbsynLoaded(p, Absyn.PROGRAM({absynClass}, within_));
      
              then
      
                Values.BOOL(true);
      
            case ("copyClass", _) then Values.BOOL(false);
      
            // see if the model exists before linearization!
      
            case ("linearize",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
          1/2✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.

        13
                false := Interactive.existClass(className, SymbolTable.getAbsyn());
      
        ✗
                errMsg := "Linearization Failed. Model: " + AbsynUtil.pathString(className) + " does not exist! Please load it first before linearization.";
      
        ✗
              then
      
                createSimulationResultFailure(errMsg, simOptionsAsString(vals));
      
            case ("linearize",(vals as Values.CODE(Absyn.C_TYPENAME(className))::_))
      
              algorithm
      
        13
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
                // Ensure that the linearization dump language is set to modelica if it is none
      
        13
                str := Flags.getConfigString(Flags.LINEARIZATION_DUMP_LANGUAGE);
      
          3/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 9 times.
✗ Branch 4 not taken.

        13
                if (stringEq(str,"none")) then
      
        9
                  FlagsUtil.setConfigString(Flags.LINEARIZATION_DUMP_LANGUAGE, "modelica");
      
                end if;
      
        13
                (b,outCache,compileDir,executable,_,outputFormat_str,_,simflags,resultValues,vals,_) := buildModel(outCache,inEnv,vals,msg);
      
          1/2✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.

        13
                if b then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.

        13
                  Values.REAL(linearizeTime) := getListNthShowError(vals,"try to get stop time",0,2);
      
        13
                  executableSuffixedExe := stringAppend(executable, getSimulationExtension(Config.simCodeTarget(),Autoconf.platform));
      
        13
                  logFile := stringAppend(executable,".log");
      
          1/2✓ Branch 1 taken 13 times.
✗ Branch 2 not taken.

        13
                  if System.regularFileExists(logFile) then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.

        13
                    0 := System.removeFile(logFile);
      
                  end if;
      
        13
                  strlinearizeTime := realString(linearizeTime);
      
        13
                  simflags := "-l=" + strlinearizeTime + " " + simflags;
      
        26
                  sim_call := stringAppendList({"\"",compileDir,executableSuffixedExe,"\""," ",simflags});
      
        13
                  System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
        13
                  SimulationResults.close() "Windows cannot handle reading and writing to the same file from different processes like any real OS :(";
      
                  // The wasm-jit target runs the JIT-compiled model in-process, as `simulate` does.
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 13 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        13
                  if Config.simCodeTarget() == "wasm-jit" then
      
        ✗
                    result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str}));
      
        ✗
                    resI := CodegenWasmJit.runSimulation(executable, result_file, simflags);
      
                  else
      
        13
                    resI := System.systemCallRestrictedEnv(sim_call, logFile);
      
                  end if;
      
          1/2✓ Branch 0 taken 13 times.
✗ Branch 1 not taken.

        13
                  if 0 == resI then
      
        26
                    result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str}));
      
        13
                    timeSimulation := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
        13
                    timeTotal := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        26
                    simValue := createSimulationResult(
      
                       result_file,
      
                       simOptionsAsString(vals),
      
                       System.readFile(logFile),
      
                       ("timeTotal", Values.REAL(timeTotal)) ::
      
                       ("timeSimulation", Values.REAL(timeSimulation)) ::
      
                      resultValues);
      
        13
                    SymbolTable.addVar(
      
                      DAE.CREF_IDENT("currentSimulationResult", DAE.T_STRING_DEFAULT, {}),
      
                      Values.STRING(result_file), FGraph.empty());
      
                  else
      
        ✗
                    res := "Succeeding building the linearized executable, but failed to run the linearize command: " + sim_call + "\n" + System.readFile(logFile);
      
        ✗
                    simValue := createSimulationResultFailure(res, simOptionsAsString(vals));
      
                  end if;
      
                else
      
                  timeSimulation := 0.0;
      
        ✗
                  timeTotal := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        ✗
                  simValue := createSimulationResult(
      
                       "",
      
                       simOptionsAsString(vals),
      
                       "Failed to run the linearize command: " + AbsynUtil.pathString(className),
      
                       ("timeTotal", Values.REAL(timeTotal)) ::
      
                       ("timeSimulation", Values.REAL(timeSimulation)) ::
      
                      resultValues);
      
                end if;
      
        13
              then
      
                simValue;
      
            case ("linearize",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
                res := "Failed to run the linearize command: " + str;
      
        ✗
              then
      
                createSimulationResultFailure(res, simOptionsAsString(vals));
      
            case ("optimize",(vals as Values.CODE(Absyn.C_TYPENAME(className))::_))
      
              algorithm
      
        34
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        34
                FlagsUtil.setConfigBool(Flags.GENERATE_SYMBOLIC_LINEARIZATION,true);
      
        34
                FlagsUtil.setConfigEnum(Flags.GRAMMAR, Flags.OPTIMICA);
      
        34
                FlagsUtil.setConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM,true);
      
        34
                (b,outCache,compileDir,executable,_,outputFormat_str,_,simflags,resultValues,vals,_) := buildModel(outCache,inEnv,vals,msg);
      
          1/2✓ Branch 0 taken 34 times.
✗ Branch 1 not taken.

        34
                if b then
      
        34
                  exeDir:=compileDir;
      
        34
                  (outCache,simSettings) := calculateSimulationSettings(outCache, vals);
      
        34
                  SimCode.SIMULATION_SETTINGS(outputFormat = outputFormat_str) := simSettings;
      
        34
                  result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str}));
      
        34
                  executableSuffixedExe := stringAppend(executable, getSimulationExtension(Config.simCodeTarget(),Autoconf.platform));
      
        34
                  logFile := stringAppend(executable,".log");
      
                  // adrpo: log file is deleted by buildModel! do NOT DELTE IT AGAIN!
      
                  // we should really have different log files for simulation/compilation!
      
                  // as the buildModel log file will be deleted here and that gives less information to the user!
      
          1/2✓ Branch 1 taken 34 times.
✗ Branch 2 not taken.

        34
                  if System.regularFileExists(logFile) then
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.

        34
                    0 := System.removeFile(logFile);
      
                  end if;
      
        68
                  sim_call := stringAppendList({"\"",exeDir,executableSuffixedExe,"\""," ",simflags});
      
        34
                  System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
        34
                  SimulationResults.close() "Windows cannot handle reading and writing to the same file from different processes like any real OS :(";
      
                  // As in the simulate() case: the wasm-jit target runs the JIT-compiled
      
                  // model in-process instead of spawning an executable.
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 34 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        34
                  if Config.simCodeTarget() == "wasm-jit" then
      
        ✗
                    resI := CodegenWasmJit.runSimulation(executable, result_file, simflags);
      
                  elseif Config.simCodeTarget() == "wasm" then
      
        ✗
                    resI := CodegenWasmJit.runSimulationWasmtime(executable, result_file, simflags);
      
                  else
      
        34
                    resI := System.systemCallRestrictedEnv(sim_call, logFile);
      
                  end if;
      
        34
                  timeSimulation := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
                else
      
                  result_file := "";
      
                  timeSimulation := 0.0;
      
                  resI := 1;
      
                  logFile := "";
      
                end if;
      
        34
                timeTotal := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        34
                (outCache,simValue) := createSimulationResultFromcallModelExecutable(b,resI,timeTotal,timeSimulation,resultValues,outCache,className,vals,result_file,logFile);
      
        34
              then
      
                simValue;
      
            case ("optimize",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
                res := "Failed to run the optimize command: " + str;
      
        ✗
              then
      
                createSimulationResultFailure(res, simOptionsAsString(vals));
      
            case ("instantiateModel", {Values.CODE(Absyn.C_TYPENAME(className))})
      
              algorithm
      
        102
                (outCache, ret_val) := instantiateModel(outCache, inEnv, className);
      
        102
              then
      
                ret_val;
      
            case ("moo",(vals as Values.CODE(Absyn.C_TYPENAME(className))::_))
      
              algorithm
      
        ✗
                System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        ✗
                FlagsUtil.setConfigBool(Flags.GENERATE_SYMBOLIC_LINEARIZATION,true);
      
        ✗
                FlagsUtil.setConfigEnum(Flags.GRAMMAR, Flags.OPTIMICA);
      
        ✗
                FlagsUtil.setConfigBool(Flags.GENERATE_DYN_OPTIMIZATION_PROBLEM,true);
      
        ✗
                (b,outCache,compileDir,executable,_,outputFormat_str,_,simflags,resultValues,vals,_) := buildModel(outCache,inEnv,vals,msg);
      
        ✗
                simflags := stringAppend(simflags, " -moo");
      
        ✗
                if b then
      
        ✗
                  exeDir:=compileDir;
      
        ✗
                  (outCache,simSettings) := calculateSimulationSettings(outCache, vals);
      
        ✗
                  SimCode.SIMULATION_SETTINGS(outputFormat = outputFormat_str) := simSettings;
      
        ✗
                  result_file := stringAppendList(List.consOnTrue(not Testsuite.isRunning(),compileDir,{executable,"_res.",outputFormat_str}));
      
        ✗
                  executableSuffixedExe := stringAppend(executable, getSimulationExtension(Config.simCodeTarget(),Autoconf.platform));
      
        ✗
                  logFile := stringAppend(executable,".log");
      
                  // adrpo: log file is deleted by buildModel! do NOT DELTE IT AGAIN!
      
                  // we should really have different log files for simulation/compilation!
      
                  // as the buildModel log file will be deleted here and that gives less information to the user!
      
        ✗
                  if System.regularFileExists(logFile) then
      
        ✗
                    0 := System.removeFile(logFile);
      
                  end if;
      
        ✗
                  sim_call := stringAppendList({"\"",exeDir,executableSuffixedExe,"\""," ",simflags});
      
        ✗
                  System.realtimeTick(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
        ✗
                  SimulationResults.close() "Windows cannot handle reading and writing to the same file from different processes like any real OS :(";
      
        ✗
                  resI := System.systemCallRestrictedEnv(sim_call, logFile);
      
        ✗
                  timeSimulation := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_SIMULATION);
      
                else
      
                  result_file := "";
      
                  timeSimulation := 0.0;
      
                  resI := 1;
      
                  logFile := "";
      
                end if;
      
        ✗
                timeTotal := System.realtimeTock(ClockIndexes.RT_CLOCK_SIMULATE_TOTAL);
      
        ✗
                (outCache,simValue) := createSimulationResultFromcallModelExecutable(b,resI,timeTotal,timeSimulation,resultValues,outCache,className,vals,result_file,logFile);
      
        ✗
              then
      
                simValue;
      
            case ("moo",vals as Values.CODE(Absyn.C_TYPENAME(className))::_)
      
              algorithm
      
        ✗
                str := AbsynUtil.pathString(className);
      
        ✗
                res := "Failed to run the moo command: " + str;
      
        ✗
              then
      
                createSimulationResultFailure(res, simOptionsAsString(vals));
      
            case ("importFMU",{Values.STRING(filename),Values.STRING(workdir),Values.INTEGER(fmiLogLevel),Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(inputConnectors), Values.BOOL(outputConnectors), Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        18
                Error.clearMessages() "Clear messages";
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 18 times.

        18
                true := System.regularFileExists(filename);
      
          1/2✓ Branch 1 taken 18 times.
✗ Branch 2 not taken.

        18
                workdir := if System.directoryExists(workdir) then workdir else System.pwd();
      
                /* Initialize FMI objects */
      
        18
                (b, fmiContext, fmiInstance, fmiInfo, fmiTypeDefinitionsList, fmiExperimentAnnotation, fmiModelVariablesInstance, fmiModelVariablesList) := FMIExt.initializeFMIImport(filename, workdir, fmiLogLevel, inputConnectors, outputConnectors);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.

        18
                true := b; /* if something goes wrong while initializing */
      
        18
                fmiTypeDefinitionsList := listReverse(fmiTypeDefinitionsList);
      
        18
                fmiModelVariablesList := listReverse(fmiModelVariablesList);
      
        18
                s1 := System.tolower(Autoconf.platform);
      
        18
                name := AbsynUtil.pathString(classpath);
      
          2/8✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.

        18
                name := if stringEq(name, "Default") or stringEq(name, "default") then "" else name;
      
          3/6✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 18 times.
✗ Branch 5 not taken.

        36
                str := Tpl.tplString2(CodegenFMU.importFMUModelica, FMI.FMIIMPORT(s1, filename, workdir, fmiLogLevel, b2, fmiContext, fmiInstance, fmiInfo, fmiTypeDefinitionsList, fmiExperimentAnnotation, fmiModelVariablesInstance, fmiModelVariablesList, inputConnectors, outputConnectors), name);
      
                pd := Autoconf.pathDelimiter;
      
        18
                str1 := FMI.getFMIModelIdentifier(fmiInfo);
      
        18
                str2 := FMI.getFMIType(fmiInfo);
      
        18
                str3 := FMI.getFMIVersion(fmiInfo);
      
          1/2✓ Branch 0 taken 18 times.
✗ Branch 1 not taken.

        36
                outputFile := if stringEmpty(name) then stringAppendList({str1,"_",str2,"_FMU.mo"}) else stringAppendList({name,".mo"});
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.

        18
                filename_1 := if b1 then stringAppendList({workdir,pd,outputFile}) else outputFile;
      
        18
                System.writeFile(stringAppendList({workdir,pd,outputFile}), str);
      
                /* Release FMI objects */
      
        18
                FMIExt.releaseFMIImport(fmiModelVariablesInstance, fmiInstance, fmiContext, str3);
      
        18
              then
      
                Values.STRING(filename_1);
      
            case ("importFMU",{Values.STRING(filename),Values.STRING(_),Values.INTEGER(_),Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.CODE(_)})
      
              algorithm
      
        ✗
                false := System.regularFileExists(filename);
      
        ✗
                Error.clearMessages() "Clear messages";
      
        ✗
                Error.addMessage(Error.FILE_NOT_FOUND_ERROR, {filename});
      
              then
      
                Values.STRING("");
      
            case ("importFMU",{Values.STRING(_),Values.STRING(_),Values.INTEGER(_),Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.CODE(_)})
      
              then
      
                Values.STRING("");
      
            case ("importFMUModelDescription",{Values.STRING(filename), Values.STRING(workdir),Values.INTEGER(fmiLogLevel),Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(inputConnectors), Values.BOOL(outputConnectors)})
      
              algorithm
      
        ✗
                Error.clearMessages() "Clear messages";
      
        ✗
                true := System.regularFileExists(filename);
      
        ✗
                workdir := if System.directoryExists(workdir) then workdir else System.pwd();
      
                // create a temporary directory
      
        ✗
                tmpDir := System.createTemporaryDirectory(Settings.getTempDirectoryPath() + "/" + "fmuTmp" + intString(System.intRand(1000)));
      
        ✗
                tmpFile := tmpDir + "/" + "modelDescription.xml";
      
        ✗
                System.systemCall("cp -f " + filename + " " + tmpFile);
      
        ✗
                modeldescriptionfilename := tmpDir + "/modelDescription.fmu";
      
        ✗
                System.systemCall("zip -j " +  modeldescriptionfilename + " " + tmpFile);
      
        ✗
                true := System.regularFileExists(modeldescriptionfilename);
      
                /* Initialize FMI objects */
      
        ✗
                (b, fmiContext, fmiInstance, fmiInfo, fmiTypeDefinitionsList, fmiExperimentAnnotation, fmiModelVariablesInstance, fmiModelVariablesList) :=
      
                  FMIExt.initializeFMIImport(modeldescriptionfilename, tmpDir, fmiLogLevel, inputConnectors, outputConnectors, true);
      
        ✗
                true := b; /* if something goes wrong while initializing */
      
        ✗
                fmiTypeDefinitionsList := listReverse(fmiTypeDefinitionsList);
      
        ✗
                fmiModelVariablesList := listReverse(fmiModelVariablesList);
      
        ✗
                s1 := System.tolower(Autoconf.platform);
      
        ✗
                str := Tpl.tplString(CodegenFMU.importFMUModelDescription, FMI.FMIIMPORT(s1, modeldescriptionfilename, workdir, fmiLogLevel, b2, fmiContext, fmiInstance, fmiInfo, fmiTypeDefinitionsList, fmiExperimentAnnotation, fmiModelVariablesInstance, fmiModelVariablesList, inputConnectors, outputConnectors));
      
                pd := Autoconf.pathDelimiter;
      
        ✗
                str1 := FMI.getFMIModelIdentifier(fmiInfo);
      
        ✗
                str3 := FMI.getFMIVersion(fmiInfo);
      
        ✗
                outputFile := stringAppendList({workdir,pd,str1,"_Input_Output_FMU.mo"});
      
        ✗
                filename_1 := if b1 then stringAppendList({workdir,pd,str1,"_Input_Output_FMU.mo"}) else stringAppendList({str1,"_Input_Output_FMU.mo"});
      
        ✗
                System.writeFile(outputFile, str);
      
                /* Release FMI objects */
      
        ✗
                FMIExt.releaseFMIImport(fmiModelVariablesInstance, fmiInstance, fmiContext, str3);
      
        ✗
                System.removeDirectory(tmpDir);
      
        ✗
              then
      
                Values.STRING(filename_1);
      
            case ("importFMUModelDescription",{Values.STRING(filename),Values.STRING(_),Values.INTEGER(_),Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.BOOL(_)})
      
              algorithm
      
        ✗
                if not System.regularFileExists(filename) then
      
        ✗
                  Error.addMessage(Error.FILE_NOT_FOUND_ERROR, {filename});
      
                end if;
      
              then
      
                Values.STRING("");
      
            case ("importFMUModelDescription",{Values.STRING(_),Values.STRING(_),Values.INTEGER(_),Values.BOOL(_), Values.BOOL(_), Values.BOOL(_), Values.BOOL(_)})
      
              then
      
                Values.STRING("");
      
            case ("getIndexReductionMethod",_)
      
              algorithm
      
        ✗
                str := Config.getIndexReductionMethod();
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getAvailableIndexReductionMethods",_)
      
              algorithm
      
        ✗
                (strs1,strs2) := FlagsUtil.getConfigOptionsStringList(Flags.INDEX_REDUCTION_METHOD);
      
        ✗
                v1 := ValuesMake.makeArray(List.map(strs1, ValuesMake.makeString));
      
        ✗
                v2 := ValuesMake.makeArray(List.map(strs2, ValuesMake.makeString));
      
        ✗
              then
      
                Values.TUPLE({v1,v2});
      
            else
      
              algorithm
      
        5099
                (outCache, ret_val) := cevalInteractiveFunctions4(inCache,inEnv,inFunctionName,inVals,msg);
      
        4077
              then
      
                ret_val;
      
          end matchcontinue;
      
        end cevalInteractiveFunctions3;
      
        public function cevalInteractiveFunctions4
      
        "defined in the interactive environment."
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input String inFunctionName;
      
          input list<Values.Value> inVals;
      
          input Absyn.Msg msg;
      
          output FCore.Cache outCache = inCache;
      
          output Values.Value outValue;
      
        protected
      
          import LexerModelicaDiff.{Token,TokenId,tokenContent,scanString,reportErrors,filterModelicaDiff,modelicaDiffTokenEq,modelicaDiffTokenWhitespace};
      
          import DiffAlgorithm.{Diff,diff,printActual,printDiffTerminalColor,printDiffXml};
      
        algorithm
      
          outValue := matchcontinue (inFunctionName, inVals)
      
            local
      
              String s1,s2,str,str1,str2,str3,str4,method_str, pd,filename_1,filename,
      
                     call,name, title,xLabel,yLabel,yLabelRight,filename2,varNameStr,xml_filename,pwd,omhome,os,
      
                     gridStr, logXStr, logYStr, x1Str, x2Str, y1Str, y2Str, yAxis, curveWidthStr, curveStyleStr, legendPosition, footer, autoScaleStr,
      
                     cname, annStr, annotationname, modifiername;
      
              list<Values.Value> vals,cvars;
      
              Absyn.Path path,classpath,baseClassPath;
      
              Interactive.GraphicEnvCache genv;
      
              Absyn.Program p,newp;
      
              InteractiveTypes.SimulationOptions simOpt;
      
              Real startTime,stopTime,tolerance,reltol,reltolDiffMinMax,rangeDelta;
      
              DAE.Exp startTimeExp,stopTimeExp,toleranceExp,intervalExp;
      
              DAE.Type tp;
      
              Absyn.Class absynClass;
      
              Absyn.Exp aexp, aexp2, aexp3;
      
              Option<DAE.DAElist> odae;
      
              Values.Value v,cvar,cvar2,v1,v2;
      
              Absyn.ComponentRef cr, cr2;
      
              Integer size,i,n,curveStyle,numberOfIntervals,x,y;
      
              Access access;
      
              list<String> vars_1,args,strings,strs1,strs2,files;
      
              Real timeStamp,val,x1,x2,y1,y2,y1R,y2R,r1,r2,curveWidth, interval;
      
              GlobalScript.Statements istmts;
      
              Boolean b, b1, b2, b3, externalWindow, logX, logY, autoScale, forceOMPlot, keepRedeclares, hintReadAllVars;
      
              list<Real> realVals;
      
              list<Absyn.Path> paths;
      
              list<Absyn.NamedArg> nargs;
      
              list<Absyn.ElementArg> annlst;
      
              list<tuple<Absyn.Path,String,list<String>,Boolean>> uses;
      
              list<String> withoutConversion, withConversion;
      
              list<tuple<String,String>> relocatableFunctionsTuple;
      
              list<list<Values.Value>> valsLst;
      
              System.StatFileType statFileType;
      
              Absyn.Modification mod;
      
            case ("getAvailableIndexReductionMethods",_)
      
              algorithm
      
        ✗
                (strs1,strs2) := FlagsUtil.getConfigOptionsStringList(Flags.INDEX_REDUCTION_METHOD);
      
        ✗
                v1 := ValuesMake.makeArray(List.map(strs1, ValuesMake.makeString));
      
        ✗
                v2 := ValuesMake.makeArray(List.map(strs2, ValuesMake.makeString));
      
        ✗
              then
      
                Values.TUPLE({v1,v2});
      
            case ("getMatchingAlgorithm",_)
      
        ✗
              then Values.STRING(Config.getMatchingAlgorithm());
      
            case ("getAvailableMatchingAlgorithms",_)
      
              algorithm
      
        ✗
                (strs1,strs2) := FlagsUtil.getConfigOptionsStringList(Flags.MATCHING_ALGORITHM);
      
        ✗
                v1 := ValuesMake.makeArray(List.map(strs1, ValuesMake.makeString));
      
        ✗
                v2 := ValuesMake.makeArray(List.map(strs2, ValuesMake.makeString));
      
        ✗
              then
      
                Values.TUPLE({v1,v2});
      
            case ("getTearingMethod",_)
      
        ✗
              then Values.STRING(Config.getTearingMethod());
      
            case ("getAvailableTearingMethods",_)
      
              algorithm
      
        ✗
                (strs1,strs2) := FlagsUtil.getConfigOptionsStringList(Flags.TEARING_METHOD);
      
        ✗
                v1 := ValuesMake.makeArray(List.map(strs1, ValuesMake.makeString));
      
        ✗
                v2 := ValuesMake.makeArray(List.map(strs2, ValuesMake.makeString));
      
        ✗
              then
      
                Values.TUPLE({v1,v2});
      
            case ("saveModel",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := false;
      
        ✗
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
        ✗
                if access >= Access.all then // i.e., The class is not encrypted.
      
        ✗
                  absynClass := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        ✗
                  str := Dump.unparseStr(Absyn.PROGRAM({absynClass},Absyn.TOP()),true);
      
                  try
      
        ✗
                    System.writeFile(filename, str);
      
        ✗
                    b := true;
      
                  else
      
        ✗
                    Error.addMessage(Error.WRITING_FILE_ERROR, {filename});
      
                  end try;
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
        ✗
                  b := false;
      
                end if;
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("save",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
        ✗
                if access >= Access.all then // i.e., The class is not encrypted.
      
        ✗
                  (newp,filename) := Interactive.getContainedClassAndFile(classpath, SymbolTable.getAbsyn());
      
        ✗
                  str := Dump.unparseStr(newp);
      
        ✗
                  System.writeFile(filename, str);
      
        ✗
                  b := true;
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
        ✗
                  b := false;
      
                end if;
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("save",{Values.CODE(Absyn.C_TYPENAME(_))})
      
              then Values.BOOL(false);
      
            case ("saveAll",{Values.STRING(filename)})
      
              algorithm
      
        ✗
                str := Dump.unparseStr(SymbolTable.getAbsyn(),true);
      
        ✗
                System.writeFile(filename, str);
      
              then
      
                Values.BOOL(true);
      
            case ("saveModel",{Values.STRING(_),Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                cname := AbsynUtil.pathString(classpath);
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {cname,"global"});
      
              then
      
                Values.BOOL(false);
      
            case ("getTotalModel",{Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                                   Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(b3)})
      
              algorithm
      
        ✗
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
        ✗
                if access >= Access.all then
      
        ✗
                  s1 := getTotalModel(classpath, b1, b2, b3);
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
                  s1 := "";
      
                end if;
      
        ✗
              then
      
                Values.STRING(s1);
      
            case ("getTotalModel",{Values.CODE(Absyn.C_TYPENAME(_)),
      
                                   Values.BOOL(_), Values.BOOL(_), Values.BOOL(_)})
      
              then Values.STRING("");
      
            case ("saveTotalModel",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                                            Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(b3)})
      
              algorithm
      
        4
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

        4
                if access >= Access.all then
      
        4
                  saveTotalModel(filename, classpath, b1, b2, b3);
      
        4
                  b := true;
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
        ✗
                  b := false;
      
                end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
              then
      
                Values.BOOL(b);
      
            case ("saveTotalModel",{Values.STRING(_),Values.CODE(Absyn.C_TYPENAME(_)),
      
                                    Values.BOOL(_), Values.BOOL(_), Values.BOOL(_)})
      
              then Values.BOOL(false);
      
            case ("previous_saveTotalModel",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                                             Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(b3)})
      
              algorithm
      
        1
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
                if access >= Access.all then
      
        1
                  saveTotalModel(filename, classpath, b1, b2, b3, previous = true);
      
        1
                  b := true;
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
        ✗
                  b := false;
      
                end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("previous_saveTotalModel",{Values.STRING(_),Values.CODE(Absyn.C_TYPENAME(_)),
      
                                             Values.BOOL(_), Values.BOOL(_), Values.BOOL(_)})
      
              then Values.BOOL(false);
      
            case ("saveTotalModelDebug",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                                         Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(b3)})
      
              algorithm
      
        ✗
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
        ✗
                if access >= Access.all then // i.e., Access.documentation
      
        ✗
                  saveTotalModelDebug(filename, classpath, b1, b2, b3);
      
        ✗
                  b := true;
      
                else
      
        ✗
                  Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
      
        ✗
                  b := false;
      
                end if;
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("saveTotalModelDebug",{Values.STRING(_),Values.CODE(Absyn.C_TYPENAME(_))})
      
              then Values.BOOL(false);
      
            case ("getDocumentationAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        3
                access := Interactive.checkAccessAnnotationAndEncryption(classpath, SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.

        3
                if access >= Access.documentation then
      
        3
                  (str1,str2,str3) := ProgramUtil.getNamedAnnotationExp(classpath, SymbolTable.getAbsyn(), Absyn.IDENT("Documentation"), SOME(("","","")),Interactive.getDocumentationAnnotationString);
      
                else
      
        ✗
                  Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
      
                  (str1,str2,str3) := ("", "", "");
      
                end if;
      
        6
              then
      
                ValuesMake.makeArray({Values.STRING(str1),Values.STRING(str2),Values.STRING(str3)});
      
            case ("addClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        16
                p := Interactive.addClassAnnotation(AbsynUtil.pathToCref(classpath), Absyn.NAMEDARG("annotate",aexp)::{}, SymbolTable.getAbsyn());
      
        8
                SymbolTable.setAbsyn(p);
      
              then
      
                Values.BOOL(true);
      
            case ("addClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=annlst,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        ✗
                p := SymbolTable.getAbsyn();
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, p);
      
        ✗
                absynClass := Interactive.addClassAnnotationToClass(absynClass, Absyn.ANNOTATION(annlst));
      
        ✗
                p := ProgramUtil.updateProgram(Absyn.PROGRAM({absynClass}, if AbsynUtil.pathIsIdent(classpath) then Absyn.TOP() else Absyn.WITHIN(AbsynUtil.stripLast(classpath))), p);
      
        ✗
                SymbolTable.setAbsyn(p);
      
              then
      
                Values.BOOL(true);
      
            case ("addClassAnnotation",_)
      
              then Values.BOOL(false);
      
            case ("setDocumentationAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(str1),Values.STRING(str2)})
      
              algorithm
      
        ✗
                p := SymbolTable.getAbsyn();
      
        ✗
                nargs := List.consOnTrue(not stringEq(str1,""), Absyn.NAMEDARG("info",Absyn.STRING(System.escapedString(str1,false))), {});
      
        ✗
                nargs := List.consOnTrue(not stringEq(str2,""), Absyn.NAMEDARG("revisions",Absyn.STRING(System.escapedString(str2,false))), nargs);
      
        ✗
                aexp := Absyn.CALL(Absyn.CREF_IDENT("Documentation",{}),Absyn.FUNCTIONARGS({},nargs),{});
      
        ✗
                p := Interactive.addClassAnnotation(AbsynUtil.pathToCref(classpath), Absyn.NAMEDARG("annotate",aexp)::{}, p);
      
        ✗
                SymbolTable.setAbsyn(p);
      
              then
      
                Values.BOOL(true);
      
            case ("setDocumentationAnnotation",_)
      
              then Values.BOOL(false);
      
            case ("stat",{Values.STRING(str)})
      
              algorithm
      
        278
                (b,r1,r2) := System.stat(str);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 278 times.

        556
              then Values.TUPLE({Values.BOOL(b),Values.REAL(r1),Values.REAL(r2)});
      
            case ("regularFileExists",{Values.STRING(str)})
      
              algorithm
      
        289
                (_,_,_,statFileType) := System.stat(str);
      
          2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 285 times.

        293
              then Values.BOOL(statFileType==System.StatFileType.RegularFile);
      
            case ("directoryExists",{Values.STRING(str)})
      
              algorithm
      
        ✗
                (_,_,_,statFileType) := System.stat(str);
      
        ✗
              then Values.BOOL(statFileType==System.StatFileType.Directory);
      
            case ("OpenModelicaInternal_fullPathName",{Values.STRING(str)})
      
        ✗
              then Values.STRING(System.realpath(str));
      
            case ("isType",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isType(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isPackage",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isPackage(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isClass",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isClass(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isRecord",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isRecord(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isBlock",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isBlock(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isFunction",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isFunction(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isPartial",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isPartial(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isReplaceable",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                b := Interactive.isReplaceable(path, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isRedeclare",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        5
                b := Interactive.isRedeclare(path, SymbolTable.getAbsyn());
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 2 times.

        8
              then
      
                Values.BOOL(b);
      
            case ("isModel",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isModel(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isConnector",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isConnector(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isOptimization",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isOptimization(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isEnumeration",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isEnumeration(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isOperator",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isOperator(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isOperatorRecord",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isOperatorRecord(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isOperatorFunction",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                b := Interactive.isOperatorFunction(classpath, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("isProtectedClass",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(name)})
      
              algorithm
      
        ✗
                b := Interactive.isProtectedClass(classpath, name, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("getBuiltinType",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                (_, tp, _) := Lookup.lookupType(outCache, inEnv, classpath, SOME(Absyn.dummyInfo));
      
        ✗
                str := TypesDump.unparseType(tp);
      
        ✗
              then
      
                Values.STRING(str);
      
            // if the lookup fails
      
            case ("getBuiltinType",{Values.CODE(Absyn.C_TYPENAME(_))})
      
              then Values.STRING("");
      
            case ("extendsFrom",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(baseClassPath))})
      
              algorithm
      
        ✗
                paths := Interactive.getAllInheritedClasses(classpath, SymbolTable.getAbsyn());
      
        ✗
                b := List.applyAndFold1(paths, boolOr, AbsynUtil.pathSuffixOfr, baseClassPath, false);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("extendsFrom",_)
      
              then Values.BOOL(false);
      
            case ("isExperiment",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
          2/2✓ Branch 2 taken 5 times.
✓ Branch 3 taken 3 times.

        13
              then Values.BOOL(isExperiment(classpath, SymbolTable.getAbsyn()));
      
            case ("getInheritedClasses",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        7
                paths := Interactive.getInheritedClasses(classpath);
      
        7
              then
      
                ValuesMake.makeCodeTypeNameArray(paths);
      
            case ("getInheritedClasses",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getComponentsTest",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        1
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        1
                genv := Interactive.getClassEnv(SymbolTable.getAbsyn(), classpath);
      
          4/4✓ Branch 1 taken 6 times.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 1 time.

        7
                valsLst := list(getComponentInfo(c, genv, isProtected=false) for c in InteractiveUtil.getPublicComponentsInClass(absynClass));
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
                valsLst := listAppend(list(getComponentInfo(c, genv, isProtected=true) for c in InteractiveUtil.getProtectedComponentsInClass(absynClass)), valsLst);
      
        1
              then ValuesMake.makeArray(List.flatten(valsLst));
      
            case ("getComponentsTest",{Values.CODE(Absyn.C_TYPENAME(_))})
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getSimulationOptions",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.REAL(startTime),Values.REAL(stopTime),Values.REAL(tolerance),Values.INTEGER(numberOfIntervals),Values.REAL(interval)})
      
              algorithm
      
        2
                cr := AbsynUtil.pathToCref(classpath);
      
                // ignore the name of the model
      
        2
                ErrorExt.setCheckpoint("getSimulationOptions");
      
        2
                simOpt := InteractiveTypes.SIMULATION_OPTIONS(DAE.RCONST(startTime),DAE.RCONST(stopTime),DAE.ICONST(numberOfIntervals),DAE.RCONST(0.0),DAE.RCONST(tolerance),DAE.SCONST(""),DAE.SCONST(""),DAE.SCONST(""),DAE.SCONST(""),DAE.SCONST(""),DAE.SCONST(""),DAE.SCONST(""));
      
        2
                ErrorExt.rollBack("getSimulationOptions");
      
          5/10✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 2 times.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 2 times.

        4
                (_, _::startTimeExp::stopTimeExp::intervalExp::toleranceExp::_) := StaticScript.getSimulationArguments(FCore.emptyCache(), FGraph.empty(), {Absyn.CREF(cr)},{},false,DAE.NOPRE(), "getSimulationOptions", Absyn.dummyInfo,SOME(simOpt));
      
        2
                startTime := ValuesUtil.valueReal(Util.makeValueOrDefault(Ceval.cevalSimple,startTimeExp,Values.REAL(startTime)));
      
        2
                stopTime := ValuesUtil.valueReal(Util.makeValueOrDefault(Ceval.cevalSimple,stopTimeExp,Values.REAL(stopTime)));
      
        2
                tolerance := ValuesUtil.valueReal(Util.makeValueOrDefault(Ceval.cevalSimple,toleranceExp,Values.REAL(tolerance)));
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

        2
                Values.INTEGER(numberOfIntervals) := Util.makeValueOrDefault(Ceval.cevalSimple,intervalExp,Values.INTEGER(numberOfIntervals)); // number of intervals
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

        2
                if numberOfIntervals == 0 and interval > 0.0 then
      
        ✗
                  numberOfIntervals := integer(ceil((stopTime - startTime)/interval));
      
                else
      
                  // What simulate() runs (SimCodeMain.createSimulationSettings): an
      
                  // Interval annotation longer than the experiment is one step to stopTime.
      
                  numberOfIntervals := max(numberOfIntervals, 1);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

        2
                  interval := (stopTime-startTime) / numberOfIntervals;
      
                end if;
      
        4
              then
      
                Values.TUPLE({Values.REAL(startTime), Values.REAL(stopTime), Values.REAL(tolerance), Values.INTEGER(numberOfIntervals), Values.REAL(interval)});
      
            case ("getModelFigures",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then getModelFigures(classpath, SymbolTable.getAbsyn());
      
            case ("getAnnotationNamedModifiers",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(annotationname)})
      
        2
              then getAnnotationNamedModifiers(classpath, annotationname, SymbolTable.getAbsyn());
      
             case ("getAnnotationModifierValue",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(annotationname),Values.STRING(modifiername)})
      
        4
               then getAnnotationModifierValue(classpath, annotationname, modifiername, SymbolTable.getAbsyn());
      
            case ("searchClassNames",{Values.STRING(str), Values.BOOL(b)})
      
              algorithm
      
        ✗
                (_,paths) := ProgramUtil.getClassNamesRecursive(NONE(),SymbolTable.getAbsyn(),false,false,{});
      
        ✗
                paths := listReverse(paths);
      
        ✗
                vals := List.map(paths,ValuesMake.makeCodeTypeName);
      
        ✗
                vals := searchClassNames(vals, str, b, SymbolTable.getAbsyn());
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getAvailableLibraries",{})
      
              algorithm
      
        ✗
                PackageManagement.installCachedPackages();
      
        ✗
                files := PackageManagement.AvailableLibraries.listKeys(PackageManagement.getInstalledLibraries());
      
        ✗
              then
      
                ValuesMake.makeArray(List.map(files, ValuesMake.makeString));
      
            case ("getAvailableLibraryVersions",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(str1)))})
      
              algorithm
      
        ✗
                PackageManagement.installCachedPackages();
      
        ✗
                files := PackageManagement.getInstalledLibraryVersions(str1);
      
        ✗
              then
      
                ValuesMake.makeArray(List.map(files, ValuesMake.makeString));
      
            case ("installPackage",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(str1))), Values.STRING(str2), Values.BOOL(b)})
      
              algorithm
      
        ✗
                (b, files) := PackageManagement.installPackage(str1, str2, b, wasmABI=CodegenWasmJitFunctions.prebuiltExternalsABI());
      
        ✗
                CodegenWasmJitFunctions.precompilePrebuiltModules(files);
      
        ✗
              then Values.BOOL(b);
      
            case ("installPackage",{Values.CODE(Absyn.C_TYPENAME(path as Absyn.QUALIFIED())), _, _})
      
              algorithm
      
        ✗
                Error.addMessage(Error.ERROR_PKG_NOT_IDENT, {AbsynUtil.pathString(path)});
      
              then
      
                Values.BOOL(false);
      
            case ("installPackage",_)
      
              then Values.BOOL(false);
      
            case ("updatePackageIndex",{})
      
        ✗
              then Values.BOOL(PackageManagement.updateIndex());
      
            case ("installWasmToolchain",{Values.BOOL(b)})
      
        ✗
              then Values.STRING(PackageManagement.installWasmToolchain(b));
      
            case ("upgradeInstalledPackages",{Values.BOOL(b)})
      
        ✗
              then Values.BOOL(PackageManagement.upgradeInstalledPackages(b, wasmABI=CodegenWasmJitFunctions.prebuiltExternalsABI()));
      
            case ("getAvailablePackageVersions",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(str1))), Values.STRING(str2)})
      
        ✗
              then ValuesMake.makeArray(list(ValuesMake.makeString(s) for s in PackageManagement.versionsThatProvideTheWanted(str1, str2, true)));
      
            case ("getAvailablePackageVersions",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getAvailablePackageConversionsFrom",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(str1))), Values.STRING(str2)})
      
        ✗
              then ValuesMake.makeStringArray(PackageManagement.versionsThatConvertFromTheWanted(str1, str2, true));
      
            case ("getAvailablePackageConversionsFrom",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getAvailablePackageConversionsTo",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(str1))), Values.STRING(str2)})
      
        ✗
              then ValuesMake.makeStringArray(PackageManagement.versionsThatConvertToTheWanted(str1, str2, true));
      
            case ("getAvailablePackageConversionsTo",_)
      
        ✗
              then ValuesMake.makeArray({});
      
            case ("getUses",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                absynClass as Absyn.CLASS() := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        ✗
                uses := Interactive.getUsesAnnotation(Absyn.PROGRAM({absynClass},Absyn.TOP()));
      
        ✗
              then
      
                ValuesMake.makeArray(List.map(uses,makeUsesArray));
      
            case ("getConversionsFromVersions",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                absynClass as Absyn.CLASS() := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        ✗
                (withoutConversion,withConversion) := Interactive.getConversionAnnotation(absynClass);
      
        ✗
              then
      
                Values.TUPLE({ValuesMake.makeArray(List.map(withoutConversion,ValuesMake.makeString)), ValuesMake.makeArray(List.map(withConversion,ValuesMake.makeString))});
      
            case ("getDerivedClassModifierNames",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        ✗
                args := Interactive.getDerivedClassModifierNames(absynClass);
      
        ✗
                vals := List.map(args, ValuesMake.makeString);
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getDerivedClassModifierValue",{Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        2
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
      
        ✗
                str := Interactive.getDerivedClassModifierValue(absynClass, path);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("readSimulationResult",{Values.STRING(filename),Values.ARRAY(valueLst=cvars),Values.INTEGER(size)})
      
              algorithm
      
        52
                vars_1 := List.map(cvars, ValuesUtil.printCodeVariableName);
      
        52
                filename := Util.absoluteOrRelative(filename);
      
        52
              then
      
                SimulationResults.readDataset(filename, vars_1, size);
      
            case ("readSimulationResult",_)
      
              algorithm
      
        ✗
                Error.addMessage(Error.SCRIPT_READ_SIM_RES_ERROR, {});
      
              then
      
                Values.META_FAIL();
      
            case ("readSimulationResultSize",{Values.STRING(filename)})
      
              algorithm
      
        39
                filename := Util.absoluteOrRelative(filename);
      
        39
                i := SimulationResults.readSimulationResultSize(filename);
      
        39
              then
      
                Values.INTEGER(i);
      
            case ("readSimulationResultVars",{Values.STRING(filename),Values.BOOL(b1),Values.BOOL(b2)})
      
              algorithm
      
        7
                filename := Util.absoluteOrRelative(filename);
      
        7
                args := SimulationResults.readVariables(filename, b1, b2);
      
        7
                vals := List.map(args, ValuesMake.makeString);
      
        7
              then
      
                ValuesMake.makeArray(vals);
      
            case ("compareSimulationResults",{Values.STRING(filename),Values.STRING(filename_1),Values.STRING(filename2),Values.REAL(x1),Values.REAL(x2),Values.ARRAY(valueLst=cvars)})
      
              algorithm
      
        183
                Error.addMessage(Error.DEPRECATED_API_CALL, {"compareSimulationResults", "diffSimulationResults"});
      
        183
                filename := Util.absoluteOrRelative(filename);
      
        183
                filename_1 := Testsuite.friendlyPath(filename_1);
      
        183
                filename_1 := Util.absoluteOrRelative(filename_1);
      
        183
                filename2 := Util.absoluteOrRelative(filename2);
      
        183
                vars_1 := List.map(cvars, ValuesUtil.extractValueString);
      
        183
                strings := SimulationResults.cmpSimulationResults(Testsuite.isRunning(),filename,filename_1,filename2,x1,x2,vars_1);
      
        183
                cvars := List.map(strings,ValuesMake.makeString);
      
        183
              then
      
                ValuesMake.makeArray(cvars);
      
            case ("compareSimulationResults",_)
      
              then Values.STRING("Error in compareSimulationResults");
      
            case ("deltaSimulationResults",{Values.STRING(filename),Values.STRING(filename_1),Values.STRING(method_str),Values.ARRAY(valueLst=cvars)})
      
              algorithm
      
        12
                filename := Util.absoluteOrRelative(filename);
      
        12
                filename_1 := Testsuite.friendlyPath(filename_1);
      
        12
                filename_1 := Util.absoluteOrRelative(filename_1);
      
        12
                vars_1 := List.map(cvars, ValuesUtil.extractValueString);
      
        12
                val := SimulationResults.deltaSimulationResults(filename,filename_1,method_str,vars_1);
      
        12
              then
      
                Values.REAL(val);
      
            case ("deltaSimulationResults",_)
      
              then Values.STRING("Error in deltaSimulationResults");
      
            case ("filterSimulationResults",{Values.STRING(filename),Values.STRING(filename_1),Values.ARRAY(valueLst=cvars),Values.INTEGER(numberOfIntervals),Values.BOOL(b),Values.BOOL(hintReadAllVars)})
      
              algorithm
      
        3
                vars_1 := List.map(cvars, ValuesUtil.extractValueString);
      
        3
                b := SimulationResults.filterSimulationResults(filename,filename_1,vars_1,numberOfIntervals,b,hintReadAllVars=hintReadAllVars);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.

        3
              then
      
                Values.BOOL(b);
      
            case ("filterSimulationResults",_)
      
              then Values.BOOL(false);
      
            case ("diffSimulationResults",{Values.STRING(filename),Values.STRING(filename_1),Values.STRING(filename2),Values.REAL(reltol),Values.REAL(reltolDiffMinMax),Values.REAL(rangeDelta),Values.ARRAY(valueLst=cvars),Values.BOOL(b)})
      
              algorithm
      
        238
                filename := Util.absoluteOrRelative(filename);
      
        238
                filename_1 := Testsuite.friendlyPath(filename_1);
      
        238
                filename_1 := Util.absoluteOrRelative(filename_1);
      
        238
                filename2 := Util.absoluteOrRelative(filename2);
      
        238
                vars_1 := List.map(cvars, ValuesUtil.extractValueString);
      
        238
                (b,strings) := SimulationResults.diffSimulationResults(Testsuite.isRunning(),filename,filename_1,filename2,reltol,reltolDiffMinMax,rangeDelta,vars_1,b);
      
        238
                cvars := List.map(strings,ValuesMake.makeString);
      
        238
                v1 := ValuesMake.makeArray(cvars);
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 235 times.

        479
              then
      
                Values.TUPLE({Values.BOOL(b),v1});
      
            case ("diffSimulationResults",_)
      
              algorithm
      
        ✗
                v := ValuesMake.makeArray({});
      
        ✗
              then
      
                Values.TUPLE({Values.BOOL(false),v});
      
            case ("diffSimulationResultsHtml",{Values.STRING(str),Values.STRING(filename),Values.STRING(filename_1),Values.REAL(reltol),Values.REAL(reltolDiffMinMax),Values.REAL(rangeDelta)})
      
              algorithm
      
        ✗
                filename := Util.absoluteOrRelative(filename);
      
        ✗
                filename_1 := Testsuite.friendlyPath(filename_1);
      
        ✗
                filename_1 := Util.absoluteOrRelative(filename_1);
      
        ✗
                str := SimulationResults.diffSimulationResultsHtml(Testsuite.isRunning(),filename,filename_1,reltol,reltolDiffMinMax,rangeDelta,str);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("diffSimulationResultsHtml",_)
      
              then Values.STRING("");
      
            case ("checkTaskGraph",{Values.STRING(filename),Values.STRING(filename_1)})
      
              algorithm
      
        1
                pwd := System.pwd();
      
                pd := Autoconf.pathDelimiter;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        2
                filename := if StringUtil.startsWith(filename, "/") then filename else stringAppendList({pwd,pd,filename});
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        2
                filename_1 := if StringUtil.startsWith(filename_1, "/") then filename_1 else stringAppendList({pwd,pd,filename_1});
      
        1
                strings := TaskGraphResults.checkTaskGraph(filename, filename_1);
      
        1
                cvars := List.map(strings,ValuesMake.makeString);
      
        1
              then
      
                ValuesMake.makeArray(cvars);
      
            case ("checkTaskGraph",_)
      
              then Values.STRING("Error in checkTaskGraph");
      
            case ("checkCodeGraph",{Values.STRING(filename),Values.STRING(filename_1)})
      
              algorithm
      
        ✗
                pwd := System.pwd();
      
                pd := Autoconf.pathDelimiter;
      
        ✗
                filename := if StringUtil.startsWith(filename, "/") then filename else stringAppendList({pwd,pd,filename});
      
        ✗
                filename_1 := if StringUtil.startsWith(filename_1, "/") then filename_1 else stringAppendList({pwd,pd,filename_1});
      
        ✗
                strings := TaskGraphResults.checkCodeGraph(filename, filename_1);
      
        ✗
                cvars := List.map(strings,ValuesMake.makeString);
      
        ✗
              then
      
                ValuesMake.makeArray(cvars);
      
            case ("checkCodeGraph",_)
      
              then Values.STRING("Error in checkCodeGraph");
      
            //plotAll(model)
      
            case ("plotAll",
      
                {
      
                  Values.BOOL(externalWindow),
      
                  Values.STRING(filename),
      
                  Values.STRING(title),
      
                  Values.STRING(gridStr),
      
                  Values.BOOL(logX),
      
                  Values.BOOL(logY),
      
                  Values.STRING(xLabel),
      
                  Values.STRING(yLabel),
      
                  Values.ARRAY(valueLst={Values.REAL(x1),Values.REAL(x2)}),
      
                  Values.ARRAY(valueLst={Values.REAL(y1),Values.REAL(y2)}),
      
                  Values.REAL(curveWidth),
      
                  Values.INTEGER(curveStyle),
      
                  Values.STRING(legendPosition),
      
                  Values.STRING(footer),
      
                  Values.BOOL(autoScale),
      
                  Values.BOOL(forceOMPlot),
      
                  Values.STRING(yAxis),
      
                  Values.STRING(yLabelRight),
      
                  Values.ARRAY(valueLst={Values.REAL(y1R),Values.REAL(y2R)})
      
                })
      
              algorithm
      
                // get OPENMODELICAHOME
      
        ✗
                omhome := Settings.getInstallationDirectoryPath();
      
                // get the simulation filename
      
        ✗
                (outCache,filename) := cevalCurrentSimulationResultExp(outCache,inEnv,filename,msg);
      
                pd := Autoconf.pathDelimiter;
      
                // create absolute path of simulation result file
      
        ✗
                str1 := System.pwd() + pd + filename;
      
                s1 := if Autoconf.os == "Windows_NT" then ".exe" else "";
      
        ✗
                filename := if System.regularFileExists(str1) then str1 else filename;
      
                // check if plot callback is defined
      
        ✗
                b := System.plotCallBackDefined();
      
        ✗
                if boolOr(forceOMPlot, boolNot(b)) then
      
                  // create the path till OMPlot
      
        ✗
                  str2 := stringAppendList({omhome,pd,"bin",pd,"OMPlot",s1});
      
                  // create the list of arguments for OMPlot
      
        ✗
                  str3 := "--filename=\"" + filename + "\" --title=\"" + title + "\" --grid=" + gridStr + " --plotAll --logx=" + boolString(logX) + " --logy=" + boolString(logY) + " --yaxis=\"" + yAxis + "\" --xlabel=\"" + xLabel + "\" --ylabel=\"" + yLabel + "\" --ylabel-right=\"" + yLabelRight + "\" --xrange=" + realString(x1) + ":" + realString(x2) + " --yrange=" + realString(y1) + ":" + realString(y2) + " --yrange-right=" + realString(y1R) + ":" + realString(y2R) + " --new-window=" + boolString(externalWindow) + " --curve-width=" + realString(curveWidth) + " --curve-style=" + intString(curveStyle) + " --legend-position=\"" + legendPosition + "\" --footer=\"" + footer + "\" --auto-scale=" + boolString(autoScale);
      
        ✗
                  call := stringAppendList({"\"",str2,"\""," ",str3});
      
        ✗
                  0 := System.spawnCall(str2, call);
      
                elseif b then
      
        ✗
                  logXStr := boolString(logX);
      
        ✗
                  logYStr := boolString(logY);
      
        ✗
                  x1Str := realString(x1);
      
        ✗
                  x2Str := realString(x2);
      
        ✗
                  y1Str := realString(y1);
      
        ✗
                  y2Str := realString(y2);
      
        ✗
                  curveWidthStr := realString(curveWidth);
      
        ✗
                  curveStyleStr := intString(curveStyle);
      
        ✗
                  autoScaleStr := boolString(autoScale);
      
        ✗
                  System.plotCallBack(externalWindow,filename,title,gridStr,"plotall",logXStr,logYStr,xLabel,yLabel,x1Str,x2Str,y1Str,y2Str,curveWidthStr,curveStyleStr,legendPosition,footer,autoScaleStr,"");
      
                end if;
      
              then
      
                Values.BOOL(true);
      
            case ("plotAll",_)
      
              then Values.BOOL(false);
      
            // plot(x, model)
      
            case ("plot",
      
                {
      
                  Values.ARRAY(valueLst = cvars),
      
                  Values.BOOL(externalWindow),
      
                  Values.STRING(filename),
      
                  Values.STRING(title),
      
                  Values.STRING(gridStr),
      
                  Values.BOOL(logX),
      
                  Values.BOOL(logY),
      
                  Values.STRING(xLabel),
      
                  Values.STRING(yLabel),
      
                  Values.ARRAY(valueLst={Values.REAL(x1),Values.REAL(x2)}),
      
                  Values.ARRAY(valueLst={Values.REAL(y1),Values.REAL(y2)}),
      
                  Values.REAL(curveWidth),
      
                  Values.INTEGER(curveStyle),
      
                  Values.STRING(legendPosition),
      
                  Values.STRING(footer),
      
                  Values.BOOL(autoScale),
      
                  Values.BOOL(forceOMPlot),
      
                  Values.STRING(yAxis),
      
                  Values.STRING(yLabelRight),
      
                  Values.ARRAY(valueLst={Values.REAL(y1R),Values.REAL(y2R)})
      
                })
      
              algorithm
      
                // get the variables list
      
        ✗
                vars_1 := List.map(cvars, ValuesUtil.printCodeVariableName);
      
                // get OPENMODELICAHOME
      
        ✗
                omhome := Settings.getInstallationDirectoryPath();
      
                // get the simulation filename
      
        ✗
                (outCache,filename) := cevalCurrentSimulationResultExp(outCache,inEnv,filename,msg);
      
                pd := Autoconf.pathDelimiter;
      
                // create absolute path of simulation result file
      
        ✗
                str1 := System.pwd() + pd + filename;
      
                s1 := if Autoconf.os == "Windows_NT" then ".exe" else "";
      
        ✗
                filename := if System.regularFileExists(str1) then str1 else filename;
      
                // check if plot callback is defined
      
        ✗
                b := System.plotCallBackDefined();
      
        ✗
                if boolOr(forceOMPlot, boolNot(b)) then
      
                  // seperate the variables
      
        ✗
                  str := stringDelimitList(vars_1,"' '");
      
                  // create the path till OMPlot
      
        ✗
                  str2 := stringAppendList({omhome,pd,"bin",pd,"OMPlot",s1});
      
                  // create the list of arguments for OMPlot
      
        ✗
                  str3 := "--filename=\"" + filename + "\" --title=\"" + title + "\" --grid=" + gridStr + " --plot --logx=" + boolString(logX) + " --logy=" + boolString(logY) + " --yaxis=\"" + yAxis + "\" --xlabel=\"" + xLabel + "\" --ylabel=\"" + yLabel + "\" --ylabel-right=\"" + yLabelRight + "\" --xrange=" + realString(x1) + ":" + realString(x2) + " --yrange=" + realString(y1) + ":" + realString(y2) + " --yrange-right=" + realString(y1R) + ":" + realString(y2R) + " --new-window=" + boolString(externalWindow) + " --curve-width=" + realString(curveWidth) + " --curve-style=" + intString(curveStyle) + " --legend-position=\"" + legendPosition + "\" --footer=\"" + footer + "\" --auto-scale=" + boolString(autoScale) + " '" + str + "'";
      
        ✗
                  call := stringAppendList({"\"",str2,"\""," ",str3});
      
        ✗
                  0 := System.spawnCall(str2, call);
      
                elseif b then
      
        ✗
                  logXStr := boolString(logX);
      
        ✗
                  logYStr := boolString(logY);
      
        ✗
                  x1Str := realString(x1);
      
        ✗
                  x2Str := realString(x2);
      
        ✗
                  y1Str := realString(y1);
      
        ✗
                  y2Str := realString(y2);
      
        ✗
                  curveWidthStr := realString(curveWidth);
      
        ✗
                  curveStyleStr := intString(curveStyle);
      
        ✗
                  autoScaleStr := boolString(autoScale);
      
                  // seperate the variables
      
        ✗
                  str := stringDelimitList(vars_1, " ");
      
        ✗
                  System.plotCallBack(externalWindow,filename,title,gridStr,"plot",logXStr,logYStr,xLabel,yLabel,x1Str,x2Str,y1Str,y2Str,curveWidthStr,curveStyleStr,legendPosition,footer,autoScaleStr,str);
      
                end if;
      
              then
      
                Values.BOOL(true);
      
            case ("plot",_)
      
              then Values.BOOL(false);
      
            case ("val",{cvar,Values.REAL(timeStamp),Values.STRING("<default>")})
      
              algorithm
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 2422 times.

        2422
                (outCache,Values.STRING(filename)) := Ceval.ceval(outCache,inEnv,buildCurrentSimulationResultExp(), true, msg, 0);
      
        2422
                varNameStr := ValuesUtil.printCodeVariableName(cvar);
      
        2422
                val := SimulationResults.val(filename,varNameStr,timeStamp);
      
        2422
              then
      
                Values.REAL(val);
      
            case ("val",{cvar,Values.REAL(timeStamp),Values.STRING(filename)})
      
              algorithm
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 88 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        88
                false := stringEq(filename,"<default>");
      
        88
                varNameStr := ValuesUtil.printCodeVariableName(cvar);
      
        88
                val := SimulationResults.val(filename,varNameStr,timeStamp);
      
        88
              then
      
                Values.REAL(val);
      
            case ("closeSimulationResultFile",_)
      
              algorithm
      
        4
                SimulationResults.close();
      
              then
      
                Values.BOOL(true);
      
            case ("getParameterNames",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                strings := Interactive.getParameterNames(path, SymbolTable.getAbsyn());
      
        ✗
                vals := List.map(strings, ValuesMake.makeString);
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getParameterValue",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str1)})
      
              algorithm
      
        4
                str2 := Interactive.getComponentBinding(path, str1, SymbolTable.getAbsyn());
      
        4
              then
      
                Values.STRING(str2);
      
            case ("setParameterValue", {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        6
                (p, b) := InteractiveUtil.setElementModifier(classpath, path,
      
                  Absyn.Modification.CLASSMOD({}, Absyn.EqMod.EQMOD(aexp, Absyn.dummyInfo)), SymbolTable.getAbsyn());
      
        6
                SymbolTable.setAbsyn(p);
      
        6
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("getComponentModifierNames",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str1)})
      
              algorithm
      
        13
                strings := Interactive.getComponentModifierNames(path, str1, SymbolTable.getAbsyn());
      
        13
                vals := List.map(strings, ValuesMake.makeString);
      
        13
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getComponentModifierValue",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        26
                cr := AbsynUtil.pathToCref(path);
      
          2/2✓ Branch 1 taken 4 times.
✓ Branch 2 taken 22 times.

        26
                if AbsynUtil.crefIsIdent(cr) then
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
                  Absyn.CREF_IDENT(name = s1) := cr;
      
        4
                  str := Interactive.getComponentBinding(classpath, s1, SymbolTable.getAbsyn());
      
                else
      
        22
                  s1 := AbsynUtil.crefFirstIdent(cr);
      
        22
                  cr := AbsynUtil.crefStripFirst(cr);
      
        22
                  str := Interactive.getComponentModifierValue(AbsynUtil.pathToCref(classpath), Absyn.CREF_IDENT(s1, {}), cr, SymbolTable.getAbsyn());
      
                end if;
      
        26
              then
      
                Values.STRING(str);
      
            case ("getComponentModifierValues",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        1
                cr := AbsynUtil.pathToCref(path);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
                if AbsynUtil.crefIsIdent(cr) then
      
        ✗
                  Absyn.CREF_IDENT(name = s1) := cr;
      
        ✗
                  str := Interactive.getComponentBinding(classpath, s1, SymbolTable.getAbsyn());
      
                else
      
        1
                  s1 := AbsynUtil.crefFirstIdent(cr);
      
        1
                  cr := AbsynUtil.crefStripFirst(cr);
      
        1
                  str := Interactive.getComponentModifierValues(AbsynUtil.pathToCref(classpath), Absyn.CREF_IDENT(s1, {}), cr, SymbolTable.getAbsyn());
      
                end if;
      
        1
              then
      
                Values.STRING(str);
      
            case ("setElementModifierValue",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(path)),
      
                   Values.CODE(Absyn.C_MODIFICATION(modification = mod))})
      
              algorithm
      
        42
                (p, b) := InteractiveUtil.setElementModifier(classpath, path, mod, SymbolTable.getAbsyn());
      
          2/2✓ Branch 0 taken 41 times.
✓ Branch 1 taken 1 time.

        42
                if b then
      
        41
                  SymbolTable.setAbsynClass(p, ProgramUtil.getPathedClassInProgram(classpath, p), classpath);
      
                else
      
        1
                  SymbolTable.setAbsyn(p);
      
                end if;
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 41 times.

        43
              then
      
                Values.BOOL(b);
      
            case ("getExtendsModifierValue",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(baseClassPath)),
      
                   Values.CODE(Absyn.C_TYPENAME(path))})
      
        12
              then Interactive.getExtendsModifierValue(classpath, baseClassPath, path, SymbolTable.getAbsyn());
      
            case ("setExtendsModifierValue",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(baseClassPath)),
      
                   Values.CODE(Absyn.C_TYPENAME(path)),
      
                   Values.CODE(Absyn.C_MODIFICATION(modification = mod))})
      
              algorithm
      
        9
                (p, b) := InteractiveUtil.setExtendsModifier(classpath, baseClassPath, path, mod, SymbolTable.getAbsyn());
      
        9
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.

        9
              then
      
                Values.BOOL(b);
      
            case ("setExtendsModifier",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(baseClassPath)),
      
                   Values.CODE(Absyn.C_MODIFICATION(modification = mod))})
      
              algorithm
      
        1
                (p, b) := InteractiveUtil.setExtendsModifier(classpath, baseClassPath, Absyn.Path.IDENT("_"), mod, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("isExtendsModifierFinal",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                   Values.CODE(Absyn.C_TYPENAME(baseClassPath)),
      
                   Values.CODE(Absyn.C_TYPENAME(path))})
      
        4
              then Interactive.isExtendsModifierFinal(classpath, baseClassPath, path, SymbolTable.getAbsyn());
      
            case ("removeComponentModifiers",
      
                Values.CODE(Absyn.C_TYPENAME(path))::
      
              Values.STRING(str1)::
      
              Values.BOOL(keepRedeclares)::_)
      
              algorithm
      
        2
                (p,b) := Interactive.removeComponentModifiers(path, str1, SymbolTable.getAbsyn(), keepRedeclares);
      
        2
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.

        2
              then
      
                Values.BOOL(b);
      
            case ("getElementModifierNames",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str1)})
      
              algorithm
      
        ✗
                strings := InteractiveUtil.getElementModifierNames(path, str1, SymbolTable.getAbsyn());
      
        ✗
                vals := List.map(strings, ValuesMake.makeString);
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getElementModifierValue",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                cr := AbsynUtil.pathToCref(path);
      
        ✗
                if AbsynUtil.crefIsIdent(cr) then
      
        ✗
                  Absyn.CREF_IDENT(name = s1) := cr;
      
        ✗
                  str := InteractiveUtil.getElementBinding(classpath, s1, SymbolTable.getAbsyn());
      
                else
      
        ✗
                  s1 := AbsynUtil.crefFirstIdent(cr);
      
        ✗
                  cr := AbsynUtil.crefStripFirst(cr);
      
        ✗
                  str := InteractiveUtil.getElementModifierValue(AbsynUtil.pathToCref(classpath), Absyn.CREF_IDENT(s1, {}), cr, SymbolTable.getAbsyn());
      
                end if;
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getElementModifierValues",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                cr := AbsynUtil.pathToCref(path);
      
        ✗
                if AbsynUtil.crefIsIdent(cr) then
      
        ✗
                  Absyn.CREF_IDENT(name = s1) := cr;
      
        ✗
                  str := InteractiveUtil.getElementBinding(classpath, s1, SymbolTable.getAbsyn());
      
                else
      
        ✗
                  s1 := AbsynUtil.crefFirstIdent(cr);
      
        ✗
                  cr := AbsynUtil.crefStripFirst(cr);
      
        ✗
                  str := InteractiveUtil.getElementModifierValues(AbsynUtil.pathToCref(classpath), Absyn.CREF_IDENT(s1, {}), cr, SymbolTable.getAbsyn());
      
                end if;
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("removeElementModifiers",
      
                Values.CODE(Absyn.C_TYPENAME(path))::
      
              Values.STRING(str1)::
      
              Values.BOOL(keepRedeclares)::_)
      
              algorithm
      
        ✗
                (p,b) := InteractiveUtil.removeElementModifiers(path, str1, SymbolTable.getAbsyn(), keepRedeclares);
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("removeExtendsModifiers",
      
                  Values.CODE(Absyn.C_TYPENAME(classpath))::
      
                  Values.CODE(Absyn.C_TYPENAME(baseClassPath))::
      
                  Values.BOOL(keepRedeclares)::_)
      
              algorithm
      
        1
                (p,b) := Interactive.removeExtendsModifiers(classpath, baseClassPath, SymbolTable.getAbsyn(), keepRedeclares);
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("getInstantiatedParametersAndValues",{Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                (outCache,_,odae) := runFrontEnd(outCache,inEnv,classpath,true);
      
        ✗
                strings := Interactive.getInstantiatedParametersAndValues(odae);
      
        ✗
                vals := List.map(strings, ValuesMake.makeString);
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
            case ("getInstantiatedParametersAndValues",_)
      
              algorithm
      
        ✗
                Error.addCompilerWarning("getInstantiatedParametersAndValues failed to instantiate the model.");
      
        ✗
              then
      
                ValuesMake.makeArray({});
      
            case ("updateConnection",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(str1), Values.STRING(str2),Values.CODE(Absyn.C_EXPRESSION(aexp))})
      
              algorithm
      
        2
                p := InteractiveUtil.updateConnectionAnnotation(AbsynUtil.pathToCref(classpath), str1, str2, Absyn.NAMEDARG("annotate",aexp)::{}, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
              then
      
                Values.BOOL(true);
      
            case ("updateConnection",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(str1), Values.STRING(str2),
      
                                      Values.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=annlst,eqMod=Absyn.NOMOD())))})
      
              algorithm
      
        1
                p := SymbolTable.getAbsyn();
      
        1
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, p);
      
        1
                absynClass := InteractiveUtil.updateConnectionAnnotationInClass(absynClass, str1, str2, Absyn.ANNOTATION(annlst));
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
                p := ProgramUtil.updateProgram(Absyn.PROGRAM({absynClass}, if AbsynUtil.pathIsIdent(classpath) then Absyn.TOP() else Absyn.WITHIN(AbsynUtil.stripLast(classpath))), p);
      
        1
                SymbolTable.setAbsyn(p);
      
              then
      
                Values.BOOL(true);
      
            case ("updateConnection",_) then Values.BOOL(false);
      
            case ("updateConnectionAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(str1), Values.STRING(str2),Values.STRING(annStr)})
      
              algorithm
      
        1
                istmts := Parser.parsestringexp("__dummy(" + annStr + ");");
      
          3/6✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 time.

        1
                GlobalScript.ISTMTS(interactiveStmtLst = {GlobalScript.IEXP(exp = aexp)}) := istmts;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        1
                Absyn.CALL(functionArgs = Absyn.FUNCTIONARGS(argNames = nargs)) := aexp;
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.
✗ Branch 5 not taken.
✓ Branch 6 taken 1 time.

        1
                Absyn.NAMEDARG(argValue = Absyn.CODE(Absyn.C_MODIFICATION(Absyn.CLASSMOD(elementArgLst=annlst,eqMod=Absyn.NOMOD())))) := listHead(nargs);
      
        1
                p := SymbolTable.getAbsyn();
      
        1
                absynClass := ProgramUtil.getPathedClassInProgram(classpath, p);
      
        1
                absynClass := InteractiveUtil.updateConnectionAnnotationInClass(absynClass, str1, str2, Absyn.ANNOTATION(annlst));
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
                p := ProgramUtil.updateProgram(Absyn.PROGRAM({absynClass}, if AbsynUtil.pathIsIdent(classpath) then Absyn.TOP() else Absyn.WITHIN(AbsynUtil.stripLast(classpath))), p);
      
        1
                SymbolTable.setAbsynClass(p, absynClass, classpath);
      
              then
      
                Values.BOOL(true);
      
            case ("updateConnectionAnnotation",_) then Values.BOOL(false);
      
            case ("updateConnectionNames",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(str1), Values.STRING(str2),
      
                                                   Values.STRING(str3), Values.STRING(str4)})
      
              algorithm
      
        ✗
                (b, p) := InteractiveUtil.updateConnectionNames(classpath, str1, str2, str3, str4, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("updateConnectionNames",_) then Values.BOOL(false);
      
            case ("getConnectionCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        2
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        2
                access := Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.

        2
                if access >= Access.diagram then
      
        2
                  n := listLength(Interactive.getConnections(absynClass));
      
                else
      
        ✗
                  Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
      
                  n := 0;
      
                end if;
      
        2
              then
      
                Values.INTEGER(n);
      
            case ("getConnectionCount",_) then Values.INTEGER(0);
      
            case ("getNthConnection",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        4
                access := Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

        4
                if access >= Access.diagram then
      
        4
                  vals := Interactive.getNthConnection(AbsynUtil.pathToCref(path), SymbolTable.getAbsyn(), n);
      
                else
      
        ✗
                  Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
      
                  vals := {};
      
                end if;
      
        4
              then
      
                ValuesMake.makeArray(vals);
      
        ✗
            case ("getNthConnection",_) then ValuesMake.makeArray({});
      
            case ("getConnectionList", {Values.CODE(Absyn.C_TYPENAME(path))})
      
        2
              then getConnectionList(path);
      
            case ("getAlgorithmCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := listLength(getAlgorithms(absynClass));
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getAlgorithmCount",_) then Values.INTEGER(0);
      
            case ("getNthAlgorithm",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthAlgorithm(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthAlgorithm",_) then Values.STRING("");
      
            case ("getInitialAlgorithmCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := listLength(getInitialAlgorithms(absynClass));
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getInitialAlgorithmCount",_) then Values.INTEGER(0);
      
            case ("getNthInitialAlgorithm",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthInitialAlgorithm(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthInitialAlgorithm",_) then Values.STRING("");
      
            case ("getAlgorithmItemsCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getAlgorithmItemsCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getAlgorithmItemsCount",_) then Values.INTEGER(0);
      
            case ("getNthAlgorithmItem",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthAlgorithmItem(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthAlgorithmItem",_) then Values.STRING("");
      
            case ("getInitialAlgorithmItemsCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getInitialAlgorithmItemsCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getInitialAlgorithmItemsCount",_) then Values.INTEGER(0);
      
            case ("getNthInitialAlgorithmItem",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthInitialAlgorithmItem(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthInitialAlgorithmItem",_) then Values.STRING("");
      
            case ("getEquationCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := listLength(getEquations(absynClass));
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getEquationCount",_) then Values.INTEGER(0);
      
            case ("getNthEquation",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthEquation(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthEquation",_) then Values.STRING("");
      
            case ("getInitialEquationCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := listLength(getInitialEquations(absynClass));
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getInitialEquationCount",_) then Values.INTEGER(0);
      
            case ("getNthInitialEquation",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthInitialEquation(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthInitialEquation",_) then Values.STRING("");
      
            case ("getEquationItemsCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getEquationItemsCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getEquationItemsCount",_) then Values.INTEGER(0);
      
            case ("getNthEquationItem",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthEquationItem(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthEquationItem",_) then Values.STRING("");
      
            case ("getInitialEquationItemsCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getInitialEquationItemsCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getInitialEquationItemsCount",_) then Values.INTEGER(0);
      
            case ("getNthInitialEquationItem",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthInitialEquationItem(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthInitialEquationItem",_) then Values.STRING("");
      
            case ("getAnnotationCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getAnnotationCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getAnnotationCount",_) then Values.INTEGER(0);
      
            case ("getNthAnnotationString",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                str := getNthAnnotationString(absynClass, n);
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("getNthAnnotationString",_) then Values.STRING("");
      
            case ("getImportCount",{Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                n := getImportCount(absynClass);
      
        ✗
              then
      
                Values.INTEGER(n);
      
            case ("getImportCount",_) then Values.INTEGER(0);
      
            case ("getNthImport",{Values.CODE(Absyn.C_TYPENAME(path)),Values.INTEGER(n)})
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(path, SymbolTable.getAbsyn());
      
        ✗
                vals := getNthImport(absynClass, n);
      
        ✗
              then
      
                ValuesMake.makeArray(vals);
      
        ✗
            case ("getNthImport",_) then ValuesMake.makeArray({});
      
            // plotParametric
      
            case ("plotParametric",
      
                {
      
                  cvar,
      
                  cvar2,
      
                  Values.BOOL(externalWindow),
      
                  Values.STRING(filename),
      
                  Values.STRING(title),
      
                  Values.STRING(gridStr),
      
                  Values.BOOL(logX),
      
                  Values.BOOL(logY),
      
                  Values.STRING(xLabel),
      
                  Values.STRING(yLabel),
      
                  Values.ARRAY(valueLst={Values.REAL(x1),Values.REAL(x2)}),
      
                  Values.ARRAY(valueLst={Values.REAL(y1),Values.REAL(y2)}),
      
                  Values.REAL(curveWidth),
      
                  Values.INTEGER(curveStyle),
      
                  Values.STRING(legendPosition),
      
                  Values.STRING(footer),
      
                  Values.BOOL(autoScale),
      
                  Values.BOOL(forceOMPlot),
      
                  Values.STRING(yAxis),
      
                  Values.STRING(yLabelRight),
      
                  Values.ARRAY(valueLst={Values.REAL(y1R),Values.REAL(y2R)})
      
                })
      
              algorithm
      
                // get OPENMODELICAHOME
      
        ✗
                omhome := Settings.getInstallationDirectoryPath();
      
                // get the simulation filename
      
        ✗
                (outCache,filename) := cevalCurrentSimulationResultExp(outCache,inEnv,filename,msg);
      
                pd := Autoconf.pathDelimiter;
      
                // create absolute path of simulation result file
      
        ✗
                str1 := System.pwd() + pd + filename;
      
                s1 := if Autoconf.os == "Windows_NT" then ".exe" else "";
      
        ✗
                filename := if System.regularFileExists(str1) then str1 else filename;
      
                // check if plot callback is defined
      
        ✗
                b := System.plotCallBackDefined();
      
        ✗
                if boolOr(forceOMPlot, boolNot(b)) then
      
                  // get the variables
      
        ✗
                  str := ValuesUtil.printCodeVariableName(cvar) + "\" \"" + ValuesUtil.printCodeVariableName(cvar2);
      
                  // create the path till OMPlot
      
        ✗
                  str2 := stringAppendList({omhome,pd,"bin",pd,"OMPlot",s1});
      
                  // create the list of arguments for OMPlot
      
        ✗
                  str3 := "--filename=\"" + filename + "\" --title=\"" + title + "\" --grid=" + gridStr + " --plotParametric --logx=" + boolString(logX) + " --logy=" + boolString(logY) + " --yaxis=\"" + yAxis + "\" --xlabel=\"" + xLabel + "\" --ylabel=\"" + yLabel + "\" --ylabel-right=\"" + yLabelRight + "\" --xrange=" + realString(x1) + ":" + realString(x2) + " --yrange=" + realString(y1) + ":" + realString(y2) + " --yrange-right=" + realString(y1R) + ":" + realString(y2R) + " --new-window=" + boolString(externalWindow) + " --curve-width=" + realString(curveWidth) + " --curve-style=" + intString(curveStyle) + " --legend-position=\"" + legendPosition + "\" --footer=\"" + footer + "\" --auto-scale=" + boolString(autoScale) + " \"" + str + "\"";
      
        ✗
                  call := stringAppendList({"\"",str2,"\""," ",str3});
      
        ✗
                  0 := System.spawnCall(str2, call);
      
                elseif b then
      
                  // get the variables
      
        ✗
                  str := ValuesUtil.printCodeVariableName(cvar) + " " + ValuesUtil.printCodeVariableName(cvar2);
      
        ✗
                  logXStr := boolString(logX);
      
        ✗
                  logYStr := boolString(logY);
      
        ✗
                  x1Str := realString(x1);
      
        ✗
                  x2Str := realString(x2);
      
        ✗
                  y1Str := realString(y1);
      
        ✗
                  y2Str := realString(y2);
      
        ✗
                  curveWidthStr := realString(curveWidth);
      
        ✗
                  curveStyleStr := intString(curveStyle);
      
        ✗
                  autoScaleStr := boolString(autoScale);
      
        ✗
                  System.plotCallBack(externalWindow,filename,title,gridStr,"plotparametric",logXStr,logYStr,xLabel,yLabel,x1Str,x2Str,y1Str,y2Str,curveWidthStr,curveStyleStr,legendPosition,footer,autoScaleStr,str);
      
                end if;
      
              then
      
                Values.BOOL(true);
      
            case ("plotParametric",_)
      
              then Values.BOOL(false);
      
            case ("dumpXMLDAE",vals)
      
              algorithm
      
        2
                (outCache,xml_filename) := dumpXMLDAE(outCache,inEnv,vals, msg);
      
        4
              then
      
                ValuesMake.makeTuple({Values.BOOL(true),Values.STRING(xml_filename)});
      
            case ("dumpXMLDAE",_)
      
        ✗
              then
      
                ValuesMake.makeTuple({Values.BOOL(false),Values.STRING("")});
      
            case ("solveLinearSystem",{Values.ARRAY(valueLst=vals),v})
      
              algorithm
      
        ✗
                (realVals,i) := System.dgesv(List.map(vals,ValuesUtil.arrayValueReals),ValuesUtil.arrayValueReals(v));
      
        ✗
                v := ValuesMake.makeArray(List.map(realVals,ValuesMake.makeReal));
      
        ✗
              then
      
                Values.TUPLE({v,Values.INTEGER(i)});
      
            case ("solveLinearSystem",{_,v,_,_})
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"Unknown input to solveLinearSystem scripting function"});
      
        ✗
              then
      
                Values.TUPLE({v,Values.INTEGER(-1)});
      
            case ("relocateFunctions",{Values.STRING(str), v as Values.ARRAY()})
      
              algorithm
      
                relocatableFunctionsTuple := {};
      
        ✗
                for varr in v.valueLst loop
      
        ✗
                  Values.ARRAY(valueLst={Values.STRING(s1),Values.STRING(s2)}) := varr;
      
        ✗
                  relocatableFunctionsTuple := (s1,s2)::relocatableFunctionsTuple;
      
                end for;
      
        ✗
                b := System.relocateFunctions(str, relocatableFunctionsTuple);
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("toJulia",{})
      
              algorithm
      
        ✗
                str := Tpl.tplString(AbsynToJulia.dumpProgram, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("interactiveDumpAbsynToJL",{})
      
              algorithm
      
        ✗
                str := Tpl.tplString(AbsynJLDumpTpl.dump, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.STRING(str);
      
            case ("relocateFunctions",_) then Values.BOOL(false);
      
            case ("runConversionScript", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str)})
      
        9
              then runConversionScript(path, str);
      
            case ("convertPackageToLibrary", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str)})
      
        2
              then convertPackageToLibrary(classpath, path, str);
      
            case ("getModelInstance", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str), Values.BOOL(b)})
      
        48
              then NFApi.getModelInstance(classpath, path, str, b);
      
            case ("getModelInstanceAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), v as Values.ARRAY(), Values.BOOL(b)})
      
        3
              then NFApi.getModelInstanceAnnotation(classpath, ValuesUtil.arrayValueStrings(v), b);
      
            case ("getModelInstanceReference", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str)})
      
        ✗
              then NFApi.getModelInstanceReference(classpath, path, str);
      
            case ("getModelInstanceAnnotationReference", {Values.CODE(Absyn.C_TYPENAME(classpath)), v as Values.ARRAY()})
      
        ✗
              then NFApi.getModelInstanceAnnotationReference(classpath, ValuesUtil.arrayValueStrings(v));
      
            case ("releaseModelInstanceReference", {Values.INTEGER(i)})
      
        ✗
              then NFApi.releaseModelInstanceReference(i);
      
            case ("modifierToJSON", {Values.STRING(str), Values.BOOL(b)})
      
        ✗
              then NFApi.modifierToJSON(str, b);
      
            case ("storeAST", {})
      
        ✗
              then Values.INTEGER(SymbolTable.storeAST());
      
            case ("restoreAST", {Values.INTEGER(integer = n)})
      
        ✗
              then Values.BOOL(SymbolTable.restoreAST(n));
      
            case ("qualifyPath", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
        1
              then ValuesMake.makeCodeTypeName(NFApi.mkFullyQual(SymbolTable.getAbsyn(), classpath, path));
      
            case ("getElementAnnotation", {Values.CODE(Absyn.C_TYPENAME(path))})
      
        4
              then Values.STRING(InteractiveUtil.getElementAnnotation(path, SymbolTable.getAbsyn()));
      
            case ("setElementAnnotation",
      
                  {Values.CODE(Absyn.C_TYPENAME(path)),
      
                   Values.CODE(Absyn.C_MODIFICATION(modification = mod))})
      
              algorithm
      
        ✗
                (_, b) := InteractiveUtil.setElementAnnotation(path, mod, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("loadClassContentString",
      
                  {Values.STRING(str), Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(x), Values.INTEGER(y)})
      
              algorithm
      
        1
                (p, b) := InteractiveUtil.loadClassContentString(str, classpath, x, y, SymbolTable.getAbsyn());
      
        1
                SymbolTable.setAbsyn(p);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              then
      
                Values.BOOL(b);
      
            case ("setElementType",
      
                  {Values.CODE(Absyn.C_TYPENAME(path)),
      
                   Values.CODE(Absyn.C_VARIABLENAME(cr))})
      
              algorithm
      
        ✗
                (_, b) := InteractiveUtil.setElementType(path, cr, SymbolTable.getAbsyn());
      
        ✗
              then
      
                Values.BOOL(b);
      
            case ("getExtendsModifierNames",
      
                  {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path)), Values.BOOL(b)})
      
        11
              then InteractiveUtil.getExtendsModifierNames(classpath, path, b, SymbolTable.getAbsyn());
      
            case ("isPrimitive", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        2
              then ValuesMake.makeBoolean(Interactive.isPrimitive(classpath, SymbolTable.getAbsyn()));
      
            case ("isParameter", {Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then ValuesMake.makeBoolean(Interactive.isParameter(path, classpath, SymbolTable.getAbsyn()));
      
            case ("isConstant", {Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then ValuesMake.makeBoolean(Interactive.isConstant(path, classpath, SymbolTable.getAbsyn()));
      
            case ("isProtected", {Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then ValuesMake.makeBoolean(Interactive.isProtected(path, classpath, SymbolTable.getAbsyn()));
      
            case ("setComponentDimensions", {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_EXPRESSION(aexp as Absyn.Exp.ARRAY()))})
      
              algorithm
      
        ✗
                (p, b) := Interactive.setComponentDimensions(classpath, path, aexp.arrayExp, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("setComponentProperties", {Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(name))),
      
                Values.ARRAY(valueLst = vals),
      
                Values.ARRAY(valueLst = {Values.STRING(s1)}),
      
                Values.ARRAY(valueLst = {Values.BOOL(b1), Values.BOOL(b2)}),
      
                Values.ARRAY(valueLst = {Values.STRING(s2)})})
      
              algorithm
      
          6/6✓ Branch 0 taken 52 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 52 times.
✓ Branch 3 taken 12 times.
✓ Branch 5 taken 24 times.
✓ Branch 6 taken 28 times.

        64
                (p, v) := Interactive.setComponentProperties(classpath, name,
      
                  list(ValuesUtil.valueBool(va) for va in vals), s1, b1, b2, s2, SymbolTable.getAbsyn());
      
        12
                SymbolTable.setAbsyn(p);
      
        12
              then
      
                v;
      
            case ("createModel", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        8
                p := Interactive.createModel(classpath, SymbolTable.getAbsyn());
      
        8
                SymbolTable.setAbsyn(p);
      
        8
              then
      
                ValuesMake.makeBoolean(true);
      
            case ("newModel", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                p := Interactive.newModel(classpath, path, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                ValuesMake.makeBoolean(true);
      
            case ("deleteClass", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        4
                (b, p) := Interactive.deleteClass(classpath, SymbolTable.getAbsyn());
      
        4
                SymbolTable.setAbsynDeleted(p, classpath);
      
        4
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("addComponent", {Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(name))),
      
                Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                Values.CODE(Absyn.C_EXPRESSION(aexp)), Values.CODE(Absyn.C_MODIFICATION(modification = mod)),
      
                Values.CODE(Absyn.C_EXPRESSION(aexp2)), Values.CODE(Absyn.C_EXPRESSION(aexp3))})
      
              algorithm
      
        18
                (p, b) := Interactive.addComponent(name, path, classpath, aexp, mod, aexp2, aexp3, SymbolTable.getAbsyn());
      
        18
                SymbolTable.setAbsyn(p);
      
        18
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("updateComponent", {Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(name))),
      
                Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath)),
      
                Values.CODE(Absyn.C_EXPRESSION(aexp)), Values.CODE(Absyn.C_MODIFICATION(modification = mod)),
      
                Values.CODE(Absyn.C_EXPRESSION(aexp2)), Values.CODE(Absyn.C_EXPRESSION(aexp3))})
      
              algorithm
      
        5
                (p, b) := Interactive.updateComponent(name, path, classpath, aexp, mod, aexp2, aexp3, SymbolTable.getAbsyn());
      
        5
                SymbolTable.setAbsyn(p);
      
        5
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("deleteComponent", {Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT(name))), Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                (p, b) := Interactive.deleteComponent(name, classpath, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("getComponentCount", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        5
              then ValuesMake.makeInteger(Interactive.getComponentCount(classpath, SymbolTable.getAbsyn()));
      
            case ("getNthComponent", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        2
              then Interactive.getNthComponent(classpath, SymbolTable.getAbsyn(), n);
      
            case ("getComponents", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.BOOL(b)})
      
        20
              then Interactive.getComponents(classpath, b, SymbolTable.getAbsyn());
      
            case ("getElements", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.BOOL(b)})
      
        2
              then Interactive.getElements(classpath, b, SymbolTable.getAbsyn());
      
            case ("getElementsInfo", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        6
              then Interactive.getElementsInfo(classpath, SymbolTable.getAbsyn());
      
            case ("getComponentAnnotations", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        5
              then Interactive.getComponentAnnotations(classpath, SymbolTable.getAbsyn());
      
            case ("getElementAnnotations", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        2
              then Interactive.getElementAnnotations(classpath, SymbolTable.getAbsyn());
      
            case ("getNthComponentAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        3
              then Interactive.getNthComponentAnnotation(classpath, n, SymbolTable.getAbsyn());
      
            case ("getNthComponentModification", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        ✗
              then Interactive.getNthComponentModification(classpath, n, SymbolTable.getAbsyn());
      
            case ("getNthComponentCondition", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        ✗
              then Interactive.getNthComponentCondition(classpath, n, SymbolTable.getAbsyn());
      
            case ("getInheritanceCount", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        2
              then Interactive.getInheritanceCount(classpath, SymbolTable.getAbsyn());
      
            case ("getNthInheritedClass", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        3
              then NFApi.getNthInheritedClass(classpath, n, SymbolTable.getAbsyn());
      
            case ("setConnectionComment", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_VARIABLENAME(cr)),
      
                                           Values.CODE(Absyn.C_VARIABLENAME(cr2)), Values.STRING(str)})
      
              algorithm
      
        2
                (p, b) := Interactive.setConnectionComment(classpath, cr, cr2, str, SymbolTable.getAbsyn());
      
        2
                SymbolTable.setAbsyn(p);
      
        2
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("addConnection", {Values.CODE(Absyn.C_VARIABLENAME(cr)), Values.CODE(Absyn.C_VARIABLENAME(cr2)),
      
                                    Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_EXPRESSION(aexp)),
      
                                    Values.CODE(Absyn.C_EXPRESSION(aexp2))})
      
              algorithm
      
        6
                (p, b) := Interactive.addConnection(classpath, cr, cr2, aexp, aexp2, SymbolTable.getAbsyn());
      
        6
                SymbolTable.setAbsyn(p);
      
        6
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("deleteConnection", {Values.CODE(Absyn.C_VARIABLENAME(cr)), Values.CODE(Absyn.C_VARIABLENAME(cr2)),
      
                                       Values.CODE(Absyn.C_TYPENAME(classpath))})
      
              algorithm
      
        ✗
                (p, b) := Interactive.deleteConnection(classpath, cr, cr2, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("getNthConnectionAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        2
              then Interactive.getNthConnectionAnnotation(classpath, n, SymbolTable.getAbsyn());
      
            case ("getConnectorCount", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        2
              then Interactive.getConnectorCount(classpath, SymbolTable.getAbsyn());
      
            case ("getNthConnector", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        ✗
              then Interactive.getNthConnector(classpath, n, SymbolTable.getAbsyn());
      
            case ("getNthConnectorIconAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        1
              then Interactive.getNthConnectorIconAnnotation(classpath, n, SymbolTable.getAbsyn());
      
            case ("getIconAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        16
              then Interactive.getIconAnnotation(classpath, SymbolTable.getAbsyn());
      
            case ("getDiagramAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        4
              then Interactive.getDiagramAnnotation(classpath, SymbolTable.getAbsyn());
      
            case ("refactorIconAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then Interactive.refactorIconAnnotation(classpath, SymbolTable.getAbsyn());
      
            case ("refactorDiagramAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then Interactive.refactorDiagramAnnotation(classpath, SymbolTable.getAbsyn());
      
            case ("refactorClass", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        1
              then Interactive.refactorClass(classpath, SymbolTable.getAbsyn());
      
            case ("getNthInheritedClassIconMapAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        ✗
              then Interactive.getNthInheritedClassIconMapAnnotation(classpath, n, SymbolTable.getAbsyn());
      
            case ("getNthInheritedClassDiagramMapAnnotation", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.INTEGER(n)})
      
        ✗
              then Interactive.getNthInheritedClassDiagramMapAnnotation(classpath, n, SymbolTable.getAbsyn());
      
            case ("getNamedAnnotation",
      
                {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
        ✗
              then Interactive.getNamedAnnotation(classpath, path, SymbolTable.getAbsyn());
      
            case ("getShortDefinitionBaseClassInformation", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then Interactive.getShortDefinitionBaseClassInformation(classpath, SymbolTable.getAbsyn());
      
            case ("getExternalFunctionSpecification", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then Interactive.getExternalFunctionSpecification(classpath, SymbolTable.getAbsyn());
      
            case ("getEnumerationLiterals", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then Interactive.getEnumerationLiterals(classpath, SymbolTable.getAbsyn());
      
            case ("existClass", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        ✗
              then ValuesMake.makeBoolean(Interactive.existClass(classpath, SymbolTable.getAbsyn()));
      
            case ("getComponentComment", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
        ✗
              then Interactive.getComponentComment(classpath, path, SymbolTable.getAbsyn());
      
            case ("setComponentComment", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str)})
      
              algorithm
      
        2
                (p, b) := Interactive.setComponentComment(classpath, path, str, SymbolTable.getAbsyn());
      
        2
                SymbolTable.setAbsyn(p);
      
        2
              then
      
                ValuesMake.makeBoolean(b);
      
            case ("renameClass", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_TYPENAME(path))})
      
              algorithm
      
        ✗
                (p, v) := Interactive.renameClass(classpath, path, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                v;
      
            case ("renameComponent", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_VARIABLENAME(cr)),
      
                                      Values.CODE(Absyn.C_VARIABLENAME(cr2))})
      
              algorithm
      
        ✗
                (p, v) := Interactive.renameComponent(classpath, cr, cr2, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                v;
      
            case ("renameComponentInClass", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.CODE(Absyn.C_VARIABLENAME(cr)),
      
                                      Values.CODE(Absyn.C_VARIABLENAME(cr2))})
      
              algorithm
      
        ✗
                (p, v) := Interactive.renameComponentOnlyInClass(classpath, cr, cr2, SymbolTable.getAbsyn());
      
        ✗
                SymbolTable.setAbsyn(p);
      
        ✗
              then
      
                v;
      
            case ("getCrefInfo", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        7
              then Interactive.getCrefInfo(classpath, SymbolTable.getAbsyn());
      
            case ("getDefaultComponentName", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        2
              then Interactive.getDefaultComponentName(classpath, SymbolTable.getAbsyn());
      
            case ("getDefaultComponentPrefixes", {Values.CODE(Absyn.C_TYPENAME(classpath))})
      
        4
              then Interactive.getDefaultComponentPrefixes(classpath, SymbolTable.getAbsyn());
      
            case ("getDefinitions", {Values.BOOL(b)})
      
        ✗
              then Interactive.getDefinitions(SymbolTable.getAbsyn(), b);
      
            case ("getDefaultOpenCLDevice", {})
      
        ✗
              then ValuesMake.makeInteger(Config.getDefaultOpenCLDevice());
      
            case ("getDefUseChains", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(str), Values.CODE(Absyn.C_TYPENAME(classpath)), Values.BOOL(b)})
      
        18
              then ValuesMake.makeString(getDefUseChains(path, str, classpath, b));
      
            case ("getDependencyGraph", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str), Values.BOOL(b)})
      
        3
              then ValuesMake.makeString(getDependencyGraph(classpath, str, b));
      
            case ("getDefinitionAt", {Values.STRING(str), Values.INTEGER(x), Values.INTEGER(y), Values.BOOL(b)})
      
        11
              then ValuesMake.makeString(getDefinitionAt(str, x, y, b));
      
            case ("getClassDiagram", {Values.CODE(Absyn.C_TYPENAME(classpath)), Values.STRING(str), Values.STRING(str1),
      
                                      Values.INTEGER(i), v as Values.ARRAY(), Values.BOOL(b)})
      
        7
              then ValuesMake.makeString(getClassDiagram(classpath, str, str1, i, ValuesUtil.arrayValueStrings(v), b));
      
            case ("reverseLookup", {Values.CODE(Absyn.C_TYPENAME(path)), Values.CODE(Absyn.C_TYPENAME(classpath)), Values.BOOL(b1), Values.BOOL(b2)})
      
        2
              then ValuesMake.makeString(ReverseLookup.lookup(path, classpath, SymbolTable.getAbsyn(), b1, b2));
      
            case ("translateResidualsDAE", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(s1)})
      
        ✗
              then ValuesMake.makeBoolean(NFApi.translateResidualsDAE(path, s1));
      
            case ("addEquation", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(s1), Values.BOOL(b1)})
      
        4
              then ValuesMake.makeBoolean(Interactive.addEquation(path, s1, b1));
      
            case ("updateEquation", {Values.CODE(Absyn.C_TYPENAME(path)), Values.STRING(s1), Values.STRING(s2), Values.BOOL(b), Values.BOOL(b1), Values.BOOL(b2), Values.BOOL(b3)})
      
        10
              then ValuesMake.makeBoolean(Interactive.updateEquation(path, s1, s2, b, b1, b2, b3));
      
         end matchcontinue;
      
        end cevalInteractiveFunctions4;
      
        protected function getSimulationExtension
      
          input String inString;
      
          input String inString2;
      
          output String outString;
      
        algorithm
      
          outString:=match(inString,inString2)
      
          local
      
            // We now use a bat script, even for the C runtime, on Windows.
      
            case ("C","WIN64")
      
             then ".bat";
      
            case ("C","WIN32")
      
              then ".bat";
      
            case ("Cpp","WIN32")
      
              then ".bat";
      
            case ("Cpp","WIN64")
      
              then ".bat";
      
            case ("Cpp","Unix")
      
              then ".sh";
      
            else Autoconf.exeExt;
      
          end match;
      
        end getSimulationExtension;
      
        public function getAdjacencyMatrix " author: adrpo
      
         translates a model and returns the adjacency matrix"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className "path for the model";
      
          input Absyn.Msg inMsg;
      
          input String filenameprefix;
      
          output FCore.Cache outCache;
      
          output Values.Value outValue;
      
          output String outString;
      
        algorithm
      
          (outCache,outValue,outString):=
      
          match (inCache, inEnv)
      
            local
      
              String filename,file_dir, str;
      
              DAE.DAElist dae;
      
              FCore.Graph env;
      
              BackendDAE.BackendDAE dlow;
      
              Absyn.ComponentRef a_cref;
      
              FCore.Cache cache;
      
              String flatModelicaStr,description;
      
            case (cache, env) /* mo file directory */
      
              algorithm
      
        ✗
                (cache, env, SOME(dae), _) := runFrontEnd(cache, env, className, true, transform = true);
      
        ✗
                description := DAEUtil.daeDescription(dae);
      
        ✗
                a_cref := AbsynUtil.pathToCref(className);
      
        ✗
                file_dir := ProgramUtil.getFileDir(a_cref, SymbolTable.getAbsyn());
      
        ✗
                dlow := BackendDAECreate.lower(dae,cache,env,BackendDAE.EXTRA_INFO(description,filenameprefix,NONE()));
      
        ✗
                dlow := FindZeroCrossings.findZeroCrossings(dlow);
      
        ✗
                flatModelicaStr := DAEDump.dumpStr(dae,FCore.getFunctionTree(cache));
      
        ✗
                flatModelicaStr := stringAppend("OldEqStr={'", flatModelicaStr);
      
        ✗
                flatModelicaStr := System.stringReplace(flatModelicaStr, "\n", "%##%");
      
        ✗
                flatModelicaStr := System.stringReplace(flatModelicaStr, "%##%", "','");
      
        ✗
                flatModelicaStr := stringAppend(flatModelicaStr,"'};");
      
        ✗
                filename := DAEQuery.writeAdjacencyMatrix(dlow, filenameprefix, flatModelicaStr);
      
        ✗
                str := stringAppend("The equation system was dumped to Matlab file:", filename);
      
        ✗
              then
      
                (cache,Values.STRING(str),file_dir);
      
          end match;
      
        end getAdjacencyMatrix;
      
        /* -------------------------------------------------------------------
      
                                 RUN FRONTEND
      
           ------------------------------------------------------------------- */
      
        public function runFrontEnd
      
          input output FCore.Cache cache;
      
          input output FCore.Graph env;
      
          input Absyn.Path className;
      
          input Boolean relaxedFrontEnd "Do not check for illegal simulation models, so we allow instantation of packages, etc";
      
          input Boolean dumpFlat = false;
      
          input Boolean transform = false;
      
          output Option<DAE.DAElist> odae = NONE();
      
          output String flatString = "";
      
        protected
      
          DAE.DAElist dae;
      
          Boolean b;
      
        algorithm
      
          // add program to the cache so it can be used to lookup modelica://
      
          // URIs in external functions IncludeDirectory/LibraryDirectory
      
        2523
          FlagsUtil.setConfigBool(Flags.BUILDING_MODEL, true);
      
          try
      
        2523
            b := loadProgram(className);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2523 times.

        2523
            true := b;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2523 times.

        2523
            if Flags.isSet(Flags.GC_PROF) then
      
        ✗
              print(GCExt.profStatsStr(GCExt.getProfStats(), head="GC stats before front-end:") + "\n");
      
            end if;
      
        2523
            ExecStat.execStat("FrontEnd - loaded program");
      
        2523
            (cache,env,dae,flatString) := runFrontEndWork(cache,env,className,relaxedFrontEnd,dumpFlat);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2213 times.

        2213
            if Flags.isSet(Flags.GC_PROF) then
      
        ✗
              print(GCExt.profStatsStr(GCExt.getProfStats(), head="GC stats after front-end:") + "\n");
      
            end if;
      
        2213
            ExecStat.execStat("FrontEnd - DAE generated");
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2211 times.

        2213
            if transform then
      
        2
              dae := DAEUtil.transformationsBeforeBackend(cache, env, dae, StateMachineFlatten.stateMachineToDataFlow);
      
            end if;
      
        2213
            odae := SOME(dae);
      
          else
      
            // Return odae=NONE(); needed to update cache and symbol table if we fail
      
          end try;
      
        2523
          FlagsUtil.setConfigBool(Flags.BUILDING_MODEL, false);
      
        end runFrontEnd;
      
        public function runFrontEndNF
      
          input Absyn.Path className;
      
          input Boolean relaxedFrontEnd = false;
      
          input Boolean dumpFlat = false;
      
          output NFFlatModel flatModel;
      
          output NFFlatten.FunctionTree functions;
      
          output String flatString;
      
        algorithm
      
        ✗
          true := loadProgram(className);
      
        ✗
          (flatModel, functions, flatString) := runFrontEndWorkNF(className, relaxedFrontEnd, dumpFlat);
      
        end runFrontEndNF;
      
        protected function loadProgram
      
          input Absyn.Path className;
      
          output Boolean success;
      
        protected
      
          String lib_name;
      
          Absyn.Program p;
      
          Boolean b;
      
        algorithm
      
        8903
          p := SymbolTable.getAbsyn();
      
        8903
          lib_name := AbsynUtil.pathFirstIdent(className);
      
          try
      
        8903
            ProgramUtil.getClassInProgram(lib_name, p);
      
            success := true;
      
          else
      
        ✗
            (p,b) := CevalScript.loadModel({(Absyn.IDENT(lib_name),"the given model name to instantiate",{"default"},false)},Settings.getModelicaPath(Testsuite.isRunning()),p,true,true,true,false);
      
        ✗
            Error.assertionOrAddSourceMessage(not b,Error.NOTIFY_IMPLICIT_LOAD,{lib_name,"default"},Absyn.dummyInfo);
      
        ✗
            System.loadModelCallBack(lib_name);
      
        ✗
            SymbolTable.setAbsyn(p);
      
            // Always update the SCode structure; otherwise the cache plays tricks on us
      
        ✗
            SymbolTable.clearSCode();
      
            success := true;
      
          end try;
      
        end loadProgram;
      
        protected function runFrontEndWork
      
          input output FCore.Cache cache;
      
          input output FCore.Graph env;
      
          input Absyn.Path className;
      
          input Boolean relaxedFrontEnd "Do not check for illegal simulation models, so we allow instantation of packages, etc";
      
          input Boolean dumpFlat;
      
                output DAE.DAElist dae;
      
                output String flatString = "";
      
        protected
      
          Integer numError = Error.getNumErrorMessages();
      
          Boolean graph_inst, nf_inst, nf_inst_actual;
      
          SCode.Program scodeP;
      
          AvlTreePathFunction.Tree funcs;
      
          NFFlatModel flat_model;
      
          NFFlatten.FunctionTree nf_funcs;
      
        algorithm
      
        2523
          graph_inst := Flags.isSet(Flags.GRAPH_INST);
      
        2523
          nf_inst := Flags.isSet(Flags.SCODE_INST);
      
        2523
          nf_inst_actual := nf_inst;
      
          // PDEModelica is not yet supported by the new frontend, switch to the old one
      
          // if `-g=PDEModelica` is set.
      
          4/4✓ Branch 0 taken 1434 times.
✓ Branch 1 taken 1089 times.
✓ Branch 3 taken 1 time.
✓ Branch 4 taken 1433 times.

        2523
          if nf_inst and Flags.getConfigEnum(Flags.GRAMMAR) == Flags.PDEMODELICA then
      
            nf_inst := false;
      
        1
            FlagsUtil.set(Flags.SCODE_INST, false);
      
        1
            Error.addMessage(Error.NF_PDE_NOT_IMPLEMENTED, {});
      
          end if;
      
          (cache,env,dae) := matchcontinue (graph_inst, nf_inst)
      
            case (false, true)
      
              algorithm
      
        1433
                (flat_model, nf_funcs, flatString) := runFrontEndWorkNF(className, relaxedFrontEnd, dumpFlat);
      
        1227
                (dae, funcs) := NFConvertDAE.convert(flat_model, nf_funcs);
      
        1227
                cache := FCore.emptyCache();
      
        1227
                FCore.setCachedFunctionTree(cache, funcs);
      
        1227
                env := FGraph.new("graph", FCore.dummyTopModel);
      
        1227
              then
      
                (cache, env, dae);
      
           case (true, false)
      
              algorithm
      
        ✗
                System.realtimeTick(ClockIndexes.RT_CLOCK_FINST);
      
        ✗
                dae := FInst.instPath(className, SymbolTable.getSCode());
      
        ✗
              then
      
                (cache,env,dae);
      
            case (false, false)
      
              algorithm
      
        1090
                scodeP := SymbolTable.getSCode();
      
        1090
                ExecStat.execStat("FrontEnd - Absyn->SCode");
      
        1090
                (cache,env,_,dae) := Inst.instantiateClass(cache,InnerOuter.emptyInstHierarchy,scodeP,className,true,relaxedFrontEnd);
      
        986
                dae := DAEUtil.mergeAlgorithmSections(dae);
      
                // adrpo: do not add it to the instantiated classes, it just consumes memory for nothing.
      
        986
                DAEUtil.getFunctionList(FCore.getFunctionTree(cache),failOnError=true); // Make sure that the functions are valid before returning success
      
        986
              then (cache,env,dae);
      
            case (_, _)
      
              guard Error.getNumErrorMessages() == numError
      
              algorithm
      
                // A user cancel unwinds with its message rolled back by the failed
      
                // speculation above; re-emit it here (the accepted branch) so it is not
      
                // masked by the generic "no error message" below.
      
        ✗
                Error.checkCancel();
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,
      
                  {"Instantiation of " + AbsynUtil.pathString(className) + " failed with no error message."});
      
        ✗
                FlagsUtil.set(Flags.SCODE_INST, nf_inst_actual);
      
        ✗
              then
      
                fail();
      
          end matchcontinue;
      
          // Switch back to the new frontend in case we changed it at the beginning of the function.
      
        2213
          FlagsUtil.set(Flags.SCODE_INST, nf_inst_actual);
      
        end runFrontEndWork;
      
        public function runFrontEndWorkNF
      
          input Absyn.Path className;
      
          input Boolean relaxedFrontend = false;
      
          input Boolean dumpFlat = false;
      
          output NFFlatModel flatModel;
      
          output NFFlatten.FunctionTree functions;
      
          output String flatString;
      
        protected
      
          SCode.Program builtin_p, scode_p, annotation_p;
      
          Boolean nf_api;
      
          Absyn.Path cls_name = className;
      
          Obfuscate.Mapping obfuscate_map;
      
          String obfuscate_mode;
      
        algorithm
      
        1637
          (_, builtin_p) := FBuiltin.getInitialFunctions();
      
        1637
          scode_p := SymbolTable.getSCode();
      
        1637
          obfuscate_mode := Flags.getConfigString(Flags.OBFUSCATE);
      
          // Enable obfuscation of encrypted variables if a higher obfuscation hasn't
      
          // been chosen and the AST contains encrypted classes.
      
          5/6✓ Branch 0 taken 1636 times.
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1635 times.
✓ Branch 4 taken 1 time.
✗ Branch 7 not taken.
✓ Branch 8 taken 1635 times.

        1637
          if obfuscate_mode == "none" and Interactive.astContainsEncryptedClass(SymbolTable.getAbsyn()) then
      
        ✗
            FlagsUtil.setConfigString(Flags.OBFUSCATE, "encrypted");
      
          end if;
      
          4/4✓ Branch 0 taken 1636 times.
✓ Branch 1 taken 1 time.
✓ Branch 3 taken 1 time.
✓ Branch 4 taken 1635 times.

        1637
          if obfuscate_mode == "full" then
      
        1
            (scode_p, cls_name, _, _, obfuscate_map) := Obfuscate.obfuscateProgram(scode_p, cls_name);
      
          end if;
      
        1637
          scode_p := listAppend(builtin_p, scode_p);
      
        1637
          ExecStat.execStat("FrontEnd - Absyn->SCode");
      
        1637
          annotation_p := AbsynToSCode.translateAbsyn2SCode(
      
            InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion()));
      
          // make sure we don't run the default instantiateModel using -d=nfAPI
      
          // only the stuff going via NFApi.mo should have this flag activated
      
        1637
          nf_api := FlagsUtil.set(Flags.NF_API, false);
      
          try
      
        1637
            (flatModel, functions, flatString) :=
      
              NFInst.instClassInProgram(cls_name, scode_p, annotation_p, relaxedFrontend, dumpFlat);
      
          else
      
        207
            NFInst.clearCaches();
      
        207
            FlagsUtil.set(Flags.NF_API, nf_api);
      
        207
            fail();
      
          end try;
      
        1430
          FlagsUtil.set(Flags.NF_API, nf_api);
      
        end runFrontEndWorkNF;
      
        public function translateModel
      
          input FCore.Cache cache;
      
          input FCore.Graph env;
      
          input Absyn.Path className "path for the model";
      
          input String fileNamePrefix;
      
          input Boolean runBackend "if true, run the backend as well. This will run SimCode and Codegen as well.";
      
          input Boolean runSilent "if true, flat modelica code will not be dumped to out stream";
      
          input Option<SimCode.SimulationSettings> simSettingsOpt;
      
          output Boolean success;
      
          output FCore.Cache outCache;
      
          output list<String> outLibs;
      
          output String outFileDir;
      
          output list<tuple<String,Values.Value>> resultValues;
      
        protected
      
          Flags.Flag flags;
      
          InteractiveTypes.SimulationOptions defaultSimOpt;
      
          Option<SimCode.SimulationSettings> simSettings;
      
        algorithm
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 2446 times.
✓ Branch 2 taken 1262 times.
✓ Branch 3 taken 1184 times.

        2446
          if isSome(simSettingsOpt)  then
      
            simSettings := simSettingsOpt;
      
          else
      
        1262
            defaultSimOpt := buildSimulationOptionsFromModelExperimentAnnotation(className, fileNamePrefix, SOME(defaultSimulationOptions));
      
        1262
            simSettings := SOME(convertSimulationOptionsToSimCode(defaultSimOpt));
      
          end if;
      
        2446
          flags := loadCommandLineOptionsFromModel(className);
      
        2446
          CodegenWasmJitFunctions.precompilePrebuiltModules(PackageManagement.installMissingWasmOfLoaded(loadedClassFiles(), CodegenWasmJitFunctions.prebuiltExternalsABI()));
      
          try
      
        2446
            (success, outCache, outLibs, outFileDir, resultValues) :=
      
              SimCodeMain.translateModel(SimCodeMain.TranslateModelKind.NORMAL(), cache, env, className, fileNamePrefix,
      
                runBackend, Flags.getConfigBool(Flags.DAE_MODE), runSilent, simSettings, Absyn.FUNCTIONARGS({},{}));
      
            // reset to the original flags
      
        2135
            FlagsUtil.saveFlags(flags);
      
          else
      
        311
            FlagsUtil.saveFlags(flags);
      
        311
            fail();
      
          end try;
      
        end translateModel;
      
        protected function loadedClassFiles
      
          output list<String> files;
      
        protected
      
          Absyn.Program p = SymbolTable.getAbsyn();
      
        algorithm
      
          4/4✓ Branch 0 taken 5443 times.
✓ Branch 1 taken 2446 times.
✓ Branch 2 taken 5443 times.
✓ Branch 3 taken 2446 times.

        7889
          files := list(AbsynUtil.classFilename(c) for c in p.classes);
      
        end loadedClassFiles;
      
        protected function getProcsStr
      
          input Boolean isMake = false;
      
          output String s;
      
        protected
      
          Integer n;
      
          String sn;
      
        algorithm
      
        81
          n := Flags.getConfigInt(Flags.NUM_PROC);
      
        81
          sn := intString(n);
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 81 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

        81
          s := if (n == 0)
      
               then ""
      
               else (if isMake
      
                     then sn
      
                     else stringAppend("-j", sn));
      
        end getProcsStr;
      
        protected function configureFMU_cmake
      
        "Configure and build binaries with CMake for target platform"
      
          input String platform;
      
          input String fmutmp;
      
          input String fmuTargetName;
      
          input String logfile;
      
          input list<String> externalLibLocations;
      
          input Boolean isWindows;
      
          input Boolean needs3rdPartyLibs;
      
        protected
      
          String fmuSourceDir;
      
          String CMAKE_GENERATOR = "", CMAKE_BUILD_TYPE;
      
          String quote, dquote, defaultFmiIncludeDirectoy;
      
          String CC;
      
          SimCodeFunction.MakefileParams makefileParams;
      
          String msvcEnv, rmrf;
      
        algorithm
      
        81
          makefileParams := SimCodeFunctionUtil.createMakefileParams({}, {}, {}, false, true);
      
        81
          fmuSourceDir := fmutmp+"/sources/";
      
          quote := "'";
      
          1/2✓ Branch 0 taken 81 times.
✗ Branch 1 not taken.

        81
          dquote := if isWindows then "\"" else "'";
      
        81
          msvcEnv := SimCodeUtil.msvcEnvironment();
      
          2/4✓ Branch 0 taken 81 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 81 times.
✗ Branch 4 not taken.

        81
          if msvcEnv <> "" then
      
            // cmake picks cl from the Visual Studio environment.
      
            CC := "";
      
            CMAKE_GENERATOR := "-G \"NMake Makefiles\" ";
      
            rmrf := "rmdir /S /Q ";
      
          else
      
        81
            CC := "-DCMAKE_C_COMPILER=" + dquote + System.basename(makefileParams.ccompiler) + dquote;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81 times.

        81
            if isWindows then
      
        ✗
              CMAKE_GENERATOR := "-G " + dquote + "MSYS Makefiles" + dquote + " ";
      
            end if;
      
            rmrf := "rm -rf ";
      
          end if;
      
        81
          defaultFmiIncludeDirectoy := dquote + Settings.getInstallationDirectoryPath() + "/include/omc/c/fmi" + dquote;
      
          // Set build type
      
          4/4✓ Branch 1 taken 80 times.
✓ Branch 2 taken 1 time.
✓ Branch 4 taken 1 time.
✓ Branch 5 taken 79 times.

        81
          if Flags.getConfigEnum(Flags.FMI_FILTER) == Flags.FMI_BLACKBOX or Flags.getConfigEnum(Flags.FMI_FILTER) == Flags.FMI_PROTECTED then
      
            CMAKE_BUILD_TYPE := "-DCMAKE_BUILD_TYPE=Release";
      
          elseif Flags.isSet(Flags.GEN_DEBUG_SYMBOLS) then
      
            CMAKE_BUILD_TYPE := "-DCMAKE_BUILD_TYPE=Debug";
      
          else
      
            CMAKE_BUILD_TYPE := "-DCMAKE_BUILD_TYPE=RelWithDebInfo";
      
          end if;
      
          // Remove old log file
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 81 times.

        81
          if System.regularFileExists(logfile) then
      
        ✗
            System.removeFile(logfile);
      
          end if;
      
          () := match Util.stringSplitAtChar(platform, " ")
      
            local
      
              String cmd;
      
              String cmakeCall;
      
              String crossTriple, buildDir, fmiTarget;
      
              String externalIncludeDirsFile;
      
              list<String> dockerImgArgs;
      
              ContainerImage.ContainerImage dockerImage;
      
              list<String> dockerArguments;
      
              String dockerRunArgs;
      
              Boolean isTrustedImage;
      
              Integer uid;
      
              String cidFile, volumeID, containerID, userID;
      
              String dockerLogFile;
      
              String cmake_toolchain;
      
              list<String> locations;
      
            case {"dynamic"}
      
              algorithm
      
                buildDir := "build_cmake_dynamic";
      
        2
                cmakeCall := Autoconf.cmake + " " + CMAKE_GENERATOR +
      
                             CMAKE_BUILD_TYPE + " " + CC +
      
                             " ..";
      
        2
                cmd := msvcEnv + "cd " + dquote + fmuSourceDir + dquote + " && " +
      
                       "mkdir " + buildDir + " && cd " + buildDir + " && " +
      
                       cmakeCall + " && " +
      
                       Autoconf.cmake + " --build . --parallel " + getProcsStr() + " --target install && " +
      
                       "cd .. && " + rmrf + buildDir;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

        2
                if 0 <> System.systemCallRestrictedEnv(cmd, outFile=logfile) then
      
        ✗
                  Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {"cmd: " + cmd + "\n" + System.readFile(logfile)});
      
        ✗
                  fail();
      
                end if;
      
                then();
      
            case {"static"}
      
              algorithm
      
                buildDir := "build_cmake_static";
      
        79
                cmakeCall := Autoconf.cmake + " " + CMAKE_GENERATOR +
      
                             CMAKE_BUILD_TYPE + " " + CC +
      
                             " ..";
      
        79
                cmd := msvcEnv + "cd " + dquote + fmuSourceDir + dquote + " && " +
      
                       "mkdir " + buildDir + " && cd " + buildDir + " && " +
      
                       cmakeCall + " && " +
      
                       Autoconf.cmake + " --build . --parallel " + getProcsStr() + " --target install && " +
      
                       "cd .. && " + rmrf + buildDir;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 79 times.

        79
                if 0 <> System.systemCallRestrictedEnv(cmd, outFile=logfile) then
      
        ✗
                  Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {"cmd: " + cmd + "\n" + System.readFile(logfile)});
      
        ✗
                  fail();
      
                end if;
      
                then();
      
            case crossTriple::"docker"::"run"::dockerImgArgs
      
              algorithm
      
        ✗
                (dockerImage, dockerArguments) := ContainerImage.parseWithArgs(dockerImgArgs);
      
        ✗
                dockerImage := ContainerImage.getDigestSha(dockerImage);
      
        ✗
                Error.addCompilerNotification("Using docker image '" + ContainerImage.toString(dockerImage) + "' for cross compilation.");
      
        ✗
                (_, isTrustedImage) := ContainerImage.isTrustedOpenModelicaImage(dockerImage);
      
        ✗
                dockerRunArgs := stringDelimitList(dockerArguments, " ") + " " + ContainerImage.toString(dockerImage);
      
        ✗
                uid := System.getuid();
      
        ✗
                cidFile := fmutmp+".cidfile";
      
                // Temp log file outside of Docker volume
      
        ✗
                dockerLogFile := crossTriple + ".tmp.log";
      
                // Remove old log file
      
        ✗
                if System.regularFileExists(dockerLogFile) then
      
        ✗
                  System.removeFile(dockerLogFile);
      
                end if;
      
                // Only download trusted images automatically, and only if the signature
      
                // can be verified. Images that are already on this machine are used as is.
      
        ✗
                if isTrustedImage and not ContainerImage.isAvailableLocally(dockerImage) then
      
        ✗
                  if ContainerImage.isCosignAvailable() then
      
                    // Verify the image in the registry first, it's only downloaded if the signature is valid.
      
        ✗
                    ContainerImage.assertSignature(dockerImage);
      
        ✗
                    ContainerImage.pull(dockerImage);
      
                  else
      
        ✗
                    Error.addCompilerError("Refusing to download container image '" + ContainerImage.toString(dockerImage) + "' without verifying its signature.");
      
        ✗
                    Error.addCompilerNotification("Download the image manually with `" + ContainerImage.pullCommand(dockerImage) + "` and run the FMU export again.");
      
        ✗
                    fail();
      
                  end if;
      
                end if;
      
                // Create a docker volume for the FMU since we can't forward volumes
      
                // to the docker run command depending on where the FMU was generated (inside another volume)
      
                cmd := "docker volume create";
      
        ✗
                runDockerCmd(cmd, dockerLogFile);
      
        ✗
                volumeID := List.last(System.strtok(System.readFile(dockerLogFile), "\n"));
      
        ✗
                if System.regularFileExists(cidFile) then
      
        ✗
                  System.removeFile(cidFile);
      
                end if;
      
        ✗
                cmd := "docker run --cidfile " + cidFile + " -v " + volumeID + ":/data busybox true";
      
        ✗
                runDockerCmd(cmd, dockerLogFile, true, volumeID, "");
      
        ✗
                containerID := System.trim(System.readFile(cidFile));
      
        ✗
                System.removeFile(cidFile);
      
                // Copy the FMU contents to the container
      
        ✗
                cmd := "docker cp " + fmutmp + " " + containerID + ":/data";
      
        ✗
                runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
                // Copy the FMI headers to the container
      
        ✗
                cmd := "docker cp " + defaultFmiIncludeDirectoy + " " + containerID + ":/data/fmiInclude";
      
        ✗
                runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
                // Copy the external library and include files to the container
      
        ✗
                (locations,_) := SimCodeUtil.getDirectoriesForDLLsFromLinkLibs(externalLibLocations);
      
                // SimCodeMain noted the external include directories of the model next to the
      
                // generated sources. Without them the cross compiler can't find the headers of
      
                // external libraries. See https://github.com/OpenModelica/OpenModelica/issues/9509
      
        ✗
                externalIncludeDirsFile := fmutmp + "/.external_include_dirs";
      
        ✗
                if System.regularFileExists(externalIncludeDirsFile) then
      
        ✗
                  locations := listAppend(System.strtok(System.readFile(externalIncludeDirsFile), "\n"), locations);
      
                end if;
      
                // CVODE_DIRECTORY is not one of the model's link directories, so nothing would
      
                // copy it for a model that has no external libraries of its own.
      
        ✗
                if needs3rdPartyLibs then
      
        ✗
                  locations := Settings.getInstallationDirectoryPath() + "/lib/" + Autoconf.triple + "/omc" :: locations;
      
                end if;
      
        ✗
                for loc in locations loop
      
        ✗
                  if System.directoryExists(loc) then
      
                    // Create path
      
        ✗
                    cmd := "docker run --rm --hostname=" + containerID + " --volume=" + volumeID + ":/data busybox mkdir -p " + dquote + "/data" + loc + dquote;
      
        ✗
                    runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
                    // Copy files
      
        ✗
                    cmd := "docker cp -a -L " + dquote + loc + dquote + " " + containerID + dquote + ":/data" + System.dirname(loc)  + dquote;
      
        ✗
                    runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
                  end if;
      
                end for;
      
                // Build for target host
      
        ✗
                userID := (if uid<>0 then "--user " + String(uid) else "");
      
        ✗
                buildDir := "build_cmake_" + crossTriple;
      
        ✗
                if 0 <> System.regex(crossTriple, "mingw", 1) then
      
                  fmiTarget := " -DCMAKE_SYSTEM_NAME=Windows ";
      
                elseif 0 <> System.regex(crossTriple, "apple", 1) then
      
                  fmiTarget := " -DCMAKE_SYSTEM_NAME=Darwin ";
      
                else
      
                  fmiTarget := "";
      
                end if;
      
        ✗
                if isTrustedImage then
      
        ✗
                  cmake_toolchain := "-DCMAKE_TOOLCHAIN_FILE=/opt/cmake/toolchain/" + crossTriple + ".cmake ";
      
                else
      
                  cmake_toolchain := "";
      
                end if;
      
        ✗
                cmakeCall := "cmake " + cmake_toolchain +
      
                                    "-DFMI_INTERFACE_HEADER_FILES_DIRECTORY=/fmu/fmiInclude " +
      
                                    "-DDOCKER_VOL_DIR=/fmu " +
      
                                    fmiTarget +
      
                                    CMAKE_BUILD_TYPE +
      
                                    " ..";
      
        ✗
                cmd := "docker run " + userID + " --rm -w /fmu -v " + volumeID + ":/fmu " + dockerRunArgs +
      
                       " sh -c " + dquote +
      
                          "cd " + dquote + "/fmu/" + fmuSourceDir + dquote + " && " +
      
                          "mkdir " + buildDir + " && cd " + buildDir + " && " +
      
                          cmakeCall + " && " +
      
                          "cmake --build . --parallel " + getProcsStr() + " --target install && " +
      
                          "cd .. && rm -rf " + buildDir +
      
                        dquote;
      
        ✗
                runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
                // Copy the files back from the volume (via the container) to the filesystem.
      
                // Docker cp can't handle too long names on Windows.
      
                // Workaround: Zip it in the container, copy it to host, unzip it
      
        ✗
                if isWindows then
      
        ✗
                  cmd := "docker run " + userID + " --rm -w /fmu -v " + volumeID + ":/fmu " + dockerRunArgs +
      
                         " tar -zcf comp-fmutmp.tar.gz " + fmutmp;
      
        ✗
                  runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
        ✗
                  cmd := "docker cp " + containerID + ":/data/comp-fmutmp.tar.gz .";
      
        ✗
                  runDockerCmd(cmd, dockerLogFile, cleanup=true, volumeID=volumeID, containerID=containerID);
      
        ✗
                  if 0 <> System.systemCall("tar zxf comp-fmutmp.tar.gz && rm comp-fmutmp.tar.gz", outFile=dockerLogFile) then
      
                    // Otherwise the failure only surfaces later as "Build commands returned
      
                    // success, but <name>.fmu does not exist".
      
        ✗
                    Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {"Failed to unpack comp-fmutmp.tar.gz:\n" + System.readFile(dockerLogFile)});
      
        ✗
                    fail();
      
                  end if;
      
                else
      
        ✗
                  cmd := "docker cp " + containerID + ":/data/" + fmutmp + "/ .";
      
        ✗
                  runDockerCmd(cmd, dockerLogFile, cleanup=false, volumeID=volumeID, containerID=containerID);
      
                end if;
      
                // Cleanup
      
        ✗
                System.systemCall("docker rm " + containerID, outFile=dockerLogFile);
      
        ✗
                System.systemCall("docker volume rm " + volumeID, outFile=dockerLogFile);
      
                // Copy log file into resources directory
      
        ✗
                System.copyFile(dockerLogFile, logfile);
      
        ✗
                System.removeFile(dockerLogFile);
      
                then();
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.SIMULATOR_BUILD_ERROR,
      
                                 {"Unknown/unsupported platform \"" + platform + " \" for CMake FMU build. " +
      
                                  "Use platforms={\"dynamic\"} for the default case."});
      
        ✗
              then fail();
      
          end match;
      
        end configureFMU_cmake;
      
        protected function runDockerCmd
      
          "Run a docker command. Can clean up volumen and container on failure."
      
          input String cmd;
      
          input String logfile;
      
          input Boolean cleanup = false;
      
          input String volumeID = "";
      
          input String containerID = "";
      
        protected
      
          Boolean verbose = false;
      
        algorithm
      
        ✗
          System.appendFile(logfile, cmd + "\n");
      
        ✗
          if 0 <> System.systemCall(cmd, outFile=logfile) then
      
        ✗
            Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {cmd + " failed:\n" + System.readFile(logfile)});
      
        ✗
            if cleanup then
      
        ✗
              if not stringEqual(containerID, "") then
      
        ✗
                System.systemCall("docker rm " + containerID, outFile=logfile);
      
              end if;
      
        ✗
              if not stringEqual(volumeID, "") then
      
        ✗
                System.systemCall("docker volume rm " + volumeID, outFile=logfile);
      
              end if;
      
            end if;
      
        ✗
            fail();
      
          elseif verbose then
      
              print(System.readFile(logfile) +"\n");
      
          end if;
      
        end runDockerCmd;
      
        protected function isDockerPlatform
      
          input String platform;
      
          output Boolean isDocker;
      
        algorithm
      
          isDocker := match Util.stringSplitAtChar(platform, " ")
      
            case _::"docker"::"run"::_ then true;
      
            else false;
      
          end match;
      
        end isDockerPlatform;
      
        protected function translateModelFMU
      
          "translates modelica model as FMU, generates only c code and does not build"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className "path for the model";
      
          input String FMUVersion;
      
          input String inFMUType;
      
          input String inFileNamePrefix;
      
          input Boolean addDummy "if true, add a dummy state";
      
          input list<String> platforms = {"static"};
      
          input Option<SimCode.SimulationSettings> inSimSettings = NONE();
      
          output Boolean success = false;
      
          output FCore.Cache cache;
      
          output Values.Value outValue;
      
        protected
      
          Flags.Flag flags;
      
        algorithm
      
        1
          flags := loadCommandLineOptionsFromModel(className);
      
          try
      
        1
            (success, cache, outValue) := callTranslateModelFMU(inCache,inEnv,className,FMUVersion,inFMUType,inFileNamePrefix,addDummy,platforms,inSimSettings);
      
            // reset to the original flags
      
        1
            FlagsUtil.saveFlags(flags);
      
          else
      
        ✗
            FlagsUtil.saveFlags(flags);
      
        ✗
            fail();
      
          end try;
      
        end translateModelFMU;
      
        protected function callTranslateModelFMU
      
         "Translates a model into target code and writes CMakeLists.txt"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className "path for the model";
      
          input String FMUVersion;
      
          input String inFMUType;
      
          input String inFileNamePrefix;
      
          input Boolean addDummy "if true, add a dummy state";
      
          input list<String> platforms = {"static"};
      
          input Option<SimCode.SimulationSettings> inSimSettings = NONE();
      
          output Boolean success;
      
          output FCore.Cache cache;
      
          output Values.Value outValue;
      
        protected
      
          String filenameprefix, fmuTargetName;
      
          InteractiveTypes.SimulationOptions defaultSimOpt;
      
          SimCode.SimulationSettings simSettings;
      
          list<String> libs;
      
          String FMUType = inFMUType;
      
          Boolean isWasmFMU = isWasmFMUExport(FMUVersion, platforms);
      
        algorithm
      
        1
          cache := inCache;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
          if not FMI.checkFMIVersion(FMUVersion) then
      
            success :=false;
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.UNKNOWN_FMU_VERSION, {FMUVersion});
      
        ✗
            return;
      
          elseif not FMI.checkFMIType(FMUType) then
      
            success :=false;
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.UNKNOWN_FMU_TYPE, {FMUType});
      
        ✗
            return;
      
          end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
          if not FMI.canExportFMU(FMUVersion, FMUType) then
      
            success :=false;
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.FMU_EXPORT_NOT_SUPPORTED, {FMUType, FMUVersion});
      
        ✗
            return;
      
          end if;
      
          1/6✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.

        1
          if Config.simCodeTarget() == "Cpp" and FMI.isFMICSType(FMUType) then
      
        ✗
            Error.addMessage(Error.FMU_EXPORT_NOT_SUPPORTED_CPP, {FMUType});
      
            FMUType := "me";
      
          end if;
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        1
          if Flags.getConfigBool(Flags.DAE_MODE) and not isWasmFMU then
      
            success := false;
      
            outValue := Values.STRING("");
      
        ✗
            if FMI.isFMIMEType(FMUType) then
      
        ✗
              Error.addMessage(Error.FMU_EXPORT_DAE_MODE_ME, {FMUType});
      
            else
      
        ✗
              Error.addMessage(Error.FMU_EXPORT_DAE_MODE_C_CS, {});
      
            end if;
      
        ✗
            return;
      
          end if;
      
          // NOTE: The FMUs use fileNamePrefix for the internal name when it would be expected to be fileNamePrefix that decides the .fmu filename
      
          //       The scripting environment from a user's perspective is like that. fmuTargetName is the name of the .fmu in the templates, etc.
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.

        1
          filenameprefix := Util.stringReplaceChar(if inFileNamePrefix == "<default>" then AbsynUtil.pathLastIdent(className) else inFileNamePrefix, ".", "_");
      
          4/8✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✓ Branch 3 taken 1 time.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 time.
✗ Branch 6 not taken.
✓ Branch 8 taken 1 time.
✗ Branch 9 not taken.

        1
          fmuTargetName := if FMUVersion == "1.0" then filenameprefix else (if inFileNamePrefix == "<default>" then AbsynUtil.pathLastIdent(className) else inFileNamePrefix);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
          if isSome(inSimSettings)  then
      
        ✗
            SOME(simSettings) := inSimSettings;
      
          else
      
        1
            defaultSimOpt := buildSimulationOptionsFromModelExperimentAnnotation(className, filenameprefix, SOME(defaultSimulationOptions));
      
        1
            simSettings := convertSimulationOptionsToSimCode(defaultSimOpt);
      
          end if;
      
          // The wasm FMU export uses the wasm-jit code generator, as buildModelFMU does;
      
          // the flag change is reverted by translateModelFMU's saveFlags wrapper.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
          if isWasmFMU then
      
        ✗
            FlagsUtil.setConfigString(Flags.SIMCODE_TARGET, "wasm-jit");
      
        ✗
            FlagsUtil.setConfigString(Flags.FMU_NATIVE_PLATFORMS, stringDelimitList(List.select(platforms, isNotWasmPlatform), ","));
      
          end if;
      
        1
          FlagsUtil.setConfigBool(Flags.BUILDING_FMU, true);
      
        1
          FlagsUtil.setConfigString(Flags.FMI_VERSION, FMUVersion);
      
          try
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        3
            (success, cache, libs, _, _) := SimCodeMain.translateModel(SimCodeMain.TranslateModelKind.FMU(FMUType, fmuTargetName, isWasmFMU),
      
                                                    cache, inEnv, className, filenameprefix, true, Flags.getConfigBool(Flags.DAE_MODE), true, SOME(simSettings));
      
            // A wasm translation wrote no FMU: it lowered the model kernel and kept it,
      
            // so force its JIT compile (and resolve its external "C") here, as
      
            // buildModel's compile phase does. The model is then ready to simulate and
      
            // the buildModelFMU that follows only links and renders.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
            if success and isWasmFMU then
      
        ✗
              CodegenWasmJit.finishCompile(filenameprefix);
      
            end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
            outValue := Values.STRING((if not Testsuite.isRunning() then System.pwd() + Autoconf.pathDelimiter else "") + fmuTargetName + ".fmu");
      
          else
      
            success :=false;
      
            outValue := Values.STRING("");
      
          end try;
      
        1
          FlagsUtil.setConfigBool(Flags.BUILDING_FMU, false);
      
        1
          FlagsUtil.setConfigString(Flags.FMI_VERSION, "");
      
        end callTranslateModelFMU;
      
        public function generateFMI3GraphicalRepresentation
      
          "FMI 3.0 graphical user annotations (issue #15686 task 9). From an in-memory
      
           structure holding the model's graphics alone (issue #15219), this renders the
      
           model Icon to terminalsAndIcons/icon.png (+ icon.svg), adds an FMI 3.0
      
           <GraphicalRepresentation> to terminalsAndIcons.xml, and for every placed
      
           connector component renders its port icon to terminalsAndIcons/<iconBaseName>.png
      
           (+ .svg) and adds a <TerminalGraphicalRepresentation> (placement box +
      
           iconBaseName). All icon files live in terminalsAndIcons/ because FMI 3.0
      
           resolves iconBaseName relative to terminalsAndIcons/terminalsAndIcons.xml and
      
           requires a PNG (the SVG is an optional companion). The set of
      
           ports and their input/output direction are NOT taken from the model instance:
      
           structured connectors already have a <Terminal> from SimCode (we only add the
      
           graphics), and a simple signal port gets a terminal whose variableKind is the
      
           flat-model causality read from modelDescription.xml. Best-effort: any failure
      
           (e.g. a model without an icon) is silently ignored so it never blocks the build."
      
          input Absyn.Path className;
      
          input String fmutmp;
      
          input String modelIdentifier;
      
        protected
      
          Integer handle, nConn, i;
      
          String svg, grepr, modelName, taiDir, taiFile, content;
      
          String info, cname, ibase, sx1, sy1, sx2, sy2, csvg, tgr;
      
          list<String> parts;
      
        algorithm
      
          try
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.

        15
            Values.INTEGER(handle) := NFApi.getModelInstanceIconReference(className);
      
          1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.

        15
            if handle > 0 then
      
              // Inner try so the model-instance handle is released on EVERY exit path
      
              // (a failure in the graphics work below must not leak the reference).
      
              try
      
        15
              modelName := AbsynUtil.pathLastIdent(className);
      
              // FMI 3.0 (section "Distribution of FMUs"): icon image files referenced
      
              // from terminalsAndIcons.xml live in the terminalsAndIcons/ directory, and
      
              // iconBaseName is resolved relative to terminalsAndIcons/terminalsAndIcons.xml.
      
        15
              taiDir := fmutmp + "/terminalsAndIcons/";
      
        15
              taiFile := taiDir + "terminalsAndIcons.xml";
      
        15
              svg := OMGraphics.iconSVGFromHandle(handle, modelName);
      
        15
              grepr := OMGraphics.graphicalRepresentationXMLFromHandle(handle, 0.5);
      
        15
              nConn := OMGraphics.placedConnectorCount(handle);
      
              // model icon -> terminalsAndIcons/icon.png (mandatory) + icon.svg (optional
      
              // companion). The fixed name "icon" is the FMI 3.0 convention for the FMU
      
              // icon "without terminals".
      
          3/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 4 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 11 times.

        15
              if svg <> "" then
      
        4
                Util.createDirectoryTree(taiDir);
      
          1/2✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.

        4
                if OMGraphics.writeIconPNGFromHandle(handle, modelName, taiDir + "icon.png") then
      
        4
                  System.writeFile(taiDir + "icon.svg", svg);
      
                else
      
                  // icon.png is mandatory for the <Icon> in <GraphicalRepresentation>;
      
                  // drop the block rather than reference a file we failed to write.
      
                  grepr := "";
      
                end if;
      
              else
      
                grepr := "";
      
              end if;
      
          4/6✓ Branch 0 taken 11 times.
✓ Branch 1 taken 4 times.
✓ Branch 3 taken 11 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 11 times.

        15
              if grepr <> "" or nConn > 0 then
      
                // start from the SimCode-written terminals file, or a fresh skeleton
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 time.

        4
                if System.regularFileExists(taiFile) then
      
        3
                  content := System.readFile(taiFile);
      
                else
      
        1
                  Util.createDirectoryTree(taiDir);
      
                  content := "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<fmiTerminalsAndIcons fmiVersion=\"3.0\">\n</fmiTerminalsAndIcons>\n";
      
                end if;
      
                // For each placed connector add its TerminalGraphicalRepresentation and
      
                // render its port icon. The terminal itself (name + member + input/output
      
                // direction) is produced by SimCode from the flat model; here we only add
      
                // the graphics, matched to the existing <Terminal> by the connector name.
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 3 times.

        23
                for i in 0:nConn-1 loop
      
        19
                  info := OMGraphics.placedConnectorInfo(handle, i);
      
        19
                  parts := System.strtok(info, "\t"); // name, iconBaseName, x1, y1, x2, y2
      
          1/2✓ Branch 1 taken 19 times.
✗ Branch 2 not taken.

        19
                  if listLength(parts) == 6 then
      
        19
                    cname := listGet(parts, 1);
      
        19
                    ibase := listGet(parts, 2);
      
        19
                    sx1 := listGet(parts, 3);
      
        19
                    sy1 := listGet(parts, 4);
      
        19
                    sx2 := listGet(parts, 5);
      
        19
                    sy2 := listGet(parts, 6);
      
          1/2✗ Branch 3 not taken.
✓ Branch 4 taken 19 times.

        19
                    if System.stringFind(content, "<Terminal name=\"" + cname + "\"") >= 0 then
      
                      // the connector's own port icon -> terminalsAndIcons/<ibase>.png
      
                      // (mandatory) + <ibase>.svg (optional). iconBaseName is mandatory on
      
                      // TerminalGraphicalRepresentation, so only emit the element when the
      
                      // PNG was actually written (a dangling iconBaseName is invalid).
      
        ✗
                      if OMGraphics.writePlacedConnectorIconPNG(handle, i, taiDir + ibase + ".png") then
      
        ✗
                        csvg := OMGraphics.placedConnectorIconSVG(handle, i);
      
        ✗
                        if csvg <> "" then
      
        ✗
                          System.writeFile(taiDir + ibase + ".svg", csvg);
      
                        end if;
      
        ✗
                        tgr := "      <TerminalGraphicalRepresentation x1=\"" + sx1 + "\" y1=\"" + sy1 +
      
                               "\" x2=\"" + sx2 + "\" y2=\"" + sy2 + "\" iconBaseName=\"" + ibase + ".png\"/>\n";
      
        ✗
                        content := insertBeforeTerminalClose(content, cname, tgr);
      
                      end if;
      
                    end if;
      
                  end if;
      
                end for;
      
                // GraphicalRepresentation first (FMI 3.0 schema order: before Terminals)
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        4
                if grepr <> "" then
      
        4
                  content := spliceGraphicalRepresentation(content, grepr);
      
                end if;
      
        4
                System.writeFile(taiFile, content);
      
              end if;
      
              else
      
                // release the handle on the failure path, then re-raise so the outer
      
                // try treats it as "no graphics" (best-effort)
      
        ✗
                Values.BOOL(_) := NFApi.releaseModelInstanceReference(handle);
      
                fail();
      
              end try;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 15 times.

        15
              Values.BOOL(_) := NFApi.releaseModelInstanceReference(handle);
      
            end if;
      
          else
      
            // no model instance / no graphics: skip graphical representation
      
          end try;
      
        end generateFMI3GraphicalRepresentation;
      
        protected function spliceGraphicalRepresentation
      
          "Insert a <GraphicalRepresentation> block in FMI 3.0 schema order: right before
      
           the <Terminals> open tag when present, otherwise before the closing root tag."
      
          input String content;
      
          input String graphicalRepresentation;
      
          output String result;
      
        algorithm
      
          // FMI 3.0 schema requires GraphicalRepresentation before Terminals. Insert it
      
          // before the <Terminals> open tag, tolerating any indentation (don't depend on
      
          // a two-space prefix); fall back to before the closing root tag when there is
      
          // no Terminals element.
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 1 time.

        4
          if System.stringFind(content, "  <Terminals>") >= 0 then
      
        3
            result := System.stringReplace(content, "  <Terminals>", graphicalRepresentation + "  <Terminals>");
      
          elseif System.stringFind(content, "<Terminals>") >= 0 then
      
        ✗
            result := System.stringReplace(content, "<Terminals>", graphicalRepresentation + "<Terminals>");
      
          else
      
        1
            result := System.stringReplace(content, "</fmiTerminalsAndIcons>", graphicalRepresentation + "</fmiTerminalsAndIcons>");
      
          end if;
      
        end spliceGraphicalRepresentation;
      
        protected function insertBeforeTerminalClose
      
          "Insert `insertion` (a TerminalGraphicalRepresentation line) on its own line just
      
           before the </Terminal> that closes the <Terminal name=\"name\" ...> element
      
           emitted by SimCode. The closing tag's own indentation is preserved by inserting
      
           after the newline that precedes it."
      
          input String content;
      
          input String name;
      
          input String insertion;
      
          output String result;
      
        protected
      
          String marker, tail;
      
          Integer p, r, k, len;
      
        algorithm
      
        ✗
          marker := "<Terminal name=\"" + name + "\"";
      
        ✗
          p := System.stringFind(content, marker);
      
        ✗
          len := stringLength(content);
      
        ✗
          if p < 0 then
      
            result := content;
      
          else
      
        ✗
            tail := substring(content, p + 1, len);   // from the opening tag onward
      
        ✗
            r := System.stringFind(tail, "</Terminal>");
      
        ✗
            if r < 0 then
      
              result := content;
      
            else
      
              // p + r is the 0-based index of '<' of </Terminal>; back up over the close
      
              // tag's leading spaces so the insertion lands after the preceding newline
      
        ✗
              k := p + r;                              // 1-based position of the char before '<'
      
        ✗
              while k >= 1 and stringEq(substring(content, k, k), " ") loop
      
        ✗
                k := k - 1;
      
              end while;
      
        ✗
              result := substring(content, 1, k) + insertion + substring(content, k + 1, len);
      
            end if;
      
          end if;
      
        end insertBeforeTerminalClose;
      
        protected function fmuMethodToSimulationFlag
      
          "`buildModelFMU(method=...)` names the integrator a Co-Simulation FMU embeds,
      
           but an FMU reads its solver from `resources/<prefix>_flags.json`, which only
      
           `--fmiFlags` writes. So fold an explicit method in there, unless the caller
      
           already said `s:`.
      
           Only a method the FMU can integrate with: C's `FMI2CS_initializeSolverData`
      
           takes `euler`/`cvode` and rejects the rest at instantiation (so a model's own
      
           `dassl` default must not become `s:dassl`); a wasm FMU serves the whole
      
           wasm-jit driver set. An unaccepted method is left out, and the FMU falls back
      
           to what it defaults to without one: euler for C, the model's own method (else
      
           DASKR) for wasm."
      
          input String method;
      
          input Boolean isWasmFMU;
      
        protected
      
          list<String> fmiFlags;
      
          list<String> accepted = if isWasmFMU then CodegenWasmJit.fmuCsSolvers() else {"euler", "cvode"};
      
        algorithm
      
          2/6✓ Branch 0 taken 88 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 88 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.

        88
          if method == "<default>" or not listMember(method, accepted) then
      
        88
            return;
      
          end if;
      
        ✗
          fmiFlags := Flags.getConfigStringList(Flags.FMI_FLAGS);
      
        ✗
          for f in fmiFlags loop
      
        ✗
            if StringUtil.startsWith(f, "s:") then
      
        ✗
              return;
      
            end if;
      
          end for;
      
          // `none` and a `*.json` path are whole-value settings, not a list to extend.
      
        ✗
          if not listEmpty(fmiFlags) and not stringEq(listHead(fmiFlags), "default") then
      
        ✗
            return;
      
          end if;
      
        ✗
          FlagsUtil.setConfigStringList(Flags.FMI_FLAGS, {"s:" + method});
      
        end fmuMethodToSimulationFlag;
      
        protected function fmuAnnotationSimulationFlags
      
          "A wasm FMU runs the model with the flags simulate() would: the class's
      
           __OpenModelica_simulationFlags go into --fmiFlags, whose `_flags.json` the FMU
      
           applies when it instantiates. A flag already named wins, and one the FMU cannot
      
           honour is left out rather than baked in to fail at the importer's first
      
           instantiate. A C FMU reads only a few flags and warns about the rest, so it
      
           keeps to what --fmiFlags said."
      
          input Absyn.Path className;
      
          input Boolean isWasmFMU;
      
        protected
      
          list<String> fmiFlags, names = {}, folded = {};
      
          list<Absyn.ElementArg> args;
      
          Option<Absyn.Modification> mod;
      
          String name, value;
      
        algorithm
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 88 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        88
          if not isWasmFMU or Flags.getConfigBool(Flags.IGNORE_SIMULATION_FLAGS_ANNOTATION) then
      
        88
            return;
      
          end if;
      
        ✗
          fmiFlags := Flags.getConfigStringList(Flags.FMI_FLAGS);
      
        ✗
          if listLength(fmiFlags) == 1 and stringEq(listHead(fmiFlags), "default") then
      
            fmiFlags := {};
      
          end if;
      
          // `none` and a `*.json` path are whole-value settings, not a list to extend.
      
        ✗
          for f in fmiFlags loop
      
        ✗
            if not stringEq(f, "default") and not (listLength(Util.stringSplitAtChar(f, ":")) == 2) then
      
        ✗
              return;
      
            end if;
      
        ✗
            names := listHead(Util.stringSplitAtChar(f, ":")) :: names;
      
          end for;
      
        ✗
          loadProgram(className);
      
        ✗
          mod := ProgramUtil.getNamedAnnotationExp(className, SymbolTable.getAbsyn(),
      
            Absyn.IDENT("__OpenModelica_simulationFlags"), SOME(NONE()), Util.id);
      
          args := match mod
      
            case SOME(Absyn.CLASSMOD(elementArgLst = args)) then args;
      
            else {};
      
          end match;
      
        ✗
          for arg in args loop
      
        ✗
            name := AbsynUtil.pathString(AbsynUtil.elementArgName(arg));
      
        ✗
            value := fmuSimulationFlagValue(arg);
      
        ✗
            if not listMember(name, names) then
      
        ✗
              if CodegenWasmJit.fmuAcceptsFlag(name, value) then
      
        ✗
                folded := (name + ":" + value) :: folded;
      
              else
      
        ✗
                Error.addCompilerNotification("Leaving the __OpenModelica_simulationFlags entry " + name
      
                  + "=\"" + value + "\" out of the FMU: it cannot honour it.");
      
              end if;
      
            end if;
      
          end for;
      
        ✗
          if not listEmpty(folded) then
      
        ✗
            FlagsUtil.setConfigStringList(Flags.FMI_FLAGS, listAppend(fmiFlags, listReverse(folded)));
      
          end if;
      
        end fmuAnnotationSimulationFlags;
      
        protected function fmuSimulationFlagValue
      
          "One __OpenModelica_simulationFlags entry as a `_flags.json` value; empty for a
      
           flag that takes none."
      
          input Absyn.ElementArg arg;
      
          output String value;
      
        algorithm
      
          value := match arg
      
            local
      
              Absyn.Exp exp;
      
            case Absyn.ElementArg.MODIFICATION(modification =
      
                SOME(Absyn.Modification.CLASSMOD(eqMod = Absyn.EqMod.EQMOD(exp = exp))))
      
              then
      
                match exp
      
                  case Absyn.STRING("()") then "";
      
        ✗
                  case Absyn.STRING() then exp.value;
      
        ✗
                  else Dump.printExpStr(exp);
      
                end match;
      
            else "";
      
          end match;
      
        end fmuSimulationFlagValue;
      
        protected function reportFMUPlatformsBuilt
      
          "The platform progress the C export reports around each platform's compile.
      
           A wasm FMU is already linked by the time `translateModel` returns, so the pair
      
           is reported once the .fmu is there — which is where the C export's own
      
           messages land relative to the translation's, so the log reads the same either
      
           way."
      
          input list<String> platforms;
      
        protected
      
          Integer platformIndex = 0, platformCount = listLength(platforms);
      
          String platformName;
      
        algorithm
      
        ✗
          for platform in platforms loop
      
        ✗
            platformIndex := platformIndex + 1;
      
        ✗
            platformName := listGet(Util.stringSplitAtChar(platform, " "), 1);
      
        ✗
            System.reportProgress(intDiv((platformIndex - 1) * 1000, platformCount), 4 /* PHASE_BACKEND */);
      
        ✗
            System.reportProgressMessage("Building FMU for " + platformName + " (" + String(platformIndex) + "/" + String(platformCount) + ")");
      
        ✗
            Error.addCompilerNotification("Building FMU for platform '" + platformName + "' (" + String(platformIndex) + "/" + String(platformCount) + ").");
      
        ✗
            Error.addCompilerNotification("Finished FMU for platform '" + platformName + "' (" + String(platformIndex) + "/" + String(platformCount) + ").");
      
          end for;
      
        ✗
          System.reportProgress(1000, 4 /* PHASE_BACKEND */);
      
        end reportFMUPlatformsBuilt;
      
        protected function fmuSimulationSettings
      
          "The SimulationSettings an FMU export runs with: the model's experiment defaults,
      
           with `method` folded in when it is not \"<default>\" (a Co-Simulation FMU embeds
      
           its integrator, so the solver is chosen at export time)."
      
          input Absyn.Path className;
      
          input String inFileNamePrefix;
      
          input String method = "<default>";
      
          output SimCode.SimulationSettings simSettings;
      
        protected
      
          String filenameprefix;
      
        algorithm
      
          3/4✓ Branch 0 taken 71 times.
✓ Branch 1 taken 19 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.

        90
          filenameprefix := Util.stringReplaceChar(if inFileNamePrefix == "<default>" then AbsynUtil.pathLastIdent(className) else inFileNamePrefix, ".", "_");
      
        90
          simSettings := convertSimulationOptionsToSimCode(
      
            buildSimulationOptionsFromModelExperimentAnnotation(className, filenameprefix, SOME(defaultSimulationOptions)));
      
          2/4✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 90 times.
✗ Branch 4 not taken.

        90
          if method <> "<default>" then
      
        ✗
            simSettings.method := method;
      
          end if;
      
        end fmuSimulationSettings;
      
        protected function buildModelFMU
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className "path for the model";
      
          input String FMUVersion;
      
          input String inFMUType;
      
          input String inFileNamePrefix;
      
          input Boolean addDummy "if true, add a dummy state";
      
          input list<String> platforms = {"static"};
      
          input Option<SimCode.SimulationSettings> inSimSettings = NONE();
      
          input String method = "<default>" "`buildModelFMU(method=)`, folded into --fmiFlags where the FMU accepts it";
      
          output FCore.Cache cache;
      
          output Values.Value outValue;
      
        protected
      
          Flags.Flag flags;
      
          list<String> fmiFlags;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 88 times.

        88
          if isProtectedContentAccess(className) then
      
            // if AST contains encrypted class show nothing
      
            cache := inCache;
      
        ✗
            outValue := Values.STRING("");
      
          else
      
        88
            flags := loadCommandLineOptionsFromModel(className);
      
            // `method=` reaches the FMU only through --fmiFlags, a global: restore it by
      
            // hand so one export does not pick the solver for the next. `saveFlags` will
      
            // not — without __OpenModelica_commandLineOptions `flags` aliases the store.
      
        88
            fmiFlags := Flags.getConfigStringList(Flags.FMI_FLAGS);
      
        88
            fmuMethodToSimulationFlag(method, isWasmFMUExport(FMUVersion, platforms));
      
        88
            fmuAnnotationSimulationFlags(className, isWasmFMUExport(FMUVersion, platforms));
      
            try
      
        88
              (cache, outValue) := callBuildModelFMU(inCache,inEnv,className,FMUVersion,inFMUType,inFileNamePrefix,addDummy,platforms,inSimSettings);
      
              // reset to the original flags
      
        88
              FlagsUtil.setConfigStringList(Flags.FMI_FLAGS, fmiFlags);
      
        88
              FlagsUtil.saveFlags(flags);
      
            else
      
        ✗
              FlagsUtil.setConfigStringList(Flags.FMI_FLAGS, fmiFlags);
      
        ✗
              FlagsUtil.saveFlags(flags);
      
        ✗
              fail();
      
            end try;
      
          end if;
      
        end buildModelFMU;
      
        public function callBuildModelFMU
      
         " Author: Frenkel TUD
      
           Translates a model into target code and writes also a makefile."
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className "path for the model";
      
          input String FMUVersion;
      
          input String inFMUType;
      
          input String inFileNamePrefix;
      
          input Boolean addDummy "if true, add a dummy state";
      
          input list<String> platforms = {"static"};
      
          input Option<SimCode.SimulationSettings> inSimSettings = NONE();
      
          output FCore.Cache cache;
      
          output Values.Value outValue;
      
        protected
      
          Boolean success;
      
          String filenameprefix, fmutmp, logfile, configureLogFile, dir, cmd, msvcEnv;
      
          String fmuTargetName;
      
          SimCode.SimulationSettings simSettings;
      
          list<String> libs = {} "the reuse path translates nothing, so nothing reports libraries";
      
          Boolean isWindows;
      
          Boolean needs3rdPartyLibs;
      
          Integer platformIndex, platformCount;
      
          String platformName;
      
          String FMUType = inFMUType;
      
          // FMI 1.0 is deprecated and the wasm export does not serve it; such a request
      
          // is the C export's business even under the wasm simCodeTarget.
      
          Boolean wasmRequested = listMember("wasm", platforms);
      
          Boolean wasmTarget = Config.simCodeTarget() == "wasm-jit" or Config.simCodeTarget() == "wasm";
      
          Boolean isWasmFMU = isWasmFMUExport(FMUVersion, platforms);
      
          Option<SimCode.SimCode> keptSimCode;
      
          SimCode.SimCode keptTranslation;
      
          // Reached through the target, the caller still wants an FMU the ordinary
      
          // tooling can load, so it gets this machine's platform too.
      
          list<String> nativePlatforms = if wasmRequested then List.select(platforms, isNotWasmPlatform) else {"native"};
      
        algorithm
      
        90
          cache := inCache;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.

        90
          if not FMI.checkFMIVersion(FMUVersion) then
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.UNKNOWN_FMU_VERSION, {FMUVersion});
      
        ✗
            return;
      
          elseif not FMI.checkFMIType(FMUType) then
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.UNKNOWN_FMU_TYPE, {FMUType});
      
        ✗
            return;
      
          end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.

        90
          if not FMI.canExportFMU(FMUVersion, FMUType) then
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.FMU_EXPORT_NOT_SUPPORTED, {FMUType, FMUVersion});
      
        ✗
            return;
      
          end if;
      
          1/6✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        90
          if wasmRequested and FMUVersion == "1.0" then
      
            outValue := Values.STRING("");
      
        ✗
            Error.addMessage(Error.FMU_EXPORT_WASM_FMI1, {});
      
        ✗
            return;
      
          end if;
      
          4/6✓ Branch 1 taken 9 times.
✓ Branch 2 taken 81 times.
✓ Branch 5 taken 9 times.
✗ Branch 6 not taken.
✗ Branch 8 not taken.
✓ Branch 9 taken 9 times.

        90
          if Config.simCodeTarget() == "Cpp" and FMI.isFMICSType(FMUType) then
      
        ✗
            Error.addMessage(Error.FMU_EXPORT_NOT_SUPPORTED_CPP, {FMUType});
      
            FMUType := "me";
      
          end if;
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 90 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        90
          if Flags.getConfigBool(Flags.DAE_MODE) and not isWasmFMU then
      
            outValue := Values.STRING("");
      
        ✗
            if FMI.isFMIMEType(FMUType) then
      
        ✗
              Error.addMessage(Error.FMU_EXPORT_DAE_MODE_ME, {FMUType});
      
            else
      
        ✗
              Error.addMessage(Error.FMU_EXPORT_DAE_MODE_C_CS, {});
      
            end if;
      
        ✗
            return;
      
          end if;
      
          // NOTE: The FMUs use fileNamePrefix for the internal name when it would be expected to be fileNamePrefix that decides the .fmu filename
      
          //       The scripting environment from a user's perspective is like that. fmuTargetName is the name of the .fmu in the templates, etc.
      
          3/4✓ Branch 0 taken 71 times.
✓ Branch 1 taken 19 times.
✓ Branch 3 taken 71 times.
✗ Branch 4 not taken.

        90
          filenameprefix := Util.stringReplaceChar(if inFileNamePrefix == "<default>" then AbsynUtil.pathLastIdent(className) else inFileNamePrefix, ".", "_");
      
          6/8✓ Branch 0 taken 90 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 87 times.
✓ Branch 4 taken 3 times.
✓ Branch 5 taken 68 times.
✓ Branch 6 taken 19 times.
✓ Branch 8 taken 68 times.
✗ Branch 9 not taken.

        90
          fmuTargetName := if FMUVersion == "1.0" then filenameprefix else (if inFileNamePrefix == "<default>" then AbsynUtil.pathLastIdent(className) else inFileNamePrefix);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 88 times.

        90
          if isSome(inSimSettings)  then
      
        88
            SOME(simSettings) := inSimSettings;
      
          else
      
        2
            simSettings := fmuSimulationSettings(className, inFileNamePrefix);
      
          end if;
      
          // The wasm FMU export uses the wasm-jit code generator; the flag change is
      
          // reverted by buildModelFMU's saveFlags wrapper.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.

        90
          if isWasmFMU then
      
        ✗
            FlagsUtil.setConfigString(Flags.SIMCODE_TARGET, "wasm-jit");
      
            // Every other entry names a native platform the FMU should also serve.
      
        ✗
            FlagsUtil.setConfigString(Flags.FMU_NATIVE_PLATFORMS, stringDelimitList(nativePlatforms, ","));
      
          elseif wasmTarget then
      
            // A browser omc has no C code generator and says so from there.
      
        ✗
            FlagsUtil.setConfigString(Flags.SIMCODE_TARGET, "C");
      
          end if;
      
        90
          FlagsUtil.setConfigBool(Flags.BUILDING_FMU, true);
      
        90
          FlagsUtil.setConfigString(Flags.FMI_VERSION, FMUVersion);
      
          // A translateModelFMU of this model, this FMI version and this kind of
      
          // interface, off the program still loaded and under the flags still set, has
      
          // already done the translation: render the metadata and link the adapter onto
      
          // the kernel it left rather than translating again. The flags are read after
      
          // the munging above so both phases fingerprint the same state.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.

        90
          keptSimCode := if isWasmFMU then SimCodeMain.fmuTranslationFor(FMUVersion, FMUType, className, SOME(simSettings)) else NONE();
      
          try
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 90 times.

        90
            if isSome(keptSimCode) then
      
        ✗
              SOME(keptTranslation) := keptSimCode;
      
        ✗
              Error.addCompilerNotification("Exporting the translation translateModelFMU already made; the model is not translated again.");
      
        ✗
              SimCodeMain.emitWasmFMU(keptTranslation, FMUVersion, FMUType, SymbolTable.getAbsyn());
      
              success := true;
      
            else
      
        180
              (success, cache, libs, _, _) := SimCodeMain.translateModel(SimCodeMain.TranslateModelKind.FMU(FMUType, fmuTargetName, false),
      
                                                      cache, inEnv, className, filenameprefix, true, Flags.getConfigBool(Flags.DAE_MODE), true, SOME(simSettings));
      
            end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.

        90
            true := success;
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 88 times.

        90
            outValue := Values.STRING((if not Testsuite.isRunning() then System.pwd() + Autoconf.pathDelimiter else "") + fmuTargetName + ".fmu");
      
          else
      
            outValue := Values.STRING("");
      
        ✗
            FlagsUtil.setConfigBool(Flags.BUILDING_FMU, false);
      
        ✗
            FlagsUtil.setConfigString(Flags.FMI_VERSION, "");
      
        ✗
            return;
      
          end try;
      
        90
          FlagsUtil.setConfigBool(Flags.BUILDING_FMU, false);
      
        90
          FlagsUtil.setConfigString(Flags.FMI_VERSION, "");
      
        90
          System.realtimeTick(ClockIndexes.RT_CLOCK_BUILD_MODEL);
      
          isWindows := Autoconf.os == "Windows_NT";
      
        90
          fmutmp := Util.hashFileNamePrefix(filenameprefix) + ".fmutmp";
      
        90
          logfile := filenameprefix + ".log";
      
        90
          dir := fmutmp+"/sources/";
      
          // wasm FMU: CodegenWasmJit.emitMeFmu already wrote the self-contained
      
          // <name>.fmu (component linked in Rust, ZIP assembled in Rust) — nothing to
      
          // build or zip. Just confirm it exists. With --fmuDirectory it is an unzipped
      
          // directory of that name instead.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 90 times.

        90
          if isWasmFMU then
      
        ✗
            if not (System.regularFileExists(fmuTargetName + ".fmu")
      
                    or (Flags.getConfigBool(Flags.FMU_DIRECTORY) and System.directoryExists(fmuTargetName + ".fmu"))) then
      
        ✗
              Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {"wasm FMU export produced no " + fmuTargetName + ".fmu"});
      
              outValue := Values.STRING("");
      
        ✗
              return;
      
            end if;
      
        ✗
            reportFMUPlatformsBuilt(platforms);
      
        ✗
            return;
      
          end if;
      
          3/4✓ Branch 1 taken 9 times.
✓ Branch 2 taken 81 times.
✓ Branch 5 taken 9 times.
✗ Branch 6 not taken.

        90
          if Config.simCodeTarget() == "Cpp" then
      
        9
            System.removeDirectory("binaries");
      
          2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.

        18
            for platform in platforms loop
      
          3/8✗ Branch 0 not taken.
✓ Branch 1 taken 9 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 9 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 9 times.
✗ Branch 9 not taken.

        9
              if platform == "dynamic" or platform == "static" then
      
        9
                CevalScript.compileModel(filenameprefix + "_FMU", libs);
      
              else
      
        ✗
                CevalScript.compileModel(filenameprefix + "_FMU", libs,
      
                                         makeVars={"TARGET_TRIPLET=" + platform});
      
              end if;
      
        9
              ExecStat.execStat("buildModelFMU: Generate C++ for platform " + platform);
      
            end for;
      
        9
            if 0 <> System.systemCallRestrictedEnv(Autoconf.make + " -f " + filenameprefix + "_FMU.makefile clean", outFile=logfile) then
      
              // do nothing
      
            end if;
      
        9
            return;
      
          end if;
      
        81
          CevalScript.compileModel(filenameprefix+"_FMU" , libs);
      
        81
          ExecStat.execStat("buildModelFMU: Generate the FMI files");
      
          // Check flag fmiFlags if we need additional 3rdParty runtime libs and files
      
        81
          needs3rdPartyLibs := SimCodeUtil.cvodeFmiFlagIsSet(SimCodeUtil.createFMISimulationFlags(false));
      
          // A docker build compiles the FMU from sources/, which --fmiSources=false only
      
          // strips when packing, so the Rust half has to be there too.
      
          4/6✓ Branch 2 taken 81 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 74 times.
✓ Branch 6 taken 7 times.
✗ Branch 8 not taken.
✓ Branch 9 taken 74 times.

        81
          if Config.simCodeRustRuntime() and not System.directoryExists(fmutmp + "/sources/rust")
      
             and List.any(platforms, isDockerPlatform) then
      
        ✗
            SimCodeMain.copyFmuRustSources(fmutmp);
      
          end if;
      
          // Configure and build the FMU with CMake
      
          // Compiling for several platforms takes minutes per platform, so report which one is
      
          // being built. Error.checkCancel() hands the thread to the host UI between platforms,
      
          // which is what keeps OMEdit responsive and lets Cancel through.
      
        81
          platformCount := listLength(platforms);
      
          platformIndex := 0;
      
          2/2✓ Branch 0 taken 81 times.
✓ Branch 1 taken 81 times.

        162
          for platform in platforms loop
      
        81
            platformIndex := platformIndex + 1;
      
        81
            platformName := listGet(Util.stringSplitAtChar(platform, " "), 1);
      
        81
            Error.checkCancel();
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 81 times.

        81
            System.reportProgress(intDiv((platformIndex - 1) * 1000, platformCount), 4 /* PHASE_BACKEND */);
      
        81
            System.reportProgressMessage("Building FMU for " + platformName + " (" + String(platformIndex) + "/" + String(platformCount) + ")");
      
        81
            Error.addCompilerNotification("Building FMU for platform '" + platformName + "' (" + String(platformIndex) + "/" + String(platformCount) + ").");
      
        81
            configureLogFile := System.realpath(fmutmp)+"/resources/"+System.stringReplace(platformName,"/","-")+".log";
      
        81
            configureFMU_cmake(platform, fmutmp, filenameprefix, configureLogFile, libs, isWindows, needs3rdPartyLibs);
      
          4/4✓ Branch 1 taken 80 times.
✓ Branch 2 taken 1 time.
✓ Branch 4 taken 79 times.
✓ Branch 5 taken 1 time.

        81
            if Flags.getConfigEnum(Flags.FMI_FILTER) == Flags.FMI_BLACKBOX or Flags.getConfigEnum(Flags.FMI_FILTER) == Flags.FMI_PROTECTED then
      
        80
              System.removeFile(configureLogFile);
      
            end if;
      
        81
            Error.addCompilerNotification("Finished FMU for platform '" + platformName + "' (" + String(platformIndex) + "/" + String(platformCount) + ").");
      
        81
            ExecStat.execStat("buildModelFMU: Generate platform " + platform);
      
          end for;
      
        81
          System.reportProgress(1000, 4 /* PHASE_BACKEND */);
      
        81
          System.reportProgressMessage("Packing FMU");
      
        81
          Error.checkCancel();
      
          // check for '--fmiSources=false' or '--fmiFilter=blackBox' and remove the sources directory before packing the fmu
      
          3/4✓ Branch 1 taken 7 times.
✓ Branch 2 taken 74 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 7 times.

        81
          if Flags.getConfigEnum(Flags.FMI_SOURCES) == Flags.FMI_SOURCES_NONE or Flags.getConfigEnum(Flags.FMI_FILTER) == Flags.FMI_BLACKBOX then
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 74 times.

        74
            if not System.removeDirectory(fmutmp + "/sources/") then
      
        ✗
              Error.addInternalError("Failed to remove directory: " + fmutmp, sourceInfo());
      
            end if;
      
          end if;
      
        81
          msvcEnv := SimCodeUtil.msvcEnvironment();
      
          2/4✓ Branch 0 taken 81 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 81 times.

        81
          if msvcEnv <> "" then
      
        ✗
            cmd := msvcEnv + Autoconf.cmake + " -E rm -f \"" + fmuTargetName + ".fmu\" && cd \"" + fmutmp + "\" && " +
      
                   Autoconf.cmake + " -E tar cf \"../" + fmuTargetName + ".fmu\" --format=zip .";
      
          else
      
        81
            cmd := "rm -f \"" + fmuTargetName + ".fmu\" && cd \"" + fmutmp + "\" && zip -r \"../" + fmuTargetName + ".fmu\" *";
      
          end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 81 times.

        81
          if 0 <> System.systemCall(cmd, outFile=logfile) then
      
        ✗
            Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {cmd + "\n\n" + System.readFile(logfile)});
      
        ✗
            ExecStat.execStat("buildModelFMU failed");
      
          end if;
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 81 times.

        81
          if not System.regularFileExists(fmuTargetName + ".fmu") then
      
        ✗
            Error.addMessage(Error.SIMULATOR_BUILD_ERROR, {"Build commands returned success, but " + fmuTargetName + ".fmu does not exist"});
      
        ✗
            fail();
      
          end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 81 times.

        81
          if not Flags.isSet(Flags.GEN_DEBUG_SYMBOLS) then
      
          1/2✓ Branch 1 taken 81 times.
✗ Branch 2 not taken.

        81
            if not System.removeDirectory(fmutmp) then
      
        ✗
              Error.addInternalError("Failed to remove directory: " + fmutmp, sourceInfo());
      
            end if;
      
          end if;
      
        end callBuildModelFMU;
      
        protected function isWasmFMUExport
      
          "Whether `buildModelFMU` takes the wasm (fmi-ls-wasm) route: the `wasm` platform
      
           was asked for, or the simCodeTarget is already a wasm one. FMI 1.0 never does."
      
          input String FMUVersion;
      
          input list<String> platforms;
      
          output Boolean isWasm;
      
        algorithm
      
          3/14✓ Branch 1 taken 267 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 267 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✗ Branch 11 not taken.
✓ Branch 12 taken 267 times.
✗ Branch 15 not taken.
✗ Branch 16 not taken.
✗ Branch 17 not taken.
✗ Branch 18 not taken.
✗ Branch 20 not taken.
✗ Branch 21 not taken.

        267
          isWasm := (listMember("wasm", platforms) or Config.simCodeTarget() == "wasm-jit"
      
                     or Config.simCodeTarget() == "wasm") and FMUVersion <> "1.0";
      
        end isWasmFMUExport;
      
        protected function isNotWasmPlatform
      
          "\"static\"/\"dynamic\" are the C target's own platform names, meaningless once
      
           the export is a wasm one; every other entry names a native platform."
      
          input String platform;
      
          output Boolean keep = not (platform == "wasm" or platform == "static" or platform == "dynamic");
      
        end isNotWasmPlatform;
      
        protected function buildEncryptedPackage
      
          input Absyn.Path className "path for the model";
      
          input Boolean encrypt;
      
          input Absyn.Program inProgram;
      
          output Boolean success = false;
      
        protected
      
          Absyn.Class cls;
      
          String fileName, logFile, omhome, pd, ext, packageTool, packageToolArgs, command;
      
          Boolean runCommand;
      
          String molName, dirPath, rmCommand, cdCommand, mvCommand, dirOrFileName, zipCommand;
      
        algorithm
      
        1
          cls := ProgramUtil.getPathedClassInProgram(className, inProgram);
      
        1
          fileName := AbsynUtil.classFilename(cls);
      
          logFile := "buildEncryptedPackage.log";
      
          runCommand := true;
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        1
          if (System.regularFileExists(fileName)) then
      
            // get OPENMODELICAHOME
      
        1
            omhome := Settings.getInstallationDirectoryPath();
      
            pd := Autoconf.pathDelimiter;
      
            ext := if Autoconf.os == "Windows_NT" then ".exe" else "";
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
            if encrypt then
      
              // create the path till packagetool
      
        ✗
              packageTool := stringAppendList({omhome,pd,"bin",pd,"omc-semla",pd,"packagetool",ext});
      
        ✗
              if System.regularFileExists(packageTool) then
      
                // create the list of arguments for packagetool
      
        ✗
                packageToolArgs := "-librarypath \"" + System.dirname(fileName) + "\" -version \"1.0\" -language \"3.2\" -encrypt \"" + boolString(encrypt) + "\"";
      
        ✗
                command := stringAppendList({"\"",packageTool,"\""," ",packageToolArgs});
      
              else
      
        ✗
                Error.addMessage(Error.ENCRYPTION_NOT_SUPPORTED, {packageTool});
      
                runCommand := false;
      
                command := "";
      
              end if;
      
            else
      
        1
              molName := AbsynUtil.pathString(className) + ".mol";
      
        1
              dirPath := System.dirname(fileName);
      
              // commands
      
        1
              rmCommand := "rm -f \"" + molName + "\"";
      
        1
              cdCommand := "cd \"" +  dirPath + "\"";
      
        1
              mvCommand := "mv \"" + molName +"\" \"" + System.pwd() + "\"";
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        1
              if (StringUtil.endsWith(fileName, "package.mo")) then
      
        1
                dirOrFileName := System.basename(dirPath);
      
        1
                zipCommand := "zip -r \"" + System.pwd() + pd + molName + "\" \"" + dirOrFileName + "\"";
      
        1
                command := stringAppendList({rmCommand, " && ", cdCommand, " && cd .. && ", zipCommand});
      
              else
      
        ✗
                dirOrFileName := System.basename(fileName);
      
        ✗
                zipCommand := "zip -r \"" + System.pwd() + pd + molName + "\" \"" + dirOrFileName + "\"";
      
        ✗
                command := stringAppendList({rmCommand, " && ", cdCommand, " && ", zipCommand});
      
              end if;
      
            end if;
      
            if runCommand then
      
              // remove the logFile if it already exists.
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
              if System.regularFileExists(logFile) then
      
        ✗
                System.removeFile(logFile);
      
              end if;
      
              // run the command
      
        1
              success := 0 == System.systemCall(command, logFile);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
              if not(success) then
      
        ✗
                Error.addCompilerError("Command failed: " + command);
      
              end if;
      
            end if;
      
          else
      
        ✗
            Error.addMessage(Error.FILE_NOT_FOUND_ERROR, {fileName});
      
          end if;
      
        end buildEncryptedPackage;
      
        protected function translateModelXML " author: Alachew
      
         translates a model into XML code "
      
          input output FCore.Cache cache;
      
          input FCore.Graph env;
      
          input Absyn.Path className "path for the model";
      
          output Values.Value outValue;
      
          input String fileNamePrefix;
      
          input Boolean addDummy "if true, add a dummy state";
      
          input Option<SimCode.SimulationSettings> inSimSettingsOpt;
      
        protected
      
          Boolean success;
      
        algorithm
      
        ✗
          if isProtectedContentAccess(className) then
      
            // if AST contains encrypted class show nothing
      
            outValue := Values.STRING("");
      
          else
      
        ✗
            (success,cache) := SimCodeMain.translateModel(SimCodeMain.TranslateModelKind.XML(), cache, env, className, fileNamePrefix, true, false, true, inSimSettingsOpt);
      
        ✗
            outValue := Values.STRING(if success then ((if not Testsuite.isRunning() then System.pwd() + Autoconf.pathDelimiter else "") + fileNamePrefix+".xml") else "");
      
          end if;
      
        end translateModelXML;
      
        public function translateGraphics "function: translates the graphical annotations from old to new version"
      
          input Absyn.Path className;
      
          input Absyn.Msg inMsg;
      
          output Values.Value outValue;
      
        algorithm
      
          outValue := matchcontinue inMsg
      
            local
      
              Absyn.Program p;
      
              String errorMsg,retStr,s1;
      
              Absyn.Class cls, refactoredClass;
      
              Absyn.Within within_;
      
              Boolean strEmpty;
      
            case _
      
              algorithm
      
        ✗
                p := SymbolTable.getAbsyn();
      
        ✗
                cls := ProgramUtil.getPathedClassInProgram(className, p);
      
        ✗
                refactoredClass := Refactor.refactorGraphicalAnnotation(p, cls);
      
        ✗
                within_ := ProgramUtil.buildWithin(className);
      
        ✗
                SymbolTable.setAbsyn(ProgramUtil.updateProgram(Absyn.PROGRAM({refactoredClass}, within_), p));
      
        ✗
                s1 := AbsynUtil.pathString(className);
      
        ✗
                retStr:=stringAppendList({"Translation of ",s1," successful.\n"});
      
        ✗
              then Values.STRING(retStr);
      
            else
      
              algorithm
      
        ✗
                errorMsg := Error.printMessagesStr(false);
      
        ✗
                strEmpty := (stringCompare("",errorMsg)==0);
      
        ✗
                errorMsg := if strEmpty then "Internal error, translating graphics to new version" else errorMsg;
      
        ✗
              then Values.STRING(errorMsg);
      
          end matchcontinue;
      
        end translateGraphics;
      
        protected function calculateSimulationSettings " author: x02lucpo
      
         calculates the start,end,interval,stepsize, method and initFileName"
      
          input FCore.Cache inCache;
      
          input list<Values.Value> vals;
      
          output FCore.Cache outCache;
      
          output SimCode.SimulationSettings outSimSettings;
      
        algorithm
      
          (outCache,outSimSettings) := match (inCache,vals)
      
            local
      
              String method_str,options_str,outputFormat_str,variableFilter_str;
      
              Values.Value starttime_v,stoptime_v,tolerance_v;
      
              Integer interval_i;
      
              Real starttime_r,stoptime_r,tolerance_r;
      
              FCore.Cache cache;
      
              String cflags, simflags;
      
            case (cache, {Values.CODE(Absyn.C_TYPENAME(_)),starttime_v,stoptime_v,Values.INTEGER(interval_i),tolerance_v,Values.STRING(method_str),_,Values.STRING(options_str),Values.STRING(outputFormat_str),Values.STRING(variableFilter_str),Values.STRING(cflags),Values.STRING(simflags)})
      
              algorithm
      
        2366
                starttime_r := ValuesUtil.valueReal(starttime_v);
      
        2366
                stoptime_r := ValuesUtil.valueReal(stoptime_v);
      
        2366
                tolerance_r := ValuesUtil.valueReal(tolerance_v);
      
        2366
                outSimSettings := SimCodeMain.createSimulationSettings(starttime_r,stoptime_r,interval_i,tolerance_r,method_str,options_str,outputFormat_str,variableFilter_str,cflags,simflags);
      
              then
      
                (cache, outSimSettings);
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {"CevalScript.calculateSimulationSettings failed: " + ValuesDump.valString(Values.TUPLE(vals))});
      
        ✗
              then
      
                fail();
      
          end match;
      
        end calculateSimulationSettings;
      
        protected function getListFirstShowError
      
        "@author: adrpo
      
         return the first element in the list and the rest of values.
      
         if the list is empty display the errorMessage!"
      
          input list<Values.Value> inValues;
      
          input String errorMessage;
      
          output Values.Value outValue;
      
          output list<Values.Value> restValues;
      
        algorithm
      
          (outValue, restValues) := match inValues
      
            local
      
              Values.Value v;
      
              list<Values.Value> rest;
      
            // everything is fine and dandy
      
            case v::rest then (v, rest);
      
            // ups, we're missing an argument
      
            case {}
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR, {errorMessage});
      
        ✗
              then
      
                fail();
      
          end match;
      
        end getListFirstShowError;
      
        protected function getListNthShowError
      
        "@author: adrpo
      
         return the N-th element in the list and the rest of values.
      
         if the list is empty display the errorMessage!"
      
          input list<Values.Value> inValues;
      
          input String errorMessage;
      
          input Integer currentElement;
      
          input Integer nthElement;
      
          output Values.Value outValue;
      
        algorithm
      
          outValue := matchcontinue(inValues, currentElement, nthElement)
      
            local
      
              Values.Value v;
      
              list<Values.Value> lst,rest;
      
              Integer i,n;
      
            // everything is fine and dandy
      
            case (lst, i, n)
      
              algorithm
      
          2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 26 times.

        39
                true := i < n;
      
        26
                (_,rest) := getListFirstShowError(lst,errorMessage);
      
        26
                v := getListNthShowError(rest,errorMessage, i+1, n);
      
              then v;
      
            // everything is fine and dandy
      
            case (lst, _, _)
      
              algorithm
      
        13
              (v, _) := getListFirstShowError(lst,errorMessage);
      
            then v;
      
          end matchcontinue;
      
        end getListNthShowError;
      
        protected function moveClass
      
          "Moves the referenced class by a certain offset in the given program, relative
      
           to other classes."
      
          input Absyn.Path inClassName;
      
          input Integer inOffset;
      
          input Absyn.Program inProgram;
      
          output Absyn.Program outProgram;
      
          output Boolean outSuccess;
      
        protected
      
          Absyn.Path parent_cls;
      
          String cls_name;
      
        algorithm
      
          // No offset, nothing to do.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
          if inOffset == 0 then
      
            outProgram := inProgram;
      
            outSuccess := true;
      
        ✗
            return;
      
          end if;
      
          try
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
            if AbsynUtil.pathIsIdent(inClassName) then
      
              // Simple identifier, move a top-level class in the program.
      
        ✗
              outProgram := moveClassInProgram(AbsynUtil.pathFirstIdent(inClassName), inOffset, inProgram);
      
            else
      
              // Qualified identifier, move the class inside its parent.
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
              (parent_cls, Absyn.IDENT(cls_name)) := AbsynUtil.splitQualAndIdentPath(inClassName);
      
        1
              outProgram := Interactive.transformPathedClassInProgram(parent_cls, inProgram,
      
                 function moveClassInClass(inName = cls_name, inOffset = inOffset));
      
            end if;
      
            outSuccess := true;
      
          else
      
            outProgram := inProgram;
      
            outSuccess := false;
      
          end try;
      
        end moveClass;
      
        protected function moveClassToTop
      
          "Moves a named class to the top of its enclosing class."
      
          input Absyn.Path inClassName;
      
          input Absyn.Program inProgram;
      
          output Absyn.Program outProgram = inProgram;
      
          output Boolean outSuccess;
      
        protected
      
          Absyn.Path parent_cls;
      
          String cls_name;
      
        algorithm
      
          try
      
        ✗
            if AbsynUtil.pathIsIdent(inClassName) then
      
              outProgram := match outProgram
      
                local
      
                  list<Absyn.Class> classes;
      
                  Absyn.Class cls;
      
                case Absyn.PROGRAM()
      
                  algorithm
      
        ✗
                    (classes, SOME(cls)) :=
      
                      List.deleteMemberOnTrue(AbsynUtil.pathFirstIdent(inClassName),
      
                        outProgram.classes, AbsynUtil.isClassNamed);
      
        ✗
                    outProgram.classes := cls :: classes;
      
                  then
      
                    outProgram;
      
              end match;
      
            else
      
        ✗
              (parent_cls, Absyn.IDENT(cls_name)) := AbsynUtil.splitQualAndIdentPath(inClassName);
      
        ✗
              outProgram := Interactive.transformPathedClassInProgram(parent_cls, inProgram,
      
                function moveClassToTopInClass(inName = cls_name));
      
            end if;
      
            outSuccess := true;
      
          else
      
            outSuccess := false;
      
          end try;
      
        end moveClassToTop;
      
        protected function moveClassToBottom
      
          "Moves a named class to the bottom of its enclosing class."
      
          input Absyn.Path inClassName;
      
          input Absyn.Program inProgram;
      
          output Absyn.Program outProgram = inProgram;
      
          output Boolean outSuccess;
      
        protected
      
          Absyn.Path parent_cls;
      
          String cls_name;
      
        algorithm
      
          try
      
        ✗
            if AbsynUtil.pathIsIdent(inClassName) then
      
              outProgram := match outProgram
      
                local
      
                  list<Absyn.Class> classes;
      
                  Absyn.Class cls;
      
                case Absyn.PROGRAM()
      
                  algorithm
      
        ✗
                    (classes, SOME(cls)) :=
      
                      List.deleteMemberOnTrue(AbsynUtil.pathFirstIdent(inClassName),
      
                        outProgram.classes, AbsynUtil.isClassNamed);
      
        ✗
                    outProgram.classes := listAppend(classes, {cls});
      
                  then
      
                    outProgram;
      
              end match;
      
            else
      
        ✗
              (parent_cls, Absyn.IDENT(cls_name)) := AbsynUtil.splitQualAndIdentPath(inClassName);
      
        ✗
              outProgram := Interactive.transformPathedClassInProgram(parent_cls, inProgram,
      
                function moveClassToBottomInClass(inName = cls_name));
      
            end if;
      
            outSuccess := true;
      
          else
      
            outSuccess := false;
      
          end try;
      
        end moveClassToBottom;
      
        protected function moveClassInProgram
      
          "Moves a named class a certain offset within a program."
      
          input String inName;
      
          input Integer inOffset;
      
          input Absyn.Program inProgram;
      
          output Absyn.Program outProgram = inProgram;
      
        algorithm
      
          outProgram := match outProgram
      
            case Absyn.PROGRAM()
      
              algorithm
      
        ✗
                outProgram.classes := moveClassInClassList(inName, inOffset, outProgram.classes);
      
              then
      
                outProgram;
      
          end match;
      
        end moveClassInProgram;
      
        protected function moveClassInClassList
      
          "Moves a named class a certain offset within a list of classes. Fails if no
      
           class with the given name could be found."
      
          input String inName;
      
          input Integer inOffset;
      
          input list<Absyn.Class> inClasses;
      
          output list<Absyn.Class> outClasses;
      
        protected
      
          Absyn.Class cls;
      
          list<Absyn.Class> acc = {}, rest = inClasses;
      
          String name;
      
          Integer offset;
      
        algorithm
      
          // Move classes from rest to acc until we find the class.
      
          // This will intentionally fail if the class isn't found.
      
        ✗
          while true loop
      
        ✗
            (cls as Absyn.CLASS(name = name)) :: rest := rest;
      
        ✗
            if name == inName then
      
              break;
      
            else
      
              acc := cls :: acc;
      
            end if;
      
          end while;
      
        ✗
          if inOffset > 0 then
      
            // Clamp offset so we don't move outside the list.
      
        ✗
            offset := min(inOffset, listLength(rest));
      
            // Move 'offset' number of classes from rest to acc.
      
        ✗
            for i in 1:offset loop
      
        ✗
              acc := listHead(rest) :: acc;
      
        ✗
              rest := listRest(rest);
      
            end for;
      
          else
      
            // Clamp offset so we don't move outside the list.
      
        ✗
            offset := max(inOffset, -listLength(acc));
      
            // Move 'offset' number of classes from acc to rest.
      
        ✗
            for i in offset:-1 loop
      
        ✗
              rest := listHead(acc) :: rest;
      
        ✗
              acc := listRest(acc);
      
            end for;
      
          end if;
      
          // Assemble the class list again with the class in the correct position.
      
        ✗
          outClasses := List.append_reverse(acc, cls :: rest);
      
        end moveClassInClassList;
      
        protected function moveClassInClass
      
          "Moves a named class a certain offset within another class. Only handles long
      
          class and class extends definitions, since there's no meaningful way of moving
      
          a class inside e.g. a short class definition. Fails if the class can't be
      
          found. An out of bounds offset is clamped."
      
          input String inName;
      
          input Integer inOffset;
      
          input Absyn.Class inClass;
      
          output Absyn.Class outClass;
      
        protected
      
          Absyn.ClassDef body;
      
        algorithm
      
        1
          Absyn.CLASS(body = body) := inClass;
      
          body := match body
      
            case Absyn.PARTS()
      
              algorithm
      
        1
                body.classParts := moveClassInClassParts(inName, inOffset, body.classParts);
      
              then
      
                body;
      
            case Absyn.CLASS_EXTENDS()
      
              algorithm
      
        ✗
                body.parts := moveClassInClassParts(inName, inOffset, body.parts);
      
              then
      
                body;
      
          end match;
      
        1
          outClass := AbsynUtil.setClassBody(inClass, body);
      
        end moveClassInClass;
      
        protected function moveClassInClassParts
      
          input String inName;
      
          input Integer inOffset;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts = inClassParts;
      
        protected
      
          Absyn.ClassPart part;
      
          list<Absyn.ClassPart> acc = {}, rest = inClassParts, parts;
      
          Option<Absyn.ElementItem> cls = NONE();
      
          Integer offset;
      
          Boolean is_public, is_empty;
      
        algorithm
      
          // Go through the parts until we find the one containing the named class.
      
        ✗
          while true loop
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
            part :: rest := rest;
      
        1
            (part, cls, offset, is_public) := moveClassInClassPart(inName, inOffset, part);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        1
            if isSome(cls) then
      
              break;
      
            else
      
              acc := part :: acc;
      
            end if;
      
          end while;
      
        1
          is_empty := AbsynUtil.isEmptyClassPart(part);
      
          // Operate on either rest or acc depending on offset direction.
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          parts := if offset > 0 then rest else acc;
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        1
          if listEmpty(parts) and offset <> 0 then
      
            // No parts left but offset isn't 0, insert the class at the end.
      
        ✗
            parts := moveClassInClassParts3(Util.getOption(cls), offset < 0, is_public, part, parts);
      
          else
      
            // Otherwise, keeps moving the class until it's in the correct part.
      
        1
            parts := moveClassInClassParts2(Util.getOption(cls), offset, is_public, parts);
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
            if not is_empty then
      
              // Only add the part we moved the class from if it contains something.
      
              parts := part :: parts;
      
            end if;
      
          end if;
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          if offset > 0 then
      
            rest := parts;
      
          else
      
            acc := parts;
      
          end if;
      
          // If the part we moved the class from is empty, try to merge the surrounding
      
          // parts so that repeated moving don't fragment the class.
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✗ Branch 3 not taken.

        1
          if is_empty and not listEmpty(rest) then
      
        ✗
            part :: rest := rest;
      
        ✗
            acc := mergeClassPartWithList(part, acc);
      
          end if;
      
        1
          outClassParts := List.append_reverse(acc, rest);
      
        end moveClassInClassParts;
      
        protected function mergeClassPartWithList
      
          "Tries to merge the given class part with the first part in the list. If they
      
           are not the same type it just adds the part to the head of the list instead."
      
          input Absyn.ClassPart inClassPart;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts;
      
        protected
      
          Absyn.ClassPart part;
      
          list<Absyn.ClassPart> rest;
      
        algorithm
      
          outClassParts := match (inClassPart, inClassParts)
      
            case (Absyn.PUBLIC(), (part as Absyn.PUBLIC()) :: rest)
      
        ✗
              then Absyn.PUBLIC(listAppend(part.contents, inClassPart.contents)) :: rest;
      
            case (Absyn.PROTECTED(), (part as Absyn.PROTECTED()) :: rest)
      
        ✗
              then Absyn.PROTECTED(listAppend(part.contents, inClassPart.contents)) :: rest;
      
            else inClassPart :: inClassParts;
      
          end match;
      
        end mergeClassPartWithList;
      
        protected function moveClassInClassParts2
      
          "Helper function to moveClassInClassParts. Inserts the class into the correct
      
           class part."
      
          input Absyn.ElementItem inClass;
      
          input Integer inOffset;
      
          input Boolean inIsPublic;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts;
      
        protected
      
          Absyn.ClassPart part;
      
          list<Absyn.ClassPart> rest = inClassParts, parts, acc = {};
      
          Integer offset = inOffset;
      
          Boolean moved;
      
        algorithm
      
          // Loop while we still have some offset to move the class.
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
          while offset <> 0 loop
      
        ✗
            part :: rest := rest;
      
            // Move the class through the next part.
      
        ✗
            (parts, offset, moved) := moveClassInClassPart3(inClass, offset, inIsPublic, part);
      
        ✗
            if listEmpty(rest) and not moved then
      
              // We ran out of class parts, add the class at the end.
      
        ✗
              acc := moveClassInClassParts3(inClass, inOffset > 0, inIsPublic, part, acc);
      
        ✗
              break;
      
            elseif offset == 0 and not moved then
      
              // The offset is zero, but the class still hasn't been inserted anywhere.
      
              // This happens when the class was just moved outside the current part,
      
              // and should be inserted into the next one.
      
              // Add the parts we've just processed.
      
        ✗
              acc := listAppend(parts, acc);
      
              // Add the class to the next part if it has the same protection, otherwise
      
              // create a new part for it.
      
        ✗
              part :: rest := rest;
      
        ✗
              acc := moveClassInClassParts3(inClass, inOffset > 0, inIsPublic, part, acc);
      
        ✗
              break;
      
            end if;
      
        ✗
            acc := listAppend(if inOffset > 0 then parts else listReverse(parts), acc);
      
          end while;
      
        1
          outClassParts := List.append_reverse(acc, rest);
      
        end moveClassInClassParts2;
      
        protected function moveClassInClassParts3
      
          "Helper function to moveClassInClassParts2. Inserts a class into a given class
      
           part if they have the same protection, or create a new part for the class
      
           otherwise. Then the part(s) are added to the given list of parts."
      
          input Absyn.ElementItem inClass;
      
          input Boolean inPositiveOffset;
      
          input Boolean inIsPublic;
      
          input Absyn.ClassPart inClassPart;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts;
      
        algorithm
      
          outClassParts := match (inPositiveOffset, inIsPublic, inClassPart)
      
            case (true,  true,  Absyn.PUBLIC())
      
        ✗
              then Absyn.PUBLIC(inClass :: inClassPart.contents) :: inClassParts;
      
            case (true,  false, Absyn.PROTECTED())
      
        ✗
              then Absyn.PROTECTED(inClass :: inClassPart.contents) :: inClassParts;
      
            case (false, true,  Absyn.PUBLIC())
      
        ✗
              then Absyn.PUBLIC(listAppend(inClassPart.contents, {inClass})) :: inClassParts;
      
            case (false, false, Absyn.PROTECTED())
      
        ✗
              then Absyn.PROTECTED(listAppend(inClassPart.contents, {inClass})) :: inClassParts;
      
            case (_,  true,  _)
      
        ✗
              then Absyn.PUBLIC({inClass}) :: inClassPart :: inClassParts;
      
            case (_,  false, _)
      
        ✗
              then Absyn.PROTECTED({inClass}) :: inClassPart :: inClassParts;
      
          end match;
      
        end moveClassInClassParts3;
      
        protected function moveClassInClassPart
      
          "Moves a named class a certain offset within a single class part."
      
          input String inName;
      
          input Integer inOffset;
      
          input Absyn.ClassPart inClassPart;
      
          output Absyn.ClassPart outClassPart = inClassPart;
      
          output Option<Absyn.ElementItem> outClass;
      
          output Integer outRemainingOffset;
      
          output Boolean outIsPublic;
      
        protected
      
          list<Absyn.ElementItem> elements;
      
        algorithm
      
          (outClassPart, outClass, outRemainingOffset, outIsPublic) := match outClassPart
      
            case Absyn.PUBLIC()
      
              algorithm
      
        1
                (elements, outClass, outRemainingOffset) :=
      
                  moveClassInClassPart2(inName, inOffset, outClassPart.contents);
      
        1
                outClassPart.contents := elements;
      
        1
              then
      
                (outClassPart, outClass, outRemainingOffset, true);
      
            case Absyn.PROTECTED()
      
              algorithm
      
        ✗
                (elements, outClass, outRemainingOffset) :=
      
                  moveClassInClassPart2(inName, inOffset, outClassPart.contents);
      
        ✗
                outClassPart.contents := elements;
      
        ✗
              then
      
                (outClassPart, outClass, outRemainingOffset, false);
      
            else (outClassPart, NONE(), inOffset, false);
      
          end match;
      
        end moveClassInClassPart;
      
        protected function moveClassInClassPart2
      
          "Helper function to moveClassInClassPart. Moves a named class a certain offset
      
           within a list of element items."
      
          input String inName;
      
          input Integer inOffset;
      
          input list<Absyn.ElementItem> inElements;
      
          output list<Absyn.ElementItem> outElements;
      
          output Option<Absyn.ElementItem> outClass = NONE();
      
          output Integer outRemainingOffset;
      
        protected
      
          Absyn.ElementItem e;
      
          list<Absyn.ElementItem> elements = inElements, acc = {};
      
        algorithm
      
          // Try to find an element item containing the class we're looking for.
      
          1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.

        2
          while not listEmpty(elements) loop
      
        2
            e :: elements := elements;
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.

        2
            if AbsynUtil.isElementItemClassNamed(inName, e) then
      
              // Found the class, exit the loop.
      
              outClass := SOME(e);
      
        1
              break;
      
            else
      
              acc := e :: acc;
      
            end if;
      
          end while;
      
          // No class found.
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        1
          if isNone(outClass) then
      
            outElements := inElements;
      
        ✗
            outRemainingOffset := inOffset;
      
        ✗
            return;
      
          end if;
      
          // Try to move the class within the elements we have.
      
        1
          (acc, elements, outRemainingOffset) :=
      
            moveClassInSplitClassPart(inOffset, acc, elements);
      
          // Insert the class again if it was moved within this class part. Otherwise it needs
      
          // to be moved into another class part, which is handled by moveClassInClassParts.
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          if outRemainingOffset == 0 then
      
        2
            elements := Util.getOption(outClass) :: elements;
      
          end if;
      
        1
          outElements := List.append_reverse(acc, elements);
      
        end moveClassInClassPart2;
      
        protected function makeClassPart
      
          input list<Absyn.ElementItem> inElements;
      
          input Boolean inPublic;
      
          output Absyn.ClassPart outPart =
      
            if inPublic then Absyn.PUBLIC(inElements) else Absyn.PROTECTED(inElements);
      
        end makeClassPart;
      
        protected function moveClassInClassPart3
      
          "Helper function to moveClassInClassParts2. Moves a class a certain offset in
      
           a given class part."
      
          input Absyn.ElementItem inClass;
      
          input Integer inOffset;
      
          input Boolean inIsPublic;
      
          input Absyn.ClassPart inClassPart;
      
          output list<Absyn.ClassPart> outClassParts;
      
          output Integer outRemainingOffset;
      
          output Boolean outMoved = false;
      
        protected
      
          Boolean same_part_type, reached_end;
      
          list<Absyn.ElementItem> elems_before, elems_after, elems;
      
        algorithm
      
          // Fetch the elements of the part, and remember if it has the same protection
      
          // as the class to be moved.
      
          (elems, same_part_type) := match inClassPart
      
        ✗
            case Absyn.PUBLIC() then (inClassPart.contents, inIsPublic);
      
        ✗
            case Absyn.PROTECTED() then (inClassPart.contents, not inIsPublic);
      
          end match;
      
          // Use moveClassInSplitClassPart to shuffle elements.
      
        ✗
          if inOffset > 0 then
      
            elems_before := {};
      
        ✗
            elems_after := elems;
      
          else
      
            elems_before := elems;
      
        ✗
            elems_after := {};
      
          end if;
      
        ✗
          (elems_before, elems_after, outRemainingOffset, reached_end) :=
      
            moveClassInSplitClassPart(inOffset, listReverse(elems_before), elems_after);
      
          // No remaining offset, the class has been moved to where it should be.
      
        ✗
          if outRemainingOffset == 0 then
      
        ✗
            if same_part_type then
      
              // The class and the class part has the same protection, insert the class
      
              // into the part.
      
        ✗
              elems := List.append_reverse(elems_before, inClass :: elems_after);
      
        ✗
              outClassParts := {makeClassPart(elems, inIsPublic)};
      
              outMoved := true;
      
            elseif not reached_end then
      
              // If we did not reach the end, and the protection isn't the same, split
      
              // the class part into three potential parts, with the class in its own
      
              // part in the middle.
      
        ✗
              outClassParts := if listEmpty(elems_before) then {} else
      
                {makeClassPart(listReverse(elems_before), not inIsPublic)};
      
        ✗
              outClassParts := makeClassPart({inClass}, inIsPublic) :: outClassParts;
      
        ✗
              if not listEmpty(elems_after) then
      
        ✗
                outClassParts := makeClassPart(elems_after, not inIsPublic) :: outClassParts;
      
              end if;
      
              outMoved := true;
      
            else
      
              // Different protection, and we did reach the end. In that case the class
      
              // should be moved into the next part, if that part has the same
      
              // protection. We don't know that here, so we return the class part as it
      
              // is and let moveClassInClassParts2 sort it out.
      
              outClassParts := {inClassPart};
      
            end if;
      
          else
      
            outClassParts := {inClassPart};
      
          end if;
      
        end moveClassInClassPart3;
      
        protected function moveClassInSplitClassPart
      
          "Takes two lists of element items and an offset. Moves elements from one list
      
           to the other until offset number of classes has been moved or the end in
      
           either direction has been reached."
      
          input Integer inOffset;
      
          input list<Absyn.ElementItem> inElementsBefore;
      
          input list<Absyn.ElementItem> inElementsAfter;
      
          output list<Absyn.ElementItem> outElementsBefore = inElementsBefore;
      
          output list<Absyn.ElementItem> outElementsAfter = inElementsAfter;
      
          output Integer outRemainingOffset = inOffset;
      
          output Boolean outReachedEnd;
      
        protected
      
          Absyn.ElementItem e;
      
        algorithm
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          if inOffset > 0 then
      
            // Positive offset, move elements from after to before.
      
        ✗
            while outRemainingOffset > 0 loop
      
        ✗
              if listEmpty(outElementsAfter) then // No more elements, we're done.
      
                break;
      
              else
      
        ✗
                e :: outElementsAfter := outElementsAfter;
      
                outElementsBefore := e :: outElementsBefore;
      
                // Decrease the offset for each class we move.
      
        ✗
                if AbsynUtil.isElementItemClass(e) then
      
        ✗
                  outRemainingOffset := outRemainingOffset - 1;
      
                end if;
      
              end if;
      
            end while;
      
        ✗
            outReachedEnd := listEmpty(outElementsAfter);
      
          else
      
            // Negative offset, move elements from before to after.
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 1 time.

        2
            while outRemainingOffset < 0 loop
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
              if listEmpty(outElementsBefore) then // No more elements, we're done.
      
                break;
      
              else
      
        1
                e :: outElementsBefore := outElementsBefore;
      
                outElementsAfter := e :: outElementsAfter;
      
                // Increase the offset for each class we move.
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.

        1
                if AbsynUtil.isElementItemClass(e) then
      
        1
                  outRemainingOffset := outRemainingOffset + 1;
      
                end if;
      
              end if;
      
            end while;
      
        1
            outReachedEnd := listEmpty(outElementsBefore);
      
          end if;
      
        end moveClassInSplitClassPart;
      
        protected function deleteClassInClassPart
      
          input String inName;
      
          input Absyn.ClassPart inClassPart;
      
          output Absyn.ClassPart outClassPart = inClassPart;
      
          output Option<Absyn.ElementItem> outClass;
      
        protected
      
          list<Absyn.ElementItem> elements;
      
        algorithm
      
          (outClassPart, outClass) := match outClassPart
      
            case Absyn.PUBLIC()
      
              algorithm
      
        ✗
                (elements, outClass) := List.deleteMemberOnTrue(inName,
      
                  outClassPart.contents, AbsynUtil.isElementItemClassNamed);
      
        ✗
                outClassPart.contents := elements;
      
        ✗
              then
      
                (outClassPart, outClass);
      
            case Absyn.PROTECTED()
      
              algorithm
      
        ✗
                (elements, outClass) := List.deleteMemberOnTrue(inName,
      
                  outClassPart.contents, AbsynUtil.isElementItemClassNamed);
      
        ✗
                outClassPart.contents := elements;
      
        ✗
              then
      
                (outClassPart, outClass);
      
            else (outClassPart, NONE());
      
          end match;
      
        end deleteClassInClassPart;
      
        protected function moveClassToTopInClass
      
          input String inName;
      
          input Absyn.Class inClass;
      
          output Absyn.Class outClass;
      
        protected
      
          Absyn.ClassDef body;
      
        algorithm
      
        ✗
          Absyn.CLASS(body = body) := inClass;
      
          body := match body
      
            case Absyn.PARTS()
      
              algorithm
      
        ✗
                body.classParts := moveClassToTopInClassParts(inName, body.classParts);
      
              then
      
                body;
      
            case Absyn.CLASS_EXTENDS()
      
              algorithm
      
        ✗
                body.parts := moveClassToTopInClassParts(inName, body.parts);
      
              then
      
                body;
      
          end match;
      
        ✗
          outClass := AbsynUtil.setClassBody(inClass, body);
      
        end moveClassToTopInClass;
      
        protected function moveClassToTopInClassParts
      
          input String inName;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts;
      
        protected
      
          Absyn.ClassPart part, first;
      
          list<Absyn.ClassPart> acc = {}, rest = inClassParts;
      
          Option<Absyn.ElementItem> ocls;
      
          Absyn.ElementItem cls;
      
        algorithm
      
        ✗
          while true loop
      
        ✗
            part :: rest := rest;
      
        ✗
            (part, ocls) := deleteClassInClassPart(inName, part);
      
        ✗
            if isSome(ocls) then
      
              // Remove the part if it's now empty and not the only part.
      
        ✗
              if not AbsynUtil.isEmptyClassPart(part) or listEmpty(acc) or listEmpty(rest) then
      
                rest := part :: rest;
      
              end if;
      
        ✗
              outClassParts := List.append_reverse(acc, rest);
      
              break;
      
            else
      
              acc := part :: acc;
      
            end if;
      
          end while;
      
        ✗
          SOME(cls) := ocls;
      
        ✗
          first :: rest := outClassParts;
      
          outClassParts := match (first, part)
      
            case (Absyn.PUBLIC(), Absyn.PUBLIC())
      
              algorithm
      
        ✗
                first.contents := cls :: first.contents;
      
              then
      
                first :: rest;
      
            case (Absyn.PROTECTED(), Absyn.PROTECTED())
      
              algorithm
      
        ✗
                first.contents := cls :: first.contents;
      
              then
      
                first :: rest;
      
        ✗
            case (_, Absyn.PUBLIC()) then Absyn.PUBLIC({cls}) :: first :: rest;
      
        ✗
            case (_, Absyn.PROTECTED()) then Absyn.PROTECTED({cls}) :: first :: rest;
      
          end match;
      
        end moveClassToTopInClassParts;
      
        protected function moveClassToBottomInClass
      
          input String inName;
      
          input Absyn.Class inClass;
      
          output Absyn.Class outClass;
      
        protected
      
          Absyn.ClassDef body;
      
        algorithm
      
        ✗
          Absyn.CLASS(body = body) := inClass;
      
          body := match body
      
            case Absyn.PARTS()
      
              algorithm
      
        ✗
                body.classParts := moveClassToBottomInClassParts(inName, body.classParts);
      
              then
      
                body;
      
            case Absyn.CLASS_EXTENDS()
      
              algorithm
      
        ✗
                body.parts := moveClassToBottomInClassParts(inName, body.parts);
      
              then
      
                body;
      
          end match;
      
        ✗
          outClass := AbsynUtil.setClassBody(inClass, body);
      
        end moveClassToBottomInClass;
      
        protected function moveClassToBottomInClassParts
      
          input String inName;
      
          input list<Absyn.ClassPart> inClassParts;
      
          output list<Absyn.ClassPart> outClassParts;
      
        protected
      
          Absyn.ClassPart part, last;
      
          list<Absyn.ClassPart> acc = {}, rest = inClassParts;
      
          Option<Absyn.ElementItem> ocls;
      
          Absyn.ElementItem cls;
      
        algorithm
      
        ✗
          while true loop
      
        ✗
            part :: rest := rest;
      
        ✗
            (part, ocls) := deleteClassInClassPart(inName, part);
      
        ✗
            if isSome(ocls) then
      
              break;
      
            else
      
              acc := part :: acc;
      
            end if;
      
          end while;
      
        ✗
          SOME(cls) := ocls;
      
          // Remove the part if it's empty and not the only remaining part.
      
        ✗
          if not AbsynUtil.isEmptyClassPart(part) or listEmpty(rest) then
      
            rest := part :: rest;
      
          end if;
      
        ✗
          last :: rest := listReverse(rest);
      
          rest := match (last, part)
      
            case (Absyn.PUBLIC(), Absyn.PUBLIC())
      
              algorithm
      
        ✗
                last.contents := listAppend(last.contents, {cls});
      
              then
      
                last :: rest;
      
            case (Absyn.PROTECTED(), Absyn.PROTECTED())
      
              algorithm
      
        ✗
                last.contents := listAppend(last.contents, {cls});
      
              then
      
                last :: rest;
      
        ✗
            case (_, Absyn.PUBLIC()) then Absyn.PUBLIC({cls}) :: last :: rest;
      
        ✗
            case (_, Absyn.PROTECTED()) then Absyn.PROTECTED({cls}) :: last :: rest;
      
          end match;
      
        ✗
          outClassParts := List.append_reverse(acc, listReverse(rest));
      
        end moveClassToBottomInClassParts;
      
        protected function copyClass
      
          input Absyn.Class inClass;
      
          input String inName;
      
          input Absyn.Within inWithin;
      
          input Absyn.Path inClassPath;
      
          input Absyn.Program inProg;
      
          output Absyn.Program outProg;
      
        protected
      
          Absyn.Class cls;
      
          String orig_file, dst_path;
      
        algorithm
      
          Absyn.CLASS(info = SOURCEINFO(fileName = orig_file)) := inClass;
      
          dst_path := match inWithin
      
            // Destination is top scope, put the copy in a new file.
      
            case Absyn.TOP() then "<interactive>";
      
            // Destination is within another class, put the copy in the same file as the
      
            // destination class.
      
            case Absyn.WITHIN()
      
              algorithm
      
        4
                Absyn.CLASS(info = SOURCEINFO(fileName = dst_path)) :=
      
                  ProgramUtil.getPathedClassInProgram(inWithin.path, inProg);
      
              then
      
                dst_path;
      
          end match;
      
          // Update the paths in the class to reflect the new location.
      
        6
          cls := NFApi.updateMovedClassPaths(inClass, inClassPath, inWithin);
      
          // Replace the filename of each element with the new path.
      
        6
          cls := moveClassInfo(cls, dst_path);
      
          // Change the name of the class and put it in as a copy in the program.
      
        6
          cls := AbsynUtil.setClassName(cls, inName);
      
        6
          outProg := ProgramUtil.updateProgram(Absyn.PROGRAM({cls}, inWithin), inProg);
      
        end copyClass;
      
        protected function moveSourceInfo
      
          input SourceInfo inInfo;
      
          input String dstPath;
      
          output SourceInfo outInfo = inInfo;
      
        algorithm
      
          () := match outInfo
      
            case SOURCEINFO()
      
              algorithm
      
        28
                outInfo.fileName := dstPath;
      
        28
                outInfo.isReadOnly := false;
      
              then
      
                ();
      
          end match;
      
        end moveSourceInfo;
      
        protected function moveClassInfo
      
          input Absyn.Class inClass;
      
          input String dstPath;
      
          output Absyn.Class outClass = inClass;
      
        protected
      
          SourceInfo info;
      
        algorithm
      
          () := match outClass
      
            case Absyn.CLASS(info = info as SOURCEINFO())
      
              algorithm
      
        8
                outClass.body := moveClassDefInfo(outClass.body, dstPath);
      
        8
                outClass.info := moveSourceInfo(info, dstPath);
      
              then
      
                ();
      
          end match;
      
        end moveClassInfo;
      
        protected function moveClassDefInfo
      
          input Absyn.ClassDef inClassDef;
      
          input String dstPath;
      
          output Absyn.ClassDef outClassDef = inClassDef;
      
        algorithm
      
          () := match outClassDef
      
            case Absyn.PARTS()
      
              algorithm
      
          4/4✓ Branch 0 taken 8 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 8 times.
✓ Branch 3 taken 6 times.

        20
                outClassDef.classParts := list(moveClassPartInfo(cp, dstPath)
      
                  for cp in outClassDef.classParts);
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.

        12
                outClassDef.ann := list(moveAnnotationInfo(a, dstPath)
      
                  for a in outClassDef.ann);
      
              then
      
                ();
      
            case Absyn.DERIVED()
      
              algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.

        4
                outClassDef.arguments := list(moveElementArgInfo(e, dstPath)
      
                  for e in outClassDef.arguments);
      
        2
                  outClassDef.comment := moveCommentInfo(outClassDef.comment, dstPath);
      
              then
      
                ();
      
            case Absyn.ENUMERATION()
      
              algorithm
      
        ✗
                outClassDef.comment := moveCommentInfo(outClassDef.comment, dstPath);
      
              then
      
                ();
      
            case Absyn.OVERLOAD()
      
              algorithm
      
        ✗
                outClassDef.comment := moveCommentInfo(outClassDef.comment, dstPath);
      
              then
      
                ();
      
            case Absyn.CLASS_EXTENDS()
      
              algorithm
      
        ✗
                outClassDef.modifications := list(moveElementArgInfo(e, dstPath)
      
                  for e in outClassDef.modifications);
      
        ✗
                outClassDef.parts := list(moveClassPartInfo(cp, dstPath)
      
                  for cp in outClassDef.parts);
      
        ✗
                outClassDef.ann := list(moveAnnotationInfo(a, dstPath)
      
                   for a in outClassDef.ann);
      
              then
      
                ();
      
            case Absyn.PDER()
      
              algorithm
      
        ✗
                outClassDef.comment := moveCommentInfo(outClassDef.comment, dstPath);
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end moveClassDefInfo;
      
        protected function moveClassPartInfo
      
          input Absyn.ClassPart inPart;
      
          input String dstPath;
      
          output Absyn.ClassPart outPart;
      
        algorithm
      
          outPart := match inPart
      
            local
      
              list<Absyn.ElementItem> el;
      
              list<Absyn.EquationItem> eq;
      
              list<Absyn.AlgorithmItem> alg;
      
              Absyn.ExternalDecl ext;
      
              Option<Absyn.Annotation> ann;
      
            case Absyn.PUBLIC(el)
      
          4/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 11 times.
✓ Branch 3 taken 6 times.

        17
              then Absyn.PUBLIC(list(moveElementItemInfo(e, dstPath) for e in el));
      
            case Absyn.PROTECTED(el)
      
        ✗
              then Absyn.PROTECTED(list(moveElementItemInfo(e, dstPath) for e in el));
      
            case Absyn.EQUATIONS(eq)
      
          4/4✓ Branch 0 taken 1 time.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 1 time.

        2
              then Absyn.EQUATIONS(list(moveEquationItemInfo(e, dstPath) for e in eq));
      
            case Absyn.INITIALEQUATIONS(eq)
      
        ✗
              then Absyn.INITIALEQUATIONS(list(moveEquationItemInfo(e, dstPath) for e in eq));
      
            case Absyn.ALGORITHMS(alg)
      
          4/4✓ Branch 0 taken 1 time.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 1 time.

        2
              then Absyn.ALGORITHMS(list(moveAlgorithmItemInfo(e, dstPath) for e in alg));
      
            case Absyn.INITIALALGORITHMS(alg)
      
        ✗
              then Absyn.INITIALALGORITHMS(list(moveAlgorithmItemInfo(e, dstPath) for e in alg));
      
            case Absyn.EXTERNAL(ext, ann)
      
              algorithm
      
        ✗
                ext := moveExternalDeclInfo(ext, dstPath);
      
        ✗
                ann := moveAnnotationOptInfo(ann, dstPath);
      
        ✗
              then
      
                Absyn.EXTERNAL(ext, ann);
      
            else inPart;
      
          end match;
      
        end moveClassPartInfo;
      
        protected function moveAnnotationOptInfo
      
          input Option<Absyn.Annotation> inAnnotation;
      
          input String dstPath;
      
          output Option<Absyn.Annotation> outAnnotation;
      
        algorithm
      
          outAnnotation := match inAnnotation
      
            local
      
              Absyn.Annotation a;
      
        ✗
            case SOME(a) then SOME(moveAnnotationInfo(a, dstPath));
      
            else inAnnotation;
      
          end match;
      
        end moveAnnotationOptInfo;
      
        protected function moveAnnotationInfo
      
          input Absyn.Annotation inAnnotation;
      
          input String dstPath;
      
          output Absyn.Annotation outAnnotation = inAnnotation;
      
        algorithm
      
          4/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 time.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 1 time.

        3
          outAnnotation.elementArgs := list(moveElementArgInfo(e, dstPath) for e in outAnnotation.elementArgs);
      
        end moveAnnotationInfo;
      
        protected function moveElementItemInfo
      
          input Absyn.ElementItem inElement;
      
          input String dstPath;
      
          output Absyn.ElementItem outElement;
      
        algorithm
      
          outElement := match inElement
      
            case Absyn.ELEMENTITEM()
      
        11
              then Absyn.ELEMENTITEM(moveElementInfo(inElement.element, dstPath));
      
            else inElement;
      
          end match;
      
        end moveElementItemInfo;
      
        protected function moveElementInfo
      
          input Absyn.Element inElement;
      
          input String dstPath;
      
          output Absyn.Element outElement = inElement;
      
        algorithm
      
          () := match outElement
      
            case Absyn.ELEMENT()
      
              algorithm
      
        11
                outElement.specification := moveElementSpecInfo(outElement.specification, dstPath);
      
        11
                outElement.constrainClass := moveConstrainClassInfo(outElement.constrainClass, dstPath);
      
        11
                outElement.info := moveSourceInfo(outElement.info, dstPath);
      
              then
      
                ();
      
            case Absyn.TEXT()
      
              algorithm
      
        ✗
                outElement.info := moveSourceInfo(outElement.info, dstPath);
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end moveElementInfo;
      
        protected function moveElementArgInfo
      
          input Absyn.ElementArg inArg;
      
          input String dstPath;
      
          output Absyn.ElementArg outArg = inArg;
      
        algorithm
      
          () := match outArg
      
            case Absyn.MODIFICATION()
      
              algorithm
      
        2
                outArg.modification := moveModificationInfo(outArg.modification, dstPath);
      
        2
                outArg.info := moveSourceInfo(outArg.info, dstPath);
      
              then
      
                ();
      
            case Absyn.REDECLARATION()
      
              algorithm
      
        ✗
                outArg.elementSpec := moveElementSpecInfo(outArg.elementSpec, dstPath);
      
        ✗
                outArg.constrainClass := moveConstrainClassInfo(outArg.constrainClass, dstPath);
      
        ✗
                outArg.info := moveSourceInfo(outArg.info, dstPath);
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end moveElementArgInfo;
      
        protected function moveModificationInfo
      
          input Option<Absyn.Modification> inMod;
      
          input String dstPath;
      
          output Option<Absyn.Modification> outMod;
      
        algorithm
      
          outMod := match inMod
      
            local
      
              list<Absyn.ElementArg> el;
      
              Absyn.EqMod eq;
      
            case SOME(Absyn.CLASSMOD(el, eq))
      
              algorithm
      
          4/4✓ Branch 0 taken 1 time.
✓ Branch 1 taken 6 times.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 6 times.

        7
                el := list(moveElementArgInfo(e, dstPath) for e in el);
      
        6
                eq := moveEqModInfo(eq, dstPath);
      
        6
              then
      
                SOME(Absyn.CLASSMOD(el, eq));
      
            else inMod;
      
          end match;
      
        end moveModificationInfo;
      
        protected function moveEqModInfo
      
          input Absyn.EqMod inEqMod;
      
          input String dstPath;
      
          output Absyn.EqMod outEqMod;
      
        algorithm
      
          outEqMod := match inEqMod
      
            case Absyn.EQMOD()
      
        5
              then Absyn.EQMOD(inEqMod.exp, moveSourceInfo(inEqMod.info, dstPath));
      
            else inEqMod;
      
          end match;
      
        end moveEqModInfo;
      
        protected function moveConstrainClassInfo
      
          input Option<Absyn.ConstrainClass> inCC;
      
          input String dstPath;
      
          output Option<Absyn.ConstrainClass> outCC;
      
        algorithm
      
          outCC := match inCC
      
            local
      
              Absyn.ElementSpec spec;
      
              Option<Absyn.Comment> cmt;
      
            case SOME(Absyn.CONSTRAINCLASS(spec, cmt))
      
              algorithm
      
        ✗
                spec := moveElementSpecInfo(spec, dstPath);
      
        ✗
                cmt := moveCommentInfo(cmt, dstPath);
      
        ✗
              then
      
                SOME(Absyn.CONSTRAINCLASS(spec, cmt));
      
            else inCC;
      
          end match;
      
        end moveConstrainClassInfo;
      
        protected function moveCommentInfo
      
          input Option<Absyn.Comment> inComment;
      
          input String dstPath;
      
          output Option<Absyn.Comment> outComment;
      
        algorithm
      
          outComment := match inComment
      
            local
      
              Absyn.Annotation a;
      
              Option<String> c;
      
            case SOME(Absyn.COMMENT(SOME(a), c))
      
              algorithm
      
        1
                a := moveAnnotationInfo(a, dstPath);
      
        1
              then
      
                SOME(Absyn.COMMENT(SOME(a), c));
      
            else inComment;
      
          end match;
      
        end moveCommentInfo;
      
        protected function moveEquationItemInfo
      
          input Absyn.EquationItem inEquation;
      
          input String dstPath;
      
          output Absyn.EquationItem outEquation;
      
        algorithm
      
          outEquation := match inEquation
      
            local
      
              Absyn.Equation eq;
      
              Option<Absyn.Comment> cmt;
      
              SourceInfo info;
      
            case Absyn.EQUATIONITEM(eq, cmt, info)
      
              algorithm
      
        1
                cmt := moveCommentInfo(cmt, dstPath);
      
        1
                info := moveSourceInfo(info, dstPath);
      
        1
              then
      
                Absyn.EQUATIONITEM(eq, cmt, info);
      
            else inEquation;
      
          end match;
      
        end moveEquationItemInfo;
      
        protected function moveAlgorithmItemInfo
      
          input Absyn.AlgorithmItem inAlgorithm;
      
          input String dstPath;
      
          output Absyn.AlgorithmItem outAlgorithm;
      
        algorithm
      
          outAlgorithm := match inAlgorithm
      
            local
      
              Absyn.Algorithm alg;
      
              Option<Absyn.Comment> cmt;
      
              SourceInfo info;
      
            case Absyn.ALGORITHMITEM(alg, cmt, info)
      
              algorithm
      
        1
                cmt := moveCommentInfo(cmt, dstPath);
      
        1
                info := moveSourceInfo(info, dstPath);
      
        1
              then
      
                Absyn.ALGORITHMITEM(alg, cmt, info);
      
            else inAlgorithm;
      
          end match;
      
        end moveAlgorithmItemInfo;
      
        protected function moveElementSpecInfo
      
          input Absyn.ElementSpec inSpec;
      
          input String dstPath;
      
          output Absyn.ElementSpec outSpec = inSpec;
      
        algorithm
      
          () := match outSpec
      
            case Absyn.CLASSDEF()
      
              algorithm
      
        2
                outSpec.class_ := moveClassInfo(outSpec.class_, dstPath);
      
              then
      
                ();
      
            case Absyn.EXTENDS()
      
              algorithm
      
        ✗
                outSpec.elementArg := list(moveElementArgInfo(e, dstPath)
      
                  for e in outSpec.elementArg);
      
        ✗
                outSpec.annotationOpt := moveAnnotationOptInfo(outSpec.annotationOpt, dstPath);
      
              then
      
                ();
      
            case Absyn.IMPORT()
      
              algorithm
      
        ✗
                outSpec.comment := moveCommentInfo(outSpec.comment, dstPath);
      
        ✗
                outSpec.info := moveSourceInfo(outSpec.info, dstPath);
      
              then
      
                ();
      
            case Absyn.COMPONENTS()
      
              algorithm
      
          4/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 9 times.

        27
                outSpec.components := list(moveComponentItemInfo(c, dstPath)
      
                  for c in outSpec.components);
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end moveElementSpecInfo;
      
        protected function moveComponentItemInfo
      
          input Absyn.ComponentItem inComponent;
      
          input String dstPath;
      
          output Absyn.ComponentItem outComponent;
      
        protected
      
          Absyn.Component comp;
      
          Option<Absyn.ComponentCondition> cond;
      
          Option<Absyn.Comment> cmt;
      
        algorithm
      
        9
          Absyn.COMPONENTITEM(comp, cond, cmt) := inComponent;
      
        9
          comp := moveComponentInfo(comp, dstPath);
      
        9
          cmt := moveCommentInfo(cmt, dstPath);
      
        9
          outComponent := Absyn.COMPONENTITEM(comp, cond, cmt);
      
        end moveComponentItemInfo;
      
        protected function moveComponentInfo
      
          input Absyn.Component inComponent;
      
          input String dstPath;
      
          output Absyn.Component outComponent = inComponent;
      
        algorithm
      
        9
          outComponent.modification := moveModificationInfo(outComponent.modification, dstPath);
      
        end moveComponentInfo;
      
        protected function moveExternalDeclInfo
      
          input Absyn.ExternalDecl inExtDecl;
      
          input String dstPath;
      
          output Absyn.ExternalDecl outExtDecl = inExtDecl;
      
        algorithm
      
        ✗
          outExtDecl.annotation_ := moveAnnotationOptInfo(outExtDecl.annotation_, dstPath);
      
        end moveExternalDeclInfo;
      
        protected function buildModel "translates and builds the model by running compiler script on the generated makefile"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input list<Values.Value> inValues;
      
          input Absyn.Msg inMsg;
      
          output Boolean success=false;
      
          output FCore.Cache outCache;
      
          output String compileDir;
      
          output String outString1 "className";
      
          output String outString2 "method";
      
          output String outputFormat_str;
      
          output String outInitFileName "initFileName";
      
          output String outSimFlags;
      
          output list<tuple<String,Values.Value>> resultValues;
      
          output list<Values.Value> outArgs;
      
          output list<String> outLibsAndLibDirs;
      
        algorithm
      
          (outCache,compileDir,outString1,outString2,outputFormat_str,outInitFileName,outSimFlags,resultValues,outArgs,outLibsAndLibDirs):=
      
          matchcontinue (inCache, inEnv, inValues)
      
            local
      
              list<String> libsAndLibDirs;
      
              String file_dir,init_filename,method_str,filenameprefix,simflags;
      
              Absyn.Path classname;
      
              Real timeCompile;
      
              FCore.Graph env;
      
              SimCode.SimulationSettings simSettings;
      
              Values.Value method,outputFormat;
      
              list<Values.Value> vals, values;
      
              FCore.Cache cache;
      
              Option<Absyn.Modification> simflags_mod;
      
            // compile the model
      
            case (cache, env, vals)
      
              algorithm
      
                // buildModel expects these arguments:
      
                // className, startTime, stopTime, numberOfIntervals, tolerance, method, fileNamePrefix,
      
                // options, outputFormat, variableFilter, cflags, simflags
      
        1160
                values := vals;
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 1160 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 1160 times.

        1160
                (Values.CODE(Absyn.C_TYPENAME(classname)),vals) := getListFirstShowError(vals, "while retrieving the className (1 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the startTime (2 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the stopTime (3 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the numberOfIntervals (4 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the tolerance (5 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the method (6 arg) from the buildModel arguments");
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1160 times.

        1160
                (Values.STRING(filenameprefix),vals) := getListFirstShowError(vals, "while retreaving the fileNamePrefix (7 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the options (8 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the outputFormat (9 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the variableFilter (10 arg) from the buildModel arguments");
      
        1160
                (_,vals) := getListFirstShowError(vals, "while retrieving the cflags (11 arg) from the buildModel arguments");
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1160 times.

        1160
                (Values.STRING(simflags),vals) := getListFirstShowError(vals, "while retrieving the simflags (12 arg) from the buildModel arguments");
      
        1160
                Error.clearMessages() "Clear messages";
      
                // If simflags is empty and --ignoreSimulationFlagsAnnotation isn't used,
      
                // use the __OpenModelica_simulationFlags annotation in the class to be simulated.
      
          3/4✓ Branch 0 taken 815 times.
✓ Branch 1 taken 345 times.
✓ Branch 3 taken 815 times.
✗ Branch 4 not taken.

        1160
                if stringEmpty(simflags) and not Flags.getConfigBool(Flags.IGNORE_SIMULATION_FLAGS_ANNOTATION) then
      
        815
                  loadProgram(classname);
      
        815
                  simflags_mod := ProgramUtil.getNamedAnnotationExp(classname, SymbolTable.getAbsyn(),
      
                    Absyn.IDENT("__OpenModelica_simulationFlags"), SOME(NONE()), Util.id);
      
        815
                  simflags := formatSimulationFlagsString(simflags_mod);
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 813 times.

        815
                  if not stringEmpty(simflags) then
      
        2
                    values := List.replaceAt(Values.STRING(simflags), 12, values);
      
                  end if;
      
                end if;
      
        1160
                compileDir := System.pwd() + Autoconf.pathDelimiter;
      
        1160
                (cache,simSettings) := calculateSimulationSettings(cache, values);
      
        1160
                SimCode.SIMULATION_SETTINGS(method = method_str, outputFormat = outputFormat_str) := simSettings;
      
        1160
                (success,cache,libsAndLibDirs,file_dir,resultValues) := translateModel(cache,env, classname, filenameprefix, true, true, SOME(simSettings));
      
                //cname_str = AbsynUtil.pathString(classname);
      
                //SimCodeUtil.generateInitData(indexed_dlow_1, classname, filenameprefix, init_filename,
      
                //  starttime_r, stoptime_r, interval_r, tolerance_r, method_str,options_str,outputFormat_str);
      
        1144
                System.realtimeTick(ClockIndexes.RT_CLOCK_BUILD_MODEL);
      
        1144
                init_filename := filenameprefix + "_init.xml"; //a hack ? should be at one place somewhere
      
                //win1 = getWithinStatement(classname);
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1144 times.

        1144
                if Flags.isSet(Flags.DYN_LOAD) then
      
        ✗
                  Debug.traceln("buildModel: about to compile model " + filenameprefix + ", " + file_dir);
      
                end if;
      
          1/2✓ Branch 0 taken 1144 times.
✗ Branch 1 not taken.

        1144
                if success then
      
                  try
      
                    // The wasm-jit target produced the model WebAssembly module during
      
                    // translateModel and runs it in-process at simulate time, so there
      
                    // is no C executable to compile/link here. Instead, force the JIT
      
                    // compile of the model's wasm modules now so its cost is attributed
      
                    // to timeCompile (this clock) rather than leaking into
      
                    // timeSimulation at runSimulation.
      
          1/4✗ Branch 1 not taken.
✓ Branch 2 taken 1144 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.

        1144
                    if Config.simCodeTarget() == "wasm-jit" then
      
        ✗
                      CodegenWasmJit.finishCompile(filenameprefix);
      
                    elseif Config.simCodeTarget() == "wasm" then
      
                      // The standalone module was already produced in emitStandalone;
      
                      // there is nothing to compile/link here.
      
                    else
      
        1144
                      CevalScript.compileModel(filenameprefix, libsAndLibDirs);
      
                    end if;
      
                  else
      
                    success := false;
      
                  end try;
      
        1144
                  timeCompile := System.realtimeTock(ClockIndexes.RT_CLOCK_BUILD_MODEL);
      
                else
      
                  timeCompile := 0.0;
      
                end if;
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1144 times.

        1144
                if Flags.isSet(Flags.DYN_LOAD) then
      
        ✗
                  Debug.trace("buildModel: Compiling done.\n");
      
                end if;
      
        1144
                resultValues := ("timeCompile",Values.REAL(timeCompile)) :: resultValues;
      
          1/2✓ Branch 0 taken 1144 times.
✗ Branch 1 not taken.

        1144
              then
      
                (cache,compileDir,filenameprefix,method_str,outputFormat_str,init_filename,simflags,resultValues,values,libsAndLibDirs);
      
            // failure
      
            else
      
              algorithm
      
        16
                Error.assertion(listLength(inValues) == 12, "buildModel failure, length = " + intString(listLength(inValues)), Absyn.dummyInfo);
      
        16
              then fail();
      
          end matchcontinue;
      
        end buildModel;
      
        function formatSimulationFlagsString
      
          "Formats a modification in the format expected by the simflags argument to buildModel."
      
          input Option<Absyn.Modification> mod;
      
          output String str;
      
        algorithm
      
          str := match mod
      
            local
      
              list<Absyn.ElementArg> args;
      
            case SOME(Absyn.CLASSMOD(elementArgLst = args))
      
        2
              then List.toStringCustom(args, formatSimulationFlagString, "", "-", " -", "", false);
      
            else "";
      
          end match;
      
        end formatSimulationFlagsString;
      
        function formatSimulationFlagString
      
          input Absyn.ElementArg arg;
      
          output String str;
      
        algorithm
      
          str := match arg
      
            local
      
              Absyn.Exp exp;
      
            case Absyn.ElementArg.MODIFICATION(modification =
      
                SOME(Absyn.Modification.CLASSMOD(eqMod = Absyn.EqMod.EQMOD(exp = exp))))
      
              then
      
                match exp
      
        1
                  case Absyn.STRING("()") then AbsynUtil.pathString(arg.path);
      
        1
                  else AbsynUtil.pathString(arg.path) + "=" + Dump.printExpStr(exp);
      
                end match;
      
            case Absyn.ElementArg.MODIFICATION()
      
        ✗
              then AbsynUtil.pathString(arg.path);
      
          end match;
      
        end formatSimulationFlagString;
      
        protected function createSimulationResultFromcallModelExecutable
      
        "This function calls the compiled simulation executable."
      
          input Boolean buildSuccess;
      
          input Integer callRet;
      
          input Real timeTotal;
      
          input Real timeSimulation;
      
          input list<tuple<String,Values.Value>> resultValues;
      
          input FCore.Cache inCache;
      
          input Absyn.Path className;
      
          input list<Values.Value> inVals;
      
          input String result_file;
      
          input String logFile;
      
          output FCore.Cache outCache;
      
          output Values.Value outValue;
      
        algorithm
      
          (outCache,outValue) := matchcontinue (buildSuccess,callRet)
      
            local
      
              String res,str;
      
              Values.Value simValue;
      
            case (false,_)
      
              algorithm
      
        2
                simValue := createSimulationResult(
      
                   result_file,
      
                   simOptionsAsString(inVals),
      
                   "Failed to build model: " + AbsynUtil.pathString(className),
      
                   ("timeTotal", Values.REAL(timeTotal)) ::
      
                   ("timeSimulation", Values.REAL(timeSimulation)) ::
      
                  resultValues);
      
              then (inCache,simValue);
      
            case (_,0)
      
              algorithm
      
        2316
                simValue := createSimulationResult(
      
                   result_file,
      
                   simOptionsAsString(inVals),
      
                   System.readFile(logFile),
      
                   ("timeTotal", Values.REAL(timeTotal)) ::
      
                   ("timeSimulation", Values.REAL(timeSimulation)) ::
      
                  resultValues);
      
        1158
                SymbolTable.addVar(
      
                  DAE.CREF_IDENT("currentSimulationResult", DAE.T_STRING_DEFAULT, {}),
      
                  Values.STRING(result_file), FGraph.empty());
      
              then
      
                (inCache,simValue);
      
            else
      
              algorithm
      
          1/2✓ Branch 1 taken 24 times.
✗ Branch 2 not taken.

        24
                res := if System.regularFileExists(logFile) then System.readFile(logFile) else (logFile + " does not exist");
      
        24
                str := AbsynUtil.pathString(className);
      
        24
                res := stringAppendList({"Simulation execution failed for model: ", str, "\n", res});
      
        48
                simValue := createSimulationResult("", simOptionsAsString(inVals), res,
      
                  ("timeTotal", Values.REAL(timeTotal)) ::
      
                  ("timeSimulation", Values.REAL(timeSimulation)) ::
      
                  resultValues);
      
              then
      
                (inCache,simValue);
      
          end matchcontinue;
      
        end createSimulationResultFromcallModelExecutable;
      
        public function checkModel " checks a model and returns number of variables and equations"
      
          input output FCore.Cache cache;
      
          input FCore.Graph env;
      
          input Absyn.Path className;
      
          input Absyn.Msg inMsg;
      
                output Values.Value outValue;
      
        algorithm
      
          outValue := matchcontinue ()
      
            local
      
              Option<DAE.DAElist> odae;
      
              DAE.DAElist dae;
      
              Integer eqnSize,varSize,simpleEqnSize;
      
              String retStr,classNameStr;
      
              Flags.Flag flags;
      
            // handle normal models
      
            case ()
      
              algorithm
      
        85
                ExecStat.execStatReset();
      
        85
                flags := loadCommandLineOptionsFromModel(className);
      
                try
      
        85
                  (cache, _, odae) := runFrontEnd(cache, env, className, false);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 85 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 82 times.

        85
                  SOME(dae) := odae;
      
        82
                  (varSize, eqnSize, simpleEqnSize) := CheckModel.checkModel(dae);
      
        82
                  FlagsUtil.saveFlags(flags);
      
                else
      
        3
                  FlagsUtil.saveFlags(flags);
      
        3
                  fail();
      
                end try;
      
        82
                classNameStr := AbsynUtil.pathString(className);
      
        164
                retStr := stringAppendList({"Check of ",classNameStr," completed successfully.\nClass ",classNameStr," has ",String(eqnSize)," equation(s) and ",
      
                  String(varSize)," variable(s).\n",String(simpleEqnSize)," of these are trivial equation(s)."});
      
        82
              then Values.STRING(retStr);
      
            case ()
      
              algorithm
      
          1/2✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.

        3
                false := Interactive.existClass(className, SymbolTable.getAbsyn());
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {AbsynUtil.pathString(className), "<TOP>"});
      
              then Values.STRING("");
      
            // errors
      
            else
      
              algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.

        3
                if Error.getNumMessages() == 0 then
      
        ✗
                  Error.addMessage(Error.INTERNAL_ERROR,
      
                    {"Check of " + AbsynUtil.pathString(className) + " failed with no error message","<TOP>"});
      
                end if;
      
              then Values.STRING("");
      
          end matchcontinue;
      
        end checkModel;
      
        protected function getWithinStatement "To get a correct Within-path with unknown input-path."
      
          input Absyn.Path ip;
      
          output Absyn.Within op;
      
        algorithm op :=  matchcontinue ip
      
          local Absyn.Path path;
      
        ✗
            case path algorithm path := AbsynUtil.stripLast(path); then Absyn.WITHIN(path);
      
            else Absyn.TOP();
      
          end matchcontinue;
      
        end getWithinStatement;
      
        protected function dumpXMLDAE " author: fildo
      
         This function outputs the DAE system corresponding to a specific model."
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input list<Values.Value> vals;
      
          input Absyn.Msg inMsg;
      
          output FCore.Cache outCache;
      
          output String xml_filename;
      
        algorithm
      
          (outCache,xml_filename) :=
      
          matchcontinue (inCache, inEnv, vals)
      
            local
      
              String cname_str,filenameprefix,compileDir,rewriteRulesFile,description;
      
              FCore.Graph env;
      
              Absyn.Path classname;
      
              BackendDAE.BackendDAE dlow,dlow_1,indexed_dlow;
      
              FCore.Cache cache;
      
              Boolean addOriginalAdjacencyMatrix,addSolvingInfo,addMathMLCode,dumpResiduals;
      
              DAE.DAElist dae;
      
            case (cache, env, {Values.CODE(Absyn.C_TYPENAME(classname)),Values.STRING(string="flat"),
      
                             Values.BOOL(addOriginalAdjacencyMatrix),Values.BOOL(addSolvingInfo),
      
                             Values.BOOL(addMathMLCode),Values.BOOL(dumpResiduals),
      
                             Values.STRING(filenameprefix),Values.STRING(rewriteRulesFile)})
      
              algorithm
      
        1
                Error.clearMessages() "Clear messages";
      
                // set the rewrite rules flag
      
        1
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, rewriteRulesFile);
      
                // load the rewrite rules
      
        1
                RewriteRules.loadRules();
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
                (cache, env, SOME(dae), _) := runFrontEnd(cache, env, classname, true, transform = true);
      
        1
                description := DAEUtil.daeDescription(dae);
      
        1
                compileDir := System.pwd() + Autoconf.pathDelimiter;
      
        1
                cname_str := AbsynUtil.pathString(classname);
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
                filenameprefix := if filenameprefix == "<default>" then cname_str else filenameprefix;
      
        1
                dlow := BackendDAECreate.lower(dae,cache,env,BackendDAE.EXTRA_INFO(description,filenameprefix,NONE())); //Verificare cosa fa
      
        1
                dlow_1 := BackendDAEUtil.preOptimizeBackendDAE(dlow,NONE());
      
        1
                dlow_1 := FindZeroCrossings.findZeroCrossings(dlow_1);
      
        1
                xml_filename := stringAppendList({filenameprefix,".xml"});
      
                // apply rewrite rules to the back-end
      
        1
                dlow_1 := applyRewriteRulesOnBackend(dlow_1);
      
        1
                Print.clearBuf();
      
        1
                XMLDump.dumpBackendDAE(dlow_1,addOriginalAdjacencyMatrix,addSolvingInfo,addMathMLCode,dumpResiduals,false);
      
        1
                Print.writeBuf(xml_filename);
      
        1
                Print.clearBuf();
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        1
                compileDir := if Testsuite.isRunning() then "" else compileDir;
      
                // clear the rewrite rules!
      
        1
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, "");
      
        1
                RewriteRules.clearRules();
      
        1
              then
      
                (cache,stringAppendList({compileDir,xml_filename}));
      
            case (cache, env, {Values.CODE(Absyn.C_TYPENAME(classname)),Values.STRING(string="optimiser"),
      
                             Values.BOOL(addOriginalAdjacencyMatrix),Values.BOOL(addSolvingInfo),
      
                             Values.BOOL(addMathMLCode),Values.BOOL(dumpResiduals),
      
                             Values.STRING(filenameprefix),Values.STRING(rewriteRulesFile)})
      
              algorithm
      
                //asInSimulationCode==false => it's NOT necessary to do all the translation's steps before dumping with xml
      
        1
                Error.clearMessages() "Clear messages";
      
                // set the rewrite rules flag
      
        1
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, rewriteRulesFile);
      
                // load the rewrite rules
      
        1
                RewriteRules.loadRules();
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
                (cache, env, SOME(dae), _) := runFrontEnd(cache, env, classname, true, transform = true);
      
        1
                description := DAEUtil.daeDescription(dae);
      
        1
                compileDir := System.pwd() + Autoconf.pathDelimiter;
      
        1
                cname_str := AbsynUtil.pathString(classname);
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
                filenameprefix := if filenameprefix == "<default>" then cname_str else filenameprefix;
      
        1
                dlow := BackendDAECreate.lower(dae,cache,env,BackendDAE.EXTRA_INFO(description,filenameprefix,NONE())); //Verificare cosa fa
      
        1
                dlow_1 := BackendDAEUtil.preOptimizeBackendDAE(dlow,NONE());
      
        1
                dlow_1 := BackendDAEUtil.transformBackendDAE(dlow_1,NONE(),NONE(),NONE());
      
        1
                dlow_1 := FindZeroCrossings.findZeroCrossings(dlow_1);
      
        1
                xml_filename := stringAppendList({filenameprefix,".xml"});
      
                // apply rewrite rules to the back-end
      
        1
                dlow_1 := applyRewriteRulesOnBackend(dlow_1);
      
        1
                Print.clearBuf();
      
        1
                XMLDump.dumpBackendDAE(dlow_1,addOriginalAdjacencyMatrix,addSolvingInfo,addMathMLCode,dumpResiduals,false);
      
        1
                Print.writeBuf(xml_filename);
      
        1
                Print.clearBuf();
      
          1/2✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.

        1
                compileDir := if Testsuite.isRunning() then "" else compileDir;
      
                // clear the rewrite rules!
      
        1
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, "");
      
        1
                RewriteRules.clearRules();
      
        1
              then
      
                (cache,stringAppendList({compileDir,xml_filename}));
      
            case (cache, env, {Values.CODE(Absyn.C_TYPENAME(classname)),Values.STRING(string="backEnd"),
      
                             Values.BOOL(addOriginalAdjacencyMatrix),Values.BOOL(addSolvingInfo),
      
                             Values.BOOL(addMathMLCode),Values.BOOL(dumpResiduals),
      
                             Values.STRING(filenameprefix),Values.STRING(rewriteRulesFile)})
      
              algorithm
      
                //asInSimulationCode==true => it's necessary to do all the translation's steps before dumping with xml
      
        ✗
                Error.clearMessages() "Clear messages";
      
                // set the rewrite rules flag
      
        ✗
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, rewriteRulesFile);
      
                // load the rewrite rules
      
        ✗
                RewriteRules.loadRules();
      
        ✗
                (cache, env, SOME(dae), _) := runFrontEnd(cache, env, classname, true, transform = true);
      
        ✗
                description := DAEUtil.daeDescription(dae);
      
        ✗
                compileDir := System.pwd() + Autoconf.pathDelimiter;
      
        ✗
                cname_str := AbsynUtil.pathString(classname);
      
        ✗
                filenameprefix := if filenameprefix == "<default>" then cname_str else filenameprefix;
      
        ✗
                dlow := BackendDAECreate.lower(dae,cache,env,BackendDAE.EXTRA_INFO(description,filenameprefix, NONE()));
      
        ✗
                indexed_dlow := BackendDAEUtil.getSolvedSystem(dlow,"");
      
        ✗
                xml_filename := stringAppendList({filenameprefix,".xml"});
      
                // apply rewrite rules to the back-end
      
        ✗
                indexed_dlow := applyRewriteRulesOnBackend(indexed_dlow);
      
        ✗
                Print.clearBuf();
      
        ✗
                XMLDump.dumpBackendDAE(indexed_dlow,addOriginalAdjacencyMatrix,addSolvingInfo,addMathMLCode,dumpResiduals,false);
      
        ✗
                Print.writeBuf(xml_filename);
      
        ✗
                Print.clearBuf();
      
        ✗
                compileDir := if Testsuite.isRunning() then "" else compileDir;
      
                // clear the rewrite rules!
      
        ✗
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, "");
      
        ✗
                RewriteRules.clearRules();
      
        ✗
              then
      
                (cache,stringAppendList({compileDir,xml_filename}));
      
            case (cache, env, {Values.CODE(Absyn.C_TYPENAME(classname)),Values.STRING(string="stateSpace"),
      
                             Values.BOOL(addOriginalAdjacencyMatrix),Values.BOOL(addSolvingInfo),
      
                             Values.BOOL(addMathMLCode),Values.BOOL(dumpResiduals),
      
                             Values.STRING(filenameprefix),Values.STRING(rewriteRulesFile)})
      
              algorithm
      
                //asInSimulationCode==true => it's necessary to do all the translation's steps before dumping with xml
      
        ✗
                Error.clearMessages() "Clear messages";
      
                // set the rewrite rules flag
      
        ✗
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, rewriteRulesFile);
      
                // load the rewrite rules
      
        ✗
                RewriteRules.loadRules();
      
        ✗
                (cache, env, SOME(dae), _) := runFrontEnd(cache, env, classname, true, transform = true);
      
        ✗
                description := DAEUtil.daeDescription(dae);
      
        ✗
                compileDir := System.pwd() + Autoconf.pathDelimiter;
      
        ✗
                cname_str := AbsynUtil.pathString(classname);
      
        ✗
                filenameprefix := if filenameprefix == "<default>" then cname_str else filenameprefix;
      
        ✗
                dlow := BackendDAECreate.lower(dae,cache,env,BackendDAE.EXTRA_INFO(description,filenameprefix,NONE()));
      
        ✗
                indexed_dlow := BackendDAEUtil.getSolvedSystem(dlow,"");
      
        ✗
                xml_filename := stringAppendList({filenameprefix,".xml"});
      
                // apply rewrite rules to the back-end
      
        ✗
                indexed_dlow := applyRewriteRulesOnBackend(indexed_dlow);
      
        ✗
                Print.clearBuf();
      
        ✗
                XMLDump.dumpBackendDAE(indexed_dlow,addOriginalAdjacencyMatrix,addSolvingInfo,addMathMLCode,dumpResiduals,true);
      
        ✗
                Print.writeBuf(xml_filename);
      
        ✗
                Print.clearBuf();
      
        ✗
                compileDir := if Testsuite.isRunning() then "" else compileDir;
      
                // clear the rewrite rules!
      
        ✗
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, "");
      
        ✗
                RewriteRules.clearRules();
      
        ✗
              then
      
                (cache,stringAppendList({compileDir,xml_filename}));
      
            else
      
            algorithm
      
                // clear the rewrite rules if we fail!
      
        ✗
                FlagsUtil.setConfigString(Flags.REWRITE_RULES_FILE, "");
      
        ✗
                RewriteRules.clearRules();
      
        ✗
            then fail();
      
          end matchcontinue;
      
        end dumpXMLDAE;
      
        protected function applyRewriteRulesOnBackend
      
          input BackendDAE.BackendDAE inBackendDAE;
      
          output BackendDAE.BackendDAE outBackendDAE;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.

        2
          outBackendDAE := if RewriteRules.noRewriteRulesBackEnd() then inBackendDAE
      
                           else BackendDAEOptimize.applyRewriteRulesBackend(inBackendDAE);
      
        end applyRewriteRulesOnBackend;
      
        protected function getClassnamesInClassList
      
          input Absyn.Path inPath;
      
          input Absyn.Program inProgram;
      
          input Absyn.Class inClass;
      
          input Boolean inShowProtected;
      
          output list<String> outStrings;
      
        algorithm
      
          outStrings :=
      
          match (inClass, inShowProtected)
      
            local
      
              list<String> strlist;
      
              list<Absyn.ClassPart> parts;
      
              Boolean b;
      
            case (Absyn.CLASS(body = Absyn.PARTS(classParts = parts)), b)
      
              algorithm
      
        ✗
                strlist := ProgramUtil.getClassnamesInParts(parts,b,false);
      
              then
      
                strlist;
      
            case (Absyn.CLASS(body = Absyn.DERIVED(typeSpec=Absyn.TPATH())), _)
      
              algorithm
      
              then
      
                {};
      
            case (Absyn.CLASS(body = Absyn.OVERLOAD(_, _)), _)
      
              algorithm
      
              then {};
      
            case (Absyn.CLASS(body = Absyn.ENUMERATION(_, _)), _)
      
              algorithm
      
              then {};
      
            case (Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts=parts)), b)
      
              algorithm
      
        ✗
                strlist := ProgramUtil.getClassnamesInParts(parts,b,false);
      
              then strlist;
      
            case (Absyn.CLASS(body = Absyn.PDER(_,_,_)), _)
      
              algorithm
      
              then {};
      
          end match;
      
        end getClassnamesInClassList;
      
        protected function joinPaths
      
          input String child;
      
          input Absyn.Path parent;
      
          output Absyn.Path outPath;
      
        algorithm
      
          outPath := match (child, parent)
      
            local
      
              Absyn.Path r, res;
      
              String c;
      
            case (c, r)
      
              algorithm
      
        ✗
                res := AbsynUtil.joinPaths(r, Absyn.IDENT(c));
      
              then res;
      
          end match;
      
        end joinPaths;
      
        protected function getAllClassPathsRecursive
      
        "@author adrpo
      
         Returns all paths of the classes recursively defined in a given class with the specified path."
      
          input Absyn.Path inPath "the given class path";
      
          input Boolean inCheckProtected;
      
          input Absyn.Program inProgram "the program";
      
          output list<Absyn.Path> outPaths;
      
        algorithm
      
          outPaths :=
      
          matchcontinue (inCheckProtected, inProgram)
      
            local
      
              Absyn.Class cdef;
      
              String parent_string, s;
      
              list<String> strlst;
      
              Absyn.Program p;
      
              list<Absyn.Path> result_path_lst, result;
      
              Boolean b;
      
            case (b, p)
      
              algorithm
      
        ✗
                cdef := ProgramUtil.getPathedClassInProgram(inPath, p);
      
        ✗
                strlst := getClassnamesInClassList(inPath, p, cdef, b);
      
        ✗
                result_path_lst := List.map1(strlst, joinPaths, inPath);
      
        ✗
                result := List.flatten(List.map2(result_path_lst, getAllClassPathsRecursive, b, p));
      
              then
      
                inPath::result;
      
            else
      
              algorithm
      
        ✗
                parent_string := AbsynUtil.pathString(inPath);
      
        ✗
                s := Error.printMessagesStr(false);
      
        ✗
                s := stringAppendList({parent_string,"->","PROBLEM GETTING CLASS PATHS: ", s, "\n"});
      
        ✗
                print(s);
      
              then {};
      
          end matchcontinue;
      
        end getAllClassPathsRecursive;
      
        public function checkAllModelsRecursive
      
        "@author adrpo
      
         checks all models and returns number of variables and equations"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input Absyn.Path className;
      
          input Boolean inCheckProtected;
      
          input Absyn.Msg inMsg;
      
          output FCore.Cache outCache;
      
          output Values.Value outValue;
      
        algorithm
      
          (outCache,outValue):=
      
          matchcontinue (inCache, inEnv, inCheckProtected, inMsg)
      
            local
      
              list<Absyn.Path> allClassPaths;
      
              Absyn.Msg msg;
      
              FCore.Cache cache;
      
              String ret;
      
              FCore.Graph env;
      
              Boolean b;
      
              Integer failed;
      
            case (cache, env, b, msg)
      
              algorithm
      
        ✗
                allClassPaths := getAllClassPathsRecursive(className, b, SymbolTable.getAbsyn());
      
        ✗
                print("Number of classes to check: " + intString(listLength(allClassPaths)) + "\n");
      
                // print ("All paths:\n" + stringDelimitList(List.map(allClassPaths, AbsynUtil.pathString), "\n") + "\n");
      
        ✗
                failed := checkAll(cache, env, allClassPaths, msg, not Testsuite.isRunning(), 0);
      
        ✗
                ret := "Number of classes checked / failed: " + intString(listLength(allClassPaths)) + "/" + intString(failed);
      
        ✗
              then
      
                (cache,Values.STRING(ret));
      
            case (cache, _, _, _)
      
              algorithm
      
        ✗
                ret := stringAppend("Error checking: ", AbsynUtil.pathString(className));
      
        ✗
            then
      
              (cache,Values.STRING(ret));
      
          end matchcontinue;
      
        end checkAllModelsRecursive;
      
        function failOrSuccess
      
        "@author adrpo"
      
          input String inStr;
      
          output String outStr;
      
          output Boolean failed = false;
      
        algorithm
      
          outStr := matchcontinue inStr
      
            local Integer res;
      
            case _
      
              algorithm
      
        ✗
                res := System.stringFind(inStr, "successfully");
      
        ✗
                true := (res >= 0);
      
                failed := false;
      
              then
      
                "OK";
      
            else
      
              algorithm
      
                failed := true;
      
              then
      
                "FAILED!";
      
          end matchcontinue;
      
        end failOrSuccess;
      
        function checkAll
      
        "@author adrpo
      
         checks all models and returns number of variables and equations"
      
          input FCore.Cache inCache;
      
          input FCore.Graph inEnv;
      
          input list<Absyn.Path> allClasses;
      
          input Absyn.Msg inMsg;
      
          input Boolean reportTimes;
      
          input output Integer failed;
      
        protected
      
          Absyn.Program p;
      
          list<Absyn.Path> rest;
      
          Absyn.Path className;
      
          String str, s, smsg;
      
          Real t1, t2, elapsedTime;
      
          Absyn.Class c;
      
          Boolean f = false;
      
        algorithm
      
        ✗
          p := SymbolTable.getAbsyn();
      
          () := matchcontinue allClasses
      
            case {} then ();
      
            case className::rest
      
              algorithm
      
        ✗
                c := ProgramUtil.getPathedClassInProgram(className, p);
      
                // filter out partial classes
      
                // Absyn.CLASS(partialPrefix = false) = c; // do not filter partial classes
      
                // filter out packages
      
        ✗
                false := Interactive.isPackage(className, p);
      
                // filter out functions
      
                // false = Interactive.isFunction(cr, p);
      
                // filter out types
      
        ✗
                false := Interactive.isType(className, p);
      
        ✗
                print("Checking: " + Dump.unparseClassAttributesStr(c) + " " + AbsynUtil.pathString(className) + "... ");
      
        ✗
                t1 := clock();
      
        ✗
                FlagsUtil.setConfigBool(Flags.CHECK_MODEL, true);
      
        ✗
                (_,Values.STRING(str)) := checkModel(FCore.emptyCache(), inEnv, className, inMsg);
      
        ✗
                FlagsUtil.setConfigBool(Flags.CHECK_MODEL, false);
      
        ✗
                t2 := clock();
      
        ✗
                elapsedTime := t2 - t1;
      
        ✗
                s := realString(elapsedTime);
      
        ✗
                (smsg, f) := failOrSuccess(str);
      
        ✗
                failed := if f then failed + 1 else failed;
      
        ✗
                if reportTimes then
      
        ✗
                  print (s + " seconds -> " + smsg + "\n");
      
                else
      
        ✗
                  print(smsg + "\n");
      
                end if;
      
        ✗
                if not stringEmpty(str) then
      
        ✗
                  print("\t");
      
                end if;
      
        ✗
                print (System.stringReplace(str, "\n", "\n\t"));
      
        ✗
                print ("\n");
      
        ✗
                print ("Error String:\n" + Print.getErrorString() + "\n");
      
        ✗
                print ("Error Buffer:\n" + ErrorExt.printMessagesStr(false) + "\n");
      
        ✗
                print ("#" + (if f then "[-]" else "[+]") + ", " +
      
                  (if reportTimes then realString(elapsedTime) + ", " else "") +
      
                  AbsynUtil.pathString(className) + "\n");
      
        ✗
                print ("-------------------------------------------------------------------------\n");
      
        ✗
                failed := checkAll(inCache, inEnv, rest, inMsg, reportTimes, failed);
      
              then ();
      
            case className::rest
      
              algorithm
      
        ✗
                c := ProgramUtil.getPathedClassInProgram(className, p);
      
        ✗
                print("Checking skipped: " + Dump.unparseClassAttributesStr(c) + " " + AbsynUtil.pathString(className) + "...\n");
      
        ✗
                failed := checkAll(inCache, inEnv, rest, inMsg, reportTimes, failed);
      
              then
      
                ();
      
          end matchcontinue;
      
        end checkAll;
      
        protected function getAlgorithms
      
        "Counts the number of Algorithm sections in a class."
      
          input Absyn.Class inClass;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inClass
      
            local
      
              list<Absyn.ClassPart> algsList;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                algsList := getAlgorithmsInClassParts(parts);
      
              then
      
                algsList;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                algsList := getAlgorithmsInClassParts(parts);
      
              then
      
                algsList;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getAlgorithms;
      
        protected function getAlgorithmsInClassParts
      
        "Helper function to getAlgorithms"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inAbsynClassPartLst
      
            local
      
              list<Absyn.ClassPart> algsList;
      
              list<Absyn.ClassPart> xs;
      
              Absyn.ClassPart cp;
      
            case (cp as Absyn.ALGORITHMS()) :: xs
      
              algorithm
      
        ✗
                algsList := getAlgorithmsInClassParts(xs);
      
              then
      
                cp::algsList;
      
            case _ :: xs
      
              algorithm
      
        ✗
                algsList := getAlgorithmsInClassParts(xs);
      
              then
      
                algsList;
      
            case {} then {};
      
          end match;
      
        end getAlgorithmsInClassParts;
      
        protected function getNthAlgorithm
      
        "Returns the Nth Algorithm section from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
          protected list<Absyn.ClassPart> algsList;
      
        algorithm
      
        ✗
          algsList := getAlgorithms(inClass);
      
        ✗
          outString := getNthAlgorithmInClass(listGet(algsList, inInteger));
      
        end getNthAlgorithm;
      
        protected function getNthAlgorithmInClass
      
        "Helper function to getNthAlgorithm."
      
          input Absyn.ClassPart inClassPart;
      
          output String outString;
      
        algorithm
      
          outString := match inClassPart
      
            local
      
              String str;
      
              list<Absyn.AlgorithmItem> algs;
      
          case Absyn.ALGORITHMS(contents = algs)
      
              algorithm
      
        ✗
                str := Dump.unparseAlgorithmStrLst(algs, "\n");
      
              then
      
                str;
      
          end match;
      
        end getNthAlgorithmInClass;
      
        protected function getInitialAlgorithms
      
        "Counts the number of Initial Algorithm sections in a class."
      
          input Absyn.Class inClass;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inClass
      
            local
      
              list<Absyn.ClassPart> algsList;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                algsList := getInitialAlgorithmsInClassParts(parts);
      
              then
      
                algsList;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                algsList := getInitialAlgorithmsInClassParts(parts);
      
              then
      
                algsList;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getInitialAlgorithms;
      
        protected function getInitialAlgorithmsInClassParts
      
        "Helper function to getInitialAlgorithms"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inAbsynClassPartLst
      
            local
      
              list<Absyn.ClassPart> algsList;
      
              list<Absyn.ClassPart> xs;
      
              Absyn.ClassPart cp;
      
            case (cp as Absyn.INITIALALGORITHMS()) :: xs
      
              algorithm
      
        ✗
                algsList := getInitialAlgorithmsInClassParts(xs);
      
              then
      
                cp::algsList;
      
            case _ :: xs
      
              algorithm
      
        ✗
                algsList := getInitialAlgorithmsInClassParts(xs);
      
              then
      
                algsList;
      
            case {} then {};
      
          end match;
      
        end getInitialAlgorithmsInClassParts;
      
        protected function getNthInitialAlgorithm
      
        "Returns the Nth Initial Algorithm section from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
          protected list<Absyn.ClassPart> algsList;
      
        algorithm
      
        ✗
          algsList := getInitialAlgorithms(inClass);
      
        ✗
          outString := getNthInitialAlgorithmInClass(listGet(algsList, inInteger));
      
        end getNthInitialAlgorithm;
      
        protected function getNthInitialAlgorithmInClass
      
        "Helper function to getNthInitialAlgorithm."
      
          input Absyn.ClassPart inClassPart;
      
          output String outString;
      
        algorithm
      
          outString := match inClassPart
      
            local
      
              String str;
      
              list<Absyn.AlgorithmItem> algs;
      
          case Absyn.INITIALALGORITHMS(contents = algs)
      
              algorithm
      
        ✗
                str := Dump.unparseAlgorithmStrLst(algs, "\n");
      
              then
      
                str;
      
          end match;
      
        end getNthInitialAlgorithmInClass;
      
        protected function getAlgorithmItemsCount
      
        "Counts the number of Algorithm items in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inClass
      
            local
      
              list<Absyn.ClassPart> parts;
      
              Integer count;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                count := getAlgorithmItemsCountInClassParts(parts);
      
              then
      
                count;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                count := getAlgorithmItemsCountInClassParts(parts);
      
              then
      
                count;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then 0;
      
          end match;
      
        end getAlgorithmItemsCount;
      
        protected function getAlgorithmItemsCountInClassParts
      
        "Helper function to getAlgorithmItemsCount"
      
         input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynClassPartLst
      
            local
      
              list<Absyn.AlgorithmItem> algs;
      
              list<Absyn.ClassPart> xs;
      
              Integer c1, c2, res;
      
            case Absyn.ALGORITHMS(contents = algs) :: xs
      
              algorithm
      
        ✗
                c1 := getAlgorithmItemsCountInAlgorithmItems(algs);
      
                c2 := getAlgorithmItemsCountInClassParts(xs);
      
              then
      
                c1 + c2;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getAlgorithmItemsCountInClassParts(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getAlgorithmItemsCountInClassParts;
      
        protected function getAlgorithmItemsCountInAlgorithmItems
      
        "Helper function to getAlgorithmItemsCountInClassParts"
      
          input list<Absyn.AlgorithmItem> inAbsynAlgorithmItemLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynAlgorithmItemLst
      
            local
      
              list<Absyn.AlgorithmItem> xs;
      
              Integer c1, res;
      
            case Absyn.ALGORITHMITEM() :: xs
      
              algorithm
      
                c1 := getAlgorithmItemsCountInAlgorithmItems(xs);
      
              then
      
                c1 + 1;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getAlgorithmItemsCountInAlgorithmItems(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getAlgorithmItemsCountInAlgorithmItems;
      
        protected function getNthAlgorithmItem
      
        "Returns the Nth Algorithm Item from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
        protected
      
          list<Absyn.ClassPart> parts;
      
        algorithm
      
          outString := match inClass
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
        ✗
              then getNthAlgorithmItemInClassParts(parts,inInteger);
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
        ✗
              then getNthAlgorithmItemInClassParts(parts,inInteger);
      
          end match;
      
        end getNthAlgorithmItem;
      
        protected function getNthAlgorithmItemInClassParts
      
        "Helper function to getNthAlgorithmItem"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue (inAbsynClassPartLst,inInteger)
      
            local
      
              String str;
      
              list<Absyn.AlgorithmItem> algs;
      
              list<Absyn.ClassPart> xs;
      
              Integer n,c1,newn;
      
            case ((Absyn.ALGORITHMS(contents = algs) :: _),n)
      
              algorithm
      
        ✗
                str := getNthAlgorithmItemInAlgorithms(algs, n);
      
              then
      
                str;
      
            case ((Absyn.ALGORITHMS(contents = algs) :: xs),n) /* The rule above failed, subtract the number of algorithms in the first section and try with the rest of the classparts */
      
              algorithm
      
        ✗
                c1 := getAlgorithmItemsCountInAlgorithmItems(algs);
      
        ✗
                newn := n - c1;
      
        ✗
                str := getNthAlgorithmItemInClassParts(xs, newn);
      
              then
      
                str;
      
            case ((_ :: xs),n)
      
              algorithm
      
        ✗
                str := getNthAlgorithmItemInClassParts(xs, n);
      
              then
      
                str;
      
          end matchcontinue;
      
        end getNthAlgorithmItemInClassParts;
      
        protected function getNthAlgorithmItemInAlgorithms
      
        " This function takes an Algorithm list and an int
      
           and returns the nth algorithm item as String.
      
           If the number is larger than the number of algorithms
      
           in the list, the function fails. Helper function to getNthAlgorithmItemInClassParts."
      
          input list<Absyn.AlgorithmItem> inAbsynAlgorithmItemLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue (inAbsynAlgorithmItemLst,inInteger)
      
            local
      
              String str;
      
              Absyn.Algorithm alg;
      
              Option<Absyn.Comment> cmt;
      
              SourceInfo inf;
      
              list<Absyn.AlgorithmItem> xs;
      
              Integer newn,n;
      
            case ((Absyn.ALGORITHMITEM(algorithm_ = alg, comment = cmt, info = inf) :: _), 1)
      
              algorithm
      
        ✗
                str := Dump.unparseAlgorithmStr(Absyn.ALGORITHMITEM(alg, cmt, inf));
      
              then
      
                str;
      
            case ((_ :: xs),n)
      
              algorithm
      
        ✗
                newn := n - 1;
      
        ✗
                str := getNthAlgorithmItemInAlgorithms(xs, newn);
      
              then
      
                str;
      
            case ({},_) then fail();
      
          end matchcontinue;
      
        end getNthAlgorithmItemInAlgorithms;
      
        protected function getInitialAlgorithmItemsCount
      
        "Counts the number of Initial Algorithm items in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inClass
      
            local
      
              list<Absyn.ClassPart> parts;
      
              Integer count;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                count := getInitialAlgorithmItemsCountInClassParts(parts);
      
              then
      
                count;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                count := getInitialAlgorithmItemsCountInClassParts(parts);
      
              then
      
                count;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then 0;
      
          end match;
      
        end getInitialAlgorithmItemsCount;
      
        protected function getInitialAlgorithmItemsCountInClassParts
      
        "Helper function to getInitialAlgorithmItemsCount"
      
         input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynClassPartLst
      
            local
      
              list<Absyn.AlgorithmItem> algs;
      
              list<Absyn.ClassPart> xs;
      
              Integer c1, c2, res;
      
            case Absyn.INITIALALGORITHMS(contents = algs) :: xs
      
              algorithm
      
        ✗
                c1 := getAlgorithmItemsCountInAlgorithmItems(algs);
      
                c2 := getInitialAlgorithmItemsCountInClassParts(xs);
      
              then
      
                c1 + c2;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getInitialAlgorithmItemsCountInClassParts(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getInitialAlgorithmItemsCountInClassParts;
      
        protected function getNthInitialAlgorithmItem
      
        "Returns the Nth Initial Algorithm Item from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := match (inClass,inInteger)
      
            local
      
              list<Absyn.ClassPart> parts;
      
              String str;
      
              Integer n;
      
            case (Absyn.CLASS(body = Absyn.PARTS(classParts = parts)),n)
      
              algorithm
      
        ✗
                str := getNthInitialAlgorithmItemInClassParts(parts,n);
      
              then
      
                str;
      
            // check also the case model extends X end X;
      
            case (Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts)),n)
      
              algorithm
      
        ✗
                str := getNthInitialAlgorithmItemInClassParts(parts,n);
      
              then
      
                str;
      
          end match;
      
        end getNthInitialAlgorithmItem;
      
        protected function getNthInitialAlgorithmItemInClassParts
      
        "Helper function to getNthInitialAlgorithmItem"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue (inAbsynClassPartLst,inInteger)
      
            local
      
              String str;
      
              list<Absyn.AlgorithmItem> algs;
      
              list<Absyn.ClassPart> xs;
      
              Integer n,c1,newn;
      
            case ((Absyn.INITIALALGORITHMS(contents = algs) :: _),n)
      
              algorithm
      
        ✗
                str := getNthAlgorithmItemInAlgorithms(algs, n);
      
              then
      
                str;
      
            case ((Absyn.INITIALALGORITHMS(contents = algs) :: xs),n) /* The rule above failed, subtract the number of algorithms in the first section and try with the rest of the classparts */
      
              algorithm
      
        ✗
                c1 := getAlgorithmItemsCountInAlgorithmItems(algs);
      
        ✗
                newn := n - c1;
      
        ✗
                str := getNthInitialAlgorithmItemInClassParts(xs, newn);
      
              then
      
                str;
      
            case ((_ :: xs),n)
      
              algorithm
      
        ✗
                str := getNthInitialAlgorithmItemInClassParts(xs, n);
      
              then
      
                str;
      
          end matchcontinue;
      
        end getNthInitialAlgorithmItemInClassParts;
      
        protected function getEquations
      
        "Counts the number of Equation sections in a class."
      
          input Absyn.Class inClass;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inClass
      
            local
      
              list<Absyn.ClassPart> eqsList;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                eqsList := getEquationsInClassParts(parts);
      
              then
      
                eqsList;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                eqsList := getEquationsInClassParts(parts);
      
              then
      
                eqsList;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getEquations;
      
        protected function getEquationsInClassParts
      
        "Helper function to getEquations"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inAbsynClassPartLst
      
            local
      
              list<Absyn.ClassPart> eqsList;
      
              list<Absyn.ClassPart> xs;
      
              Absyn.ClassPart cp;
      
            case (cp as Absyn.EQUATIONS()) :: xs
      
              algorithm
      
        ✗
                eqsList := getEquationsInClassParts(xs);
      
              then
      
                cp::eqsList;
      
            case _ :: xs
      
              algorithm
      
        ✗
                eqsList := getEquationsInClassParts(xs);
      
              then
      
                eqsList;
      
            case {} then {};
      
          end match;
      
        end getEquationsInClassParts;
      
        protected function getNthEquation
      
        "Returns the Nth Equation section from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
          protected list<Absyn.ClassPart> eqsList;
      
        algorithm
      
        ✗
          eqsList := getEquations(inClass);
      
        ✗
          outString := getNthEquationInClass(listGet(eqsList, inInteger));
      
        end getNthEquation;
      
        protected function getNthEquationInClass
      
        "Helper function to getNthEquation"
      
          input Absyn.ClassPart inClassPart;
      
          output String outString;
      
        algorithm
      
          outString := match inClassPart
      
            local
      
              String str;
      
              list<Absyn.EquationItem> eqs;
      
          case Absyn.EQUATIONS(contents = eqs)
      
              algorithm
      
        ✗
                str := Dump.unparseEquationItemStrLst(eqs, "\n");
      
              then
      
                str;
      
          end match;
      
        end getNthEquationInClass;
      
        protected function getInitialEquations
      
        "Counts the number of Initial Equation sections in a class."
      
          input Absyn.Class inClass;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inClass
      
            local
      
              list<Absyn.ClassPart> eqsList;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                eqsList := getInitialEquationsInClassParts(parts);
      
              then
      
                eqsList;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                eqsList := getInitialEquationsInClassParts(parts);
      
              then
      
                eqsList;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getInitialEquations;
      
        protected function getInitialEquationsInClassParts
      
        "Helper function to getInitialEquations"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<Absyn.ClassPart> outList;
      
        algorithm
      
          outList := match inAbsynClassPartLst
      
            local
      
              list<Absyn.ClassPart> eqsList;
      
              list<Absyn.ClassPart> xs;
      
              Absyn.ClassPart cp;
      
            case (cp as Absyn.INITIALEQUATIONS()) :: xs
      
              algorithm
      
        ✗
                eqsList := getInitialEquationsInClassParts(xs);
      
              then
      
                cp::eqsList;
      
            case _ :: xs
      
              algorithm
      
        ✗
                eqsList := getInitialEquationsInClassParts(xs);
      
              then
      
                eqsList;
      
            case {} then {};
      
          end match;
      
        end getInitialEquationsInClassParts;
      
        protected function getNthInitialEquation
      
        "Returns the Nth Initial Equation section from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
          protected list<Absyn.ClassPart> eqsList;
      
        algorithm
      
        ✗
          eqsList := getInitialEquations(inClass);
      
        ✗
          outString := getNthInitialEquationInClass(listGet(eqsList, inInteger));
      
        end getNthInitialEquation;
      
        protected function getNthInitialEquationInClass
      
        "Helper function to getNthInitialEquation."
      
          input Absyn.ClassPart inClassPart;
      
          output String outString;
      
        algorithm
      
          outString := match inClassPart
      
            local
      
              String str;
      
              list<Absyn.EquationItem> eqs;
      
          case Absyn.INITIALEQUATIONS(contents = eqs)
      
              algorithm
      
        ✗
                str := Dump.unparseEquationItemStrLst(eqs, "\n");
      
              then
      
                str;
      
          end match;
      
        end getNthInitialEquationInClass;
      
        protected function getEquationItemsCount
      
        "Counts the number of Equation items in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inClass
      
            local
      
              list<Absyn.ClassPart> parts;
      
              Integer count;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                count := getEquationItemsCountInClassParts(parts);
      
              then
      
                count;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                count := getEquationItemsCountInClassParts(parts);
      
              then
      
                count;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then 0;
      
          end match;
      
        end getEquationItemsCount;
      
        protected function getEquationItemsCountInClassParts
      
        "Helper function to getEquationItemsCount"
      
         input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynClassPartLst
      
            local
      
              list<Absyn.EquationItem> eqs;
      
              list<Absyn.ClassPart> xs;
      
              Integer c1, c2, res;
      
            case Absyn.EQUATIONS(contents = eqs) :: xs
      
              algorithm
      
        ✗
                c1 := getEquationItemsCountInEquationItems(eqs);
      
                c2 := getEquationItemsCountInClassParts(xs);
      
              then
      
                c1 + c2;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getEquationItemsCountInClassParts(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getEquationItemsCountInClassParts;
      
        protected function getEquationItemsCountInEquationItems
      
        "Helper function to getEquationItemsCountInClassParts"
      
          input list<Absyn.EquationItem> inAbsynEquationItemLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynEquationItemLst
      
            local
      
              list<Absyn.EquationItem> xs;
      
              Integer c1, res;
      
            case Absyn.EQUATIONITEM() :: xs
      
              algorithm
      
                c1 := getEquationItemsCountInEquationItems(xs);
      
              then
      
                c1 + 1;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getEquationItemsCountInEquationItems(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getEquationItemsCountInEquationItems;
      
        protected function getNthEquationItem
      
        "Returns the Nth Equation Item from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := match (inClass,inInteger)
      
            local
      
              list<Absyn.ClassPart> parts;
      
              String str;
      
              Integer n;
      
            case (Absyn.CLASS(body = Absyn.PARTS(classParts = parts)),n)
      
              algorithm
      
        ✗
                str := getNthEquationItemInClassParts(parts,n);
      
              then
      
                str;
      
            // check also the case model extends X end X;
      
            case (Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts)),n)
      
              algorithm
      
        ✗
                str := getNthEquationItemInClassParts(parts,n);
      
              then
      
                str;
      
          end match;
      
        end getNthEquationItem;
      
        protected function getNthEquationItemInClassParts
      
        "Helper function to getNthEquationItem"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue (inAbsynClassPartLst,inInteger)
      
            local
      
              String str;
      
              list<Absyn.EquationItem> eqs;
      
              list<Absyn.ClassPart> xs;
      
              Integer n,c1,newn;
      
            case ((Absyn.EQUATIONS(contents = eqs) :: _),n)
      
              algorithm
      
        ✗
                str := getNthEquationItemInEquations(eqs, n);
      
              then
      
                str;
      
            case ((Absyn.EQUATIONS(contents = eqs) :: xs),n) /* The rule above failed, subtract the number of equations in the first section and try with the rest of the classparts */
      
              algorithm
      
        ✗
                c1 := getEquationItemsCountInEquationItems(eqs);
      
        ✗
                newn := n - c1;
      
        ✗
                str := getNthEquationItemInClassParts(xs, newn);
      
              then
      
                str;
      
            case ((_ :: xs),n)
      
              algorithm
      
        ✗
                str := getNthEquationItemInClassParts(xs, n);
      
              then
      
                str;
      
          end matchcontinue;
      
        end getNthEquationItemInClassParts;
      
        protected function getNthEquationItemInEquations
      
        " This function takes an Equation list and an int
      
           and returns the nth Equation item as String.
      
           If the number is larger than the number of algorithms
      
           in the list, the function fails. Helper function to getNthEquationItemInClassParts."
      
          input list<Absyn.EquationItem> inAbsynEquationItemLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue (inAbsynEquationItemLst,inInteger)
      
            local
      
              String str;
      
              Absyn.Equation eq;
      
              list<Absyn.EquationItem> xs;
      
              Integer newn,n;
      
            case ((Absyn.EQUATIONITEM(equation_ = eq) :: _), 1)
      
              algorithm
      
        ✗
                str := Dump.unparseEquationStr(eq);
      
        ✗
                str := stringAppend(str, ";");
      
        ✗
                str := System.trim(str, " ");
      
              then
      
                str;
      
            case ((_ :: xs),n)
      
              algorithm
      
        ✗
                newn := n - 1;
      
        ✗
                str := getNthEquationItemInEquations(xs, newn);
      
              then
      
                str;
      
            case ({},_) then fail();
      
          end matchcontinue;
      
        end getNthEquationItemInEquations;
      
        protected function getInitialEquationItemsCount
      
        "Counts the number of Initial Equation items in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inClass
      
            local
      
              list<Absyn.ClassPart> parts;
      
              Integer count;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        ✗
                count := getInitialEquationItemsCountInClassParts(parts);
      
              then
      
                count;
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                count := getInitialEquationItemsCountInClassParts(parts);
      
              then
      
                count;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then 0;
      
          end match;
      
        end getInitialEquationItemsCount;
      
        protected function getInitialEquationItemsCountInClassParts
      
        "Helper function to getInitialEquationItemsCount"
      
         input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inAbsynClassPartLst
      
            local
      
              list<Absyn.EquationItem> eqs;
      
              list<Absyn.ClassPart> xs;
      
              Integer c1, c2, res;
      
            case Absyn.INITIALEQUATIONS(contents = eqs) :: xs
      
              algorithm
      
        ✗
                c1 := getEquationItemsCountInEquationItems(eqs);
      
                c2 := getInitialEquationItemsCountInClassParts(xs);
      
              then
      
                c1 + c2;
      
            case _ :: xs
      
              algorithm
      
        ✗
                res := getInitialEquationItemsCountInClassParts(xs);
      
              then
      
                res;
      
            case {} then 0;
      
          end match;
      
        end getInitialEquationItemsCountInClassParts;
      
        protected function getNthInitialEquationItem
      
        "Returns the Nth Initial Equation Item from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
        protected
      
          list<Absyn.ClassPart> parts;
      
        algorithm
      
          outString := match inClass
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
        ✗
              then getNthInitialEquationItemInClassParts(parts,inInteger);
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
        ✗
              then getNthInitialEquationItemInClassParts(parts,inInteger);
      
          end match;
      
        end getNthInitialEquationItem;
      
        protected function getNthInitialEquationItemInClassParts
      
        "Helper function to getNthInitialEquationItem"
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := matchcontinue inAbsynClassPartLst
      
            local
      
              list<Absyn.EquationItem> eqs;
      
              list<Absyn.ClassPart> xs;
      
              Integer c1,newn;
      
            case Absyn.INITIALEQUATIONS(contents = eqs) :: _
      
        ✗
              then getNthEquationItemInEquations(eqs, inInteger);
      
            case Absyn.INITIALEQUATIONS(contents = eqs) :: xs /* The rule above failed, subtract the number of equations in the first section and try with the rest of the classparts */
      
              algorithm
      
        ✗
                c1 := getEquationItemsCountInEquationItems(eqs);
      
        ✗
                newn := inInteger - c1;
      
        ✗
              then
      
                getNthInitialEquationItemInClassParts(xs, newn);
      
            case _ :: xs
      
        ✗
              then getNthInitialEquationItemInClassParts(xs, inInteger);
      
          end matchcontinue;
      
        end getNthInitialEquationItemInClassParts;
      
        protected function getAnnotationCount
      
        "Counts the number of Annotation sections in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        algorithm
      
          outInteger := match inClass
      
            local
      
              list<Absyn.Annotation> ann;
      
            case Absyn.CLASS(body = Absyn.PARTS(ann = ann))
      
        ✗
              then listLength(ann);
      
            // check also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(ann = ann))
      
        ✗
              then listLength(ann);
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then 0;
      
          end match;
      
        end getAnnotationCount;
      
        protected function getNthAnnotationString
      
        "Returns the Nth Annotation String from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output String outString;
      
        algorithm
      
          outString := match (inClass,inInteger)
      
            local
      
              list<Absyn.Annotation> anns;
      
              Absyn.Annotation ann;
      
              String str;
      
              Integer n;
      
            case (Absyn.CLASS(body = Absyn.PARTS(ann = anns)),n)
      
              algorithm
      
        ✗
                ann := listGet(anns,n);
      
        ✗
                str := Dump.unparseAnnotation(ann);
      
        ✗
                str := stringAppend(str, ";");
      
        ✗
                str := System.trim(str, " ");
      
              then
      
                str;
      
            // check also the case model extends X end X;
      
            case (Absyn.CLASS(body = Absyn.CLASS_EXTENDS(ann = anns)),n)
      
              algorithm
      
        ✗
                ann := listGet(anns,n);
      
        ✗
                str := Dump.unparseAnnotation(ann);
      
        ✗
                str := stringAppend(str, ";");
      
        ✗
                str := System.trim(str, " ");
      
              then
      
                str;
      
          end match;
      
        end getNthAnnotationString;
      
        protected function getImportCount
      
        "Counts the number of Import sections in a class."
      
          input Absyn.Class inClass;
      
          output Integer outInteger;
      
        protected
      
          list<Absyn.Import> pub_imports_list , pro_imports_list;
      
        algorithm
      
        ✗
          (pub_imports_list , pro_imports_list) := CevalScript.getImportList(inClass);
      
        ✗
          outInteger := listLength(pub_imports_list) + listLength(pro_imports_list);
      
        end getImportCount;
      
        protected function getNthImport
      
        "Returns the Nth Import String from a class."
      
          input Absyn.Class inClass;
      
          input Integer inInteger;
      
          output list<Values.Value> outValue;
      
        protected
      
          list<Absyn.Import> pub_imports_list , pro_imports_list;
      
        algorithm
      
        ✗
          (pub_imports_list, pro_imports_list) := CevalScript.getImportList(inClass);
      
        ✗
          outValue := unparseNthImport(listGet(pub_imports_list,inInteger));
      
        end getNthImport;
      
        protected function unparseNthImport
      
        " helperfunction to getNthImport."
      
          input Absyn.Import inImport;
      
          output list<Values.Value> outValue;
      
        algorithm
      
          outValue := match inImport
      
            local
      
              list<Values.Value> vals;
      
              list<Absyn.GroupImport> gi;
      
              String path_str,id;
      
              Absyn.Path path;
      
            case Absyn.NAMED_IMPORT(name = id,path = path)
      
              algorithm
      
        ✗
                path_str := AbsynUtil.pathString(path);
      
        ✗
                vals := {Values.STRING(path_str),Values.STRING(id),Values.STRING("named")};
      
              then
      
                vals;
      
            case Absyn.QUAL_IMPORT(path = path)
      
              algorithm
      
        ✗
                path_str := AbsynUtil.pathString(path);
      
        ✗
                vals := {Values.STRING(path_str),Values.STRING(""),Values.STRING("qualified")};
      
              then
      
                vals;
      
            case Absyn.UNQUAL_IMPORT(path = path)
      
              algorithm
      
        ✗
                path_str := AbsynUtil.pathString(path);
      
        ✗
                path_str := stringAppendList({path_str, ".*"});
      
        ✗
                vals := {Values.STRING(path_str),Values.STRING(""),Values.STRING("unqualified")};
      
              then
      
                vals;
      
            case Absyn.GROUP_IMPORT(prefix = path, groups = gi)
      
              algorithm
      
        ✗
                path_str := AbsynUtil.pathString(path);
      
        ✗
                id := stringDelimitList(unparseGroupImport(gi),",");
      
        ✗
                path_str := stringAppendList({path_str,".{",id,"}"});
      
        ✗
                vals := {Values.STRING(path_str),Values.STRING(""),Values.STRING("multiple")};
      
              then
      
                vals;
      
          end match;
      
        end unparseNthImport;
      
        protected function unparseGroupImport
      
          input list<Absyn.GroupImport> inAbsynGroupImportLst;
      
          output list<String> outList;
      
        algorithm
      
          outList := match inAbsynGroupImportLst
      
          local
      
            list<Absyn.GroupImport> rest;
      
            list<String> lst;
      
            String str;
      
            case {} then {};
      
            case Absyn.GROUP_IMPORT_NAME(name = str) :: rest
      
              algorithm
      
        ✗
                lst := unparseGroupImport(rest);
      
              then
      
                (str::lst);
      
            case _ :: rest
      
              algorithm
      
        ✗
                lst := unparseGroupImport(rest);
      
              then
      
                lst;
      
          end match;
      
        end unparseGroupImport;
      
        public function isShortDefinition
      
        "@auhtor:adrpo
      
          returns true if the class is derived or false otherwise"
      
          input Absyn.Path inPath;
      
          input Absyn.Program inProgram;
      
          output Boolean outBoolean;
      
        algorithm
      
          try
      
        ✗
            Absyn.CLASS(body = Absyn.DERIVED()) := ProgramUtil.getPathedClassInProgram(inPath, inProgram);
      
            outBoolean := true;
      
          else
      
            outBoolean := false;
      
          end try;
      
        end isShortDefinition;
      
        protected function isExperiment
      
          input Absyn.Path path;
      
          input Absyn.Program program;
      
          output Boolean res;
      
        protected
      
          Absyn.Class cdef;
      
        algorithm
      
          try
      
        8
            cdef := ProgramUtil.getPathedClassInProgram(path, program);
      
          2/2✓ Branch 1 taken 1 time.
✓ Branch 2 taken 7 times.

        8
            false := AbsynUtil.isPartial(cdef);
      
          4/4✓ Branch 1 taken 3 times.
✓ Branch 2 taken 4 times.
✓ Branch 4 taken 1 time.
✓ Branch 5 taken 2 times.

        7
            true := AbsynUtil.isModel(cdef) or AbsynUtil.isBlock(cdef);
      
          3/4✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 1 time.
✓ Branch 4 taken 4 times.

        5
            SOME(res) := AbsynUtil.getNamedAnnotationInClass(cdef, Absyn.Path.IDENT("experiment"), hasStopTime);
      
          else
      
            res := false;
      
          end try;
      
        end isExperiment;
      
        protected function hasStopTime "For use with getNamedAnnotationExp"
      
          input Option<Absyn.Modification> mod;
      
          output Boolean b;
      
        algorithm
      
          b := match mod
      
            local
      
              list<Absyn.ElementArg> arglst;
      
            case SOME(Absyn.CLASSMOD(elementArgLst = arglst))
      
        4
              then List.any(arglst,hasStopTime2);
      
          end match;
      
        end hasStopTime;
      
        protected function hasStopTime2 "For use with getNamedAnnotationExp"
      
          input Absyn.ElementArg arg;
      
          output Boolean b;
      
        algorithm
      
          b := match arg
      
            local
      
            case Absyn.MODIFICATION(path=Absyn.IDENT(name="StopTime")) then true;
      
            else false;
      
          end match;
      
        end hasStopTime2;
      
        protected function searchClassNames
      
          input list<Values.Value> inVals;
      
          input String inSearchText;
      
          input Boolean inFindInText;
      
          input Absyn.Program inProgram;
      
          output list<Values.Value> outVals;
      
        algorithm
      
          outVals := matchcontinue (inVals, inSearchText, inFindInText, inProgram)
      
            local
      
              list<Values.Value> valsList;
      
              String str, str1;
      
              Boolean b;
      
              Absyn.Program p, p1;
      
              Absyn.Class absynClass;
      
              Integer position;
      
              list<Values.Value> xs;
      
              Values.Value val;
      
            case ((val as Values.CODE(_)) :: xs, str1, true, p)
      
              algorithm
      
        ✗
                absynClass := ProgramUtil.getPathedClassInProgram(ValuesUtil.getPath(val), p);
      
        ✗
                p1 := Absyn.PROGRAM({absynClass},Absyn.TOP());
      
                /* Don't consider packages for FindInText search */
      
        ✗
                false := Interactive.isPackage(ValuesUtil.getPath(val), inProgram);
      
        ✗
                str := Dump.unparseStr(p1, false);
      
        ✗
                position := System.stringFind(System.tolower(str), System.tolower(str1));
      
        ✗
                true := (position > -1);
      
        ✗
                valsList := searchClassNames(xs, str1, true, p);
      
              then
      
                val::valsList;
      
            case ((val as Values.CODE(_)) :: xs, str1, b, p)
      
              algorithm
      
        ✗
                str := ValuesDump.valString(val);
      
        ✗
                position := System.stringFind(System.tolower(str), System.tolower(str1));
      
        ✗
                true := (position > -1);
      
        ✗
                valsList := searchClassNames(xs, str1, b, p);
      
              then
      
                val::valsList;
      
            case ((_ :: xs), str1, b, p)
      
              algorithm
      
        ✗
                valsList := searchClassNames(xs, str1, b, p);
      
              then
      
                valsList;
      
            case ({}, _, _, _) then {};
      
          end matchcontinue;
      
        end searchClassNames;
      
        protected function makeUsesArray
      
          input tuple<Absyn.Path,String,list<String>,Boolean> inTpl;
      
          output Values.Value v;
      
        algorithm
      
          v := match inTpl
      
            local
      
              Absyn.Path p;
      
              String pstr,ver;
      
            case (p,_,{ver},_)
      
              algorithm
      
        ✗
                pstr := AbsynUtil.pathString(p);
      
        ✗
              then ValuesMake.makeArray({Values.STRING(pstr),Values.STRING(ver)});
      
            else
      
              algorithm
      
        ✗
                Error.addMessage(Error.INTERNAL_ERROR,{"makeUsesArray failed"});
      
        ✗
              then fail();
      
          end match;
      
        end makeUsesArray;
      
        protected function saveTotalModel
      
          input String filename;
      
          input Absyn.Path classpath;
      
          input Boolean stripAnnotations;
      
          input Boolean stripComments;
      
          input Boolean obfuscate;
      
          input Boolean previous = false "Use previousGetTotalModel.";
      
        protected
      
          String result, obfuscate_map;
      
        algorithm
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 4 times.

        5
          if previous then
      
        1
            (result, obfuscate_map) := previousGetTotalModel(classpath, stripAnnotations, stripComments, obfuscate);
      
          else
      
        4
            (result, obfuscate_map) := getTotalModel(classpath, stripAnnotations, stripComments, obfuscate);
      
          end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.

        5
          if obfuscate then
      
        ✗
            System.writeFile(StringUtil.stripFileExtension(filename) + "_mapping.json", obfuscate_map);
      
          end if;
      
        5
          System.writeFile(filename, result);
      
        end saveTotalModel;
      
        protected function getTotalModel
      
          input Absyn.Path classpath;
      
          input Boolean stripAnnotations;
      
          input Boolean stripComments;
      
          input Boolean obfuscate;
      
          output String result;
      
          output String obfuscate_map = "";
      
        protected
      
          SCode.Program scodeP;
      
          String str1,str2,str3;
      
          SCode.Element cls;
      
          SCode.Comment cmt;
      
          Absyn.Path cls_path = classpath;
      
          Boolean extendable;
      
        algorithm
      
        4
          loadProgram(cls_path);
      
        4
          (scodeP, cls) := getTotalProgramNF(cls_path);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
          SCode.CLASS(cmt = cmt) := cls;
      
          // A model can't extend a package or a function, those get no _total model.
      
          2/4✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.

        4
          extendable := not (SCodeUtil.isPackage(cls) or SCodeUtil.isFunction(cls));
      
        4
          scodeP := SCodeUtil.removeBuiltinsFromTopScope(scodeP);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
          if stripAnnotations or stripComments then
      
        ✗
            scodeP := SCodeUtil.stripCommentsFromProgram(scodeP, stripAnnotations, stripComments);
      
          end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
          if obfuscate then
      
        ✗
            (scodeP, cls_path, cmt, obfuscate_map) := Obfuscate.obfuscateProgram(scodeP, cls_path, cmt);
      
          end if;
      
        4
          result := SCodeDump.programStr(scodeP,SCodeDump.defaultOptions);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
          if extendable then
      
        4
            str1 := AbsynUtil.pathLastIdent(cls_path) + "_total";
      
          1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

        4
            str2 := if stripComments then "" else SCodeDump.printCommentStr(cmt);
      
          3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.

        4
            str2 := if stringEq(str2,"") then "" else (" " + str2);
      
          1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.

        4
            str3 := if stripAnnotations then "" else SCodeDump.printAnnotationStr(cmt,SCodeDump.defaultOptions);
      
          3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
✓ Branch 4 taken 3 times.

        4
            str3 := if stringEq(str3,"") then "" else (str3 + ";\n");
      
        4
            result := result + "\nmodel " + str1 + str2 + "\n  extends " + AbsynUtil.pathString(cls_path) + ";\n" + str3 + "end " + str1 + ";\n";
      
          end if;
      
        end getTotalModel;
      
        protected function previousGetTotalModel
      
          "The previous implementation of getTotalModel, which finds the used classes
      
           with NFSCodeFlatten. Kept for comparison by previous_saveTotalModel."
      
          input Absyn.Path classpath;
      
          input Boolean stripAnnotations;
      
          input Boolean stripComments;
      
          input Boolean obfuscate;
      
          output String result;
      
          output String obfuscate_map = "";
      
        protected
      
          SCode.Program scodeP;
      
          String str,str1,str2,str3;
      
          NFSCodeEnv.Env env;
      
          SCode.Comment cmt;
      
          Absyn.Path cls_path = classpath;
      
        algorithm
      
        1
          loadProgram(cls_path);
      
        1
          scodeP := SymbolTable.getSCode();
      
        1
          (scodeP, env) := NFSCodeFlatten.flattenClassInProgram(cls_path, scodeP);
      
          2/4✗ Branch 1 not taken.
✓ Branch 2 taken 1 time.
✗ Branch 4 not taken.
✓ Branch 5 taken 1 time.

        1
          (NFSCodeEnv.CLASS(cls=SCode.CLASS(cmt=cmt)),_,_) := NFSCodeLookup.lookupClassName(cls_path, env, Absyn.dummyInfo);
      
        1
          scodeP := SCodeUtil.removeBuiltinsFromTopScope(scodeP);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
          if stripAnnotations or stripComments then
      
        ✗
            scodeP := SCodeUtil.stripCommentsFromProgram(scodeP, stripAnnotations, stripComments);
      
          end if;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.

        1
          if obfuscate then
      
        ✗
            (scodeP, cls_path, cmt, obfuscate_map) := Obfuscate.obfuscateProgram(scodeP, cls_path, cmt);
      
          end if;
      
        1
          str := SCodeDump.programStr(scodeP,SCodeDump.defaultOptions);
      
        1
          str1 := AbsynUtil.pathLastIdent(cls_path) + "_total";
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          str2 := if stripComments then "" else SCodeDump.printCommentStr(cmt);
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
          str2 := if stringEq(str2,"") then "" else (" " + str2);
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          str3 := if stripAnnotations then "" else SCodeDump.printAnnotationStr(cmt,SCodeDump.defaultOptions);
      
          2/4✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 time.

        1
          str3 := if stringEq(str3,"") then "" else (str3 + ";\n");
      
        1
          str1 := "\nmodel " + str1 + str2 + "\n  extends " + AbsynUtil.pathString(cls_path) + ";\n" + str3 + "end " + str1 + ";\n";
      
        1
          result := str + str1;
      
        end previousGetTotalModel;
      
        protected function getTotalProgramNF
      
          "Returns the loaded program reduced to the given class and what it uses. The
      
           class is kept whole, and the names in it, in every class declared in it and
      
           in everything they use are looked up with the new frontend to find what they
      
           use, without instantiating them. That also works for packages and for
      
           classes that can't be instantiated."
      
          input Absyn.Path classPath;
      
          output SCode.Program program;
      
          output SCode.Element cls "The class as saved.";
      
        protected
      
          UnorderedSet<String> used;
      
          Boolean nf_inst;
      
          SCode.Program builtin_p, annotation_p;
      
        algorithm
      
        4
          cls := InteractiveUtil.getPathedSCodeElementInProgram(classPath, SymbolTable.getSCode());
      
          // Only the used elements are wanted from the lookups, not their messages.
      
        4
          ErrorExt.setCheckpoint(getInstanceName());
      
          // The new frontend needs its own builtin classes, also with -d=nonewInst.
      
        4
          nf_inst := FlagsUtil.set(Flags.SCODE_INST, true);
      
          try
      
        4
            (_, builtin_p) := FBuiltin.getInitialFunctions();
      
        4
            annotation_p := AbsynToSCode.translateAbsyn2SCode(
      
              InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion()));
      
        8
            used := NFUsedElements.collect(classPath :: getNestedClassPaths(cls, classPath),
      
              listAppend(builtin_p, SymbolTable.getSCode()), annotation_p);
      
          else
      
        ✗
            used := UnorderedSet.new<String>(stringHashDjb2, stringEq);
      
          end try;
      
        4
          FlagsUtil.set(Flags.SCODE_INST, nf_inst);
      
        4
          ErrorExt.rollBack(getInstanceName());
      
        4
          markElementUsed(cls, used);
      
          // Lookups may have loaded libraries, so fetch the program afterwards.
      
        4
          program := SymbolTable.getSCode();
      
        4
          program := filterUsedClasses(program, used, program);
      
        4
          cls := InteractiveUtil.getPathedSCodeElementInProgram(classPath, program);
      
        end getTotalProgramNF;
      
        protected function getDefUseChains
      
          "Returns the def-use chains of the names in a class as JSON, or writes them
      
           to a file and returns its name."
      
          input Absyn.Path className "A class, or a component declared in a class.";
      
          input String fileName;
      
          input Absyn.Path scope "The class to look for the uses in, or AllLoadedClasses.";
      
          input Boolean prettyPrint;
      
          output String result;
      
        protected
      
          Absyn.Path cls_path = className;
      
          list<Absyn.Path> paths = {};
      
          SCode.Program program;
      
          SCode.Element cls;
      
          list<NFUsedElements.Definition> defs;
      
          list<NFUsedElements.Use> uses, unresolved;
      
        algorithm
      
        18
          program := SymbolTable.getSCode();
      
          // A component gives the chain of the component, the class it's declared in is walked.
      
          try
      
        18
            cls := InteractiveUtil.getPathedSCodeElementInProgram(className, program);
      
          2/2✓ Branch 1 taken 11 times.
✓ Branch 2 taken 3 times.

        14
            if not SCodeUtil.elementIsClass(cls) then
      
        11
              cls_path := AbsynUtil.stripLast(className);
      
            end if;
      
          else
      
        4
            cls_path := AbsynUtil.stripLast(className);
      
          end try;
      
        18
          paths := scopeClassPaths(scope, program);
      
          4/4✓ Branch 1 taken 3 times.
✓ Branch 2 taken 15 times.
✓ Branch 4 taken 1 time.
✓ Branch 5 taken 2 times.

        18
          if not isAllLoadedClasses(scope) and not AbsynUtil.pathPrefixOf(scope, cls_path) then
      
            try
      
        1
              cls := InteractiveUtil.getPathedSCodeElementInProgram(cls_path, program);
      
        1
              paths := getNestedClassPaths(cls, cls_path, cls_path :: paths);
      
            else
      
            end try;
      
          end if;
      
        18
          (defs, uses, unresolved) := collectDefUse(paths, program);
      
          2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 15 times.

        18
          result := NFDefUseChains.toJSON(AbsynUtil.pathString(className), defs, uses, unresolved,
      
            if isAllLoadedClasses(scope) then "" else AbsynUtil.pathString(scope), prettyPrint);
      
          2/2✓ Branch 0 taken 16 times.
✓ Branch 1 taken 2 times.

        18
          if not stringEmpty(fileName) then
      
        2
            System.writeFile(fileName, result);
      
            result := fileName;
      
          end if;
      
        end getDefUseChains;
      
        protected function getClassDiagram
      
          "Returns a UML class diagram of a class, see NFClassDiagram, or writes it to a
      
           file and returns its name."
      
          input Absyn.Path className;
      
          input String fileName;
      
          input String format;
      
          input Integer depth;
      
          input list<String> exclude;
      
          input Boolean showModifiers;
      
          output String result = "";
      
        protected
      
          SCode.Program program, builtin_p, annotation_p;
      
          Boolean nf_inst;
      
        algorithm
      
          7/12✓ Branch 0 taken 5 times.
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 time.
✓ Branch 11 taken 1 time.
✗ Branch 13 not taken.
✓ Branch 14 taken 1 time.

        7
          if format <> "plantuml" and format <> "mermaid" and format <> "drawio" then
      
        1
            Error.addCompilerError("getClassDiagram: unknown format " + format + ", expected plantuml, mermaid or drawio.");
      
        1
            return;
      
          end if;
      
        6
          program := SymbolTable.getSCode();
      
          try
      
        6
            _ := InteractiveUtil.getPathedSCodeElementInProgram(className, program);
      
          else
      
        2
            Error.addMessage(Error.LOOKUP_ERROR, {AbsynUtil.pathString(className), "<TOP>"});
      
        1
            return;
      
          end try;
      
          // Only the uses are wanted from the lookups, not their messages, see collectDefUse.
      
        5
          ErrorExt.setCheckpoint(getInstanceName());
      
        5
          nf_inst := FlagsUtil.set(Flags.SCODE_INST, true);
      
          try
      
        5
            (_, builtin_p) := FBuiltin.getInitialFunctions();
      
        5
            annotation_p := AbsynToSCode.translateAbsyn2SCode(
      
              InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion()));
      
        5
            result := NFClassDiagram.generate(className, listAppend(builtin_p, program), annotation_p,
      
              format, depth, exclude, showModifiers);
      
          else
      
          end try;
      
        5
          FlagsUtil.set(Flags.SCODE_INST, nf_inst);
      
        5
          ErrorExt.rollBack(getInstanceName());
      
          3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        5
          if not stringEmpty(fileName) and not stringEmpty(result) then
      
        1
            System.writeFile(fileName, result);
      
            result := fileName;
      
          end if;
      
        end getClassDiagram;
      
        protected function getDependencyGraph
      
          "Returns the classes in a scope, the hashes of their source and the classes
      
           they use as JSON, or writes it to a file and returns its name."
      
          input Absyn.Path scope "A class, or AllLoadedClasses.";
      
          input String fileName;
      
          input Boolean prettyPrint;
      
          output String result;
      
        protected
      
          SCode.Program program;
      
          list<NFUsedElements.Definition> defs;
      
          list<NFUsedElements.Use> uses;
      
        algorithm
      
        3
          program := SymbolTable.getSCode();
      
        3
          (defs, uses, _) := collectDefUse(scopeClassPaths(scope, program), program);
      
        3
          result := NFDefUseChains.dependencyGraphJSON(AbsynUtil.pathString(scope), defs, uses, prettyPrint);
      
          2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 time.

        3
          if not stringEmpty(fileName) then
      
        1
            System.writeFile(fileName, result);
      
            result := fileName;
      
          end if;
      
        end getDependencyGraph;
      
        protected function getDefinitionAt
      
          "Returns the definition of the name at a position in a file as JSON."
      
          input String fileName;
      
          input Integer line;
      
          input Integer column;
      
          input Boolean prettyPrint;
      
          output String result;
      
        protected
      
          SCode.Program program;
      
          Option<tuple<Absyn.Path, String>> found = NONE();
      
          Absyn.Path path;
      
          String file = fileName, real_path;
      
          list<NFUsedElements.Definition> defs = {};
      
          list<NFUsedElements.Use> uses = {};
      
        algorithm
      
        11
          program := SymbolTable.getSCode();
      
        11
          real_path := System.realpath(fileName);
      
          2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 11 times.

        22
          for c in program loop
      
        11
            found := findClassAt(c, Absyn.IDENT(SCodeUtil.elementName(c)), fileName, real_path, line, column, found);
      
          end for;
      
          // The names in the innermost class the position is in are looked up. The
      
          // classes it's in and their class extends and redeclared classes are also
      
          // walked, since those replace what the names are looked up through.
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
✓ Branch 2 taken 11 times.
✗ Branch 3 not taken.

        11
          if isSome(found) then
      
        11
            SOME((path, file)) := found;
      
        22
            (defs, uses, _) := collectDefUse(path :: enclosingReplacingClasses(path, program), program);
      
          end if;
      
        11
          result := NFDefUseChains.definitionAtJSON(file, line, column, defs, uses, prettyPrint);
      
        end getDefinitionAt;
      
        protected function enclosingReplacingClasses
      
          "Returns the classes a class is in and the class extends and redeclared
      
           classes declared in them, outermost first."
      
          input Absyn.Path path;
      
          input SCode.Program program;
      
          output list<Absyn.Path> paths = {};
      
        protected
      
          Absyn.Path p = path;
      
          SCode.Element cls;
      
        algorithm
      
          2/2✓ Branch 1 taken 13 times.
✓ Branch 2 taken 11 times.

        24
          while AbsynUtil.pathIsQual(p) loop
      
        13
            p := AbsynUtil.stripLast(p);
      
            try
      
        13
              cls := InteractiveUtil.getPathedSCodeElementInProgram(p, program);
      
          2/2✓ Branch 1 taken 139 times.
✓ Branch 2 taken 13 times.

        165
              for e in SCodeUtil.getClassElements(cls) loop
      
          5/6✓ Branch 1 taken 138 times.
✓ Branch 2 taken 1 time.
✓ Branch 4 taken 136 times.
✓ Branch 5 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 136 times.

        139
                if SCodeUtil.elementIsClass(e) and (SCodeUtil.isClassExtends(e) or SCodeUtil.isElementRedeclare(e)) then
      
        2
                  paths := AbsynUtil.suffixPath(p, SCodeUtil.elementName(e)) :: paths;
      
                end if;
      
              end for;
      
              paths := p :: paths;
      
            else
      
            end try;
      
          end while;
      
        end enclosingReplacingClasses;
      
        protected function findClassAt
      
          "Finds the innermost class declared in a file that a position is in, and the
      
           name of the file as the class has it."
      
          input SCode.Element element;
      
          input Absyn.Path path;
      
          input String fileName;
      
          input String realPath "fileName with a full path.";
      
          input Integer line;
      
          input Integer column;
      
          input output Option<tuple<Absyn.Path, String>> found;
      
        protected
      
          SourceInfo info;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 275 times.

        275
          if not SCodeUtil.elementIsClass(element) then
      
        ✗
            return;
      
          end if;
      
        275
          info := SCodeUtil.elementInfo(element);
      
          11/20✗ Branch 0 not taken.
✓ Branch 1 taken 275 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 275 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 275 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 158 times.
✓ Branch 11 taken 117 times.
✗ Branch 12 not taken.
✓ Branch 13 taken 158 times.
✗ Branch 14 not taken.
✗ Branch 15 not taken.
✓ Branch 16 taken 94 times.
✓ Branch 17 taken 23 times.
✓ Branch 18 taken 1 time.
✓ Branch 19 taken 93 times.
✓ Branch 20 taken 1 time.
✗ Branch 21 not taken.

        275
          if (info.fileName == fileName or info.fileName == realPath) and
      
             (line > info.lineNumberStart or (line == info.lineNumberStart and column >= info.columnNumberStart)) and
      
             (line < info.lineNumberEnd or (line == info.lineNumberEnd and column <= info.columnNumberEnd)) then
      
        24
            found := SOME((path, info.fileName));
      
          end if;
      
          // A class in a file of its own is declared in a class in another file.
      
          2/2✓ Branch 1 taken 583 times.
✓ Branch 2 taken 275 times.

        858
          for e in SCodeUtil.getClassElements(element) loop
      
          2/2✓ Branch 1 taken 264 times.
✓ Branch 2 taken 319 times.

        583
            if SCodeUtil.elementIsClass(e) then
      
        264
              found := findClassAt(e, AbsynUtil.suffixPath(path, SCodeUtil.elementName(e)),
      
                fileName, realPath, line, column, found);
      
            end if;
      
          end for;
      
        end findClassAt;
      
        protected function isAllLoadedClasses
      
          input Absyn.Path path;
      
          output Boolean res = AbsynUtil.pathEqual(path, Absyn.Path.IDENT("AllLoadedClasses"));
      
        end isAllLoadedClasses;
      
        protected function scopeClassPaths
      
          "Returns the paths of a class and all classes declared in it, or of all
      
           loaded classes."
      
          input Absyn.Path scope;
      
          input SCode.Program program;
      
          output list<Absyn.Path> paths = {};
      
        protected
      
          SCode.Element cls;
      
        algorithm
      
          2/2✓ Branch 1 taken 15 times.
✓ Branch 2 taken 6 times.

        21
          if isAllLoadedClasses(scope) then
      
          2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 15 times.

        30
            for c in program loop
      
          2/6✓ Branch 1 taken 15 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 15 times.
✗ Branch 8 not taken.
✗ Branch 9 not taken.

        15
              if SCodeUtil.elementIsClass(c) and SCodeUtil.elementName(c) <> "OpenModelica" then
      
        30
                paths := getNestedClassPaths(c, Absyn.IDENT(SCodeUtil.elementName(c)),
      
                  Absyn.IDENT(SCodeUtil.elementName(c)) :: paths);
      
              end if;
      
            end for;
      
          else
      
            try
      
        6
              cls := InteractiveUtil.getPathedSCodeElementInProgram(scope, program);
      
        6
              paths := getNestedClassPaths(cls, scope, {scope});
      
            else
      
            end try;
      
          end if;
      
        end scopeClassPaths;
      
        protected function collectDefUse
      
          "Walks the given classes and returns the definitions and uses of the names in
      
           them, see NFUsedElements.collectUses."
      
          input list<Absyn.Path> paths "In reverse order.";
      
          input SCode.Program program;
      
          output list<NFUsedElements.Definition> defs = {};
      
          output list<NFUsedElements.Use> uses = {};
      
          output list<NFUsedElements.Use> unresolved = {};
      
        protected
      
          SCode.Program builtin_p, annotation_p;
      
          Boolean nf_inst;
      
        algorithm
      
          // Only the uses are wanted from the lookups, not their messages.
      
        32
          ErrorExt.setCheckpoint(getInstanceName());
      
          // The new frontend needs its own builtin classes, also with -d=nonewInst.
      
        32
          nf_inst := FlagsUtil.set(Flags.SCODE_INST, true);
      
          try
      
        32
            (_, builtin_p) := FBuiltin.getInitialFunctions();
      
        32
            annotation_p := AbsynToSCode.translateAbsyn2SCode(
      
              InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion()));
      
        32
            (defs, uses, unresolved) := NFUsedElements.collectUses(listReverse(paths),
      
              listAppend(builtin_p, program), annotation_p);
      
          else
      
          end try;
      
        32
          FlagsUtil.set(Flags.SCODE_INST, nf_inst);
      
        32
          ErrorExt.rollBack(getInstanceName());
      
        end collectDefUse;
      
        protected function getNestedClassPaths
      
          "Returns the paths of all classes declared in a class, at any depth."
      
          input SCode.Element cls;
      
          input Absyn.Path clsPath;
      
          input output list<Absyn.Path> paths = {};
      
        protected
      
          Absyn.Path path;
      
        algorithm
      
          2/2✓ Branch 1 taken 373 times.
✓ Branch 2 taken 135 times.

        508
          for e in SCodeUtil.getClassElements(cls) loop
      
          2/2✓ Branch 1 taken 109 times.
✓ Branch 2 taken 264 times.

        373
            if SCodeUtil.elementIsClass(e) then
      
        109
              path := AbsynUtil.suffixPath(clsPath, SCodeUtil.elementName(e));
      
        109
              paths := getNestedClassPaths(e, path, path :: paths);
      
            end if;
      
          end for;
      
        end getNestedClassPaths;
      
        protected function markElementUsed
      
          "Adds an element and everything declared in it to the used set."
      
          input SCode.Element element;
      
          input UnorderedSet<String> used;
      
        algorithm
      
        22
          UnorderedSet.add(NFUsedElements.elementKey(element), used);
      
          2/2✓ Branch 1 taken 16 times.
✓ Branch 2 taken 6 times.

        22
          if SCodeUtil.elementIsClass(element) then
      
          2/2✓ Branch 1 taken 19 times.
✓ Branch 2 taken 6 times.

        25
            for e in SCodeUtil.getClassElements(element) loop
      
          4/4✓ Branch 1 taken 17 times.
✓ Branch 2 taken 2 times.
✓ Branch 4 taken 16 times.
✓ Branch 5 taken 1 time.

        19
              if SCodeUtil.elementIsClass(e) or SCodeUtil.isComponent(e) then
      
        18
                markElementUsed(e, used);
      
              end if;
      
            end for;
      
          end if;
      
        end markElementUsed;
      
        protected function filterUsedClasses
      
          "Removes the classes that aren't in the used set from a list of elements,
      
           also from the classes that are kept. Components are only removed from
      
           packages, where they are constants that may or may not be used."
      
          input list<SCode.Element> elements;
      
          input UnorderedSet<String> used;
      
          input SCode.Program program "The whole program, to resolve imports in.";
      
          input Boolean inPackage = false;
      
          output list<SCode.Element> outElements = {};
      
        algorithm
      
          2/2✓ Branch 0 taken 3665 times.
✓ Branch 1 taken 236 times.

        3901
          for e in elements loop
      
          2/2✓ Branch 1 taken 1259 times.
✓ Branch 2 taken 2406 times.

        3665
            if SCodeUtil.elementIsClass(e) then
      
          2/2✓ Branch 2 taken 321 times.
✓ Branch 3 taken 938 times.

        1259
              if UnorderedSet.contains(NFUsedElements.elementKey(e), used) then
      
        321
                outElements := filterUsedNestedClasses(e, used, program) :: outElements;
      
              end if;
      
            elseif inPackage and SCodeUtil.isComponent(e) then
      
          2/2✓ Branch 2 taken 54 times.
✓ Branch 3 taken 1294 times.

        1348
              if UnorderedSet.contains(NFUsedElements.elementKey(e), used) then
      
                outElements := e :: outElements;
      
              end if;
      
            elseif not isUnusedImport(e, used, program) then
      
              outElements := e :: outElements;
      
            end if;
      
          end for;
      
        236
          outElements := listReverse(outElements);
      
        end filterUsedClasses;
      
        protected function filterUsedNestedClasses
      
          input output SCode.Element cls;
      
          input UnorderedSet<String> used;
      
          input SCode.Program program;
      
        algorithm
      
          () := match cls
      
            case SCode.CLASS()
      
              algorithm
      
        321
                cls.classDef := filterUsedClassDef(cls.classDef, used, program, SCodeUtil.isPackage(cls));
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end filterUsedNestedClasses;
      
        protected function filterUsedClassDef
      
          input output SCode.ClassDef classDef;
      
          input UnorderedSet<String> used;
      
          input SCode.Program program;
      
          input Boolean inPackage;
      
        algorithm
      
          () := match classDef
      
            case SCode.PARTS()
      
              algorithm
      
        232
                classDef.elementLst := filterUsedClasses(classDef.elementLst, used, program, inPackage);
      
              then
      
                ();
      
            case SCode.CLASS_EXTENDS()
      
              algorithm
      
        17
                classDef.composition := filterUsedClassDef(classDef.composition, used, program, inPackage);
      
              then
      
                ();
      
            else ();
      
          end match;
      
        end filterUsedClassDef;
      
        protected function isUnusedImport
      
          "Returns true for an import of a single element that is declared in the
      
           program but wasn't used. Imports are only resolved when a name is looked up
      
           through them, so the import of a used element has recorded it."
      
          input SCode.Element element;
      
          input UnorderedSet<String> used;
      
          input SCode.Program program;
      
          output Boolean unused;
      
        protected
      
          Absyn.Path path;
      
        algorithm
      
          unused := match element
      
            case SCode.IMPORT(imp = Absyn.Import.NAMED_IMPORT(path = path))
      
        6
              then isUnusedElementPath(path, used, program);
      
            case SCode.IMPORT(imp = Absyn.Import.QUAL_IMPORT(path = path))
      
        41
              then isUnusedElementPath(path, used, program);
      
            else false;
      
          end match;
      
        end isUnusedImport;
      
        protected function isUnusedElementPath
      
          input Absyn.Path path;
      
          input UnorderedSet<String> used;
      
          input SCode.Program program;
      
          output Boolean unused;
      
        algorithm
      
          try
      
        47
            unused := not UnorderedSet.contains(NFUsedElements.elementKey(
      
              InteractiveUtil.getPathedSCodeElementInProgram(path, program)), used);
      
          else
      
            // Not declared where the path points, e.g. inherited. Keep the import.
      
            unused := false;
      
          end try;
      
        end isUnusedElementPath;
      
        protected function saveTotalModelDebug
      
          input String filename;
      
          input Absyn.Path classPath;
      
          input Boolean stripAnnotations;
      
          input Boolean stripComments;
      
          input Boolean obfuscate;
      
        protected
      
          SCode.Program prog;
      
          String str, str1, str2, str3;
      
          Absyn.Path cls_path = classPath;
      
          Option<SCode.Comment> ocmt;
      
          SCode.Comment cmt;
      
        algorithm
      
        ✗
          loadProgram(cls_path);
      
        ✗
          prog := SymbolTable.getSCode();
      
        ✗
          prog := TotalModelDebug.getTotalModel(prog, cls_path);
      
        ✗
          prog := SCodeUtil.removeBuiltinsFromTopScope(prog);
      
        ✗
          ocmt := SCodeUtil.getElementComment(InteractiveUtil.getPathedSCodeElementInProgram(cls_path, prog));
      
        ✗
          cmt := if isSome(ocmt) then Util.getOption(ocmt) else SCode.noComment;
      
        ✗
          if stripAnnotations or stripComments then
      
        ✗
            prog := SCodeUtil.stripCommentsFromProgram(prog, stripAnnotations, stripComments);
      
          end if;
      
        ✗
          if obfuscate then
      
        ✗
            (prog, cls_path, cmt, _) := Obfuscate.obfuscateProgram(prog, cls_path, cmt);
      
          end if;
      
        ✗
          str := SCodeDump.programStr(prog, SCodeDump.defaultOptions);
      
        ✗
          str1 := AbsynUtil.pathLastIdent(cls_path) + "_total";
      
        ✗
          str2 := if stripComments then "" else SCodeDump.printCommentStr(cmt);
      
        ✗
          str2 := if stringEq(str2,"") then "" else (" " + str2);
      
        ✗
          str3 := if stripAnnotations then "" else SCodeDump.printAnnotationStr(cmt,SCodeDump.defaultOptions);
      
        ✗
          str3 := if stringEq(str3,"") then "" else (str3 + ";\n");
      
        ✗
          str1 := "\nmodel " + str1 + str2 + "\n  extends " + AbsynUtil.pathString(cls_path) + ";\n" + str3 + "end " + str1 + ";\n";
      
        ✗
          System.writeFile(filename, str + str1);
      
        end saveTotalModelDebug;
      
        protected function getDymolaStateAnnotation
      
          "Returns the __Dymola_state annotation of a class.
      
          This is annotated with the annotation:
      
          annotation (__Dymola_state=true); in the class definition"
      
          input Absyn.Path className;
      
          input Absyn.Program p;
      
          output Boolean isState;
      
        algorithm
      
          isState := match p
      
            local
      
              String stateStr;
      
            case _
      
              algorithm
      
        6
                stateStr := ProgramUtil.getNamedAnnotationExp(className, p, Absyn.IDENT("__Dymola_state"), SOME("false"), getDymolaStateAnnotationModStr);
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        6
              then
      
                stringEq(stateStr, "true");
      
          end match;
      
        end getDymolaStateAnnotation;
      
        protected function getDymolaStateAnnotationModStr
      
          "Extractor function for getDymolaStateAnnotation"
      
          input Option<Absyn.Modification> mod;
      
          output String stateStr;
      
        algorithm
      
          stateStr := matchcontinue mod
      
            local Absyn.Exp e;
      
            case SOME(Absyn.CLASSMOD(eqMod = Absyn.EQMOD(exp=e)))
      
              algorithm
      
        ✗
                stateStr := Dump.printExpStr(e);
      
              then
      
                stateStr;
      
            else "false";
      
          end matchcontinue;
      
        end getDymolaStateAnnotationModStr;
      
        protected function getClassInformation
      
        "author: PA
      
          Returns all the possible class information.
      
          changed by adrpo 2006-02-24 (latest 2006-03-14) to return more info and in a different format:
      
          {\"restriction\",\"comment\",\"filename.mo\",{bool,bool,bool},{\"readonly|writable\",int,int,int,int}}
      
          if you like more named attributes, use getClassAttributes API which uses get_class_attributes function
      
          change by sjoelund.se 2014-11-14 to actually be sane. Using the typed API.
      
          "
      
          input Absyn.Path path;
      
          input Absyn.Program p;
      
          output Values.Value res_1;
      
        protected
      
          String name,file,res,cmt,version,preferredView,access,versionDate,versionBuild,dateModified,revisionId;
      
          String lastIdent;
      
          Boolean partialPrefix,finalPrefix,encapsulatedPrefix,isReadOnly,isProtectedClass,isDocClass,isState;
      
          Absyn.Restriction restr;
      
          Absyn.ClassDef cdef;
      
          Integer sl,sc,el,ec;
      
          Absyn.Path classPath;
      
        algorithm
      
        6
          Absyn.CLASS(name,partialPrefix,finalPrefix,encapsulatedPrefix,restr,cdef,_,_,_,SOURCEINFO(file,isReadOnly,sl,sc,el,ec,_)) := ProgramUtil.getPathedClassInProgram(path, p);
      
        6
          res := Dump.unparseRestrictionStr(restr);
      
        6
          cmt := getClassDefComment(cdef);
      
        6
          file := Testsuite.friendly(file);
      
          2/2✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.

        6
          if AbsynUtil.pathIsIdent(AbsynUtil.makeNotFullyQualified(path)) then
      
            isProtectedClass := false;
      
          else
      
        4
            lastIdent := AbsynUtil.pathLastIdent(AbsynUtil.makeNotFullyQualified(path));
      
        4
            classPath := AbsynUtil.stripLast(path);
      
        4
            isProtectedClass := Interactive.isProtectedClass(classPath, lastIdent, p);
      
          end if;
      
        6
          isDocClass := Interactive.getDocumentationClassAnnotation(path, p);
      
        6
          version := CevalScript.getPackageVersion(path, p);
      
        6
          preferredView := Interactive.getStringNamedAnnotation(path, p, Absyn.IDENT("preferredView"));
      
        6
          isState := getDymolaStateAnnotation(path, p);
      
        6
          access := Interactive.getAccessAnnotation(path, p);
      
        6
          versionDate := Interactive.getStringNamedAnnotation(path, p, Absyn.IDENT("versionDate"));
      
        6
          versionBuild := Interactive.getIntegerNamedAnnotation(path, p, Absyn.IDENT("versionBuild"));
      
        6
          dateModified := Interactive.getStringNamedAnnotation(path, p, Absyn.IDENT("dateModified"));
      
        6
          revisionId := Interactive.getStringNamedAnnotation(path, p, Absyn.IDENT("revisionId"));
      
          7/14✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 6 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 19 taken 6 times.
✗ Branch 20 not taken.
✓ Branch 22 taken 6 times.
✗ Branch 23 not taken.
✓ Branch 27 taken 6 times.
✗ Branch 28 not taken.

        60
          res_1 := Values.TUPLE({
      
            Values.STRING(res),
      
            Values.STRING(cmt),
      
            Values.BOOL(partialPrefix),
      
            Values.BOOL(finalPrefix),
      
            Values.BOOL(encapsulatedPrefix),
      
            Values.STRING(file),
      
            Values.BOOL(isReadOnly),
      
            Values.INTEGER(sl),
      
            Values.INTEGER(sc),
      
            Values.INTEGER(el),
      
            Values.INTEGER(ec),
      
            getClassDimensions(cdef),
      
            Values.BOOL(isProtectedClass),
      
            Values.BOOL(isDocClass),
      
            Values.STRING(version),
      
            Values.STRING(preferredView),
      
            Values.BOOL(isState),
      
            Values.STRING(access),
      
            Values.STRING(versionDate),
      
            Values.STRING(versionBuild),
      
            Values.STRING(dateModified),
      
            Values.STRING(revisionId)
      
          });
      
        end getClassInformation;
      
        function getClassDimensions
      
        "return the dimensions of a class
      
         as vector of dimension sizes in a string.
      
         Note: A class can only have dimensions if it is a short class definition."
      
          input Absyn.ClassDef cdef;
      
          output Values.Value v;
      
        algorithm
      
          v := match cdef
      
            local
      
              Absyn.ArrayDim ad;
      
            case Absyn.DERIVED(typeSpec=Absyn.TPATH(arrayDim=SOME(ad)))
      
        ✗
              then ValuesMake.makeArray(list(Values.STRING(Dump.printSubscriptStr(d)) for d in ad));
      
        6
            else ValuesMake.makeArray({});
      
          end match;
      
        end getClassDimensions;
      
        function getClassElementComment
      
          "Returns the comment on a class element."
      
          input Absyn.Element element;
      
          output String commentStr;
      
        protected
      
          Absyn.Class cls;
      
        algorithm
      
          commentStr := match element
      
            case Absyn.Element.ELEMENT(specification = Absyn.ElementSpec.CLASSDEF(class_ = cls))
      
              algorithm
      
                // The comment can go either before and/or after the constrainedby clause,
      
                // the one after has higher priority.
      
        ✗
                commentStr := InteractiveUtil.getConstrainingClassComment(element.constrainClass);
      
        ✗
                if stringEmpty(commentStr) then
      
        ✗
                  commentStr := getClassDefComment(cls.body);
      
                end if;
      
              then
      
                commentStr;
      
            else "";
      
          end match;
      
        end getClassElementComment;
      
        function getClassDefComment "Returns the class comment of a Absyn.ClassDef"
      
          input Absyn.ClassDef inClassDef;
      
          output String outString;
      
        algorithm
      
          outString:=
      
          match inClassDef
      
            local
      
              String str;
      
              Option<Absyn.Comment> cmt;
      
            case Absyn.PARTS(comment = SOME(str)) then str;
      
            case Absyn.DERIVED(comment = cmt)
      
        ✗
              then Interactive.getStringComment(cmt);
      
            case Absyn.ENUMERATION(comment = cmt)
      
        ✗
              then Interactive.getStringComment(cmt);
      
            case Absyn.ENUMERATION(comment = cmt)
      
        ✗
              then Interactive.getStringComment(cmt);
      
            case Absyn.OVERLOAD(comment = cmt)
      
        ✗
              then Interactive.getStringComment(cmt);
      
            case Absyn.CLASS_EXTENDS(comment = SOME(str)) then str;
      
            else "";
      
          end match;
      
        end getClassDefComment;
      
        protected function getAnnotationInEquation
      
          "This function takes an `EquationItem\' and returns a comma separated
      
          string of values  from the flat record of an equation annotation that
      
          is found in the `EquationItem\'."
      
          input Absyn.EquationItem inEquationItem;
      
          output String outString;
      
        algorithm
      
          outString := match inEquationItem
      
            local
      
              String annotationStr;
      
              list<String> annotationList;
      
              list<Absyn.ElementArg> annotations;
      
            case Absyn.EQUATIONITEM(comment = SOME(Absyn.COMMENT(SOME(Absyn.ANNOTATION(annotations)),_)))
      
              algorithm
      
        11
                annotationList := getAnnotationInEquationElArgs(annotations);
      
        11
                annotationStr := stringDelimitList(annotationList, ", ");
      
              then
      
                annotationStr;
      
            case Absyn.EQUATIONITEM(comment = NONE())
      
              then
      
                "";
      
          end match;
      
        end getAnnotationInEquation;
      
        protected function getAnnotationInEquationElArgs
      
          input list<Absyn.ElementArg> inElArgLst;
      
          output list<String> outStringLst;
      
        algorithm
      
          outStringLst := matchcontinue inElArgLst
      
            local
      
              Absyn.FunctionArgs fargs;
      
              list<SCode.Element> p_1;
      
              FCore.Graph env;
      
              DAE.Exp newexp;
      
              String gexpstr, gexpstr_1, annName;
      
              list<String> res;
      
              list<Absyn.ElementArg>  mod, rest;
      
              FCore.Cache cache;
      
              DAE.Properties prop;
      
              Absyn.Program lineProgram;
      
            // handle empty
      
            case {} then {};
      
            case Absyn.MODIFICATION(path = Absyn.IDENT(annName), modification = SOME(Absyn.CLASSMOD(mod,_))) :: rest
      
              algorithm
      
        11
                lineProgram := InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion());
      
        11
                fargs := Interactive.createFuncargsFromElementargs(mod);
      
        11
                p_1 := AbsynToSCode.translateAbsyn2SCode(lineProgram);
      
        11
                (cache,env) := Inst.makeEnvFromProgram(p_1);
      
        11
                (_,newexp,prop) := StaticScript.elabGraphicsExp(cache,env, Absyn.CALL(Absyn.CREF_IDENT(annName,{}),fargs,{}), false,DAE.NOPRE(), sourceInfo()) "impl" ;
      
        11
                (cache, newexp, prop) := Ceval.cevalIfConstant(cache, env, newexp, prop, false, sourceInfo());
      
        11
                Print.clearErrorBuf() "this is to clear the error-msg generated by the annotations." ;
      
        11
                gexpstr := ExpressionBasics.printExpStr(newexp);
      
        11
                res := getAnnotationInEquationElArgs(rest);
      
              then
      
                (gexpstr :: res);
      
            case Absyn.MODIFICATION(path = Absyn.IDENT(annName), modification = SOME(Absyn.CLASSMOD(_,Absyn.NOMOD()))) :: rest
      
              algorithm
      
        ✗
                gexpstr_1 := stringAppendList({annName,"(error)"});
      
        ✗
                res := getAnnotationInEquationElArgs(rest);
      
              then
      
                (gexpstr_1 :: res);
      
          end matchcontinue;
      
        end getAnnotationInEquationElArgs;
      
        protected function getTransitions
      
          input Absyn.Path path;
      
          input Absyn.Program p;
      
          output Values.Value res;
      
        protected
      
          list<list<String>> transitions;
      
          Absyn.Class cdef;
      
        algorithm
      
        4
          cdef := ProgramUtil.getPathedClassInProgram(path, p);
      
        4
          transitions := listReverse(getTransitionsInClass(cdef));
      
        4
          res := ValuesMake.makeArray(List.map(transitions, ValuesMake.makeStringArray));
      
        end getTransitions;
      
        protected function getTransitionsInClass
      
          "Gets the list of transitions in a class."
      
          input Absyn.Class inClass;
      
          output list<list<String>> outTransitions;
      
        algorithm
      
          outTransitions := match inClass
      
            local
      
              list<list<String>> transitions;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        4
                transitions := getTransitionsInClassParts(parts);
      
              then
      
                transitions;
      
            // handle also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                transitions := getTransitionsInClassParts(parts);
      
              then
      
                transitions;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getTransitionsInClass;
      
        protected function getTransitionsInClassParts
      
          "Helper function for getTransitionsInClass."
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<list<String>> outTransitions;
      
        algorithm
      
          outTransitions := matchcontinue inAbsynClassPartLst
      
            local
      
              list<list<String>> transitions1, transitions2;
      
              list<Absyn.EquationItem> eqlist;
      
              list<Absyn.ClassPart> xs;
      
            case Absyn.EQUATIONS(contents = eqlist) :: xs
      
              algorithm
      
        4
                transitions1 := getTransitionsInEquations(eqlist, {});
      
        4
                transitions2 := getTransitionsInClassParts(xs);
      
        4
              then
      
                listAppend(transitions1, transitions2);
      
            case _ :: xs
      
              algorithm
      
        4
                transitions1 := getTransitionsInClassParts(xs);
      
              then
      
                transitions1;
      
            case {}
      
              then {};
      
          end matchcontinue;
      
        end getTransitionsInClassParts;
      
        protected function getTransitionsInEquations
      
          "Helper function for getTransitionsInClass."
      
          input list<Absyn.EquationItem> inAbsynEquationItemLst;
      
          input list<list<String>> inTransitions;
      
          output list<list<String>> outTransitions;
      
        algorithm
      
          outTransitions := match (inAbsynEquationItemLst, inTransitions)
      
            local
      
              list<list<String>> transitions;
      
              list<String> transition;
      
              Absyn.EquationItem eqItem;
      
              Absyn.Equation eq;
      
              list<Absyn.EquationItem> xs;
      
            case (((eqItem as Absyn.EQUATIONITEM(equation_ = eq as Absyn.EQ_NORETCALL(functionName = Absyn.CREF_IDENT(name = "transition")))) :: xs),transitions)
      
              algorithm
      
        14
                transition := getTransitionInEquation(eq);
      
        14
                transition := List.insert(transition, listLength(transition) + 1, getAnnotationInEquation(eqItem));
      
                transitions := listAppend({transition}, transitions);
      
        14
              then
      
                getTransitionsInEquations(xs, transitions);
      
            case ((_ :: xs), _)
      
        8
              then
      
                getTransitionsInEquations(xs, inTransitions);
      
            case ({}, _)
      
              then
      
                inTransitions;
      
          end match;
      
        end getTransitionsInEquations;
      
        protected function getTransitionInEquation
      
          "Transition is a Absyn.EQ_NORETCALL.
      
          So we read the function arguments and named arguments.
      
          This function should always return a list with 7 values."
      
          input Absyn.Equation inEquation;
      
          output list<String> outTransition;
      
        algorithm
      
          outTransition := match inEquation
      
            local
      
              list<Absyn.Exp> expArgs;
      
              list<Absyn.NamedArg> namedArgs;
      
              list<String> transition;
      
            case Absyn.EQ_NORETCALL(functionArgs = Absyn.FUNCTIONARGS(args = expArgs, argNames = namedArgs))
      
              algorithm
      
        14
                transition := List.map(expArgs, Dump.printExpStr);
      
                // if we have named args then give them preference
      
        14
                transition := Interactive.addOrUpdateNamedArg(namedArgs, "immediate", "true", transition, 4);
      
        14
                transition := Interactive.addOrUpdateNamedArg(namedArgs, "reset", "true", transition, 5);
      
        14
                transition := Interactive.addOrUpdateNamedArg(namedArgs, "synchronize", "false", transition, 6);
      
        14
                transition := Interactive.addOrUpdateNamedArg(namedArgs, "priority", "1", transition, 7);
      
              then
      
                transition;
      
            else {"", "", "", "true", "true", "false", "1"};
      
          end match;
      
        end getTransitionInEquation;
      
        protected function getInitialStates
      
          input Absyn.Path path;
      
          input Absyn.Program p;
      
          output Values.Value res;
      
        protected
      
          list<list<String>> initialStates;
      
          Absyn.Class cdef;
      
        algorithm
      
        1
          cdef := ProgramUtil.getPathedClassInProgram(path, p);
      
        1
          initialStates := listReverse(getInitialStatesInClass(cdef));
      
        1
          res := ValuesMake.makeArray(List.map(initialStates, ValuesMake.makeStringArray));
      
        end getInitialStates;
      
        protected function getInitialStatesInClass
      
          "Gets the list of initial states in a class."
      
          input Absyn.Class inClass;
      
          output list<list<String>> outInitialStates;
      
        algorithm
      
          outInitialStates := match inClass
      
            local
      
              list<list<String>> initialStates;
      
              list<Absyn.ClassPart> parts;
      
            case Absyn.CLASS(body = Absyn.PARTS(classParts = parts))
      
              algorithm
      
        1
                initialStates := getInitialStatesInClassParts(parts);
      
              then
      
                initialStates;
      
            // handle also the case model extends X end X;
      
            case Absyn.CLASS(body = Absyn.CLASS_EXTENDS(parts = parts))
      
              algorithm
      
        ✗
                initialStates := getInitialStatesInClassParts(parts);
      
              then
      
                initialStates;
      
            case Absyn.CLASS(body = Absyn.DERIVED()) then {};
      
          end match;
      
        end getInitialStatesInClass;
      
        protected function getInitialStatesInClassParts
      
          "Helper function for getInitialStatesInClass."
      
          input list<Absyn.ClassPart> inAbsynClassPartLst;
      
          output list<list<String>> outInitialStates;
      
        algorithm
      
          outInitialStates := matchcontinue inAbsynClassPartLst
      
            local
      
              list<list<String>> initialStates1, initialStates2;
      
              list<Absyn.EquationItem> eqlist;
      
              list<Absyn.ClassPart> xs;
      
            case Absyn.EQUATIONS(contents = eqlist) :: xs
      
              algorithm
      
        1
                initialStates1 := getInitialStatesInEquations(eqlist, {});
      
        1
                initialStates2 := getInitialStatesInClassParts(xs);
      
        1
              then
      
                listAppend(initialStates1, initialStates2);
      
            case _ :: xs
      
              algorithm
      
        1
                initialStates1 := getInitialStatesInClassParts(xs);
      
              then
      
                initialStates1;
      
            case {}
      
              then {};
      
          end matchcontinue;
      
        end getInitialStatesInClassParts;
      
        protected function getInitialStatesInEquations
      
          "Helper function for getInitialStatesInClass."
      
          input list<Absyn.EquationItem> inAbsynEquationItemLst;
      
          input list<list<String>> inInitialStates;
      
          output list<list<String>> outInitialStates;
      
        algorithm
      
          outInitialStates := match (inAbsynEquationItemLst, inInitialStates)
      
            local
      
              list<list<String>> initialStates;
      
              list<String> initialState;
      
              Absyn.EquationItem eqItem;
      
              Absyn.Equation eq;
      
              list<Absyn.EquationItem> xs;
      
            case (((eqItem as Absyn.EQUATIONITEM(equation_ = eq as Absyn.EQ_NORETCALL(functionName = Absyn.CREF_IDENT(name = "initialState")))) :: xs),initialStates)
      
              algorithm
      
        1
                initialState := getInitialStateInEquation(eq);
      
        1
                initialState := List.insert(initialState, listLength(initialState) + 1, getAnnotationInEquation(eqItem));
      
                initialStates := listAppend({initialState}, initialStates);
      
        1
              then
      
                getInitialStatesInEquations(xs, initialStates);
      
            case ((_ :: xs), _)
      
        4
              then
      
                getInitialStatesInEquations(xs, inInitialStates);
      
            case ({}, _)
      
              then
      
                inInitialStates;
      
          end match;
      
        end getInitialStatesInEquations;
      
        protected function getInitialStateInEquation
      
          "Initial state is a Absyn.EQ_NORETCALL.
      
          So we read the function arguments and named arguments.
      
          This function should always return a list with 1 value."
      
          input Absyn.Equation inEquation;
      
          output list<String> outInitialState;
      
        algorithm
      
          outInitialState := match inEquation
      
            local
      
              list<Absyn.Exp> expArgs;
      
              list<String> initialState;
      
            case Absyn.EQ_NORETCALL(functionArgs = Absyn.FUNCTIONARGS(args = expArgs))
      
              algorithm
      
        1
                initialState := List.map(expArgs, Dump.printExpStr);
      
              then
      
                initialState;
      
            else {""};
      
          end match;
      
        end getInitialStateInEquation;
      
        protected function addInitialState
      
        "Adds an initial state to the model, i.e., initialState(state1)"
      
          input Absyn.Path inPath;
      
          input String state;
      
          input list<Absyn.NamedArg> inAbsynNamedArgLst;
      
          input Absyn.Program inProgram;
      
          output Boolean b;
      
          output Absyn.Program outProgram;
      
        algorithm
      
        2
          (b, outProgram) := addInitialStateWithAnnotation(inPath, state, InteractiveUtil.annotationListToAbsyn(inAbsynNamedArgLst), inProgram);
      
        end addInitialState;
      
        protected function addInitialStateWithAnnotation
      
        "Adds an initial state to the model, i.e., initialState(state1)"
      
          input Absyn.Path inPath;
      
          input String state;
      
          input Absyn.Annotation inAnnotation;
      
          input Absyn.Program inProgram;
      
          output Boolean b;
      
          output Absyn.Program outProgram = inProgram;
      
        protected
      
          Absyn.Path package_;
      
          Absyn.Class cdef, newcdef;
      
          Option<Absyn.Comment> cmt;
      
        algorithm
      
          try
      
        2
            cdef := ProgramUtil.getPathedClassInProgram(inPath, inProgram);
      
        2
            cmt := SOME(Absyn.COMMENT(SOME(inAnnotation), NONE()));
      
        4
            newcdef := InteractiveUtil.addToEquation(cdef, Absyn.EQUATIONITEM(Absyn.EQ_NORETCALL(Absyn.CREF_IDENT("initialState", {}),
      
                                    Absyn.FUNCTIONARGS({Absyn.CREF(Absyn.CREF_IDENT(state, {}))}, {})), cmt, Absyn.dummyInfo));
      
          1/2✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.

        2
            if AbsynUtil.pathIsIdent(AbsynUtil.makeNotFullyQualified(inPath)) then
      
        2
              outProgram := ProgramUtil.updateProgram(Absyn.PROGRAM({newcdef},inProgram.within_), inProgram);
      
            else
      
        ✗
              package_ := AbsynUtil.stripLast(inPath);
      
        ✗
              outProgram := ProgramUtil.updateProgram(Absyn.PROGRAM({newcdef},Absyn.WITHIN(package_)), inProgram);
      
            end if;
      
            b := true;
      
          else
      
            b := false;
      
          end try;
      
        end addInitialStateWithAnnotation;
      
        protected function deleteInitialState
      
        "Delete the initial state initialState(c1) from a model."
      
          input Absyn.Path inPath;
      
          input String state;
      
          input Absyn.Program inProgram;
      
          output Boolean b;
      
          output Absyn.Program outProgram;
      
        algorithm
      
          (b,outProgram) := matchcontinue (inPath, state, inProgram)
      
            local
      
              Absyn.Path modelpath, modelwithin;
      
              Absyn.Class cdef, newcdef;
      
              Absyn.Program newp, p;
      
              String state_;
      
            case (modelpath, state_, (p as Absyn.PROGRAM()))
      
              algorithm
      
        2
                cdef := ProgramUtil.getPathedClassInProgram(modelpath, p);
      
        2
                newcdef := deleteInitialStateInClass(cdef, state_);
      
          1/2✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.

        2
                if AbsynUtil.pathIsIdent(AbsynUtil.makeNotFullyQualified(modelpath)) then
      
        2
                  newp := ProgramUtil.updateProgram(Absyn.PROGRAM({newcdef}, Absyn.TOP()), p);
      
                else
      
        ✗
                  modelwithin := AbsynUtil.stripLast(modelpath);
      
        ✗
                  newp := ProgramUtil.updateProgram(Absyn.PROGRAM({newcdef}, Absyn.WITHIN(modelwithin)), p);
      
                end if;
      
              then
      
                (true, newp);
      
            case (_,_,(p as Absyn.PROGRAM())) then (false, p);
      
          end matchcontinue;
      
        end deleteInitialState;
      
        protected function deleteInitialStateInClass
      
        "Helper function to deleteInitialState."
      
          input Absyn.Class inClass;
      
          input String state;
      
          output Absyn.Class outClass;
      
        algorithm
      
          outClass := match inClass
      
            local
      
              list<Absyn.EquationItem> eqlst,eqlst_1;
      
              list<Absyn.ClassPart> parts2,parts;
      
              String bcname;
      
              Option<String> cmt;
      
              list<Absyn.ElementArg> modif;
      
              list<String> typeVars;
      
              list<Absyn.NamedArg> classAttrs;
      
              list<Absyn.Annotation> ann;
      
            /* a class with parts */
      
            case outClass as Absyn.CLASS(
      
                              body = Absyn.PARTS(typeVars = typeVars,classAttrs = classAttrs,classParts = parts,ann=ann,comment = cmt))
      
              algorithm
      
        2
                eqlst := InteractiveUtil.getEquationList(parts);
      
        2
                eqlst_1 := deleteInitialStateInEqlist(eqlst, state);
      
        2
                parts2 := InteractiveUtil.replaceEquationList(parts, eqlst_1);
      
        4
                outClass.body := Absyn.PARTS(typeVars,classAttrs,parts2,ann,cmt);
      
              then outClass;
      
            /* an extended class with parts: model extends M end M;  */
      
            case outClass as Absyn.CLASS(
      
                              body = Absyn.CLASS_EXTENDS(baseClassName = bcname,modifications=modif,parts = parts,ann = ann,comment = cmt))
      
              algorithm
      
        ✗
                eqlst := InteractiveUtil.getEquationList(parts);
      
        ✗
                eqlst_1 := deleteInitialStateInEqlist(eqlst, state);
      
        ✗
                parts2 := InteractiveUtil.replaceEquationList(parts, eqlst_1);
      
        ✗
                outClass.body := Absyn.CLASS_EXTENDS(bcname,modif,cmt,parts2,ann);
      
              then outClass;
      
          end match;
      
        end deleteInitialStateInClass;
      
        protected function deleteInitialStateInEqlist
      
        "Helper function to deleteInitialState."
      
          input list<Absyn.EquationItem> inEqs;
      
          input String state;
      
          output list<Absyn.EquationItem> outEqs;
      
        protected
      
          function is_matching_initial_state
      
            input Absyn.EquationItem item;
      
            input String state;
      
            output Boolean isMatch;
      
          protected
      
            Absyn.ComponentRef name;
      
            list<Absyn.Exp> args;
      
          algorithm
      
            isMatch := match item
      
              case Absyn.EQUATIONITEM(equation_ = Absyn.EQ_NORETCALL(functionName = name, functionArgs = Absyn.FUNCTIONARGS(args = args)))
      
                guard AbsynUtil.crefEqual(name, Absyn.CREF_IDENT("initialState", {}))
      
          4/6✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 9 taken 2 times.
✓ Branch 10 taken 2 times.

        4
                then not listEmpty(args) and state == Dump.printExpStr(listHead(args));
      
              else false;
      
            end match;
      
          end is_matching_initial_state;
      
        algorithm
      
          6/6✓ Branch 1 taken 2 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 10 times.
✓ Branch 6 taken 2 times.

        14
          outEqs := list(e for e guard not is_matching_initial_state(e, state) in inEqs);
      
        end deleteInitialStateInEqlist;
      
        function getComponentInfo
      
          input Absyn.Element comp;
      
          input Interactive.GraphicEnvCache inEnv;
      
          input Boolean isProtected;
      
          output list<Values.Value> vs;
      
        algorithm
      
          vs := match comp
      
            local
      
              Absyn.Path p_1, p;
      
              String typename, inout_str, variability_str, dir_str, name, comment;
      
              Boolean r_1;
      
              Absyn.ElementAttributes attr;
      
              list<String> dims, dims1;
      
              Absyn.ArrayDim subs;
      
              Absyn.ElementSpec spec;
      
            case Absyn.ELEMENT(specification = spec as Absyn.COMPONENTS(attributes = attr,typeSpec = Absyn.TPATH(p, _)))
      
              algorithm
      
                typename := matchcontinue ()
      
                  case ()
      
                    algorithm
      
        6
                      (_, p_1) := Interactive.mkFullyQual(inEnv, p);
      
        6
                    then AbsynUtil.pathString(p_1);
      
        ✗
                  else AbsynUtil.pathString(p);
      
                end matchcontinue;
      
                vs := {};
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.

        6
                dims1 := list(Dump.printSubscriptStr(sub) for sub in attr.arrayDim);
      
        6
                r_1 := Interactive.keywordReplaceable(comp.redeclareKeywords);
      
        6
                inout_str := AbsynUtil.innerOuterStr(comp.innerOuter);
      
        6
                variability_str := attrVariabilityStr(attr);
      
        6
                dir_str := attrDirectionStr(attr);
      
          2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 6 times.

        12
                for ci in spec.components loop
      
        6
                  (name, comment) := getComponentitemsName(ci);
      
        6
                  Absyn.COMPONENTITEM(component=Absyn.COMPONENT(arrayDim=subs)) := ci;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.

        6
                  dims := listAppend(list(Dump.printSubscriptStr(sub) for sub in subs), dims1);
      
        6
                  vs := makeGetComponentsRecord(
      
                    className = typename, name = name, comment = comment,
      
                    isProtected=isProtected, isReplaceable=r_1, isFinal=comp.finalPrefix, innerOuter=inout_str, isFlow=attr.flowPrefix,
      
                    isStream=attr.streamPrefix, variability=variability_str, inputOutput=dir_str, dimensions=dims) :: vs;
      
                end for;
      
              then vs;
      
          end match;
      
        end getComponentInfo;
      
        function makeGetComponentsRecord
      
          input String className;
      
          input String name;
      
          input String comment;
      
          input Boolean isProtected;
      
          input Boolean isFinal;
      
          input Boolean isFlow;
      
          input Boolean isStream;
      
          input Boolean isReplaceable;
      
          input String variability;
      
          input String innerOuter;
      
          input String inputOutput;
      
          input list<String> dimensions;
      
          output Values.Value v;
      
        algorithm
      
          7/14✓ Branch 3 taken 6 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 9 taken 6 times.
✗ Branch 10 not taken.
✓ Branch 12 taken 6 times.
✗ Branch 13 not taken.
✓ Branch 15 taken 6 times.
✗ Branch 16 not taken.
✗ Branch 21 not taken.
✓ Branch 22 taken 6 times.
✗ Branch 23 not taken.
✓ Branch 24 taken 6 times.

        42
          v := Values.RECORD(
      
            Absyn.QUALIFIED("OpenModelica", Absyn.QUALIFIED("Scripting", Absyn.QUALIFIED("getComponentsTest", Absyn.IDENT("Component")))),
      
            {
      
              Values.STRING(className),
      
              Values.STRING(name),
      
              Values.STRING(comment),
      
              Values.BOOL(isProtected),
      
              Values.BOOL(isFinal),
      
              Values.BOOL(isFlow),
      
              Values.BOOL(isStream),
      
              Values.BOOL(isReplaceable),
      
              Values.STRING(variability),
      
              Values.STRING(innerOuter),
      
              Values.STRING(inputOutput),
      
              ValuesMake.makeArray(list(Values.STRING(s) for s in dimensions))
      
            },
      
            {"className","name","comment","isProtected","isFinal","isFlow","isStream","isReplaceable","variability","innerOuter","inputOutput","dimensions"},
      
            -1
      
          );
      
        end makeGetComponentsRecord;
      
        function attrVariabilityStr
      
        "Helper function to get_component_info,
      
          retrieve variability as a string."
      
          input Absyn.ElementAttributes inElementAttributes;
      
          output String outString;
      
        algorithm
      
          outString:=
      
          match inElementAttributes
      
            case Absyn.ATTR(variability = Absyn.VAR()) then "";
      
            case Absyn.ATTR(variability = Absyn.DISCRETE()) then "discrete";
      
            case Absyn.ATTR(variability = Absyn.PARAM()) then "parameter";
      
            case Absyn.ATTR(variability = Absyn.CONST()) then "constant";
      
          end match;
      
        end attrVariabilityStr;
      
        function attrDirectionStr
      
        "Helper function to get_component_info,
      
          retrieve direction as a string."
      
          input Absyn.ElementAttributes inElementAttributes;
      
          output String outString;
      
        algorithm
      
          outString:=
      
          match inElementAttributes
      
            case Absyn.ATTR(direction = Absyn.INPUT()) then "input";
      
            case Absyn.ATTR(direction = Absyn.OUTPUT()) then "output";
      
            case Absyn.ATTR(direction = Absyn.BIDIR()) then "";
      
          end match;
      
        end attrDirectionStr;
      
        function getComponentitemsName
      
          " separated list of all component names and comments (if any)."
      
          input Absyn.ComponentItem ci;
      
          output String name;
      
          output String comment;
      
        algorithm
      
          (name, comment) := match ci
      
            local
      
              String c1,s2;
      
            case Absyn.COMPONENTITEM(component = Absyn.COMPONENT(name = c1),comment = SOME(Absyn.COMMENT(_,SOME(s2))))
      
              then (c1, s2);
      
            case Absyn.COMPONENTITEM(component = Absyn.COMPONENT(name = c1),comment = SOME(Absyn.COMMENT(_,_)))
      
              then (c1, "");
      
            case Absyn.COMPONENTITEM(component = Absyn.COMPONENT(name = c1),comment = NONE())
      
              then (c1, "");
      
          end match;
      
        end getComponentitemsName;
      
        function getModelFigures
      
          "The figures sub-annotation of Documentation, as Scripting.Figure records."
      
          input Absyn.Path classPath;
      
          input Absyn.Program program;
      
          output Values.Value result;
      
        protected
      
          Absyn.Class cls;
      
          Option<list<Values.Value>> ofigs;
      
          list<Values.Value> figs;
      
        algorithm
      
        ✗
          cls := ProgramUtil.getPathedClassInProgram(classPath, program);
      
        ✗
          ofigs := AbsynUtil.getNamedAnnotationInClass(cls,
      
            Absyn.QUALIFIED("Documentation", Absyn.IDENT("figures")), figuresFromMod);
      
          figs := match ofigs case SOME(figs) then figs; else {}; end match;
      
        ✗
          result := ValuesMake.makeArray(figs);
      
        end getModelFigures;
      
        function figuresFromMod
      
          input Option<Absyn.Modification> mod;
      
          output list<Values.Value> figures;
      
        algorithm
      
          figures := match mod
      
            local
      
              Absyn.Exp exp;
      
            case SOME(Absyn.CLASSMOD(eqMod = Absyn.EQMOD(exp = exp)))
      
        ✗
              then list(figureValue(e) for e in figureExpElements(exp));
      
            else {};
      
          end match;
      
        end figuresFromMod;
      
        function figureExpElements
      
          "Array elements of a figures/plots/curves value, or the value itself if scalar."
      
          input Absyn.Exp exp;
      
          output list<Absyn.Exp> exps;
      
        algorithm
      
          exps := match exp
      
        ✗
            case Absyn.ARRAY() then exp.arrayExp;
      
            else {exp};
      
          end match;
      
        end figureExpElements;
      
        function figureValue
      
          input Absyn.Exp exp;
      
          output Values.Value value;
      
        protected
      
          list<tuple<String, Absyn.Exp>> args;
      
          list<Values.Value> plots;
      
        algorithm
      
        ✗
          args := figureArgs(exp, {"title", "identifier", "group", "preferred", "plots", "caption"});
      
          plots := match figureArgExp(args, "plots")
      
            local Absyn.Exp e;
      
        ✗
            case SOME(e) then list(plotValue(p) for p in figureExpElements(e));
      
            else {};
      
          end match;
      
        ✗
          value := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.Figure"),
      
            {figureStringArg(args, "title", ""),
      
             figureStringArg(args, "identifier", ""),
      
             figureStringArg(args, "group", ""),
      
             figureBoolArg(args, "preferred", false),
      
             ValuesMake.makeArray(plots),
      
             figureStringArg(args, "caption", "")},
      
            {"title", "identifier", "group", "preferred", "plots", "caption"}, -1);
      
        end figureValue;
      
        function plotValue
      
          input Absyn.Exp exp;
      
          output Values.Value value;
      
        protected
      
          list<tuple<String, Absyn.Exp>> args;
      
          list<Values.Value> curves;
      
        algorithm
      
        ✗
          args := figureArgs(exp, {"title", "identifier", "curves", "x", "y"});
      
          curves := match figureArgExp(args, "curves")
      
            local Absyn.Exp e;
      
        ✗
            case SOME(e) then list(curveValue(c) for c in figureExpElements(e));
      
            else {};
      
          end match;
      
        ✗
          value := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.Plot"),
      
            {figureStringArg(args, "title", ""),
      
             figureStringArg(args, "identifier", ""),
      
             ValuesMake.makeArray(curves),
      
             axisValue(figureArgExp(args, "x")),
      
             axisValue(figureArgExp(args, "y"))},
      
            {"title", "identifier", "curves", "x", "y"}, -1);
      
        end plotValue;
      
        function curveValue
      
          input Absyn.Exp exp;
      
          output Values.Value value;
      
        protected
      
          list<tuple<String, Absyn.Exp>> args;
      
        algorithm
      
        ✗
          args := figureArgs(exp, {"x", "y", "legend", "zOrder"});
      
        ✗
          value := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.Curve"),
      
            {figureRefArg(args, "x", "time"),
      
             figureRefArg(args, "y", ""),
      
             figureStringArg(args, "legend", ""),
      
             figureIntArg2(args, "zOrder", 0)},
      
            {"x", "y", "legend", "zOrder"}, -1);
      
        end curveValue;
      
        function axisValue
      
          input Option<Absyn.Exp> oexp;
      
          output Values.Value value;
      
        protected
      
          list<tuple<String, Absyn.Exp>> args;
      
        algorithm
      
        ✗
          args := match oexp case SOME(_) then figureArgs(Util.getOption(oexp), {"min", "max", "unit", "label", "scale"}); else {}; end match;
      
        ✗
          value := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.Axis"),
      
            {figureRealBoundArg(args, "min"),
      
             figureRealBoundArg(args, "max"),
      
             figureStringArg(args, "unit", ""),
      
             figureStringArg(args, "label", ""),
      
             axisScaleValue(figureArgExp(args, "scale"))},
      
            {"min", "max", "unit", "label", "scale"}, -1);
      
        end axisValue;
      
        function axisScaleValue
      
          input Option<Absyn.Exp> oexp;
      
          output Values.Value value;
      
        protected
      
          String scaleType = "Linear";
      
          Integer base = 10;
      
        algorithm
      
          _ := match oexp
      
            local
      
              Absyn.ComponentRef cr;
      
              Absyn.FunctionArgs fargs;
      
            case SOME(Absyn.CALL(function_ = cr, functionArgs = fargs))
      
              algorithm
      
        ✗
                scaleType := AbsynUtil.crefIdent(cr);
      
        ✗
                base := figureIntArg(figureArgs(Absyn.CALL(cr, fargs, {}), {"base"}), "base", 10);
      
              then ();
      
            else ();
      
          end match;
      
        ✗
          value := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.AxisScale"),
      
            {Values.STRING(scaleType), Values.INTEGER(base)},
      
            {"scaleType", "base"}, -1);
      
        end axisScaleValue;
      
        function figureArgs
      
          "Maps a record-constructor call's arguments to (fieldName, exp) pairs;
      
           positional args by declared field order, named args by name."
      
          input Absyn.Exp exp;
      
          input list<String> fieldNames;
      
          output list<tuple<String, Absyn.Exp>> args = {};
      
        protected
      
          list<Absyn.Exp> pos;
      
          list<Absyn.NamedArg> named;
      
          list<String> names = fieldNames;
      
          String name;
      
        algorithm
      
          () := match exp
      
            case Absyn.CALL(functionArgs = Absyn.FUNCTIONARGS(args = pos, argNames = named))
      
              algorithm
      
        ✗
                for e in pos loop
      
        ✗
                  name :: names := names;
      
        ✗
                  args := (name, e) :: args;
      
                end for;
      
        ✗
                for na in named loop
      
        ✗
                  args := (na.argName, na.argValue) :: args;
      
                end for;
      
              then ();
      
            else ();
      
          end match;
      
        end figureArgs;
      
        function figureArgExp
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          output Option<Absyn.Exp> oexp = NONE();
      
        protected
      
          String n;
      
          Absyn.Exp e;
      
        algorithm
      
        ✗
          for a in args loop
      
        ✗
            (n, e) := a;
      
        ✗
            if n == name then
      
              oexp := SOME(e);
      
        ✗
              return;
      
            end if;
      
          end for;
      
        end figureArgExp;
      
        function figureStringArg
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input String default;
      
          output Values.Value value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
        ✗
            case SOME(Absyn.STRING()) then Values.STRING(figureArgString(args, name, default));
      
        ✗
            else Values.STRING(default);
      
          end match;
      
        end figureStringArg;
      
        function figureArgString
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input String default;
      
          output String value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
            local String s;
      
            case SOME(Absyn.STRING(value = s)) then s;
      
            else default;
      
          end match;
      
        end figureArgString;
      
        function figureRefArg
      
          "A Curve x/y result reference, serialized as its Modelica source text."
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input String default;
      
          output Values.Value value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
            local Absyn.Exp e;
      
        ✗
            case SOME(e) then Values.STRING(Dump.printExpStr(e));
      
        ✗
            else Values.STRING(default);
      
          end match;
      
        end figureRefArg;
      
        function figureBoolArg
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input Boolean default;
      
          output Values.Value value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
            local Boolean b;
      
        ✗
            case SOME(Absyn.BOOL(value = b)) then Values.BOOL(b);
      
        ✗
            else Values.BOOL(default);
      
          end match;
      
        end figureBoolArg;
      
        function figureIntArg
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input Integer default;
      
          output Integer value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
            local Integer i;
      
            case SOME(Absyn.INTEGER(value = i)) then i;
      
            else default;
      
          end match;
      
        end figureIntArg;
      
        function figureRealBoundArg
      
          "An axis bound: empty Real[:] when absent (auto), length 1 when given."
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          output Values.Value value;
      
        algorithm
      
          value := match figureArgExp(args, name)
      
            local Absyn.Exp e;
      
        ✗
            case SOME(e) then ValuesMake.makeArray({Values.REAL(figureExpReal(e))});
      
        ✗
            else ValuesMake.makeArray({});
      
          end match;
      
        end figureRealBoundArg;
      
        function figureExpReal
      
          input Absyn.Exp exp;
      
          output Real value;
      
        algorithm
      
          value := match exp
      
            local Integer i; String s;
      
        ✗
            case Absyn.INTEGER(value = i) then intReal(i);
      
        ✗
            case Absyn.REAL(value = s) then stringReal(s);
      
        ✗
            case Absyn.UNARY(op = Absyn.UMINUS()) then -figureExpReal(exp.exp);
      
            else 0.0;
      
          end match;
      
        end figureExpReal;
      
        function figureIntArg2
      
          input list<tuple<String, Absyn.Exp>> args;
      
          input String name;
      
          input Integer default;
      
          output Values.Value value;
      
        algorithm
      
        ✗
          value := Values.INTEGER(figureIntArg(args, name, default));
      
        end figureIntArg2;
      
        function getAnnotationNamedModifiers
      
          input Absyn.Path classPath;
      
          input String annotationName;
      
          input Absyn.Program program;
      
          output Values.Value result;
      
        protected
      
          Absyn.Class cls;
      
          list<String> names;
      
          function get_names
      
            input Option<Absyn.Modification> mod;
      
            output list<String> names;
      
          protected
      
            Absyn.Modification m;
      
            list<Absyn.Path> paths;
      
          algorithm
      
            names := match mod
      
              case SOME(m)
      
                algorithm
      
          4/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 2 times.

        6
                  paths := list(AbsynUtil.elementArgName(a) for a in m.elementArgLst);
      
          5/6✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 2 times.
✓ Branch 5 taken 4 times.
✓ Branch 6 taken 2 times.

        6
                then
      
                  list(AbsynUtil.pathString(p) for p guard AbsynUtil.pathIsIdent(p) in paths);
      
              else {};
      
            end match;
      
          end get_names;
      
        algorithm
      
        2
          cls := ProgramUtil.getPathedClassInProgram(classPath, program);
      
          2/4✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.

        2
          SOME(names) := AbsynUtil.getNamedAnnotationInClass(cls, Absyn.Path.IDENT(annotationName), get_names);
      
        2
          result := ValuesMake.makeStringArray(names);
      
        end getAnnotationNamedModifiers;
      
        function getOptModifierValue
      
          input Option<Absyn.Modification> modifier;
      
          output Values.Value value;
      
        protected
      
          Absyn.Modification mod;
      
          Absyn.Exp exp;
      
        algorithm
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.

        4
          SOME(mod) := modifier;
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.

        4
          Absyn.EqMod.EQMOD(exp = exp) := mod.eqMod;
      
        4
          value := ValuesUtil.absynExpValue(exp);
      
        end getOptModifierValue;
      
        function getAnnotationModifierValue
      
          input Absyn.Path classPath;
      
          input String annotationName;
      
          input String modifierName;
      
          input Absyn.Program program;
      
          output Values.Value result;
      
        protected
      
          Absyn.Class cls;
      
        algorithm
      
        4
          cls := ProgramUtil.getPathedClassInProgram(classPath, program);
      
          2/4✗ Branch 3 not taken.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.

        4
          SOME(result) := AbsynUtil.getNamedAnnotationInClass(cls,
      
            Absyn.Path.QUALIFIED(annotationName, Absyn.Path.IDENT(modifierName)), getOptModifierValue);
      
        end getAnnotationModifierValue;
      
        function makeLoadLibrariesEntryAbsyn "Needed to be able to resolve modelica:// during runtime, etc.
      
        Should not be part of CevalScript since ModelicaServices needs this feature and the frontend needs to take care of it."
      
          input Absyn.Class cl;
      
          input list<Values.Value> acc;
      
          output list<Values.Value> out;
      
        algorithm
      
          out := match cl
      
            local
      
              String name,fileName,dir;
      
              Values.Value v;
      
              Boolean b;
      
            case Absyn.CLASS(info=SOURCEINFO(fileName="<interactive>")) then acc;
      
            case Absyn.CLASS(name=name,info=SOURCEINFO(fileName=fileName))
      
              algorithm
      
        ✗
                dir := System.dirname(fileName);
      
        ✗
                fileName := System.basename(fileName);
      
        ✗
                v := ValuesMake.makeArray({Values.STRING(name),Values.STRING(dir)});
      
        ✗
                b := stringEq(fileName,"ModelicaBuiltin.mo") or stringEq(fileName,"MetaModelicaBuiltin.mo") or stringEq(dir,".");
      
        ✗
              then List.consOnTrue(not b,v,acc);
      
          end match;
      
        end makeLoadLibrariesEntryAbsyn;
      
        function selectResultFile
      
          input output String resultFile;
      
          input String simflags;
      
        protected
      
          Integer nm;
      
          String f = "";
      
        algorithm
      
          // if there is no -r in the simflags, return
      
          2/2✓ Branch 1 taken 1106 times.
✓ Branch 2 taken 42 times.

        1148
          if  System.stringFind(simflags, "-r") < 0 then
      
        1106
            return;
      
          end if;
      
          // never fail!
      
          try
      
           // match -r="file"
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.

        42
           (nm, {_, f}) := System.regex(simflags, "-r=\"(.*?)\"", 2, true);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.

        42
           if nm == 2 then
      
        42
             resultFile := f; return;
      
           end if;
      
           // match -r='file'
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.

        42
           (nm, {_, f}) := System.regex(simflags, "-r=\'(.*?)\'", 2, true);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.

        42
           if nm == 2 then
      
        ✗
             resultFile := f; return;
      
           end if;
      
           // match -r 'file'
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.

        42
           (nm, {_, f}) := System.regex(simflags, "-r[ ]*\"(.*?)\"", 2, true);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.

        42
           if nm == 2 then
      
        ✗
             resultFile := f; return;
      
           end if;
      
           // match -r "file"
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.

        42
           (nm, {_, f}) := System.regex(simflags, "-r[ ]*\'(.*?)\'", 2, true);
      
          1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.

        42
           if nm == 2 then
      
        ✗
             resultFile := f; return;
      
           end if;
      
           // match -r=file
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 42 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 42 times.

        42
           (nm, {_, f}) := System.regex(simflags, "-r=([^ ]*)", 2, true);
      
          2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 28 times.

        42
           if nm == 2 then
      
        14
             resultFile := f; return;
      
           end if;
      
           // match -r file
      
          3/6✗ Branch 1 not taken.
✓ Branch 2 taken 28 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 28 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 28 times.

        28
           (nm, {_, f}) := System.regex(simflags, "-r[ ]*([^ ]*)", 2, true);
      
          1/2✓ Branch 0 taken 28 times.
✗ Branch 1 not taken.

        28
           if nm == 2 then
      
        28
             resultFile := f; return;
      
           end if;
      
          else
      
            // do nothing
      
          end try;
      
        end selectResultFile;
      
        function instantiateModel
      
          input output FCore.Cache cache;
      
          input FCore.Graph env;
      
          input Absyn.Path path;
      
                output Values.Value result;
      
        protected
      
          String str;
      
          Option<DAE.DAElist> odae;
      
          Flags.Flag flags;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 102 times.

        102
          if isProtectedContentAccess(path) then
      
            // if AST contains encrypted class show nothing
      
            result := Values.STRING("");
      
        ✗
            return;
      
          end if;
      
          str := matchcontinue ()
      
            case ()
      
              algorithm
      
        102
                ExecStat.execStatReset();
      
        102
                flags := loadCommandLineOptionsFromModel(path);
      
                try
      
          3/4✓ Branch 1 taken 8 times.
✓ Branch 2 taken 94 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 8 times.

        102
                  (cache, _, odae, str) := runFrontEnd(cache, env, path, relaxedFrontEnd = false,
      
                    dumpFlat = Config.flatModelica() and not Config.silent());
      
        102
                  ExecStat.execStat("runFrontEnd");
      
          5/6✓ Branch 0 taken 95 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 95 times.
✓ Branch 4 taken 13 times.
✓ Branch 5 taken 82 times.

        102
                  if not stringEmpty(str) then
      
                    // str already contains flat model.
      
                  elseif isNone(odae) then
      
        13
                    str := "";
      
                  elseif Config.silent() then
      
        ✗
                    str := "model " + AbsynUtil.pathString(path) + "\n  /* Silent mode */\nend" +
      
                      AbsynUtil.pathString(path) + ";\n"; // Not the empty string, so we can
      
                  else
      
        82
                    str := DAEDump.dumpStr(Util.getOption(odae), FCore.getFunctionTree(cache));
      
        82
                    ExecStat.execStat("DAEDump.dumpStr");
      
                  end if;
      
        102
                  FlagsUtil.saveFlags(flags);
      
                else
      
        ✗
                  FlagsUtil.saveFlags(flags);
      
        ✗
                  fail();
      
                end try;
      
        102
              then
      
                str;
      
            case ()
      
              algorithm
      
        ✗
                false := Interactive.existClass(path, SymbolTable.getAbsyn());
      
        ✗
                Error.addMessage(Error.LOOKUP_ERROR, {AbsynUtil.pathString(path), "<TOP>"});
      
              then
      
                "";
      
            else
      
              algorithm
      
        ✗
                if Error.getNumMessages() == 0 then
      
        ✗
                  str := "Instantiation of " + AbsynUtil.pathString(path) +
      
                         " failed with no error message";
      
        ✗
                  Error.addMessage(Error.INTERNAL_ERROR, {str, "<TOP>"});
      
                end if;
      
              then
      
                "";
      
          end matchcontinue;
      
        102
          result := Values.STRING(str);
      
        end instantiateModel;
      
        protected function getConnectionList
      
        "@author: rahulp
      
          Returns a list of all connect equations including those in loops"
      
          input Absyn.Path className;
      
          output Values.Value valList;
      
          protected
      
            SCode.Program sp, annotation_sp;
      
            list<list<String>> connList;
      
          algorithm
      
        2
            annotation_sp := AbsynToSCode.translateAbsyn2SCode(InteractiveUtil.modelicaAnnotationProgram(Config.getAnnotationVersion()));
      
        2
            (_, sp) := FBuiltin.getInitialFunctions();
      
        2
            sp := listAppend(SymbolTable.getSCode(), sp);
      
        2
            connList := NFInst.instClassForConnection(className, sp, annotation_sp);
      
          4/4✓ Branch 0 taken 9 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 9 times.
✓ Branch 3 taken 2 times.

        11
            valList := ValuesMake.makeArray(list(ValuesMake.makeArray(List.map(conn, ValuesMake.makeString)) for conn in connList));
      
        end getConnectionList;
      
        protected function runConversionScript
      
          input Absyn.Path clsPath;
      
          input String scriptFile;
      
          output Values.Value res;
      
        protected
      
          Absyn.Program p;
      
          Absyn.Class cls;
      
          Absyn.Within wi;
      
        algorithm
      
          try
      
        9
            p := SymbolTable.getAbsyn();
      
        9
            cls := ProgramUtil.getPathedClassInProgram(clsPath, p, showError = true);
      
            //System.startTimer();
      
        9
            cls := Conversion.convertPackage(cls, scriptFile);
      
            //System.stopTimer();
      
            //print("Conversion took " + String(System.getTimerIntervalTime()) + " seconds.\n");
      
        8
            wi := ProgramUtil.buildWithin(clsPath);
      
        8
            p := ProgramUtil.updateProgram(Absyn.PROGRAM({cls}, wi), p);
      
        8
            SymbolTable.setAbsyn(p);
      
            res := Values.BOOL(true);
      
          else
      
            res := Values.BOOL(false);
      
          end try;
      
        end runConversionScript;
      
        protected function convertPackageToLibrary
      
          input Absyn.Path clsPath;
      
          input Absyn.Path libPath;
      
          input String libVersion;
      
          output Values.Value res;
      
        protected
      
          Absyn.Program p, lib_program;
      
          Absyn.Class cls, lib_cls;
      
          Absyn.Within wi;
      
          Option<String> uses_version;
      
          SemanticVersion.Version lib_version, lib_version_used;
      
          list<tuple<String, Option<String>, Option<String>>> conversions;
      
          list<String> scripts;
      
          String lib_name;
      
        algorithm
      
          try
      
            // Get the Absyn for the class and check which version of the library it's using.
      
        2
            p := SymbolTable.getAbsyn();
      
        2
            cls := ProgramUtil.getPathedClassInProgram(clsPath, p, showError = true);
      
        2
            uses_version := Interactive.getUsedVersion(cls, libPath);
      
          3/4✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 time.
✓ Branch 3 taken 1 time.

        2
            if isSome(uses_version) then
      
        1
              lib_version_used := SemanticVersion.parse(Util.getOption(uses_version), true);
      
            else
      
        3
              Error.addMessage(Error.CONVERSION_MISSING_USES,
      
                {AbsynUtil.pathString(clsPath), AbsynUtil.pathString(libPath)});
      
        1
              fail();
      
            end if;
      
        1
            lib_name := AbsynUtil.pathFirstIdent(libPath);
      
        1
            lib_version := SemanticVersion.parse(CevalScript.getPackageVersion(libPath, p));
      
            // Check if the wanted version of the library is already loaded, otherwise
      
            // we need to load it.
      
          1/2✓ Branch 2 taken 1 time.
✗ Branch 3 not taken.

        1
            if SemanticVersion.compare(lib_version, SemanticVersion.parse(libVersion)) <> 0 then
      
              // Try to set the language standard to the version needed to load the wanted library.
      
          1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 3 not taken.
✗ Branch 4 not taken.

        1
              if lib_name == "Modelica" then
      
        ✗
                Config.setLanguageStandardFromMSL("Modelica " + libVersion, force = true);
      
              end if;
      
              // Load the library that we want to convert the class to.
      
          1/2✗ Branch 4 not taken.
✓ Branch 5 taken 1 time.

        2
              (lib_program, true) := CevalScript.loadModel({(libPath, lib_name, {libVersion}, false)},
      
                Settings.getModelicaPath(Testsuite.isRunning()), p, true, true, false, true);
      
        1
              SymbolTable.setAbsyn(lib_program);
      
            else
      
              lib_program := p;
      
            end if;
      
            // Get the version of the library.
      
        1
            lib_version := SemanticVersion.parse(CevalScript.getPackageVersion(libPath, lib_program));
      
            // Try to find a sequence of conversion scripts that can be used to convert
      
            // the class to the desired library version.
      
        1
            lib_cls := ProgramUtil.getPathedClassInProgram(libPath, lib_program, showError = true);
      
        1
            conversions := Interactive.getConversionsInClass(lib_cls);
      
        1
            scripts := findConversionPaths(conversions, lib_version, lib_version_used);
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
            if listEmpty(scripts) then
      
        ✗
              Error.addMessage(Error.CONVERSION_NO_COMPATIBLE_SCRIPT_FOUND,
      
                {AbsynUtil.pathString(libPath),
      
                 SemanticVersion.toString(lib_version_used),
      
                 SemanticVersion.toString(lib_version)});
      
        ✗
              fail();
      
            end if;
      
            // Apply the conversion scripts.
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 1 time.

        2
            for script in scripts loop
      
        1
              script := uriToFilename(script);
      
        1
              cls := Conversion.convertPackage(cls, script);
      
            end for;
      
            // Update the uses-annotation in the class to refer to the new version of the library.
      
        1
            cls := Interactive.updateUsedVersion(cls, libPath, SemanticVersion.toString(lib_version));
      
            // Finally update the class in the global Absyn.
      
        1
            wi := ProgramUtil.buildWithin(clsPath);
      
        1
            lib_program := ProgramUtil.updateProgram(Absyn.PROGRAM({cls}, wi), lib_program);
      
        1
            SymbolTable.setAbsyn(lib_program);
      
            res := Values.BOOL(true);
      
          else
      
            res := Values.BOOL(false);
      
          end try;
      
        end convertPackageToLibrary;
      
        function findConversionPaths
      
          "Tries to find the shortest path for converting from one version to another
      
           and returns the list of conversion scripts for that path. Usually only one
      
           conversion is needed, but sometimes the conversion might need to be done in
      
           several steps (e.g. 2.0.0 => 2.3.5 => 2.4.0)."
      
          input list<tuple<String, Option<String>, Option<String>>> conversions;
      
          input SemanticVersion.Version libVersion;
      
          input SemanticVersion.Version libVersionUsed;
      
          input Integer depth = 0;
      
          output list<String> scripts = {};
      
        protected
      
          list<list<String>> paths = {};
      
          Integer path_len, path_min = 100;
      
        algorithm
      
          // Abort if we go too deep to avoid crashing on malicious conversion annotations.
      
          1/2✓ Branch 0 taken 1 time.
✗ Branch 1 not taken.

        1
          if depth > 100 then
      
        ✗
            return;
      
          end if;
      
          // Find the possible path for each conversion to the version we're looking for.
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 time.

        4
          for c in conversions loop
      
        3
            paths := findConversionPath(c, libVersion, libVersionUsed, conversions, depth) :: paths;
      
          end for;
      
          // Return the shortest non-empty path.
      
          2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 time.

        4
          for p in paths loop
      
        3
            path_len := listLength(p);
      
          2/2✓ Branch 0 taken 1 time.
✓ Branch 1 taken 2 times.

        3
            if path_len > 0 and path_len < path_min then
      
              scripts := p;
      
              path_min := path_len;
      
            end if;
      
          end for;
      
        end findConversionPaths;
      
        function findConversionPath
      
          input tuple<String, Option<String>, Option<String>> conversion;
      
          input SemanticVersion.Version libVersion;
      
          input SemanticVersion.Version libVersionUsed;
      
          input list<tuple<String, Option<String>, Option<String>>> conversions;
      
          input Integer depth;
      
          output list<String> scripts = {};
      
        protected
      
          String from;
      
          Option<String> to;
      
          Option<String> script;
      
          SemanticVersion.Version from_version, to_version;
      
        algorithm
      
        3
          (from, to, script) := conversion;
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 3 times.

        3
          if isNone(script) then
      
        ✗
            return;
      
          end if;
      
        3
          from_version := SemanticVersion.parse(from, true);
      
          2/2✓ Branch 1 taken 2 times.
✓ Branch 2 taken 1 time.

        3
          if SemanticVersion.compare(libVersionUsed, from_version) == 0 then
      
          2/4✗ Branch 0 not taken.
✓ Branch 1 taken 1 time.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 time.

        1
            if isSome(to) then
      
        ✗
              to_version := SemanticVersion.parse(Util.getOption(to), true);
      
        ✗
              if SemanticVersion.compare(libVersion, to_version) <> 0 then
      
        ✗
                scripts := findConversionPaths(conversions, libVersion, to_version, depth + 1);
      
              end if;
      
            end if;
      
        1
            scripts := Util.getOption(script) :: scripts;
      
          end if;
      
        end findConversionPath;
      
        public function loadCommandLineOptionsFromModel
      
          "Applies flags from the __OpenModelica_commandLineOptions annotation of a given class and returns the old flags."
      
          input Absyn.Path className;
      
          output Flags.Flag oldFlags;
      
        protected
      
          String opts;
      
          list<String> args;
      
        algorithm
      
          1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2722 times.

        2722
          if Config.ignoreCommandLineOptionsAnnotation() then
      
        ✗
            oldFlags := FlagsUtil.loadFlags();
      
        ✗
            return;
      
          end if;
      
        2722
          loadProgram(className);
      
          // read the __OpenModelica_commandLineOptions
      
          1/2✗ Branch 2 not taken.
✓ Branch 3 taken 2722 times.

        2722
          Absyn.STRING(opts) := ProgramUtil.getNamedAnnotationExp(className, SymbolTable.getAbsyn(),
      
            Absyn.IDENT("__OpenModelica_commandLineOptions"), SOME(Absyn.STRING("")), Interactive.getAnnotationExp);
      
          2/2✓ Branch 0 taken 616 times.
✓ Branch 1 taken 2106 times.

        2722
          if not stringEmpty(opts) then
      
            // backup the current flags and apply the flags from the annotation
      
        616
            oldFlags := FlagsUtil.backupFlags();
      
        616
            args := System.strtok(opts, " ");
      
        616
            FlagsUtil.readArgs(args);
      
          else
      
        2106
            oldFlags := FlagsUtil.loadFlags();
      
          end if;
      
        end loadCommandLineOptionsFromModel;
      
        public function isProtectedContentAccess
      
          "Loads the given class, then checks if any encrypted classes are present.
      
           Note that this checks for encrypted classes everywhere, not just in the
      
           given class. The reason the class is loaded first is to make sure it's
      
           included in the check, otherwise it might be automatically loaded later and
      
           bypass the check."
      
          input Absyn.Path className;
      
          output Boolean restricted;
      
        algorithm
      
        190
          loadProgram(className);
      
        190
          restricted := Interactive.astContainsEncryptedClass(SymbolTable.getAbsyn());
      
          1/2✓ Branch 0 taken 190 times.
✗ Branch 1 not taken.

        190
          if restricted then
      
        ✗
            Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
      
          end if;
      
        end isProtectedContentAccess;
      
        annotation(__OpenModelica_Interface="backend_main");
      
        end CevalScriptBackend;