Changeset 0c3c162 in OpenModelica


Ignore:
Timestamp:
2020-10-27T16:27:07+01:00 (4 years ago)
Author:
perost <perost86@…>
Branches:
Added-citation-metadata, maintenance/v1.17, maintenance/v1.18, maintenance/v1.19, maintenance/v1.20, maintenance/v1.21, maintenance/v1.22, maintenance/v1.23, master, omlib-staging
Children:
cf1db474
Parents:
ea0ab07
git-author:
Per Östlund <perost86@…> (10/27/20 15:30:18)
git-committer:
perost <perost86@…> (10/27/20 16:27:07)
Message:

Scrape some barnacles off CevalScript.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • OMCompiler/Compiler/Script/CevalScript.mo

    r094bb66 r0c3c162  
    116116import Util;
    117117import ValuesUtil;
     118import MetaModelica.Dangerous.listReverseInPlace;
    118119
    119120public
    … …  
    548549public function cevalInteractiveFunctions2
    549550"defined in the interactive environment."
    550   input FCore.Cache inCache;
    551   input FCore.Graph inEnv;
    552   input String inFunctionName;
    553   input list<Values.Value> inVals;
     551  input FCore.Cache cache;
     552  input FCore.Graph env;
     553  input String functionName;
     554  input list<Values.Value> args;
    554555  input Absyn.Msg msg;
    555   output FCore.Cache outCache;
     556  output FCore.Cache outCache = cache;
    556557  output Values.Value outValue;
    557558algorithm
    558   (outCache,outValue) := matchcontinue (inCache,inEnv,inFunctionName,inVals,msg)
    559     local
    560       String omdev,simflags,s1,s2,s3,str,str1,str2,str3,token,varid,cmd,executable,executable1,encoding,method_str,
    561              outputFormat_str,initfilename,pd,executableSuffixedExe,sim_call,result_file,filename_1,filename,filename1,filename2,
    562              call,str_1,mp,pathstr,name,cname,errMsg,errorStr,
    563              title,xLabel,yLabel,filename2,varNameStr,xml_filename,xml_contents,visvar_str,pwd,omhome,omlib,omcpath,os,
    564              platform,usercflags,senddata,res,workdir,gcc,confcmd,touch_file,uname,filenameprefix,compileDir,libDir,exeDir,configDir,from,to,
    565              gridStr, logXStr, logYStr, x1Str, x2Str, y1Str, y2Str, curveWidthStr, curveStyleStr, legendPosition, footer, autoScaleStr,scriptFile,logFile, simflags2, outputFile,
    566              systemPath, gccVersion, gd, strlinearizeTime, direction, suffix;
    567       list<DAE.Exp> simOptions;
    568       list<Values.Value> vals;
    569       Absyn.Path path,classpath,className,baseClassPath,parentClass;
    570       SCode.Program scodeP,sp;
    571       Option<list<SCode.Element>> fp;
    572       FCore.Graph env;
    573       Absyn.Program p,ip,pnew,newp,ptot;
     559  outValue := matchcontinue (functionName, args)
     560    local
     561      String str,str1,str2,str3,token,cmd,encoding,filename,pathstr,name,res,workdir,from,to;
     562      list<Values.Value> vals, cvars;
     563      Absyn.Path path,classpath,className,parentClass;
     564      SCode.Program sp;
     565      Absyn.Program p,newp;
    574566      list<Absyn.Program> newps;
    575       list<GlobalScript.Variable> iv;
    576       GlobalScript.SimulationOptions simOpt;
    577       Real startTime,stopTime,tolerance,reltol,reltolDiffMinMax,rangeDelta;
    578       DAE.Exp startTimeExp,stopTimeExp,toleranceExp,intervalExp;
    579       DAE.Type tp, ty;
     567      DAE.Type ty;
    580568      list<DAE.Type> tys;
    581       Absyn.Class absynClass;
    582       Absyn.ClassDef cdef;
    583       Absyn.Exp aexp;
    584       DAE.DAElist dae;
    585       array<list<Integer>> m,mt;
    586       Values.Value ret_val,simValue,value,v,cvar,cvar2,v1,v2,v3,gcStatRec;
    587       Absyn.ComponentRef cr,cr_1;
    588       Integer size,resI,i,i1,i2,i3,n,curveStyle,numberOfIntervals, status, access;
    589       list<Integer> is;
    590       list<String> vars_1,args,strings,strs,strs1,strs2,visvars,postOptModStrings,postOptModStringsOrg,mps,files,dirs;
    591       Real timeTotal,timeSimulation,timeStamp,val,x1,x2,y1,y2,r,r1,r2,linearizeTime,curveWidth,offset,offset1,offset2,scaleFactor,scaleFactor1,scaleFactor2;
    592       GlobalScript.Statements istmts;
    593       list<GlobalScript.Statements> istmtss;
    594       Boolean have_corba, bval, anyCode, b, b1, b2, externalWindow, logX, logY, autoScale, forceOMPlot,
    595               gcc_res, omcfound, rm_res, touch_res, uname_res,  ifcpp, ifmsvc,sort, builtin, showProtected,
    596               includeConstants, inputConnectors, outputConnectors, mergeAST, includePartial, qualified;
    597       FCore.Cache cache;
    598       Absyn.ComponentRef  crefCName;
    599       list<tuple<String,Values.Value>> resultValues;
    600       list<Real> realVals;
    601       list<tuple<String,list<String>>> deps,depstransitive,depstransposed,depstransposedtransitive,depsmerged,depschanged;
     569      Values.Value v;
     570      Integer i, access;
     571      list<String> strs, strs1, strs2, interfaceType;
     572      Real r,r1,r2;
     573      Boolean bval, b, b1, mergeAST, includePartial, qualified, sort, requireExactVersion;
    602574      Absyn.CodeNode codeNode;
    603       list<Values.Value> cvars,vals2;
    604575      list<Absyn.Path> paths;
    605       list<Absyn.NamedArg> nargs;
    606576      list<Absyn.Class> classes;
    607577      Absyn.Within within_;
    608       GlobalScript.SimulationOptions defaulSimOpt;
    609       SimCode.SimulationSettings simSettings;
    610       Boolean dumpExtractionSteps, requireExactVersion;
    611       list<tuple<Absyn.Path,list<String>>> uses;
    612578      Config.LanguageStandard oldLanguageStd;
    613579      SCode.Element cl;
    614       list<SCode.Element> cls, elts;
    615       list<String> names, namesPublic, namesProtected, namesChanged, fileNames;
    616       HashSetString.HashSet hashSetString;
    617       list<Boolean> blst;
     580      list<SCode.Element> elts;
    618581      list<ErrorTypes.TotalMessage> messages;
    619       Real stoptime,starttime,tol,stepsize,interval;
    620       String stoptime_str,stepsize_str,starttime_str,tol_str,num_intervalls_str,description,prefix;
    621       list<String> interfaceType;
    622582      list<tuple<String,list<String>>> interfaceTypeAssoc;
    623       SCode.Encapsulated encflag;
    624       SCode.Restriction restr;
    625       list<list<Values.Value>> valsLst;
    626       Boolean new_inst;
    627       SymbolTable interactiveSymbolTable, interactiveSymbolTable2;
    628583      GC.ProfStats gcStats;
    629       Absyn.Restriction restriction;
    630 
    631     case (cache,_,"parseString",{Values.STRING(str1),Values.STRING(str2)},_)
    632       equation
    633         Absyn.PROGRAM(classes=classes,within_=within_) = Parser.parsestring(str1,str2);
    634         paths = List.map(classes,AbsynUtil.className);
    635         paths = List.map1r(paths,AbsynUtil.joinWithinPath,within_);
    636         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    637       then (cache,ValuesUtil.makeArray(vals));
    638 
    639     case (cache,_,"parseString",_,_)
    640       then (cache,ValuesUtil.makeArray({}));
    641 
    642     case (cache,_,"parseFile",{Values.STRING(str1),Values.STRING(encoding)},_)
    643       equation
     584
     585    case ("parseString",{Values.STRING(str1),Values.STRING(str2)})
     586      algorithm
     587        Absyn.PROGRAM(classes=classes,within_=within_) := Parser.parsestring(str1,str2);
     588        paths := List.map(classes,AbsynUtil.className);
     589        paths := List.map1r(paths,AbsynUtil.joinWithinPath,within_);
     590        vals := List.map(paths,ValuesUtil.makeCodeTypeName);
     591      then
     592        ValuesUtil.makeArray(vals);
     593
     594    case ("parseString",_)
     595      then ValuesUtil.makeArray({});
     596
     597    case ("parseFile",{Values.STRING(str1),Values.STRING(encoding)})
     598      algorithm
    644599        // clear the errors before!
    645600        Error.clearMessages() "Clear messages";
    646601        Print.clearErrorBuf() "Clear error buffer";
    647         (paths) = Interactive.parseFile(str1, encoding);
    648         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    649       then (cache,ValuesUtil.makeArray(vals));
    650 
    651     case (cache,_,"loadFileInteractiveQualified",{Values.STRING(str1),Values.STRING(encoding)},_)
    652       equation
     602        paths := Interactive.parseFile(str1, encoding);
     603        vals := List.map(paths,ValuesUtil.makeCodeTypeName);
     604      then
     605        ValuesUtil.makeArray(vals);
     606
     607    case ("loadFileInteractiveQualified",{Values.STRING(str1),Values.STRING(encoding)})
     608      algorithm
    653609        // clear the errors before!
    654610        Error.clearMessages() "Clear messages";
    655611        Print.clearErrorBuf() "Clear error buffer";
    656         paths = Interactive.parseFile(str1, encoding, updateProgram=true);
    657         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    658       then (cache,ValuesUtil.makeArray(vals));
    659 
    660     case (cache,_,"loadFileInteractive",{Values.STRING(str1),Values.STRING(encoding),Values.BOOL(b),Values.BOOL(b1),Values.BOOL(requireExactVersion)},_)
    661       equation
    662         pnew = loadFile(str1, encoding, SymbolTable.getAbsyn(), b, b1, requireExactVersion) "System.regularFileExists(name) => 0 &    Parser.parse(name) => p1 &" ;
    663         vals = List.map(Interactive.getTopClassnames(pnew),ValuesUtil.makeCodeTypeName);
    664         SymbolTable.setAbsyn(pnew);
    665       then (cache,ValuesUtil.makeArray(vals));
    666 
    667     case (cache,_,"getSourceFile",{Values.CODE(Absyn.C_TYPENAME(path))},_)
    668       equation
    669         str = Interactive.getSourceFile(path, SymbolTable.getAbsyn());
    670       then
    671         (cache,Values.STRING(str));
    672 
    673     case (cache,_,"setSourceFile",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str)},_)
    674       equation
    675         Values.ENUM_LITERAL(index=access) = Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
     612        paths := Interactive.parseFile(str1, encoding, updateProgram=true);
     613        vals := List.map(paths,ValuesUtil.makeCodeTypeName);
     614      then
     615        ValuesUtil.makeArray(vals);
     616
     617    case ("loadFileInteractive",{Values.STRING(str1),Values.STRING(encoding),Values.BOOL(b),Values.BOOL(b1),Values.BOOL(requireExactVersion)})
     618      algorithm
     619        newp := loadFile(str1, encoding, SymbolTable.getAbsyn(), b, b1, requireExactVersion) "System.regularFileExists(name) => 0 &    Parser.parse(name) => p1 &" ;
     620        vals := List.map(Interactive.getTopClassnames(newp),ValuesUtil.makeCodeTypeName);
     621        SymbolTable.setAbsyn(newp);
     622      then
     623        ValuesUtil.makeArray(vals);
     624
     625    case ("getSourceFile",{Values.CODE(Absyn.C_TYPENAME(path))})
     626      algorithm
     627        str := Interactive.getSourceFile(path, SymbolTable.getAbsyn());
     628      then
     629        Values.STRING(str);
     630
     631    case ("setSourceFile",{Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str)})
     632      algorithm
     633        Values.ENUM_LITERAL(index=access) := Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
    676634        if (access >= 9) then // i.e., The class is not encrypted.
    677           (b,p) = Interactive.setSourceFile(path, str, SymbolTable.getAbsyn());
     635          (b,p) := Interactive.setSourceFile(path, str, SymbolTable.getAbsyn());
    678636          SymbolTable.setAbsyn(p);
    679637        else
    680638          Error.addMessage(Error.SAVE_ENCRYPTED_CLASS_ERROR, {});
    681           b = false;
     639          b := false;
    682640        end if;
    683641      then
    684         (cache,Values.BOOL(b));
    685 
    686     case (cache,_,"basename",{Values.STRING(str)},_)
    687       equation
    688         str = System.basename(str);
    689       then (cache,Values.STRING(str));
    690 
    691     case (cache,_,"dirname",{Values.STRING(str)},_)
    692       equation
    693         str = System.dirname(str);
    694       then (cache,Values.STRING(str));
    695 
    696     case (cache,_,"codeToString",{Values.CODE(codeNode)},_)
    697       equation
    698         str = Dump.printCodeStr(codeNode);
    699       then (cache,Values.STRING(str));
    700 
    701     case (cache,_,"typeOf",{Values.CODE(Absyn.C_VARIABLENAME(Absyn.CREF_IDENT(name = varid)))},_)
    702       equation
    703         tp = Interactive.getTypeOfVariable(varid, SymbolTable.getVars());
    704         str = Types.unparseType(tp);
    705       then
    706         (cache,Values.STRING(str));
    707 
    708     case (cache,_,"GC_gcollect_and_unmap",{},_)
    709       equation
     642        Values.BOOL(b);
     643
     644    case ("basename",{Values.STRING(str)})
     645      then Values.STRING(System.basename(str));
     646
     647    case ("dirname",{Values.STRING(str)})
     648      then Values.STRING(System.dirname(str));
     649
     650    case ("codeToString",{Values.CODE(codeNode)})
     651      then Values.STRING(Dump.printCodeStr(codeNode));
     652
     653    case ("typeOf",{Values.CODE(Absyn.C_VARIABLENAME(Absyn.CREF_IDENT(name = name)))})
     654      algorithm
     655        ty := Interactive.getTypeOfVariable(name, SymbolTable.getVars());
     656      then
     657        Values.STRING(Types.unparseType(ty));
     658
     659    case ("GC_gcollect_and_unmap",{})
     660      algorithm
    710661        GC.gcollectAndUnmap();
    711       then (cache,Values.BOOL(true));
    712 
    713     case (cache,_,"GC_expand_hp",{Values.INTEGER(i)},_)
    714       equation
    715         b = GC.expandHeap(i);
    716       then (cache,Values.BOOL(b));
    717 
    718     case (cache,_,"GC_set_max_heap_size",{Values.INTEGER(i)},_)
    719       equation
     662      then
     663        Values.BOOL(true);
     664
     665    case ("GC_expand_hp",{Values.INTEGER(i)})
     666      then Values.BOOL(GC.expandHeap(i));
     667
     668    case ("GC_set_max_heap_size",{Values.INTEGER(i)})
     669      algorithm
    720670        GC.setMaxHeapSize(i);
    721       then (cache,Values.BOOL(true));
    722 
    723     case (cache,_,"GC_get_prof_stats",{},_)
    724       equation
    725         gcStats = GC.getProfStats();
    726         gcStatRec = match gcStats
    727          case GC.PROFSTATS() then
    728            Values.RECORD(Absyn.IDENT("GC_PROFSTATS"),
    729             {
    730               Values.INTEGER(gcStats.heapsize_full),
    731               Values.INTEGER(gcStats.free_bytes_full),
    732               Values.INTEGER(gcStats.unmapped_bytes),
    733               Values.INTEGER(gcStats.bytes_allocd_since_gc),
    734               Values.INTEGER(gcStats.allocd_bytes_before_gc),
    735               Values.INTEGER(gcStats.bytes_allocd_since_gc+gcStats.allocd_bytes_before_gc),
    736               Values.INTEGER(gcStats.non_gc_bytes),
    737               Values.INTEGER(gcStats.gc_no),
    738               Values.INTEGER(gcStats.markers_m1),
    739               Values.INTEGER(gcStats.bytes_reclaimed_since_gc),
    740               Values.INTEGER(gcStats.reclaimed_bytes_before_gc)
    741             },
    742             {
    743               "heapsize_full",
    744               "free_bytes_full",
    745               "unmapped_bytes: ",
    746               "bytes_allocd_since_gc",
    747               "allocd_bytes_before_gc",
    748               "total_allocd_bytes",
    749               "non_gc_bytes",
    750               "gc_no",
    751               "markers_m1",
    752               "bytes_reclaimed_since_gc",
    753               "reclaimed_bytes_before_gc"
    754             },
    755             -1);
    756        end match;
    757       then (cache, gcStatRec);
    758 
    759     case (cache,_,"clear",{},_)
     671      then
     672        Values.BOOL(true);
     673
     674    case ("GC_get_prof_stats",{})
     675      algorithm
     676        gcStats := GC.getProfStats();
     677      then
     678        Values.RECORD(Absyn.IDENT("GC_PROFSTATS"),
     679         {
     680           Values.INTEGER(gcStats.heapsize_full),
     681           Values.INTEGER(gcStats.free_bytes_full),
     682           Values.INTEGER(gcStats.unmapped_bytes),
     683           Values.INTEGER(gcStats.bytes_allocd_since_gc),
     684           Values.INTEGER(gcStats.allocd_bytes_before_gc),
     685           Values.INTEGER(gcStats.bytes_allocd_since_gc+gcStats.allocd_bytes_before_gc),
     686           Values.INTEGER(gcStats.non_gc_bytes),
     687           Values.INTEGER(gcStats.gc_no),
     688           Values.INTEGER(gcStats.markers_m1),
     689           Values.INTEGER(gcStats.bytes_reclaimed_since_gc),
     690           Values.INTEGER(gcStats.reclaimed_bytes_before_gc)
     691         },
     692         {
     693           "heapsize_full",
     694           "free_bytes_full",
     695           "unmapped_bytes: ",
     696           "bytes_allocd_since_gc",
     697           "allocd_bytes_before_gc",
     698           "total_allocd_bytes",
     699           "non_gc_bytes",
     700           "gc_no",
     701           "markers_m1",
     702           "bytes_reclaimed_since_gc",
     703           "reclaimed_bytes_before_gc"
     704         },
     705         -1);
     706
     707    case ("clear",{})
    760708      algorithm
    761709        SymbolTable.reset();
    762       then (cache,Values.BOOL(true));
    763 
    764     case (cache,_,"clearProgram",{},_)
     710      then
     711        Values.BOOL(true);
     712
     713    case ("clearProgram",{})
    765714      algorithm
    766715        SymbolTable.clearProgram();
    767       then (cache,Values.BOOL(true));
    768 
    769     case (cache,_,"clearVariables",{},_)
    770       equation
     716      then
     717        Values.BOOL(true);
     718
     719    case ("clearVariables",{})
     720      algorithm
    771721        SymbolTable.setVars({});
    772       then (cache,Values.BOOL(true));
    773 
    774     // handle encryption
    775     case (cache,_,"list",_,_)
    776       equation
    777         // if AST contains encrypted class show nothing
    778         p = SymbolTable.getAbsyn();
    779         true = Interactive.astContainsEncryptedClass(p);
    780         Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
    781       then
    782         (cache,Values.STRING(""));
    783 
    784     case (cache,_,"list",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("AllLoadedClasses"))),Values.BOOL(false),Values.BOOL(false),Values.ENUM_LITERAL(name=path)},_)
    785       equation
    786         name = AbsynUtil.pathLastIdent(path);
    787         str = match name
    788           case "Absyn" then Dump.unparseStr(SymbolTable.getAbsyn(), false);
    789           case "SCode" then SCodeDump.programStr(SymbolTable.getSCode());
    790           case "MetaModelicaInterface" then SCodeDump.programStr(SymbolTable.getSCode(), SCodeDump.OPTIONS(true,false,true,true,true,true,true,true,true));
    791           case "Internal" then System.anyStringCode(SymbolTable.getAbsyn());
    792           else "";
    793         end match;
    794       then
    795         (cache,Values.STRING(str));
    796 
    797     case (cache,_,"list",{Values.CODE(Absyn.C_TYPENAME(className)),Values.BOOL(b1),Values.BOOL(b2),Values.ENUM_LITERAL(name=path)},_)
    798       equation
    799         false = valueEq(Absyn.IDENT("AllLoadedClasses"),className);
    800         name = AbsynUtil.pathLastIdent(path);
    801         p = SymbolTable.getAbsyn();
    802         scodeP = SymbolTable.getSCode();
    803         absynClass = Interactive.getPathedClassInProgram(className, p);
    804         absynClass = if b1 then AbsynUtil.getFunctionInterface(absynClass) else absynClass;
    805         absynClass = if b2 then AbsynUtil.getShortClass(absynClass) else absynClass;
    806         p = Absyn.PROGRAM({absynClass},Absyn.TOP());
    807         cl = FBuiltin.getElementWithPathCheckBuiltin(scodeP, className);
    808         str = match name
    809           case "Absyn" then Dump.unparseStr(p, false);
    810           case "SCode" then SCodeDump.unparseElementStr(cl);
    811           case "MetaModelicaInterface" then SCodeDump.unparseElementStr(cl, SCodeDump.OPTIONS(true,false,true,true,true,true,true,true,true));
    812           case "Internal" then System.anyStringCode(p);
    813           else "";
    814         end match;
    815       then
    816         (cache,Values.STRING(str));
    817 
    818     case (cache,_,"list",_,_) then (cache,Values.STRING(""));
    819 
    820     case (cache,_,"listFile",{Values.CODE(Absyn.C_TYPENAME(className)),Values.BOOL(b)},_)
    821       equation
    822         path = match className
    823           case Absyn.FULLYQUALIFIED() then className.path;
    824           else className;
    825         end match;
    826         // handle encryption
    827         Values.ENUM_LITERAL(index=access) = Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
    828         (absynClass as Absyn.CLASS(restriction=restriction, info=SOURCEINFO(fileName=str))) = Interactive.getPathedClassInProgram(className, SymbolTable.getAbsyn());
    829         absynClass = if b then absynClass else AbsynUtil.filterNestedClasses(absynClass);
    830         /* If the class has Access.packageText annotation or higher
    831          * If the class has Access.nonPackageText annotation or higher and class is not a package
    832          */
    833         if ((access >= 7) or ((access >= 5) and not AbsynUtil.isPackageRestriction(restriction))) then
    834           str = Dump.unparseStr(Absyn.PROGRAM({absynClass}, match path case Absyn.IDENT() then Absyn.TOP(); else Absyn.WITHIN(AbsynUtil.stripLast(path)); end match), options=Dump.DUMPOPTIONS(str));
    835         else
    836           Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
    837           str = "";
    838         end if;
    839       then
    840         (cache,Values.STRING(str));
    841 
    842     case (cache,_,"listFile",_,_) then (cache,Values.STRING(""));
    843 
    844     case (cache,_,"sortStrings",{Values.ARRAY(valueLst=vals)},_)
    845       equation
    846         strs = List.map(vals, ValuesUtil.extractValueString);
    847         strs = List.sort(strs,Util.strcmpBool);
    848         v = ValuesUtil.makeArray(List.map(strs,ValuesUtil.makeString));
    849       then
    850         (cache,v);
    851 
    852     case (cache,_,"listVariables",{},_)
    853       equation
    854         v = ValuesUtil.makeArray(getVariableNames(SymbolTable.getVars(),{}));
    855       then
    856         (cache,v);
    857 
    858     case (cache,_,"setCompileCommand",{Values.STRING(cmd)},_)
    859       equation
     722      then
     723        Values.BOOL(true);
     724
     725    case ("list", _) then listClass(args);
     726    case ("listFile", _) then listFile(args);
     727
     728    case ("sortStrings",{Values.ARRAY(valueLst=vals)})
     729      algorithm
     730        strs := List.map(vals, ValuesUtil.extractValueString);
     731        strs := List.sort(strs, Util.strcmpBool);
     732      then
     733        ValuesUtil.makeArray(List.map(strs,ValuesUtil.makeString));
     734
     735    case ("listVariables",{})
     736      then ValuesUtil.makeArray(getVariableNames(SymbolTable.getVars(),{}));
     737
     738    case ("setCompileCommand",{Values.STRING(cmd)})
     739      algorithm
    860740        // cmd = Util.rawStringToInputString(cmd);
    861741        Settings.setCompileCommand(cmd);
    862742      then
    863         (cache,Values.BOOL(true));
    864 
    865     case (cache,_,"getCompileCommand",{},_)
    866       equation
    867         res = Settings.getCompileCommand();
    868       then
    869         (cache,Values.STRING(res));
    870 
    871     case (cache,_,"setTempDirectoryPath",{Values.STRING(cmd)},_)
    872       equation
     743        Values.BOOL(true);
     744
     745    case ("getCompileCommand",{})
     746      then Values.STRING(Settings.getCompileCommand());
     747
     748    case ("setTempDirectoryPath",{Values.STRING(cmd)})
     749      algorithm
    873750        // cmd = Util.rawStringToInputString(cmd);
    874751        Settings.setTempDirectoryPath(cmd);
    875752      then
    876         (cache,Values.BOOL(true));
    877 
    878     case (cache,_,"getTempDirectoryPath",{},_)
    879       equation
    880         res = Settings.getTempDirectoryPath();
    881       then
    882         (cache,Values.STRING(res));
    883 
    884     case (cache,_,"setEnvironmentVar",{Values.STRING(varid),Values.STRING(str)},_)
    885       equation
    886         b = 0 == System.setEnv(varid,str,true);
    887       then
    888         (cache,Values.BOOL(b));
    889 
    890     case (cache,_,"getEnvironmentVar",{Values.STRING(varid)},_)
    891       equation
    892         res = Util.makeValueOrDefault(System.readEnv, varid, "");
    893       then
    894         (cache,Values.STRING(res));
    895 
    896     case (cache,_,"setInstallationDirectoryPath",{Values.STRING(cmd)},_)
    897       equation
     753        Values.BOOL(true);
     754
     755    case ("getTempDirectoryPath",{})
     756      then Values.STRING(Settings.getTempDirectoryPath());
     757
     758    case ("setEnvironmentVar",{Values.STRING(name), Values.STRING(str)})
     759      then Values.BOOL(System.setEnv(name, str, true) == 0);
     760
     761    case ("getEnvironmentVar",{Values.STRING(name)})
     762      then Values.STRING(Util.makeValueOrDefault(System.readEnv, name, ""));
     763
     764    case ("setInstallationDirectoryPath",{Values.STRING(cmd)})
     765      algorithm
    898766        // cmd = Util.rawStringToInputString(cmd);
    899767        Settings.setInstallationDirectoryPath(cmd);
    900768      then
    901         (cache,Values.BOOL(true));
    902 
    903     case (cache,_,"getInstallationDirectoryPath",{},_)
    904       equation
    905         res = Settings.getInstallationDirectoryPath();
    906       then
    907         (cache,Values.STRING(res));
    908 
    909     case (cache,_,"getModelicaPath",{},_)
    910       equation
    911         res = Settings.getModelicaPath(Testsuite.isRunning());
    912       then
    913         (cache,Values.STRING(res));
    914 
    915     case (cache,_,"setModelicaPath",{Values.STRING(cmd)},_)
    916       equation
     769        Values.BOOL(true);
     770
     771    case ("getInstallationDirectoryPath",{})
     772      then Values.STRING(Settings.getInstallationDirectoryPath());
     773
     774    case ("getModelicaPath",{})
     775      then Values.STRING(Settings.getModelicaPath(Testsuite.isRunning()));
     776
     777    case ("setModelicaPath",{Values.STRING(cmd)})
     778      algorithm
    917779        // cmd = Util.rawStringToInputString(cmd);
    918780        Settings.setModelicaPath(cmd);
    919781      then
    920         (cache,Values.BOOL(true));
    921 
    922     case (cache,_,"setModelicaPath",_,_)
    923       then
    924         (cache,Values.BOOL(false));
    925 
    926     case (cache,_,"getLanguageStandard",{},_)
    927       equation
    928         res = Config.languageStandardString(Config.getLanguageStandard());
    929       then
    930         (cache,Values.STRING(res));
    931 
    932     case (cache,_,"reopenStandardStream",{Values.ENUM_LITERAL(index=i),Values.STRING(filename)},_)
    933       equation
    934         b = System.reopenStandardStream(i-1,filename);
    935       then
    936         (cache,Values.BOOL(b));
    937 
    938     case (cache,_,"iconv",{Values.STRING(str),Values.STRING(from),Values.STRING(to)},_)
    939       equation
    940         str = System.iconv(str,from,to);
    941       then
    942         (cache,Values.STRING(str));
    943 
    944     case (cache,_,"getCompiler",{},_)
    945       equation
    946         str = System.getCCompiler();
    947       then
    948         (cache,Values.STRING(str));
    949 
    950     case (cache,_,"setCFlags",{Values.STRING(str)},_)
    951       equation
     782        Values.BOOL(true);
     783
     784    case ("setModelicaPath",_)
     785      then Values.BOOL(false);
     786
     787    case ("getLanguageStandard",{})
     788      then Values.STRING(Config.languageStandardString(Config.getLanguageStandard()));
     789
     790    case ("reopenStandardStream",{Values.ENUM_LITERAL(index=i),Values.STRING(filename)})
     791      then Values.BOOL(System.reopenStandardStream(i-1,filename));
     792
     793    case ("iconv",{Values.STRING(str),Values.STRING(from),Values.STRING(to)})
     794      then Values.STRING(System.iconv(str,from,to));
     795
     796    case ("getCompiler",{})
     797      then Values.STRING(System.getCCompiler());
     798
     799    case ("setCFlags",{Values.STRING(str)})
     800      algorithm
    952801        System.setCFlags(str);
    953802      then
    954         (cache,Values.BOOL(true));
    955 
    956     case (cache,_,"getCFlags",{},_)
    957       equation
    958         str = System.getCFlags();
    959       then
    960         (cache,Values.STRING(str));
    961 
    962     case (cache,_,"setCompiler",{Values.STRING(str)},_)
    963       equation
     803        Values.BOOL(true);
     804
     805    case ("getCFlags",{})
     806      then Values.STRING(System.getCFlags());
     807
     808    case ("setCompiler",{Values.STRING(str)})
     809      algorithm
    964810        System.setCCompiler(str);
    965811      then
    966         (cache,Values.BOOL(true));
    967 
    968     case (cache,_,"getCXXCompiler",{},_)
    969       equation
    970         str = System.getCXXCompiler();
    971       then
    972         (cache,Values.STRING(str));
    973 
    974     case (cache,_,"setCXXCompiler",{Values.STRING(str)},_)
    975       equation
     812        Values.BOOL(true);
     813
     814    case ("getCXXCompiler",{})
     815      then Values.STRING(System.getCXXCompiler());
     816
     817    case ("setCXXCompiler",{Values.STRING(str)})
     818      algorithm
    976819        System.setCXXCompiler(str);
    977820      then
    978         (cache,Values.BOOL(true));
    979 
    980     case (cache,_,"setCompilerFlags",{Values.STRING(str)},_)
    981       equation
     821        Values.BOOL(true);
     822
     823    case ("setCompilerFlags",{Values.STRING(str)})
     824      algorithm
    982825        System.setCFlags(str);
    983826      then
    984         (cache,Values.BOOL(true));
    985 
    986     case (cache,_,"getLinker",{},_)
    987       equation
    988         str = System.getLinker();
    989       then
    990         (cache,Values.STRING(str));
    991 
    992     case (cache,_,"setLinker",{Values.STRING(str)},_)
    993       equation
     827        Values.BOOL(true);
     828
     829    case ("getLinker",{})
     830      then Values.STRING(System.getLinker());
     831
     832    case ("setLinker",{Values.STRING(str)})
     833      algorithm
    994834        System.setLinker(str);
    995835      then
    996         (cache,Values.BOOL(true));
    997 
    998     case (cache,_,"getLinkerFlags",{},_)
    999       equation
    1000         str = System.getLDFlags();
    1001       then
    1002         (cache,Values.STRING(str));
    1003 
    1004     case (cache,_,"setLinkerFlags",{Values.STRING(str)},_)
    1005       equation
     836        Values.BOOL(true);
     837
     838    case ("getLinkerFlags",{})
     839      then Values.STRING(System.getLDFlags());
     840
     841    case ("setLinkerFlags",{Values.STRING(str)})
     842      algorithm
    1006843        System.setLDFlags(str);
    1007844      then
    1008         (cache,Values.BOOL(true));
    1009 
    1010     case (_,_,"setCommandLineOptions",{Values.STRING(str)},_)
    1011       equation
    1012         args = System.strtok(str, " ");
    1013         {} = FlagsUtil.readArgs(args);
    1014       then
    1015         (FCore.emptyCache(),Values.BOOL(true));
    1016 
    1017     case (cache,_,"setCommandLineOptions",_,_)
    1018       then (cache,Values.BOOL(false));
    1019 
    1020     case (cache, _, "getCommandLineOptions", {}, _)
    1021       then (cache, ValuesUtil.makeStringArray(FlagsUtil.unparseFlags()));
    1022 
    1023     case (cache, _, "getCommandLineOptions", _, _)
    1024       then (cache, Values.META_FAIL());
    1025 
    1026     case (cache,_,"clearCommandLineOptions",{},_)
    1027       equation
     845        Values.BOOL(true);
     846
     847    case ("setCommandLineOptions",{Values.STRING(str)})
     848      algorithm
     849        strs := System.strtok(str, " ");
     850        {} := FlagsUtil.readArgs(strs);
     851        outCache := FCore.emptyCache();
     852      then
     853        Values.BOOL(true);
     854
     855    case ("setCommandLineOptions",_)
     856      then Values.BOOL(false);
     857
     858    case ("getCommandLineOptions", {})
     859      then ValuesUtil.makeStringArray(FlagsUtil.unparseFlags());
     860
     861    case ("getCommandLineOptions", _)
     862      then Values.META_FAIL();
     863
     864    case ("clearCommandLineOptions", {})
     865      algorithm
    1028866        FlagsUtil.resetDebugFlags();
    1029867        FlagsUtil.resetConfigFlags();
    1030868      then
    1031         (cache,Values.BOOL(true));
    1032 
    1033     case (cache,_,"clearCommandLineOptions",_,_)
    1034       then (cache,Values.BOOL(false));
    1035 
    1036     case (cache,_,"enableNewInstantiation",_,_)
    1037       equation
     869        Values.BOOL(true);
     870
     871    case ("clearCommandLineOptions",_)
     872      then Values.BOOL(false);
     873
     874    case ("enableNewInstantiation",_)
     875      algorithm
    1038876        FlagsUtil.enableDebug(Flags.SCODE_INST);
    1039877      then
    1040         (cache,Values.BOOL(true));
    1041 
    1042     case (cache,_,"enableNewInstantiation",_,_)
    1043       then
    1044         (cache,Values.BOOL(false));
    1045 
    1046     case (cache,_,"disableNewInstantiation",_,_)
    1047       equation
     878        Values.BOOL(true);
     879
     880    case ("enableNewInstantiation",_)
     881      then Values.BOOL(false);
     882
     883    case ("disableNewInstantiation",_)
     884      algorithm
    1048885        FlagsUtil.disableDebug(Flags.SCODE_INST);
    1049886      then
    1050         (cache,Values.BOOL(true));
    1051 
    1052     case (cache,_,"disableNewInstantiation",_,_)
    1053       then
    1054         (cache,Values.BOOL(false));
    1055 
    1056     case (cache,_,"clearDebugFlags",_,_)
    1057       equation
     887        Values.BOOL(true);
     888
     889    case ("disableNewInstantiation",_)
     890      then
     891        Values.BOOL(false);
     892
     893    case ("clearDebugFlags",_)
     894      algorithm
    1058895        FlagsUtil.resetDebugFlags();
    1059896      then
    1060         (cache,Values.BOOL(true));
    1061 
    1062     case (cache,_,"clearDebugFlags",_,_)
    1063       then (cache,Values.BOOL(false));
    1064 
    1065     case (cache,_,"getConfigFlagValidOptions",{Values.STRING(str)},_)
    1066       equation
    1067         (strs1,str,strs2) = FlagsUtil.getValidOptionsAndDescription(str);
    1068         v1 = ValuesUtil.makeArray(List.map(strs1, ValuesUtil.makeString));
    1069         v2 = Values.STRING(str);
    1070         v3 = ValuesUtil.makeArray(List.map(strs2, ValuesUtil.makeString));
    1071         v = Values.TUPLE({v1,v2,v3});
    1072       then (cache,v);
    1073 
    1074     case (cache,_,"getConfigFlagValidOptions",{Values.STRING(_)},_)
    1075       equation
    1076         v1 = ValuesUtil.makeArray({});
    1077         v2 = Values.STRING("");
    1078         v3 = ValuesUtil.makeArray({});
    1079         v = Values.TUPLE({v1,v2,v3});
    1080       then (cache,v);
    1081 
    1082     case (cache,_,"cd",{Values.STRING("")},_)
    1083       equation
    1084         str_1 = System.pwd();
    1085       then
    1086         (cache,Values.STRING(str_1));
    1087 
    1088     case (cache,_,"cd",{Values.STRING(str)},_)
    1089       equation
    1090         resI = System.cd(str);
    1091         (resI == 0) = true;
    1092         str_1 = System.pwd();
    1093       then
    1094         (cache,Values.STRING(str_1));
    1095 
    1096     case (cache,_,"cd",{Values.STRING(str)},_)
    1097       equation
    1098         failure(true = System.directoryExists(str));
    1099         res = stringAppendList({"Error, directory ",str," does not exist,"});
    1100       then
    1101         (cache,Values.STRING(res));
    1102 
    1103     case (cache,_,"mkdir",{Values.STRING(str)},_)
    1104       equation
    1105         true = System.directoryExists(str);
    1106       then
    1107         (cache,Values.BOOL(true));
    1108 
    1109     case (cache,_,"mkdir",{Values.STRING(str)},_)
    1110       equation
    1111         b = Util.createDirectoryTree(str);
    1112       then
    1113         (cache,Values.BOOL(b));
    1114 
    1115     case (cache,_,"copy",{Values.STRING(str1),Values.STRING(str2)},_)
    1116       equation
    1117         b = System.copyFile(str1,str2);
    1118       then
    1119         (cache,Values.BOOL(b));
    1120 
    1121     case (cache,_,"remove",{Values.STRING(str)},_)
    1122       equation
    1123         b = System.removeDirectory(str);
    1124       then
    1125         (cache,Values.BOOL(b));
    1126 
    1127     case (cache,_,"getVersion",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("OpenModelica")))},_)
    1128       equation
    1129         str_1 = Settings.getVersionNr();
    1130       then
    1131         (cache,Values.STRING(str_1));
    1132 
    1133     case (cache,_,"getVersion",{Values.CODE(Absyn.C_TYPENAME(path))},_)
    1134       equation
    1135         str_1 = getPackageVersion(path,SymbolTable.getAbsyn());
    1136       then
    1137         (cache,Values.STRING(str_1));
    1138 
    1139     case (cache,_,"getTempDirectoryPath",{},_)
    1140       equation
    1141         str_1 = Settings.getTempDirectoryPath();
    1142       then
    1143         (cache,Values.STRING(str_1));
    1144 
    1145     case (cache,_,"system",{Values.STRING(str),Values.STRING(filename)},_)
    1146       equation
    1147         resI = System.systemCall(str,filename);
    1148       then
    1149         (cache,Values.INTEGER(resI));
    1150 
    1151     case (cache,_,"system_parallel",{Values.ARRAY(valueLst=vals),Values.INTEGER(i)},_)
    1152       equation
    1153         strs = List.map(vals, ValuesUtil.extractValueString);
    1154         v = ValuesUtil.makeIntArray(System.systemCallParallel(strs,i));
    1155       then
    1156         (cache,v);
    1157 
    1158     case (cache,_,"timerClear",{Values.INTEGER(i)},_)
    1159       equation
     897        Values.BOOL(true);
     898
     899    case ("clearDebugFlags",_)
     900      then Values.BOOL(false);
     901
     902    case ("getConfigFlagValidOptions",{Values.STRING(str)})
     903      algorithm
     904        (strs1, str, strs2) := FlagsUtil.getValidOptionsAndDescription(str);
     905      then
     906        Values.TUPLE({
     907          ValuesUtil.makeStringArray(strs1),
     908          Values.STRING(str),
     909          ValuesUtil.makeStringArray(strs2)
     910        });
     911
     912    case ("getConfigFlagValidOptions",{Values.STRING(_)})
     913      then
     914        Values.TUPLE({
     915          ValuesUtil.makeArray({}),
     916          Values.STRING(""),
     917          ValuesUtil.makeArray({})
     918        });
     919
     920    case ("cd",{Values.STRING("")})
     921      then Values.STRING(System.pwd());
     922
     923    case ("cd",{Values.STRING(str)})
     924      algorithm
     925        0 := System.cd(str);
     926      then
     927        Values.STRING(System.pwd());
     928
     929    case ("cd",{Values.STRING(str)})
     930      algorithm
     931        false := System.directoryExists(str);
     932        res := stringAppendList({"Error, directory ",str," does not exist,"});
     933      then
     934        Values.STRING(res);
     935
     936    case ("mkdir",{Values.STRING(str)})
     937      algorithm
     938        true := System.directoryExists(str);
     939      then
     940        Values.BOOL(true);
     941
     942    case ("mkdir",{Values.STRING(str)})
     943      then Values.BOOL(Util.createDirectoryTree(str));
     944
     945    case ("copy",{Values.STRING(str1),Values.STRING(str2)})
     946      then Values.BOOL(System.copyFile(str1,str2));
     947
     948    case ("remove",{Values.STRING(str)})
     949      then Values.BOOL(System.removeDirectory(str));
     950
     951    case ("getVersion",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("OpenModelica")))})
     952      then Values.STRING(Settings.getVersionNr());
     953
     954    case ("getVersion",{Values.CODE(Absyn.C_TYPENAME(path))})
     955      then Values.STRING(getPackageVersion(path,SymbolTable.getAbsyn()));
     956
     957    case ("getTempDirectoryPath",{})
     958      then Values.STRING(Settings.getTempDirectoryPath());
     959
     960    case ("system",{Values.STRING(str),Values.STRING(filename)})
     961      then Values.INTEGER(System.systemCall(str,filename));
     962
     963    case ("system_parallel",{Values.ARRAY(valueLst=vals),Values.INTEGER(i)})
     964      algorithm
     965        strs := List.map(vals, ValuesUtil.extractValueString);
     966      then
     967        ValuesUtil.makeIntArray(System.systemCallParallel(strs,i));
     968
     969    case ("timerClear",{Values.INTEGER(i)})
     970      algorithm
    1160971        System.realtimeClear(i);
    1161972      then
    1162         (cache,Values.NORETCALL());
    1163 
    1164     case (cache,_,"timerTick",{Values.INTEGER(i)},_)
    1165       equation
     973        Values.NORETCALL();
     974
     975    case ("timerTick",{Values.INTEGER(i)})
     976      algorithm
    1166977        System.realtimeTick(i);
    1167978      then
    1168         (cache,Values.NORETCALL());
    1169 
    1170     case (cache,_,"timerTock",{Values.INTEGER(i)},_)
    1171       equation
    1172         true = System.realtimeNtick(i) > 0;
    1173         r = System.realtimeTock(i);
    1174       then
    1175         (cache,Values.REAL(r));
    1176 
    1177     case (cache,_,"timerTock",_,_)
    1178       then (cache,Values.REAL(-1.0));
    1179 
    1180     case (cache,_,"readFile",{Values.STRING(str)},_)
    1181       equation
    1182         str_1 = System.readFile(str);
    1183       then (cache,Values.STRING(str_1));
    1184 
    1185     case (cache,_,"readFile",_,_)
    1186       then (cache,Values.STRING(""));
    1187 
    1188     case (cache,_,"writeFile",{Values.STRING(str),Values.STRING(str1),Values.BOOL(false)},_)
    1189       equation
     979        Values.NORETCALL();
     980
     981    case ("timerTock",{Values.INTEGER(i)})
     982      algorithm
     983        true := System.realtimeNtick(i) > 0;
     984      then
     985        Values.REAL(System.realtimeTock(i));
     986
     987    case ("timerTock",_)
     988      then Values.REAL(-1.0);
     989
     990    case ("readFile",{Values.STRING(str)})
     991      then Values.STRING(System.readFile(str));
     992
     993    case ("readFile",_)
     994      then Values.STRING("");
     995
     996    case ("writeFile",{Values.STRING(str),Values.STRING(str1),Values.BOOL(false)})
     997      algorithm
    1190998        System.writeFile(str,str1);
    1191999      then
    1192         (cache,Values.BOOL(true));
    1193 
    1194     case (cache,_,"writeFile",{Values.STRING(str),Values.STRING(str1),Values.BOOL(true)},_)
    1195       equation
     1000        Values.BOOL(true);
     1001
     1002    case ("writeFile",{Values.STRING(str),Values.STRING(str1),Values.BOOL(true)})
     1003      algorithm
    11961004        System.appendFile(str, str1);
    11971005      then
    1198         (cache,Values.BOOL(true));
    1199 
    1200     case (cache,_,"writeFile",_,_)
    1201       then
    1202         (cache,Values.BOOL(false));
    1203 
    1204     case (cache,_,"deleteFile",{Values.STRING(str)},_)
    1205       equation
    1206         b = System.removeFile(str) == 0;
    1207       then
    1208         (cache,Values.BOOL(b));
    1209 
    1210     case (cache,_,"compareFiles",{Values.STRING(str1),Values.STRING(str2)},_)
    1211       equation
    1212         b = System.fileContentsEqual(str1,str2);
    1213       then
    1214         (cache,Values.BOOL(b));
    1215 
    1216     case (cache,_,"compareFilesAndMove",{Values.STRING(str1),Values.STRING(str2)},_)
    1217       equation
    1218         true = System.regularFileExists(str1);
    1219         b = System.regularFileExists(str2) and System.fileContentsEqual(str1,str2);
    1220         b = if not b then System.rename(str1,str2) else b;
    1221       then
    1222         (cache,Values.BOOL(b));
    1223 
    1224     case (cache,_,"compareFilesAndMove",_,_)
    1225       then (cache,Values.BOOL(false));
    1226 
    1227     case (cache,_,"readFileNoNumeric",{Values.STRING(str)},_)
    1228       equation
    1229         str_1 = System.readFileNoNumeric(str);
    1230       then
    1231         (cache,Values.STRING(str_1));
    1232 
    1233     case (cache,_,"getErrorString",{Values.BOOL(b)},_)
    1234       equation
    1235         str = Error.printMessagesStr(b);
    1236       then
    1237         (cache,Values.STRING(str));
    1238 
    1239     case (cache,_,"countMessages",_,_)
    1240       equation
    1241         i1 = Error.getNumMessages();
    1242         i2 = Error.getNumErrorMessages();
    1243         i3 = ErrorExt.getNumWarningMessages();
    1244       then
    1245         (cache,Values.TUPLE({Values.INTEGER(i1),Values.INTEGER(i2),Values.INTEGER(i3)}));
    1246 
    1247     case (cache,_,"clearMessages",{},_)
    1248       equation
     1006        Values.BOOL(true);
     1007
     1008    case ("writeFile",_)
     1009      then Values.BOOL(false);
     1010
     1011    case ("deleteFile",{Values.STRING(str)})
     1012      then Values.BOOL(System.removeFile(str) == 0);
     1013
     1014    case ("compareFiles",{Values.STRING(str1),Values.STRING(str2)})
     1015      then Values.BOOL(System.fileContentsEqual(str1,str2));
     1016
     1017    case ("compareFilesAndMove",{Values.STRING(str1),Values.STRING(str2)})
     1018      algorithm
     1019        true := System.regularFileExists(str1);
     1020        b := System.regularFileExists(str2) and System.fileContentsEqual(str1,str2);
     1021        b := if not b then System.rename(str1,str2) else b;
     1022      then
     1023        Values.BOOL(b);
     1024
     1025    case ("compareFilesAndMove",_)
     1026      then Values.BOOL(false);
     1027
     1028    case ("readFileNoNumeric",{Values.STRING(str)})
     1029      then Values.STRING(System.readFileNoNumeric(str));
     1030
     1031    case ("getErrorString",{Values.BOOL(b)})
     1032      then Values.STRING(Error.printMessagesStr(b));
     1033
     1034    case ("countMessages",_)
     1035      then Values.TUPLE({
     1036        Values.INTEGER(Error.getNumMessages()),
     1037        Values.INTEGER(Error.getNumErrorMessages()),
     1038        Values.INTEGER(ErrorExt.getNumWarningMessages())
     1039      });
     1040
     1041    case ("clearMessages",{})
     1042      algorithm
    12491043        Error.clearMessages();
    12501044      then
    1251         (cache,Values.BOOL(true));
    1252 
    1253     case (cache,_,"getMessagesStringInternal",{Values.BOOL(true)},_)
    1254       equation
    1255         messages = List.unique(Error.getMessages());
    1256         v = ValuesUtil.makeArray(List.map(messages, errorToValue));
    1257       then
    1258         (cache,v);
    1259 
    1260     case (cache,_,"getMessagesStringInternal",{Values.BOOL(false)},_)
    1261       equation
    1262         v = ValuesUtil.makeArray(List.map(Error.getMessages(), errorToValue));
    1263       then
    1264         (cache,v);
    1265 
    1266     case (cache,_,"stringTypeName",{Values.STRING(str)},_)
    1267       equation
    1268         path = Parser.stringPath(str);
    1269       then (cache,Values.CODE(Absyn.C_TYPENAME(path)));
    1270 
    1271     case (cache,_,"stringVariableName",{Values.STRING(str)},_)
    1272       equation
    1273         cr = Parser.stringCref(str);
    1274       then (cache,Values.CODE(Absyn.C_VARIABLENAME(cr)));
    1275 
    1276     case (cache,_,"typeNameString",{Values.CODE(A=Absyn.C_TYPENAME(path=path))},_)
    1277       equation
    1278         str = AbsynUtil.pathString(path);
    1279       then (cache,Values.STRING(str));
    1280 
    1281     case (cache,_,"typeNameStrings",{Values.CODE(A=Absyn.C_TYPENAME(path=path))},_)
    1282       equation
    1283         v = ValuesUtil.makeArray(List.map(AbsynUtil.pathToStringList(path),ValuesUtil.makeString));
    1284       then (cache,v);
    1285 
    1286     case (cache,_,"generateHeader",{Values.STRING(filename)},_)
    1287       equation
    1288         str = Tpl.tplString(Unparsing.programExternalHeader, SymbolTable.getSCode());
     1045        Values.BOOL(true);
     1046
     1047    case ("getMessagesStringInternal",{Values.BOOL(true)})
     1048      algorithm
     1049        messages := List.unique(Error.getMessages());
     1050      then
     1051        ValuesUtil.makeArray(List.map(messages, errorToValue));
     1052
     1053    case ("getMessagesStringInternal",{Values.BOOL(false)})
     1054      then ValuesUtil.makeArray(List.map(Error.getMessages(), errorToValue));
     1055
     1056    case ("stringTypeName",{Values.STRING(str)})
     1057      then Values.CODE(Absyn.C_TYPENAME(Parser.stringPath(str)));
     1058
     1059    case ("stringVariableName",{Values.STRING(str)})
     1060      then Values.CODE(Absyn.C_VARIABLENAME(Parser.stringCref(str)));
     1061
     1062    case ("typeNameString",{Values.CODE(A=Absyn.C_TYPENAME(path=path))})
     1063      then Values.STRING(AbsynUtil.pathString(path));
     1064
     1065    case ("typeNameStrings",{Values.CODE(A=Absyn.C_TYPENAME(path=path))})
     1066      then ValuesUtil.makeArray(List.map(AbsynUtil.pathToStringList(path),ValuesUtil.makeString));
     1067
     1068    case ("generateHeader",{Values.STRING(filename)})
     1069      algorithm
     1070        str := Tpl.tplString(Unparsing.programExternalHeader, SymbolTable.getSCode());
    12891071        System.writeFile(filename,str);
    12901072      then
    1291         (cache,Values.BOOL(true));
    1292 
    1293     case (cache,_,"generateHeader",_,_)
    1294       then
    1295         (cache,Values.BOOL(false));
    1296 
    1297     case (cache,_,"generateJuliaHeader",{Values.STRING(filename)},_)
    1298       equation
    1299         str = Tpl.tplString(Unparsing.programExternalHeaderJulia, SymbolTable.getSCode());
     1073        Values.BOOL(true);
     1074
     1075    case ("generateHeader",_)
     1076      then Values.BOOL(false);
     1077
     1078    case ("generateJuliaHeader",{Values.STRING(filename)})
     1079      algorithm
     1080        str := Tpl.tplString(Unparsing.programExternalHeaderJulia, SymbolTable.getSCode());
    13001081        System.writeFile(filename,str);
    13011082      then
    1302         (cache,Values.BOOL(true));
    1303 
    1304     case (cache,_,"generateJuliaHeader",_,_)
    1305       then
    1306         (cache,Values.BOOL(false));
    1307 
    1308     case (cache,env,"generateCode",{Values.CODE(Absyn.C_TYPENAME(path))},_)
    1309       equation
    1310         (cache,Util.SUCCESS()) = Static.instantiateDaeFunction(cache, env, path, false, NONE(), true);
    1311         (cache,_,_) = cevalGenerateFunction(cache,env,SymbolTable.getAbsyn(),path);
    1312       then
    1313         (cache,Values.BOOL(true));
    1314 
    1315     case (cache,_,"generateCode",_,_)
    1316       then
    1317         (cache,Values.BOOL(false));
    1318 
    1319     case (cache,env,"generateScriptingAPI",{Values.CODE(Absyn.C_TYPENAME(className)), Values.STRING(name)},_)
    1320       algorithm
    1321         scodeP := SymbolTable.getSCode();
    1322         elts := match FBuiltin.getElementWithPathCheckBuiltin(scodeP, className)
     1083        Values.BOOL(true);
     1084
     1085    case ("generateJuliaHeader",_)
     1086      then Values.BOOL(false);
     1087
     1088    case ("generateCode",{Values.CODE(Absyn.C_TYPENAME(path))})
     1089      algorithm
     1090        (outCache, Util.SUCCESS()) := Static.instantiateDaeFunction(outCache, env, path, false, NONE(), true);
     1091        outCache := cevalGenerateFunction(outCache,env,SymbolTable.getAbsyn(),path);
     1092      then
     1093        Values.BOOL(true);
     1094
     1095    case ("generateCode",_)
     1096      then Values.BOOL(false);
     1097
     1098    case ("generateScriptingAPI",{Values.CODE(Absyn.C_TYPENAME(className)), Values.STRING(name)})
     1099      algorithm
     1100        sp := SymbolTable.getSCode();
     1101        elts := match FBuiltin.getElementWithPathCheckBuiltin(sp, className)
    13231102          case SCode.CLASS(classDef=SCode.PARTS(elementLst=elts)) then elts;
    13241103          case cl equation Error.addSourceMessage(Error.INTERNAL_ERROR, {AbsynUtil.pathString(className) + " does not contain SCode.PARTS"}, SCodeUtil.elementInfo(cl)); then fail();
    … …  
    13291108            case SCode.CLASS(partialPrefix=SCode.NOT_PARTIAL(), restriction=SCode.R_FUNCTION(SCode.FR_EXTERNAL_FUNCTION()))
    13301109              algorithm
    1331                 (cache, ty, _) := Lookup.lookupType(cache, env, AbsynUtil.suffixPath(className, elt.name), NONE() /*SOME(elt.info)*/);
     1110                (outCache, ty, _) := Lookup.lookupType(outCache, env, AbsynUtil.suffixPath(className, elt.name), NONE() /*SOME(elt.info)*/);
    13321111                if isSimpleAPIFunction(ty) then
    13331112                  tys := ty::tys;
    … …  
    13371116          end matchcontinue;
    13381117        end for;
    1339         s1 := Tpl.tplString(GenerateAPIFunctionsTpl.getCevalScriptInterface, tys);
    1340         s2 := Tpl.tplString3(GenerateAPIFunctionsTpl.getQtInterface, tys, name + "::", name);
    1341         s3 := Tpl.tplString2(GenerateAPIFunctionsTpl.getQtInterfaceHeaders, tys, name);
    1342       then (cache,Values.TUPLE({Values.BOOL(true),Values.STRING(s1),Values.STRING(s2),Values.STRING(s3)}));
    1343 
    1344     case (cache,_,"generateScriptingAPI",_,_)
    1345       then (cache,Values.TUPLE({Values.BOOL(false),Values.STRING(""),Values.STRING("")}));
    1346 
    1347     case (cache,_,"generateEntryPoint",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str)},_)
    1348       equation
    1349         str = Tpl.tplString2(CodegenCFunctions.generateEntryPoint, path, str);
     1118        str1 := Tpl.tplString(GenerateAPIFunctionsTpl.getCevalScriptInterface, tys);
     1119        str2 := Tpl.tplString3(GenerateAPIFunctionsTpl.getQtInterface, tys, name + "::", name);
     1120        str3 := Tpl.tplString2(GenerateAPIFunctionsTpl.getQtInterfaceHeaders, tys, name);
     1121      then
     1122        Values.TUPLE({Values.BOOL(true),Values.STRING(str1),Values.STRING(str2),Values.STRING(str3)});
     1123
     1124    case ("generateScriptingAPI",_)
     1125      then Values.TUPLE({Values.BOOL(false),Values.STRING(""),Values.STRING("")});
     1126
     1127    case ("generateEntryPoint",{Values.STRING(filename),Values.CODE(Absyn.C_TYPENAME(path)),Values.STRING(str)})
     1128      algorithm
     1129        str := Tpl.tplString2(CodegenCFunctions.generateEntryPoint, path, str);
    13501130        System.writeFile(filename,str);
    1351       then (cache,Values.BOOL(true));
    1352 
    1353     case (cache,_,"generateEntryPoint",_,_)
    1354       then (cache,Values.BOOL(false));
    1355 
    1356     case (cache,_,"checkInterfaceOfPackages",{Values.CODE(Absyn.C_TYPENAME(path)),Values.ARRAY(valueLst=vals)},_)
    1357       equation
    1358         sp = SymbolTable.getSCode();
    1359         cl = SCodeUtil.getElementWithPath(sp,path);
    1360         interfaceTypeAssoc = List.map1(vals, getInterfaceTypeAssocElt, SCodeUtil.elementInfo(cl));
    1361         interfaceType = getInterfaceType(cl, interfaceTypeAssoc);
     1131      then
     1132        Values.BOOL(true);
     1133
     1134    case ("generateEntryPoint", _)
     1135      then Values.BOOL(false);
     1136
     1137    case ("checkInterfaceOfPackages",{Values.CODE(Absyn.C_TYPENAME(path)),Values.ARRAY(valueLst=vals)})
     1138      algorithm
     1139        sp := SymbolTable.getSCode();
     1140        cl := SCodeUtil.getElementWithPath(sp,path);
     1141        interfaceTypeAssoc := List.map1(vals, getInterfaceTypeAssocElt, SCodeUtil.elementInfo(cl));
     1142        interfaceType := getInterfaceType(cl, interfaceTypeAssoc);
    13621143        List.map1_0(sp, verifyInterfaceType, interfaceType);
    1363       then (cache,Values.BOOL(true));
    1364 
    1365     case (cache,_,"checkInterfaceOfPackages",_,_)
    1366       then (cache,Values.BOOL(false));
    1367 
    1368     case (cache,_,"generateSeparateCodeDependenciesMakefile",{Values.STRING(filename),Values.STRING(prefix),Values.STRING(suffix)},_)
    1369       equation
    1370         sp = SymbolTable.getSCode();
    1371         names = List.filterMap(sp,SCodeUtil.getElementName);
    1372         deps = Graph.buildGraph(names,buildDependencyGraphPublicImports,sp);
    1373         strs = List.map3(sp,writeModuleDepends,prefix,suffix,deps);
    1374         System.writeFile(filename,stringDelimitList(strs,"\n"));
    1375       then (cache,Values.BOOL(true));
    1376 
    1377     case (cache,_,"generateSeparateCodeDependenciesMakefile",_,_)
    1378       then (cache,Values.BOOL(false));
    1379 
    1380     case (cache,_,"generateSeparateCodeDependencies",{Values.STRING(suffix)},_)
    1381       equation
    1382         sp = SymbolTable.getSCode();
    1383         names = List.filterMap(sp,SCodeUtil.getElementName);
    1384 
    1385         deps = Graph.buildGraph(names,buildDependencyGraph,sp);
    1386         namesPublic = List.map(List.select(sp, containsPublicInterface), SCodeUtil.getElementName);
    1387         namesChanged = List.filterMap1(sp,getChangedClass,suffix);
    1388         hashSetString = HashSetString.emptyHashSet();
    1389         hashSetString = List.fold(namesChanged,BaseHashSet.add,hashSetString);
    1390         // print("namesChanged: " + stringDelimitList(namesChanged, ",") + "\n");
    1391 
    1392         depstransposed = Graph.transposeGraph(Graph.emptyGraph(names),deps,stringEq);
    1393         depstransposedtransitive = Graph.buildGraph(namesPublic,buildTransitiveDependencyGraph,depstransposed);
    1394         // depstransposedtransitive = List.sort(depstransposed, compareNumberOfDependencies);
    1395 
    1396         depstransitive = Graph.transposeGraph(Graph.emptyGraph(names),depstransposedtransitive,stringEq);
    1397         depstransitive = List.sort(depstransitive, compareNumberOfDependencies);
    1398 
    1399         depsmerged = Graph.merge(deps,depstransitive,stringEq,compareDependencyNode);
    1400         // depsmerged = List.sort(depsmerged, compareNumberOfDependencies);
    1401 
    1402         /*
    1403          print("Total number of modules: " + intString(listLength(depsmerged)) + "\n");
    1404          str = stringDelimitList(List.map(depsmerged, transitiveDependencyString), "\n");
    1405          print(str + "\n");
    1406         */
    1407 
    1408         depschanged = List.select1(depsmerged,isChanged,hashSetString);
    1409         names = List.map(depschanged, Util.tuple21);
    1410         // print("Files to recompile (" + intString(listLength(depschanged)) + "): " + stringDelimitList(names, ",") + "\n");
    1411         fileNames = List.map1(names, stringAppend, suffix);
    1412         _ = List.map(fileNames, System.removeFile);
    1413         v = ValuesUtil.makeArray(List.map(names,ValuesUtil.makeString));
    1414       then (cache,v);
    1415 
    1416     case (cache,_,"generateSeparateCodeDependencies",_,_)
    1417       then (cache,Values.META_FAIL());
    1418 
    1419     case (cache,env,"generateSeparateCode",{v,Values.BOOL(b)},_)
    1420       equation
    1421         p = SymbolTable.getAbsyn();
    1422         sp = SymbolTable.getSCode();
    1423         name = getTypeNameIdent(v);
    1424         setGlobalRoot(Global.instOnlyForcedFunctions,SOME(true));
    1425         cl = List.getMemberOnTrue(name, sp, SCodeUtil.isClassNamed);
    1426         (cache,env) = generateFunctions(cache,env,p,sp,{cl},b);
    1427         setGlobalRoot(Global.instOnlyForcedFunctions,NONE());
    1428       then (cache,Values.BOOL(true));
    1429 
    1430     case (_,_,"generateSeparateCode",{v,Values.BOOL(_)},_)
    1431       equation
    1432         sp = SymbolTable.getSCode();
    1433         name = getTypeNameIdent(v);
    1434         failure(_ = List.getMemberOnTrue(name, sp, SCodeUtil.isClassNamed));
    1435         Error.addMessage(Error.LOOKUP_ERROR, {name,"<TOP>"});
    1436       then fail();
    1437 
    1438     case (cache,_,"generateSeparateCode",_,_)
    1439       equation
    1440         setGlobalRoot(Global.instOnlyForcedFunctions,NONE());
    1441       then (cache,Values.BOOL(false));
    1442 
    1443     case (_,_,"loadModel",{Values.CODE(Absyn.C_TYPENAME(path)),Values.ARRAY(valueLst=cvars),Values.BOOL(b),Values.STRING(str),Values.BOOL(requireExactVersion)},_)
    1444       equation
    1445         p = SymbolTable.getAbsyn();
     1144      then
     1145        Values.BOOL(true);
     1146
     1147    case ("checkInterfaceOfPackages",_)
     1148      then Values.BOOL(false);
     1149
     1150    case ("generateSeparateCodeDependenciesMakefile",_)
     1151      then generateSeparateCodeDependenciesMakefile(args);
     1152
     1153    case ("generateSeparateCodeDependencies",_)
     1154      then generateSeparateCodeDependencies(args);
     1155
     1156    case ("generateSeparateCode", _)
     1157      algorithm
     1158        (v, outCache) := generateSeparateCode(args, outCache, env);
     1159      then
     1160        v;
     1161
     1162    case ("loadModel",{Values.CODE(Absyn.C_TYPENAME(path)),Values.ARRAY(valueLst=cvars),Values.BOOL(b),Values.STRING(str),Values.BOOL(requireExactVersion)})
     1163      algorithm
     1164        p := SymbolTable.getAbsyn();
    14461165        execStatReset();
    1447         mp = Settings.getModelicaPath(Testsuite.isRunning());
    1448         strings = List.map(cvars, ValuesUtil.extractValueString);
     1166        pathstr := Settings.getModelicaPath(Testsuite.isRunning());
     1167        strs := List.map(cvars, ValuesUtil.extractValueString);
    14491168        /* If the user requests a custom version to parse as, set it up */
    1450         oldLanguageStd = Config.getLanguageStandard();
    1451         b1 = not stringEq(str,"");
     1169        oldLanguageStd := Config.getLanguageStandard();
     1170        b1 := not stringEq(str,"");
    14521171        if b1 then
    14531172          Config.setLanguageStandard(Config.versionStringToStd(str));
    14541173        end if;
    1455         (p,b) = loadModel({(path,"call to loadModel",strings,false)},mp,p,true,b,true,requireExactVersion,false);
     1174        (p,b) := loadModel({(path,"call to loadModel",strs,false)},pathstr,p,true,b,true,requireExactVersion,false);
    14561175        if b1 then
    14571176          Config.setLanguageStandard(oldLanguageStd);
    … …  
    14601179        SymbolTable.setAbsyn(p);
    14611180        execStat("loadModel("+AbsynUtil.pathString(path)+")");
    1462       then (FCore.emptyCache(),Values.BOOL(b));
    1463 
    1464     case (cache,_,"loadModel",Values.CODE(Absyn.C_TYPENAME(path))::_,_)
     1181        outCache := FCore.emptyCache();
     1182      then
     1183        Values.BOOL(b);
     1184
     1185    case ("loadModel",Values.CODE(Absyn.C_TYPENAME(path))::_)
    14651186      equation
    14661187        pathstr = AbsynUtil.pathString(path);
    14671188        Error.addMessage(Error.LOAD_MODEL_ERROR, {pathstr});
    14681189      then
    1469         (cache,Values.BOOL(false));
    1470 
    1471     case (_,_,"loadFile",Values.STRING(name)::Values.STRING(encoding)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_,_)
    1472       equation
     1190        Values.BOOL(false);
     1191
     1192    case ("loadFile",Values.STRING(name)::Values.STRING(encoding)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_)
     1193      algorithm
    14731194        execStatReset();
    1474         name = Testsuite.friendlyPath(name);
    1475         newp = loadFile(name, encoding, SymbolTable.getAbsyn(), b, b1, requireExactVersion);
     1195        name := Testsuite.friendlyPath(name);
     1196        newp := loadFile(name, encoding, SymbolTable.getAbsyn(), b, b1, requireExactVersion);
    14761197        execStat("loadFile("+name+")");
    14771198        SymbolTable.setAbsyn(newp);
    1478       then
    1479         (FCore.emptyCache(),Values.BOOL(true));
    1480 
    1481     case (cache,_,"loadFile",_,_)
    1482       then (cache,Values.BOOL(false));
    1483 
    1484     case (_,_,"loadFiles",Values.ARRAY(valueLst=vals)::Values.STRING(encoding)::Values.INTEGER(i)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_,_)
    1485       equation
    1486         strs = List.mapMap(vals,ValuesUtil.extractValueString,Testsuite.friendlyPath);
    1487         newps = Parser.parallelParseFilesToProgramList(strs,encoding,numThreads=i);
    1488         newp = List.fold(newps, function checkUsesAndUpdateProgram(checkUses=b, modelicaPath=Settings.getModelicaPath(Testsuite.isRunning()), notifyLoad=b1, requireExactVersion=requireExactVersion), SymbolTable.getAbsyn());
     1199        outCache := FCore.emptyCache();
     1200      then
     1201        Values.BOOL(true);
     1202
     1203    case ("loadFile",_)
     1204      then Values.BOOL(false);
     1205
     1206    case ("loadFiles",Values.ARRAY(valueLst=vals)::Values.STRING(encoding)::Values.INTEGER(i)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_)
     1207      algorithm
     1208        strs := List.mapMap(vals,ValuesUtil.extractValueString,Testsuite.friendlyPath);
     1209        newps := Parser.parallelParseFilesToProgramList(strs,encoding,numThreads=i);
     1210        newp := List.fold(newps, function checkUsesAndUpdateProgram(checkUses=b, modelicaPath=Settings.getModelicaPath(Testsuite.isRunning()), notifyLoad=b1, requireExactVersion=requireExactVersion), SymbolTable.getAbsyn());
    14891211        SymbolTable.setAbsyn(newp);
    1490       then
    1491         (FCore.emptyCache(),Values.BOOL(true));
    1492 
    1493     case (cache,_,"loadFiles",_,_)
    1494       equation
     1212        outCache := FCore.emptyCache();
     1213      then
     1214        Values.BOOL(true);
     1215
     1216    case ("loadFiles",_)
     1217      algorithm
    14951218        // System.GC_enable();
    1496       then (cache,Values.BOOL(false));
    1497 
    1498     case (cache,_,"parseEncryptedPackage",Values.STRING(filename)::Values.STRING(workdir)::_,_)
    1499       equation
    1500         vals = {};
    1501         (b, filename_1) = unZipEncryptedPackageAndCheckFile(workdir, filename, false);
    1502         if (b) then
     1219      then Values.BOOL(false);
     1220
     1221    case ("parseEncryptedPackage",Values.STRING(filename)::Values.STRING(workdir)::_)
     1222      algorithm
     1223        vals := {};
     1224        (b, filename) := unZipEncryptedPackageAndCheckFile(workdir, filename, false);
     1225        if b then
    15031226          // clear the errors before!
    15041227          Error.clearMessages() "Clear messages";
    15051228          Print.clearErrorBuf() "Clear error buffer";
    1506           filename_1 = Testsuite.friendlyPath(filename_1);
    1507           (paths) = Interactive.parseFile(filename_1, "UTF-8");
    1508           vals = List.map(paths,ValuesUtil.makeCodeTypeName);
     1229          filename := Testsuite.friendlyPath(filename);
     1230          (paths) := Interactive.parseFile(filename, "UTF-8");
     1231          vals := List.map(paths,ValuesUtil.makeCodeTypeName);
    15091232        end if;
    1510       then (cache,ValuesUtil.makeArray(vals));
    1511 
    1512     case (_,_,"loadEncryptedPackage",Values.STRING(filename)::Values.STRING(workdir)::Values.BOOL(bval)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_,_)
    1513       equation
    1514         (b, filename_1) = unZipEncryptedPackageAndCheckFile(workdir, filename, bval);
     1233      then
     1234        ValuesUtil.makeArray(vals);
     1235
     1236    case ("loadEncryptedPackage",Values.STRING(filename)::Values.STRING(workdir)::Values.BOOL(bval)::Values.BOOL(b)::Values.BOOL(b1)::Values.BOOL(requireExactVersion)::_)
     1237      algorithm
     1238        (b, filename) := unZipEncryptedPackageAndCheckFile(workdir, filename, bval);
    15151239        if (b) then
    15161240          execStatReset();
    1517           filename_1 = Testsuite.friendlyPath(filename_1);
    1518           p = SymbolTable.getAbsyn();
    1519           newp = loadFile(filename_1, "UTF-8", p, b, b1, requireExactVersion);
    1520           execStat("loadFile("+filename_1+")");
     1241          filename := Testsuite.friendlyPath(filename);
     1242          p := SymbolTable.getAbsyn();
     1243          newp := loadFile(filename, "UTF-8", p, b, b1, requireExactVersion);
     1244          execStat("loadFile("+filename+")");
    15211245          SymbolTable.setAbsyn(newp);
    15221246        end if;
    1523       then
    1524         (FCore.emptyCache(),Values.BOOL(b));
    1525 
    1526     case (cache,_,"loadEncryptedPackage",_,_)
    1527       then
    1528         (cache,Values.BOOL(false));
    1529 
    1530     case (cache,_,"alarm",{Values.INTEGER(i)},_)
    1531       equation
    1532         i = System.alarm(i);
    1533       then (cache,Values.INTEGER(i));
    1534 
    1535     case (cache,_,"getClassNames",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("AllLoadedClasses"))),Values.BOOL(false),_,Values.BOOL(sort),Values.BOOL(builtin),Values.BOOL(_),_},_)
    1536       equation
    1537         (ip,_) = FBuiltin.getInitialFunctions();
    1538         p = SymbolTable.getAbsyn();
    1539         p = if builtin then Interactive.updateProgram(p,ip) else p;
    1540         paths = Interactive.getTopClassnames(p);
    1541         paths = if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
    1542         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    1543       then
    1544         (cache,ValuesUtil.makeArray(vals));
    1545 
    1546     case (cache,_,"getClassNames",{Values.CODE(Absyn.C_TYPENAME(path)),Values.BOOL(false),Values.BOOL(b),Values.BOOL(sort),Values.BOOL(builtin),Values.BOOL(showProtected),Values.BOOL(includeConstants)},_)
    1547       equation
    1548         (ip,_) = FBuiltin.getInitialFunctions();
    1549         p = SymbolTable.getAbsyn();
    1550         p = if builtin then Interactive.updateProgram(p,ip) else p;
    1551         paths = Interactive.getClassnamesInPath(path, p, showProtected, includeConstants);
    1552         paths = if b then List.map1r(paths,AbsynUtil.joinPaths,path) else paths;
    1553         paths = if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
    1554         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    1555       then
    1556         (cache,ValuesUtil.makeArray(vals));
    1557 
    1558     case (cache,_,"getClassNames",{Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("AllLoadedClasses"))),Values.BOOL(true),_,Values.BOOL(sort),Values.BOOL(builtin),Values.BOOL(showProtected),Values.BOOL(includeConstants)},_)
    1559       equation
    1560         (ip,_) = FBuiltin.getInitialFunctions();
    1561         p = SymbolTable.getAbsyn();
    1562         p = if builtin then Interactive.updateProgram(p,ip) else p;
    1563         (_,paths) = Interactive.getClassNamesRecursive(NONE(),p,showProtected,includeConstants,{});
    1564         paths = listReverse(paths);
    1565         paths = if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
    1566         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    1567       then
    1568         (cache,ValuesUtil.makeArray(vals));
    1569 
    1570     case (cache,_,"getClassNames",{Values.CODE(Absyn.C_TYPENAME(path)),Values.BOOL(true),_,Values.BOOL(sort),Values.BOOL(builtin),Values.BOOL(showProtected),Values.BOOL(includeConstants)},_)
    1571       equation
    1572         (ip,_) = FBuiltin.getInitialFunctions();
    1573         p = SymbolTable.getAbsyn();
    1574         p = if builtin then Interactive.updateProgram(p,ip) else p;
    1575         (_,paths) = Interactive.getClassNamesRecursive(SOME(path),p,showProtected,includeConstants,{});
    1576         paths = listReverse(paths);
    1577         paths = if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
    1578         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    1579       then
    1580         (cache,ValuesUtil.makeArray(vals));
    1581 
    1582     case (cache,_,"reloadClass",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(encoding)},_)
    1583       equation
    1584         Absyn.CLASS(info=SOURCEINFO(fileName=filename,lastModification=r2)) = Interactive.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
    1585         (true,_,r1) = System.stat(filename);
    1586         b = realEq(r1,r2);
    1587         if not b then
     1247        outCache := FCore.emptyCache();
     1248      then
     1249        Values.BOOL(b);
     1250
     1251    case ("loadEncryptedPackage",_)
     1252      then Values.BOOL(false);
     1253
     1254    case ("alarm",{Values.INTEGER(i)})
     1255      then Values.INTEGER(System.alarm(i));
     1256
     1257    case ("getClassNames", _) then getClassNames(args);
     1258
     1259    case ("reloadClass",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.STRING(encoding)})
     1260      algorithm
     1261        Absyn.CLASS(info=SOURCEINFO(fileName=filename,lastModification=r2)) :=
     1262          Interactive.getPathedClassInProgram(classpath, SymbolTable.getAbsyn());
     1263        (true,_,r1) := System.stat(filename);
     1264        if not realEq(r1, r2) then
    15881265          reloadClass(filename, encoding);
    15891266        end if;
    1590       then (cache,Values.BOOL(true));
    1591 
    1592     case (cache,_,"reloadClass",{Values.CODE(Absyn.C_TYPENAME(classpath)),_},_)
    1593       equation
    1594         failure(_ = Interactive.getPathedClassInProgram(classpath, SymbolTable.getAbsyn()));
    1595         str = AbsynUtil.pathString(classpath);
    1596         Error.addMessage(Error.LOAD_MODEL_ERROR, {str});
    1597       then (cache,Values.BOOL(false));
    1598 
    1599     case (cache,_,"reloadClass",_,_)
    1600       then (cache,Values.BOOL(false));
    1601 
    1602     case (_,_,"loadString",Values.STRING(str)::Values.STRING(name)::Values.STRING(encoding)::Values.BOOL(mergeAST)::_,_)
    1603       equation
    1604         str = if not (encoding == "UTF-8") then System.iconv(str, encoding, "UTF-8") else str;
    1605         newp = Parser.parsestring(str,name);
    1606         newp = Interactive.updateProgram(newp, SymbolTable.getAbsyn(), mergeAST);
     1267      then
     1268        Values.BOOL(true);
     1269
     1270    case ("reloadClass",{Values.CODE(Absyn.C_TYPENAME(classpath)),_})
     1271      algorithm
     1272        failure(_ := Interactive.getPathedClassInProgram(classpath, SymbolTable.getAbsyn()));
     1273        Error.addMessage(Error.LOAD_MODEL_ERROR, {AbsynUtil.pathString(classpath)});
     1274      then
     1275        Values.BOOL(false);
     1276
     1277    case ("reloadClass",_)
     1278      then Values.BOOL(false);
     1279
     1280    case ("loadString",Values.STRING(str)::Values.STRING(name)::Values.STRING(encoding)::Values.BOOL(mergeAST)::_)
     1281      algorithm
     1282        str := if not (encoding == "UTF-8") then System.iconv(str, encoding, "UTF-8") else str;
     1283        newp := Parser.parsestring(str,name);
     1284        newp := Interactive.updateProgram(newp, SymbolTable.getAbsyn(), mergeAST);
    16071285        SymbolTable.setAbsyn(newp);
    1608       then (FCore.emptyCache(), Values.BOOL(true));
    1609 
    1610     case (cache,_,"loadString",_,_)
    1611     then (cache,Values.BOOL(false));
    1612 
    1613     case (cache,_,"help",{Values.STRING("")},_)
    1614       equation
    1615         str = FlagsUtil.printUsage();
    1616       then
    1617         (cache,Values.STRING(str));
    1618 
    1619     case (cache,_,"help",{Values.STRING(str)},_)
    1620       equation
    1621         str = FlagsUtil.printHelp({str});
    1622       then
    1623         (cache,Values.STRING(str));
    1624 
    1625     case (cache,_,"getTimeStamp",{Values.CODE(Absyn.C_TYPENAME(classpath))},_)
    1626       equation
    1627         Absyn.CLASS(info=SOURCEINFO(lastModification=r)) = Interactive.getPathedClassInProgram(classpath,SymbolTable.getAbsyn());
    1628         str = System.ctime(r);
    1629       then (cache,Values.TUPLE({Values.REAL(r),Values.STRING(str)}));
    1630 
    1631     case (cache,_,"getTimeStamp",_,_)
    1632       then
    1633         (cache,Values.TUPLE({Values.REAL(0.0),Values.STRING("")}));
    1634 
    1635     case (cache,_,"getClassRestriction",{Values.CODE(Absyn.C_TYPENAME(classpath))},_)
    1636       equation
    1637         str = Interactive.getClassRestriction(classpath, SymbolTable.getAbsyn());
    1638       then
    1639         (cache,Values.STRING(str));
    1640 
    1641     case (cache,_,"classAnnotationExists",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))},_)
    1642       equation
    1643         b = Interactive.getNamedAnnotation(classpath, SymbolTable.getAbsyn(), path, SOME(false), isSome);
    1644       then
    1645         (cache,Values.BOOL(b));
    1646 
    1647     case (cache,_,"getBooleanClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))},_)
    1648       equation
    1649         Absyn.BOOL(b) = Interactive.getNamedAnnotation(classpath, SymbolTable.getAbsyn(), path, NONE(), Interactive.getAnnotationExp);
    1650       then
    1651         (cache,Values.BOOL(b));
    1652 
    1653     case (_,_,"getBooleanClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))},_)
    1654       equation
    1655         str1 = AbsynUtil.pathString(path);
    1656         str2 = AbsynUtil.pathString(classpath);
    1657         Error.addMessage(Error.CLASS_ANNOTATION_DOES_NOT_EXIST, {str1,str2});
    1658       then fail();
    1659 
    1660     case (cache,_,"strtok",{Values.STRING(str),Values.STRING(token)},_)
    1661       equation
    1662         vals = List.map(System.strtok(str,token), ValuesUtil.makeString);
    1663         i = listLength(vals);
    1664       then (cache,Values.ARRAY(vals,{i}));
    1665 
    1666     case (cache,_,"stringSplit",{Values.STRING(str),Values.STRING(token)},_)
    1667       equation
    1668         vals = List.map(Util.stringSplitAtChar(str,token), ValuesUtil.makeString);
    1669         i = listLength(vals);
    1670       then (cache,Values.ARRAY(vals,{i}));
    1671 
    1672     case (cache,_,"stringReplace",{Values.STRING(str1),Values.STRING(str2),Values.STRING(str3)},_)
    1673       equation
    1674         str = System.stringReplace(str1, str2, str3);
    1675       then (cache,Values.STRING(str));
    1676 
    1677         /* Checks the installation of OpenModelica and tries to find common errors */
    1678     case (cache,_,"checkSettings",{},_)
    1679       equation
    1680         vars_1 = {"OPENMODELICAHOME",
    1681                   "OPENMODELICALIBRARY",
    1682                   "OMC_PATH",
    1683                   "SYSTEM_PATH",
    1684                   "OMDEV_PATH",
    1685                   "OMC_FOUND",
    1686                   "MODELICAUSERCFLAGS",
    1687                   "WORKING_DIRECTORY",
    1688                   "CREATE_FILE_WORKS",
    1689                   "REMOVE_FILE_WORKS",
    1690                   "OS",
    1691                   "SYSTEM_INFO",
    1692                   "RTLIBS",
    1693                   "C_COMPILER",
    1694                   "C_COMPILER_VERSION",
    1695                   "C_COMPILER_RESPONDING",
    1696                   "HAVE_CORBA",
    1697                   "CONFIGURE_CMDLINE"};
    1698         omhome = Settings.getInstallationDirectoryPath();
    1699         omlib = Settings.getModelicaPath(Testsuite.isRunning());
    1700         omcpath = omhome + "/bin/omc" + Autoconf.exeExt;
    1701         systemPath = Util.makeValueOrDefault(System.readEnv,"PATH","");
    1702         omdev = Util.makeValueOrDefault(System.readEnv,"OMDEV","");
    1703         omcfound = System.regularFileExists(omcpath);
    1704         os = Autoconf.os;
    1705         touch_file = "omc.checksettings.create_file_test";
    1706         usercflags = Util.makeValueOrDefault(System.readEnv,"MODELICAUSERCFLAGS","");
    1707         workdir = System.pwd();
    1708         touch_res = 0 == System.systemCall("touch " + touch_file, "");
    1709         System.systemCall("uname -a", touch_file);
    1710         uname = System.readFile(touch_file);
    1711         rm_res = 0 == System.systemCall("rm " + touch_file, "");
    1712         // _ = System.platform();
    1713         senddata = Autoconf.ldflags_runtime;
    1714         gcc = System.getCCompiler();
    1715         have_corba = Corba.haveCorba();
    1716         System.systemCall("rm -f " + touch_file, "");
    1717         gcc_res = 0 == System.systemCall(gcc + " --version", touch_file);
    1718         gccVersion = System.readFile(touch_file);
    1719         System.systemCall("rm -f " + touch_file, "");
    1720         confcmd = Autoconf.configureCommandLine;
    1721         vals = {Values.STRING(omhome),
    1722                 Values.STRING(omlib),
    1723                 Values.STRING(omcpath),
    1724                 Values.STRING(systemPath),
    1725                 Values.STRING(omdev),
    1726                 Values.BOOL(omcfound),
    1727                 Values.STRING(usercflags),
    1728                 Values.STRING(workdir),
    1729                 Values.BOOL(touch_res),
    1730                 Values.BOOL(rm_res),
    1731                 Values.STRING(os),
    1732                 Values.STRING(uname),
    1733                 Values.STRING(senddata),
    1734                 Values.STRING(gcc),
    1735                 Values.STRING(gccVersion),
    1736                 Values.BOOL(gcc_res),
    1737                 Values.BOOL(have_corba),
    1738                 Values.STRING(confcmd)};
    1739       then (cache,Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.CheckSettingsResult"),vals,vars_1,-1));
    1740 
    1741     case (cache,_,"echo",{v as Values.BOOL(bval)},_)
    1742       equation
     1286        outCache := FCore.emptyCache();
     1287      then
     1288        Values.BOOL(true);
     1289
     1290    case ("loadString",_) then Values.BOOL(false);
     1291
     1292    case ("help",{Values.STRING("")})
     1293      then Values.STRING(FlagsUtil.printUsage());
     1294
     1295    case ("help",{Values.STRING(str)})
     1296      then Values.STRING(FlagsUtil.printHelp({str}));
     1297
     1298    case ("getTimeStamp",{Values.CODE(Absyn.C_TYPENAME(classpath))})
     1299      algorithm
     1300        Absyn.CLASS(info=SOURCEINFO(lastModification=r)) :=
     1301          Interactive.getPathedClassInProgram(classpath,SymbolTable.getAbsyn());
     1302        str := System.ctime(r);
     1303      then
     1304        Values.TUPLE({Values.REAL(r),Values.STRING(str)});
     1305
     1306    case ("getTimeStamp",_)
     1307      then Values.TUPLE({Values.REAL(0.0),Values.STRING("")});
     1308
     1309    case ("getClassRestriction",{Values.CODE(Absyn.C_TYPENAME(classpath))})
     1310      algorithm
     1311        str := Interactive.getClassRestriction(classpath, SymbolTable.getAbsyn());
     1312      then
     1313        Values.STRING(str);
     1314
     1315    case ("classAnnotationExists",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
     1316      algorithm
     1317        b := Interactive.getNamedAnnotation(classpath, SymbolTable.getAbsyn(), path, SOME(false), isSome);
     1318      then
     1319        Values.BOOL(b);
     1320
     1321    case ("getBooleanClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
     1322      algorithm
     1323        Absyn.BOOL(b) := Interactive.getNamedAnnotation(classpath, SymbolTable.getAbsyn(), path, NONE(), Interactive.getAnnotationExp);
     1324      then
     1325        Values.BOOL(b);
     1326
     1327    case ("getBooleanClassAnnotation",{Values.CODE(Absyn.C_TYPENAME(classpath)),Values.CODE(Absyn.C_TYPENAME(path))})
     1328      algorithm
     1329        Error.addMessage(Error.CLASS_ANNOTATION_DOES_NOT_EXIST,
     1330          {AbsynUtil.pathString(path), AbsynUtil.pathString(classpath)});
     1331      then
     1332        fail();
     1333
     1334    case ("strtok",{Values.STRING(str),Values.STRING(token)})
     1335      algorithm
     1336        strs := System.strtok(str, token);
     1337      then
     1338        ValuesUtil.makeStringArray(strs);
     1339
     1340    case ("stringSplit",{Values.STRING(str),Values.STRING(token)})
     1341      algorithm
     1342        strs := Util.stringSplitAtChar(str, token);
     1343      then
     1344        ValuesUtil.makeStringArray(strs);
     1345
     1346    case ("stringReplace",{Values.STRING(str1),Values.STRING(str2),Values.STRING(str3)})
     1347      algorithm
     1348        str := System.stringReplace(str1, str2, str3);
     1349      then
     1350        Values.STRING(str);
     1351
     1352    /* Checks the installation of OpenModelica and tries to find common errors */
     1353    case ("checkSettings",{}) then checkSettings();
     1354
     1355    case ("echo",{v as Values.BOOL(bval)})
     1356      algorithm
    17431357        Settings.setEcho(if bval then 1 else 0);
    1744       then (cache,v);
    1745 
    1746     case (cache,_,"numProcessors",{},_)
    1747       equation
    1748         i = Config.noProc();
    1749       then (cache,Values.INTEGER(i));
    1750 
    1751     case (cache,_,"runScript",{Values.STRING(str)},_)
    1752       equation
    1753         str = Testsuite.friendlyPath(str);
    1754         istmts = Parser.parseexp(str);
    1755         res = Interactive.evaluate(istmts, true);
    1756       then
    1757         (cache,Values.STRING(res));
    1758 
    1759     case (cache,_,"runScript",_,_)
    1760       then (cache,Values.STRING("Failed"));
    1761 
    1762     case (_,_,"exit",{Values.INTEGER(i)},_)
     1358      then
     1359        v;
     1360
     1361    case ("numProcessors",{})
     1362      then Values.INTEGER(Config.noProc());
     1363
     1364    case ("runScript",{Values.STRING(str)})
     1365      algorithm
     1366        str := Testsuite.friendlyPath(str);
     1367        res := Interactive.evaluate(Parser.parseexp(str), true);
     1368      then
     1369        Values.STRING(res);
     1370
     1371    case ("runScript",_)
     1372      then Values.STRING("Failed");
     1373
     1374    case ("exit",{Values.INTEGER(i)})
    17631375      equation
    17641376        System.exit(i);
    17651377        /* Cannot reach here */
    1766       then fail();
    1767 
    1768     case (cache,_,"getMemorySize",{},_)
    1769       equation
    1770         r = System.getMemorySize();
    1771         v = Values.REAL(r);
    1772       then (cache,v);
    1773 
    1774     case (cache,_,"getAllSubtypeOf",{
     1378      then
     1379        fail();
     1380
     1381    case ("getMemorySize",{})
     1382      then Values.REAL(System.getMemorySize());
     1383
     1384    case ("getAllSubtypeOf",{
    17751385          Values.CODE(Absyn.C_TYPENAME(path)),
    17761386          Values.CODE(Absyn.C_TYPENAME(parentClass)),
    17771387          Values.BOOL(qualified),
    17781388          Values.BOOL(includePartial),
    1779           Values.BOOL(sort)},_)
    1780       equation
    1781         paths = InteractiveUtil.getAllSubtypeOf(path, parentClass, SymbolTable.getAbsyn(), qualified, includePartial);
    1782         paths = listReverse(paths);
    1783         paths = if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
    1784         vals = List.map(paths,ValuesUtil.makeCodeTypeName);
    1785       then
    1786         (cache,ValuesUtil.makeArray(vals));
     1389          Values.BOOL(sort)})
     1390      algorithm
     1391        paths := InteractiveUtil.getAllSubtypeOf(path, parentClass, SymbolTable.getAbsyn(), qualified, includePartial);
     1392        paths := listReverse(paths);
     1393        paths := if sort then List.sort(paths, AbsynUtil.pathGe) else paths;
     1394        vals := List.map(paths,ValuesUtil.makeCodeTypeName);
     1395      then
     1396        ValuesUtil.makeArray(vals);
    17871397
    17881398    // check for OMSimulator API calls
    1789     case (cache,_,_,_,_)
    1790       equation
    1791         v = CevalScriptOMSimulator.ceval(inFunctionName,inVals);
    1792        then
    1793          (cache,v);
     1399    case (_,_)
     1400      then CevalScriptOMSimulator.ceval(functionName, args);
     1401
    17941402    else
    17951403      algorithm
    1796         (cache,v) := CevalScriptBackend.cevalInteractiveFunctions3(inCache,inEnv,inFunctionName,inVals,msg);
    1797       then (cache,v);
     1404        (outCache,v) := CevalScriptBackend.cevalInteractiveFunctions3(outCache,env,functionName,args,msg);
     1405      then
     1406        v;
    17981407
    17991408 end matchcontinue;
    … …  
    32782887end unZipEncryptedPackageAndCheckFile;
    32792888
     2889function listClass
     2890  input list<Values.Value> args;
     2891  output Values.Value res;
     2892protected
     2893  String str, name;
     2894  Absyn.Program p;
     2895  SCode.Program scodeP;
     2896  Absyn.Class absynClass;
     2897  SCode.Element cl;
     2898  Absyn.Path path, className;
     2899  Boolean interface_only, short_only;
     2900  constant SCodeDump.SCodeDumpOptions dumpOpt =
     2901    SCodeDump.OPTIONS(true,false,true,true,true,true,true,true,true);
     2902algorithm
     2903  str := matchcontinue args
     2904    // handle encryption
     2905    case _
     2906      algorithm
     2907        // if AST contains encrypted class show nothing
     2908        p := SymbolTable.getAbsyn();
     2909        true := Interactive.astContainsEncryptedClass(p);
     2910        Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
     2911      then
     2912        "";
     2913
     2914    case {Values.CODE(Absyn.C_TYPENAME(Absyn.IDENT("AllLoadedClasses"))),
     2915          Values.BOOL(false), Values.BOOL(false), Values.ENUM_LITERAL(name=path)}
     2916      then
     2917        match AbsynUtil.pathLastIdent(path)
     2918          case "Absyn" then Dump.unparseStr(SymbolTable.getAbsyn(), false);
     2919          case "SCode" then SCodeDump.programStr(SymbolTable.getSCode());
     2920          case "MetaModelicaInterface" then SCodeDump.programStr(SymbolTable.getSCode(), dumpOpt);
     2921          case "Internal" then System.anyStringCode(SymbolTable.getAbsyn());
     2922          else "";
     2923        end match;
     2924
     2925    case {Values.CODE(Absyn.C_TYPENAME(className)), Values.BOOL(interface_only),
     2926          Values.BOOL(short_only), Values.ENUM_LITERAL(name=path)}
     2927      algorithm
     2928        false := valueEq(Absyn.IDENT("AllLoadedClasses"),className);
     2929        p := SymbolTable.getAbsyn();
     2930        scodeP := SymbolTable.getSCode();
     2931        absynClass := Interactive.getPathedClassInProgram(className, p);
     2932        absynClass := if interface_only then AbsynUtil.getFunctionInterface(absynClass) else absynClass;
     2933        absynClass := if short_only then AbsynUtil.getShortClass(absynClass) else absynClass;
     2934        p := Absyn.PROGRAM({absynClass},Absyn.TOP());
     2935        cl := FBuiltin.getElementWithPathCheckBuiltin(scodeP, className);
     2936      then
     2937        match AbsynUtil.pathLastIdent(path)
     2938          case "Absyn" then Dump.unparseStr(p, false);
     2939          case "SCode" then SCodeDump.unparseElementStr(cl);
     2940          case "MetaModelicaInterface" then SCodeDump.unparseElementStr(cl, dumpOpt);
     2941          case "Internal" then System.anyStringCode(p);
     2942          else "";
     2943        end match;
     2944
     2945    else "";
     2946  end matchcontinue;
     2947
     2948  res := Values.STRING(str);
     2949end listClass;
     2950
     2951function listFile
     2952  input list<Values.Value> args;
     2953  output Values.Value res;
     2954protected
     2955  String str;
     2956  Absyn.Path path, className;
     2957  Boolean nested;
     2958  Integer access;
     2959  Absyn.Class absynClass;
     2960  Absyn.Restriction restriction;
     2961algorithm
     2962  str := matchcontinue args
     2963    case {Values.CODE(Absyn.C_TYPENAME(className)), Values.BOOL(nested)}
     2964      algorithm
     2965        path := match className
     2966          case Absyn.FULLYQUALIFIED() then className.path;
     2967          else className;
     2968        end match;
     2969        // handle encryption
     2970        Values.ENUM_LITERAL(index=access) := Interactive.checkAccessAnnotationAndEncryption(path, SymbolTable.getAbsyn());
     2971        (absynClass as Absyn.CLASS(restriction=restriction, info=SOURCEINFO(fileName=str))) := Interactive.getPathedClassInProgram(className, SymbolTable.getAbsyn());
     2972        absynClass := if nested then absynClass else AbsynUtil.filterNestedClasses(absynClass);
     2973        /* If the class has Access.packageText annotation or higher
     2974         * If the class has Access.nonPackageText annotation or higher and class is not a package
     2975         */
     2976        if ((access >= 7) or ((access >= 5) and not AbsynUtil.isPackageRestriction(restriction))) then
     2977          str := Dump.unparseStr(Absyn.PROGRAM({absynClass}, match path case Absyn.IDENT() then Absyn.TOP(); else Absyn.WITHIN(AbsynUtil.stripLast(path)); end match), options=Dump.DUMPOPTIONS(str));
     2978        else
     2979          Error.addMessage(Error.ACCESS_ENCRYPTED_PROTECTED_CONTENTS, {});
     2980          str := "";
     2981        end if;
     2982      then
     2983        str;
     2984
     2985    else "";
     2986  end matchcontinue;
     2987
     2988  res := Values.STRING(str);
     2989end listFile;
     2990
     2991function getClassNames
     2992  input list<Values.Value> args;
     2993  output Values.Value res;
     2994protected
     2995  Absyn.Path path;
     2996  String clsName;
     2997  Boolean recursive, qualified, sort, builtin, protects, constants;
     2998  Absyn.Program p;
     2999  list<Absyn.Path> paths;
     3000algorithm
     3001  {Values.CODE(Absyn.C_TYPENAME(path)),
     3002   Values.BOOL(recursive),
     3003   Values.BOOL(qualified),
     3004   Values.BOOL(sort),
     3005   Values.BOOL(builtin),
     3006   Values.BOOL(protects),
     3007   Values.BOOL(constants)} := args;
     3008
     3009  p := SymbolTable.getAbsyn();
     3010
     3011  if builtin then
     3012    p := Interactive.updateProgram(p, FBuiltin.getInitialFunctions());
     3013  end if;
     3014
     3015  if AbsynUtil.pathEqual(path, Absyn.IDENT("AllLoadedClasses")) then
     3016    if recursive then
     3017      (_, paths) := Interactive.getClassNamesRecursive(NONE(), p, protects, constants, {});
     3018      paths := listReverseInPlace(paths);
     3019    else
     3020      paths := Interactive.getTopClassnames(p);
     3021    end if;
     3022  else
     3023    if recursive then
     3024      (_, paths) := Interactive.getClassNamesRecursive(SOME(path), p, protects, constants, {});
     3025      paths := listReverseInPlace(paths);
     3026    else
     3027      paths := Interactive.getClassnamesInPath(path, p, protects, constants);
     3028
     3029      if qualified then
     3030        paths := list(AbsynUtil.joinPaths(path, p) for p in paths);
     3031      end if;
     3032    end if;
     3033  end if;
     3034
     3035  if sort then
     3036    paths := List.sort(paths, AbsynUtil.pathGe);
     3037  end if;
     3038
     3039  res := ValuesUtil.makeArray(list(ValuesUtil.makeCodeTypeName(p) for p in paths));
     3040end getClassNames;
     3041
     3042function checkSettings
     3043  output Values.Value res;
     3044protected
     3045  list<String> vars;
     3046  String omhome, omlib, omcpath, systemPath, omdev, os, touch_file, usercflags;
     3047  String workdir, uname, senddata, gcc, gccVersion, confcmd;
     3048  Boolean omcfound, touch_res, rm_res, have_corba, gcc_res;
     3049  list<Values.Value> vals;
     3050algorithm
     3051  vars := {"OPENMODELICAHOME",
     3052           "OPENMODELICALIBRARY",
     3053           "OMC_PATH",
     3054           "SYSTEM_PATH",
     3055           "OMDEV_PATH",
     3056           "OMC_FOUND",
     3057           "MODELICAUSERCFLAGS",
     3058           "WORKING_DIRECTORY",
     3059           "CREATE_FILE_WORKS",
     3060           "REMOVE_FILE_WORKS",
     3061           "OS",
     3062           "SYSTEM_INFO",
     3063           "RTLIBS",
     3064           "C_COMPILER",
     3065           "C_COMPILER_VERSION",
     3066           "C_COMPILER_RESPONDING",
     3067           "HAVE_CORBA",
     3068           "CONFIGURE_CMDLINE"};
     3069  omhome := Settings.getInstallationDirectoryPath();
     3070  omlib := Settings.getModelicaPath(Testsuite.isRunning());
     3071  omcpath := omhome + "/bin/omc" + Autoconf.exeExt;
     3072  systemPath := Util.makeValueOrDefault(System.readEnv,"PATH","");
     3073  omdev := Util.makeValueOrDefault(System.readEnv,"OMDEV","");
     3074  omcfound := System.regularFileExists(omcpath);
     3075  os := Autoconf.os;
     3076  touch_file := "omc.checksettings.create_file_test";
     3077  usercflags := Util.makeValueOrDefault(System.readEnv,"MODELICAUSERCFLAGS","");
     3078  workdir := System.pwd();
     3079  touch_res := 0 == System.systemCall("touch " + touch_file, "");
     3080  System.systemCall("uname -a", touch_file);
     3081  uname := System.readFile(touch_file);
     3082  rm_res := 0 == System.systemCall("rm " + touch_file, "");
     3083  // _ = System.platform();
     3084  senddata := Autoconf.ldflags_runtime;
     3085  gcc := System.getCCompiler();
     3086  have_corba := Corba.haveCorba();
     3087  System.systemCall("rm -f " + touch_file, "");
     3088  gcc_res := 0 == System.systemCall(gcc + " --version", touch_file);
     3089  gccVersion := System.readFile(touch_file);
     3090  System.systemCall("rm -f " + touch_file, "");
     3091  confcmd := Autoconf.configureCommandLine;
     3092  vals := {Values.STRING(omhome),
     3093           Values.STRING(omlib),
     3094           Values.STRING(omcpath),
     3095           Values.STRING(systemPath),
     3096           Values.STRING(omdev),
     3097           Values.BOOL(omcfound),
     3098           Values.STRING(usercflags),
     3099           Values.STRING(workdir),
     3100           Values.BOOL(touch_res),
     3101           Values.BOOL(rm_res),
     3102           Values.STRING(os),
     3103           Values.STRING(uname),
     3104           Values.STRING(senddata),
     3105           Values.STRING(gcc),
     3106           Values.STRING(gccVersion),
     3107           Values.BOOL(gcc_res),
     3108           Values.BOOL(have_corba),
     3109           Values.STRING(confcmd)};
     3110
     3111  res := Values.RECORD(Absyn.IDENT("OpenModelica.Scripting.CheckSettingsResult"), vals, vars, -1);
     3112end checkSettings;
     3113
     3114function generateSeparateCodeDependenciesMakefile
     3115  input list<Values.Value> args;
     3116  output Values.Value res;
     3117protected
     3118  SCode.Program sp;
     3119  list<String> names, strs;
     3120  list<tuple<String,list<String>>> deps;
     3121  String filename, prefix, suffix;
     3122algorithm
     3123  try
     3124    {Values.STRING(filename),Values.STRING(prefix),Values.STRING(suffix)} := args;
     3125    sp := SymbolTable.getSCode();
     3126    names := List.filterMap(sp,SCodeUtil.getElementName);
     3127    deps := Graph.buildGraph(names,buildDependencyGraphPublicImports,sp);
     3128    strs := List.map3(sp,writeModuleDepends,prefix,suffix,deps);
     3129    System.writeFile(filename,stringDelimitList(strs,"\n"));
     3130    res := Values.BOOL(true);
     3131  else
     3132    res := Values.BOOL(false);
     3133  end try;
     3134end generateSeparateCodeDependenciesMakefile;
     3135
     3136function generateSeparateCodeDependencies
     3137  input list<Values.Value> args;
     3138  output Values.Value res;
     3139protected
     3140  String suffix;
     3141  SCode.Program sp;
     3142  list<String> names, namesPublic, namesChanged, fileNames;
     3143  list<tuple<String,list<String>>> deps, depstransitive, depstransposed,
     3144                                   depstransposedtransitive, depsmerged, depschanged;
     3145  HashSetString.HashSet hashSetString;
     3146algorithm
     3147  try
     3148    {Values.STRING(suffix)} := args;
     3149    sp := SymbolTable.getSCode();
     3150    names := List.filterMap(sp,SCodeUtil.getElementName);
     3151
     3152    deps := Graph.buildGraph(names,buildDependencyGraph,sp);
     3153    namesPublic := List.map(List.select(sp, containsPublicInterface), SCodeUtil.getElementName);
     3154    namesChanged := List.filterMap1(sp,getChangedClass,suffix);
     3155    hashSetString := HashSetString.emptyHashSet();
     3156    hashSetString := List.fold(namesChanged,BaseHashSet.add,hashSetString);
     3157    // print("namesChanged: " + stringDelimitList(namesChanged, ",") + "\n");
     3158
     3159    depstransposed := Graph.transposeGraph(Graph.emptyGraph(names),deps,stringEq);
     3160    depstransposedtransitive := Graph.buildGraph(namesPublic,buildTransitiveDependencyGraph,depstransposed);
     3161    // depstransposedtransitive = List.sort(depstransposed, compareNumberOfDependencies);
     3162
     3163    depstransitive := Graph.transposeGraph(Graph.emptyGraph(names),depstransposedtransitive,stringEq);
     3164    depstransitive := List.sort(depstransitive, compareNumberOfDependencies);
     3165
     3166    depsmerged := Graph.merge(deps,depstransitive,stringEq,compareDependencyNode);
     3167    // depsmerged = List.sort(depsmerged, compareNumberOfDependencies);
     3168
     3169    /*
     3170     print("Total number of modules: " + intString(listLength(depsmerged)) + "\n");
     3171     str = stringDelimitList(List.map(depsmerged, transitiveDependencyString), "\n");
     3172     print(str + "\n");
     3173    */
     3174
     3175    depschanged := List.select1(depsmerged,isChanged,hashSetString);
     3176    names := List.map(depschanged, Util.tuple21);
     3177    // print("Files to recompile (" + intString(listLength(depschanged)) + "): " + stringDelimitList(names, ",") + "\n");
     3178    fileNames := List.map1(names, stringAppend, suffix);
     3179    _ := List.map(fileNames, System.removeFile);
     3180    res := ValuesUtil.makeArray(List.map(names,ValuesUtil.makeString));
     3181  else
     3182    res := Values.META_FAIL();
     3183  end try;
     3184end generateSeparateCodeDependencies;
     3185
     3186function generateSeparateCode
     3187  input list<Values.Value> args;
     3188  input FCore.Cache cache;
     3189  input FCore.Graph env;
     3190  output Values.Value res;
     3191  output FCore.Cache outCache;
     3192protected
     3193  Values.Value v;
     3194  Boolean b;
     3195  Absyn.Program p;
     3196  SCode.Program sp;
     3197  String name;
     3198  SCode.Element cl;
     3199algorithm
     3200  res := matchcontinue args
     3201    case {v, Values.BOOL(b)}
     3202      algorithm
     3203        p := SymbolTable.getAbsyn();
     3204        sp := SymbolTable.getSCode();
     3205        name := getTypeNameIdent(v);
     3206        setGlobalRoot(Global.instOnlyForcedFunctions,SOME(true));
     3207        cl := List.getMemberOnTrue(name, sp, SCodeUtil.isClassNamed);
     3208        outCache := generateFunctions(cache,env,p,sp,{cl},b);
     3209        setGlobalRoot(Global.instOnlyForcedFunctions,NONE());
     3210      then
     3211        Values.BOOL(true);
     3212
     3213    case {v, Values.BOOL(_)}
     3214      algorithm
     3215        sp := SymbolTable.getSCode();
     3216        name := getTypeNameIdent(v);
     3217        false := List.isMemberOnTrue(name, sp, SCodeUtil.isClassNamed);
     3218        Error.addMessage(Error.LOOKUP_ERROR, {name,"<TOP>"});
     3219      then
     3220        fail();
     3221
     3222    else
     3223      algorithm
     3224        setGlobalRoot(Global.instOnlyForcedFunctions,NONE());
     3225      then
     3226        Values.BOOL(false);
     3227
     3228  end matchcontinue;
     3229end generateSeparateCode;
     3230
    32803231annotation(__OpenModelica_Interface="backend");
    32813232end CevalScript;
Note: See TracChangeset for help on using the changeset viewer.