@sdeverywhere/compile 0.7.16 → 0.7.18

package/package.json

@@ -1,13 +1,11 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.16",
+  "version": "0.7.18",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
     "@sdeverywhere/parse": "^0.1.0",
-    "antlr4": "4.12.0",
-    "antlr4-vensim": "0.6.2",
     "bufx": "^1.0.5",
     "byline": "^5.0.0",
     "csv-parse": "^5.3.3",

package/src/generate/expand-var-names.js

@@ -5,8 +5,6 @@ import { sub, isDimension } from '../_shared/subscript.js'
 
 import Model from '../model/model.js'
 
-import ModelLHSReader from './model-lhs-reader.js'
-
 /**
  * Return an array of names for all variable in the model, sorted alphabetically and expanded to
  * include the full set of subscripted variants for variables that include subscripts.
@@ -43,14 +41,6 @@ export function expandVarNames(canonical) {
  * @returns {string[]} An array of expanded names for the given variable.
  */
 function namesForVar(v) {
-  if (process.env.SDE_NONPUBLIC_USE_NEW_PARSE === '0') {
-    // TODO: When the old parsing code is active, use the old ModelLHSReader.  This code path
-    // will be removed when the old parsing code is removed.
-    let modelLHSReader = new ModelLHSReader()
-    modelLHSReader.read(v.modelLHS)
-    return modelLHSReader.names()
-  }
-
   if (v.parsedEqn === undefined) {
     // XXX: The special `Time` variable does not have a `parsedEqn`, so use the raw LHS
     return [v.modelLHS]

package/src/generate/{code-gen.js → gen-code-c.js}

@@ -1,14 +1,13 @@
 import * as R from 'ramda'
 
-import { asort, lines, strlist, mapIndexed } from '../_shared/helpers.js'
+import { asort, canonicalVensimName, lines, strlist, mapIndexed } from '../_shared/helpers.js'
 import { sub, allDimensions, allMappings, subscriptFamilies } from '../_shared/subscript.js'
 import Model from '../model/model.js'
 
 import { generateEquation } from './gen-equation.js'
-import EquationGen from './equation-gen.js'
 import { expandVarNames } from './expand-var-names.js'
 
-export function generateCode(parsedModel, opts) {
+export function generateC(parsedModel, opts) {
   return codeGenerator(parsedModel, opts).generate()
 }
 
@@ -17,21 +16,10 @@ let codeGenerator = (parsedModel, opts) => {
   // Set to 'decl', 'init-lookups', 'eval', etc depending on the section being generated.
   let mode = ''
   // Set to true to output all variables when there is no model run spec.
-  let outputAllVars
-  if (spec.outputVars && spec.outputVars.length > 0) {
-    outputAllVars = false
-  } else if (spec.outputVarNames && spec.outputVarNames.length > 0) {
-    outputAllVars = false
-  } else {
-    outputAllVars = true
-  }
+  let outputAllVars = spec.outputVarNames === undefined || spec.outputVarNames.length === 0
   // Function to generate a section of the code
   let generateSection = R.map(v => {
-    if (parsedModel.kind === 'vensim-legacy') {
-      return new EquationGen(v, extData, directData, mode, modelDirname).generate()
-    } else {
-      return generateEquation(v, mode, extData, directData, modelDirname)
-    }
+    return generateEquation(v, mode, extData, directData, modelDirname, 'c')
   })
   let section = R.pipe(generateSection, R.flatten, lines)
   function generate() {
@@ -93,51 +81,54 @@ ${section(Model.dataVars())}
   //
   function emitInitLookupsCode() {
     mode = 'init-lookups'
-    let code = `// Internal state
+    let code = `\
+// Internal state
 bool lookups_initialized = false;
 bool data_initialized = false;
+
 `
     code += chunkedFunctions(
       'initLookups',
       Model.lookupVars(),
-      `  // Initialize lookups.
-  if (!lookups_initialized) {
-`,
-      `      lookups_initialized = true;
-  }
-`
+      `\
+  // Initialize lookups.
+  if (lookups_initialized) {
+    return;
+  }`,
+      '  lookups_initialized = true;'
     )
     code += chunkedFunctions(
       'initData',
       Model.dataVars(),
-      `  // Initialize data.
-  if (!data_initialized) {
-`,
-      `      data_initialized = true;
-  }
-`
+      `\
+  // Initialize data.
+  if (data_initialized) {
+    return;
+  }`,
+      '  data_initialized = true;'
     )
     return code
   }
 
   function emitInitConstantsCode() {
     mode = 'init-constants'
-    return `
-${chunkedFunctions('initConstants', Model.constVars(), '  // Initialize constants.', '  initLookups();\n  initData();')}
-`
+    return chunkedFunctions(
+      'initConstants',
+      Model.constVars(),
+      '  // Initialize constants.',
+      '  initLookups();\n  initData();'
+    )
   }
 
   function emitInitLevelsCode() {
     mode = 'init-levels'
-    return `
-${chunkedFunctions(
-  'initLevels',
-  Model.initVars(),
-  `
+    return chunkedFunctions(
+      'initLevels',
+      Model.initVars(),
+      `\
   // Initialize variables with initialization values, such as levels, and the variables they depend on.
   _time = _initial_time;`
-)}
-`
+    )
   }
 
   //
@@ -146,40 +137,96 @@ ${chunkedFunctions(
   function emitEvalCode() {
     mode = 'eval'
 
-    return `
-${chunkedFunctions('evalAux', Model.auxVars(), '  // Evaluate auxiliaries in order from the bottom up.')}
-
-${chunkedFunctions('evalLevels', Model.levelVars(), '  // Evaluate levels.')}
-`
+    return `\
+${chunkedFunctions('evalAux', Model.auxVars(), '  // Evaluate auxiliaries in order from the bottom up.')}\
+${chunkedFunctions('evalLevels', Model.levelVars(), '  // Evaluate levels.')}`
   }
 
   //
   // Input/output section
   //
   function emitIOCode() {
-    let headerVars = outputAllVars ? expandedVarNames(true) : spec.outputVars
-    let outputVars = outputAllVars ? expandedVarNames() : spec.outputVars
+    // Configure the body of the `setLookup` function depending on the value
+    // of the `customLookups` property in the spec file
+    // TODO: The fprintf calls should be replaced with a mechanism that throws
+    // an error (we could add a wrapper function at the JS level)
+    let setLookupBody
+    if (spec.customLookups === true || Array.isArray(spec.customLookups)) {
+      setLookupBody = `\
+  switch (varIndex) {
+${setLookupImpl(Model.varIndexInfo(), spec.customLookups)}
+    default:
+      fprintf(stderr, "No lookup found for var index %zu in setLookup\\n", varIndex);
+      break;
+  }`
+    } else {
+      let msg = 'The setLookup function was not enabled for the generated model. '
+      msg += 'Set the customLookups property in the spec/config file to allow for overriding lookups at runtime.'
+      setLookupBody = `\
+  fprintf(stderr, "${msg}\\n");`
+    }
+
+    // Configure the output variables that appear in the generated `getHeader`
+    // and `storeOutputData` functions
+    let headerVarNames = outputAllVars ? expandedVarNames(true) : spec.outputVarNames
+    let outputVarIds = outputAllVars ? expandedVarNames() : spec.outputVars
+
+    // Configure the body of the `storeOutput` function depending on the value
+    // of the `customOutputs` property in the spec file
+    let storeOutputBody
+    if (spec.customOutputs === true || Array.isArray(spec.customOutputs)) {
+      storeOutputBody = `\
+  switch (varIndex) {
+${customOutputSection(Model.varIndexInfo(), spec.customOutputs)}
+    default:
+      fprintf(stderr, "No variable found for var index %zu in storeOutput\\n", varIndex);
+      break;
+  }`
+    } else {
+      let msg = 'The storeOutput function was not enabled for the generated model. '
+      msg +=
+        'Set the customOutputs property in the spec/config file to allow for capturing arbitrary variables at runtime.'
+      storeOutputBody = `\
+  fprintf(stderr, "${msg}\\n");`
+    }
+
     mode = 'io'
-    return `void setInputs(const char* inputData) {${inputsFromStringImpl()}}
+    return `\
+void setInputs(const char* inputData) {
+${inputsFromStringImpl()}
+}
+
+void setInputsFromBuffer(double* inputData) {
+${inputsFromBufferImpl()}
+}
+
+void replaceLookup(Lookup** lookup, double* points, size_t numPoints) {
+  if (lookup == NULL) {
+    return;
+  }
+  if (*lookup != NULL) {
+    __delete_lookup(*lookup);
+    *lookup = NULL;
+  }
+  if (points != NULL) {
+    *lookup = __new_lookup(numPoints, /*copy=*/true, points);
+  }
+}
 
-void setInputsFromBuffer(double* inputData) {${inputsFromBufferImpl()}}
+void setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints) {
+${setLookupBody}
+}
 
 const char* getHeader() {
-  return "${R.map(varName => headerTitle(varName), headerVars).join('\\t')}";
+  return "${R.map(varName => varName.replace(/"/g, '\\"'), headerVarNames).join('\\t')}";
 }
 
 void storeOutputData() {
-${specOutputSection(outputVars)}
+${specOutputSection(outputVarIds)}
 }
 
-void storeOutput(size_t varIndex, size_t subIndex0, size_t subIndex1, size_t subIndex2) {
-#if SDE_USE_OUTPUT_INDICES
-  switch (varIndex) {
-${fullOutputSection(Model.varIndexInfo())}
-    default:
-      break;
-  }
-#endif
+void storeOutput(size_t varIndex, size_t* subIndices) {
+${storeOutputBody}
 }
 `
   }
@@ -190,9 +237,9 @@ ${fullOutputSection(Model.varIndexInfo())}
   function chunkedFunctions(name, vars, preStep, postStep) {
     // Emit one function for each chunk
     let func = (chunk, idx) => {
-      return `
+      return `\
 void ${name}${idx}() {
-  ${section(chunk)}
+${section(chunk)}
 }
 `
     }
@@ -220,22 +267,25 @@ void ${name}${idx}() {
       chunks = [vars]
     }
 
-    if (!preStep) {
-      preStep = ''
+    let funcsPart = funcs(chunks)
+    let callsPart = funcCalls(chunks)
+
+    let out = ''
+    if (funcsPart.length > 0) {
+      out += funcsPart + '\n'
     }
-    if (!postStep) {
-      postStep = ''
+    out += `void ${name}() {\n`
+    if (preStep) {
+      out += preStep + '\n'
     }
-
-    return `
-${funcs(chunks)}
-
-void ${name}() {
-${preStep}
-${funcCalls(chunks)}
-${postStep}
-}
-    `
+    if (callsPart.length > 0) {
+      out += callsPart + '\n'
+    }
+    if (postStep) {
+      out += postStep + '\n'
+    }
+    out += '}\n\n'
+    return out
   }
 
   //
@@ -283,9 +333,6 @@ ${postStep}
     } else {
       decls = `const int numOutputs = ${spec.outputVars.length};`
     }
-    decls += `\n#define SDE_USE_OUTPUT_INDICES 0`
-    decls += `\n#define SDE_MAX_OUTPUT_INDICES 1000`
-    decls += `\nconst int maxOutputIndices = SDE_USE_OUTPUT_INDICES ? SDE_MAX_OUTPUT_INDICES : 0;`
     return decls
   }
   function arrayDimensionsSection() {
@@ -320,31 +367,44 @@ ${postStep}
   // Input/output section helpers
   //
   function specOutputSection(varNames) {
-    // Emit output calls using varNames in C format.
+    // Emit `outputVar` calls for all variables listed in the `outputVarNames`
+    // array in the spec file using varNames in C format.
     let code = R.map(varName => `  outputVar(${varName});`)
     let section = R.pipe(code, lines)
     return section(varNames)
   }
-  function fullOutputSection(varIndexInfo) {
-    // Emit output calls for all variables.
+  function customOutputSection(varIndexInfo, customOutputs) {
+    // Emit `outputVar` calls for all variables that can be accessed as an output.
+    // This excludes data and lookup variables; at this time, the data for these
+    // cannot be output like for other types of variables.
+    let includeCase
+    if (Array.isArray(customOutputs)) {
+      // Only include a case statement if the variable was explicitly included
+      // in the `customOutputs` array in the spec file
+      const customOutputVarNames = customOutputs.map(varName => {
+        // The developer might specify a variable name that includes subscripts,
+        // but we will ignore the subscript part and only match on the base name
+        return canonicalVensimName(varName.split('[')[0])
+      })
+      includeCase = varName => customOutputVarNames.includes(varName)
+    } else {
+      // Include a case statement for all accessible variables
+      includeCase = () => true
+    }
+    const outputVars = R.filter(info => {
+      return info.varType !== 'lookup' && info.varType !== 'data' && includeCase(info.varName)
+    })
     const code = R.map(info => {
       let varAccess = info.varName
-      if (info.subscriptCount > 0) {
-        varAccess += '[subIndex0]'
+      for (let i = 0; i < info.subscriptCount; i++) {
+        varAccess += `[subIndices[${i}]]`
       }
-      if (info.subscriptCount > 1) {
-        varAccess += '[subIndex1]'
-      }
-      if (info.subscriptCount > 2) {
-        varAccess += '[subIndex2]'
-      }
-      let c = ''
-      c += `    case ${info.varIndex}:\n`
-      c += `      outputVar(${varAccess});\n`
-      c += `      break;`
-      return c
+      return `\
+    case ${info.varIndex}:
+      outputVar(${varAccess});
+      break;`
     })
-    const section = R.pipe(code, lines)
+    const section = R.pipe(outputVars, code, lines)
     return section(varIndexInfo)
   }
   function inputsFromStringImpl() {
@@ -353,7 +413,7 @@ ${postStep}
     let inputVars = ''
     if (spec.inputVars && spec.inputVars.length > 0) {
       let inputVarPtrs = R.reduce((a, inputVar) => R.concat(a, `    &${inputVar},\n`), '', spec.inputVars)
-      inputVars = `
+      inputVars = `\
   static double* inputVarPtrs[] = {\n${inputVarPtrs}  };
   char* inputs = (char*)inputData;
   char* token = strtok(inputs, " ");
@@ -366,24 +426,53 @@ ${postStep}
       *inputVarPtrs[modelVarIndex] = value;
     }
     token = strtok(NULL, " ");
-  }
-`
+  }`
     }
     return inputVars
   }
   function inputsFromBufferImpl() {
-    let inputVars = ''
+    let inputVars = []
     if (spec.inputVars && spec.inputVars.length > 0) {
-      inputVars += '\n'
       for (let i = 0; i < spec.inputVars.length; i++) {
         const inputVar = spec.inputVars[i]
-        inputVars += `  ${inputVar} = inputData[${i}];\n`
+        inputVars.push(`  ${inputVar} = inputData[${i}];`)
       }
     }
-    return inputVars
+    return inputVars.join('\n')
   }
-  function headerTitle(varName) {
-    return Model.vensimName(varName).replace(/"/g, '\\"')
+  function setLookupImpl(varIndexInfo, customLookups) {
+    // Emit `replaceLookup` calls for all lookups and data variables that can be overridden
+    // at runtime
+    let includeCase
+    if (Array.isArray(customLookups)) {
+      // Only include a case statement if the variable was explicitly included
+      // in the `customLookups` array in the spec file
+      const customLookupVarNames = customLookups.map(varName => {
+        // The developer might specify a variable name that includes subscripts,
+        // but we will ignore the subscript part and only match on the base name
+        return canonicalVensimName(varName.split('[')[0])
+      })
+      includeCase = varName => customLookupVarNames.includes(varName)
+    } else {
+      // Include a case statement for all lookup and data variables
+      includeCase = () => true
+    }
+    const lookupAndDataVars = R.filter(info => {
+      return (info.varType === 'lookup' || info.varType === 'data') && includeCase(info.varName)
+    })
+    const code = R.map(info => {
+      let lookupVar = info.varName
+      for (let i = 0; i < info.subscriptCount; i++) {
+        lookupVar += `[subIndices[${i}]]`
+      }
+      let c = ''
+      c += `    case ${info.varIndex}:\n`
+      c += `      replaceLookup(&${lookupVar}, points, numPoints);\n`
+      c += `      break;`
+      return c
+    })
+    const section = R.pipe(lookupAndDataVars, code, lines)
+    return section(varIndexInfo)
   }
 
   return {