@sdeverywhere/compile 0.7.21 → 0.7.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.21",
+  "version": "0.7.23",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",

package/src/generate/gen-code-c.js

@@ -153,11 +153,19 @@ ${chunkedFunctions('evalLevels', Model.levelVars(), '  // Evaluate levels.')}`
     let setLookupBody
     if (spec.customLookups === true || Array.isArray(spec.customLookups)) {
       setLookupBody = `\
+  Lookup** pLookup = NULL;
   switch (varIndex) {
 ${setLookupImpl(Model.varIndexInfo(), spec.customLookups)}
     default:
       fprintf(stderr, "No lookup found for var index %zu in setLookup\\n", varIndex);
       break;
+  }
+  if (pLookup != NULL) {
+    if (*pLookup == NULL) {
+      *pLookup = __new_lookup(numPoints, /*copy=*/true, points);
+    } else {
+      __set_lookup(*pLookup, numPoints, points);
+    }
   }`
     } else {
       let msg = 'The setLookup function was not enabled for the generated model. '
@@ -200,19 +208,6 @@ 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 setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints) {
 ${setLookupBody}
 }
@@ -441,7 +436,7 @@ ${section(chunk)}
     return inputVars.join('\n')
   }
   function setLookupImpl(varIndexInfo, customLookups) {
-    // Emit `replaceLookup` calls for all lookups and data variables that can be overridden
+    // Emit case statements for all lookups and data variables that can be overridden
     // at runtime
     let includeCase
     if (Array.isArray(customLookups)) {
@@ -467,7 +462,7 @@ ${section(chunk)}
       }
       let c = ''
       c += `    case ${info.varIndex}:\n`
-      c += `      replaceLookup(&${lookupVar}, points, numPoints);\n`
+      c += `      pLookup = &${lookupVar};\n`
       c += `      break;`
       return c
     })

package/src/generate/gen-code-js.js

@@ -251,10 +251,15 @@ ${chunkedFunctions('evalLevels', true, Model.levelVars(), '  // Evaluate levels'
   }
   const varIndex = varSpec.varIndex;
   const subs = varSpec.subscriptIndices;
+  let lookup;
   switch (varIndex) {
 ${setLookupImpl(Model.varIndexInfo(), spec.customLookups)}
     default:
       throw new Error(\`No lookup found for var index \${varIndex} in setLookup\`);
+  }
+  if (lookup) {
+    const size = points ? points.length / 2 : 0;
+    lookup.setData(size, points);
   }`
     } else {
       let msg = 'The setLookup function was not enabled for the generated model. '
@@ -307,7 +312,7 @@ ${customOutputSection(Model.varIndexInfo(), spec.customOutputs)}
     return `\
 /*export*/ function setInputs(valueAtIndex /*: (index: number) => number*/) {${inputsFromBufferImpl()}}
 
-/*export*/ function setLookup(varSpec /*: VarSpec*/, points /*: Float64Array*/) {
+/*export*/ function setLookup(varSpec /*: VarSpec*/, points /*: Float64Array | undefined*/) {
 ${setLookupBody}
 }
 
@@ -517,7 +522,7 @@ ${section(chunk)}
     return inputVars
   }
   function setLookupImpl(varIndexInfo, customLookups) {
-    // Emit `createLookup` calls for all lookups and data variables that can be overridden
+    // Emit case statements for all lookups and data variables that can be overridden
     // at runtime
     let overrideAllowed
     if (Array.isArray(customLookups)) {
@@ -543,7 +548,7 @@ ${section(chunk)}
       }
       let c = ''
       c += `    case ${info.varIndex}:\n`
-      c += `      ${lookupVar} = fns.createLookup(points.length / 2, points);\n`
+      c += `      lookup = ${lookupVar};\n`
       c += `      break;`
       return c
     })

package/src/generate/gen-equation.js

@@ -113,13 +113,12 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
   // Apply special handling for lookup variables.  The data for lookup variables is already
   // defined as a set of explicit data points (stored in the `Variable` instance).
   if (variable.isLookup()) {
-    if (variable.varSubtype === 'gameInputs') {
-      // For a synthesized game inputs lookup, there is no data array (the data is expected
-      // to be supplied at runtime), so don't emit decl or init code for these
-      return []
+    // Emit decl/init code for the lookup
+    const lookupDef = generateLookupFromPoints(variable, mode, /*copy=*/ false, cLhs, loopIndexVars, outFormat)
+    if (lookupDef.length > 0) {
+      return [...openLoops, ...lookupDef, ...closeLoops]
     } else {
-      // For all other lookups, emit decl/init code for the lookup
-      return generateLookupFromPoints(variable, mode, /*copy=*/ false, cLhs, loopIndexVars, outFormat)
+      return []
     }
   }
 

package/src/generate/gen-lookup-from-points.js

@@ -16,10 +16,23 @@ import { isDimension, isTrivialDimension, sub } from '../_shared/subscript.js'
  */
 export function generateLookupFromPoints(variable, mode, copy, varLhs, loopIndexVars, outFormat) {
   if (variable.points.length === 0) {
-    throw new Error(`Empty lookup data array for ${variable.modelLHS}`)
-  }
-
-  if (copy) {
+    // In the case where the lookup data array is empty (typically this only occurs in the
+    // case of game inputs), generate a new empty lookup
+    if (mode === 'decl') {
+      // Nothing to emit in decl mode
+      return []
+    } else if (mode === 'init-lookups') {
+      // In init mode, generate a new empty lookup
+      switch (outFormat) {
+        case 'c':
+          return [`  ${varLhs} = __new_lookup(0, /*copy=*/false, NULL);`]
+        case 'js':
+          return [`  ${varLhs} = fns.createLookup(0, undefined);`]
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
+    }
+  } else if (copy) {
     // Inline the data points and copy them when initializing the lookup
     if (mode === 'decl') {
       // Nothing to emit in decl mode

package/src/model/model.js

@@ -71,6 +71,10 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   // Some arrays need to be separated into variables with individual indices to
   // prevent eval cycles. They are manually added to the spec file.
   let specialSeparationDims = spec.specialSeparationDims
+  // All arrays that have one of the specified dimension ID lists are
+  // separated on those dimensions. This allows variables to be separated
+  // without listing each one.
+  let separateAllVarsWithDims = spec.separateAllVarsWithDims
 
   // Dimensions must be defined before reading variables that use them.
   readDimensionDefs(parsedModel, modelDirname)
@@ -79,7 +83,7 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   if (opts?.stopAfterResolveSubscripts) return
 
   // Read variables from the model parse tree.
-  const vars = readVariables(parsedModel, specialSeparationDims)
+  const vars = readVariables(parsedModel, specialSeparationDims, separateAllVarsWithDims)
 
   // Include a placeholder variable for the exogenous `Time` variable
   const timeVar = new Variable()

package/src/model/read-equations.js

@@ -114,6 +114,9 @@ class Context {
     const parsedModel = { kind: 'vensim', root: parseVensimModel(eqnText) }
 
     // Create one or more `Variable` instances from the equations
+    // TODO: Technically we should pass `spec.separateAllVarsWithDims` here so that any
+    // generated apply-to-all variables will be separated according to the spec like other
+    // normal variables
     const vars = readVariables(parsedModel)
 
     // Add the variables to the `Model`

package/src/model/read-variables.js

@@ -12,17 +12,21 @@ import Variable from './variable.js'
  *
  * @param {*} parsedModel TODO: Use ParsedVensimModel type here
  * @param {Object.<string, string>} [specialSeparationDims] The variable names that need to be
- * separated because of circular references.  A mapping from "C" variable name to "C" dimension
- * name to separate on.
+ * separated because of circular references.  This is an optional mapping from "C" variable name
+ * to "C" dimension name to separate on.
+ * @param {string[][]} [separateAllVarsWithDims] An optional array containing arrays of dimension
+ * identifiers for which variables will be separated.  For example, if the LHS is `x[DimA,DimB,DimC]`
+ * and this array contains a list `['_dima', '_dimb']`, then the LHS will be separated on both
+ * DimA and DimB.
  * @returns {*} An array containing all `Variable` instances that were generated from
  * the model equations.
  */
-export function readVariables(parsedModel, specialSeparationDims) {
+export function readVariables(parsedModel, specialSeparationDims, separateAllVarsWithDims) {
   const variables = []
 
   // Add one or more `Variable` definitions for each parsed equation
   for (const eqn of parsedModel.root.equations) {
-    variables.push(...variablesForEquation(eqn, specialSeparationDims || {}))
+    variables.push(...variablesForEquation(eqn, specialSeparationDims || {}, separateAllVarsWithDims || []))
   }
 
   return variables
@@ -37,10 +41,12 @@ export function readVariables(parsedModel, specialSeparationDims) {
  * @param {*} eqn The parsed equation.
  * @param {Object.<string, string>} specialSeparationDims The variable names that need to be
  * separated because of circular references.
+ * @param {string[][]} separateAllVarsWithDims An array containing arrays of dimension
+ * identifiers for which variables will be separated.
  * @returns {*} An array containing all `Variable` instances that were generated from
  * the given equation.
  */
-function variablesForEquation(eqn, specialSeparationDims) {
+function variablesForEquation(eqn, specialSeparationDims, separateAllVarsWithDims) {
   // Start a new variable defined by this equation
   const variable = new Variable()
 
@@ -115,6 +121,23 @@ function variablesForEquation(eqn, specialSeparationDims) {
       if (!Array.isArray(separationDims)) {
         separationDims = [separationDims]
       }
+      // Alternatively, if the variable was not in `specialSeparationDims`, separate
+      // on dims from `separateAllVarsWithDims` if the var matches one of the dim lists.
+      if (separationDims.length === 0) {
+        for (let dimList of separateAllVarsWithDims) {
+          // Technically we allow each entry in the spec array to be either a single
+          // dim ID string or an array of dim IDs, so convert to array if needed
+          if (!Array.isArray(dimList)) {
+            dimList = [dimList]
+          }
+          // The list entry from the spec is only considered a match if every dimension
+          // in the spec list appears on the LHS
+          if (dimList.every(dim => subIds.includes(dim))) {
+            separationDims = dimList
+            break
+          }
+        }
+      }
       positionsToExpand = subscriptPositionsToExpand(subIds, exceptSubIdSets, separationDims, variable.modelFormula)
     }
 

package/src/model/toposort.js

@@ -42,7 +42,7 @@ function toposort(nodes, edges) {
       } catch (e) {
         nodeRep = ''
       }
-      throw new Error('Found cyclic dependency during toposort:\n' + [...predecessors].join(' →\n') + nodeRep)
+      throw new Error('Found cyclic dependency during toposort:\n' + [...predecessors].join(' →\n') + ' →' + nodeRep)
     }
 
     if (!nodesHash.has(node)) {