@sdeverywhere/compile 0.7.6 → 0.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "files": [

package/src/generate/code-gen.js

@@ -163,7 +163,17 @@ const char* getHeader() {
 }
 
 void storeOutputData() {
-${outputSection(outputVars)}
+${specOutputSection(outputVars)}
+}
+
+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
 }
 `
   }
@@ -250,11 +260,16 @@ ${postStep}
   }
   function internalVarsSection() {
     // Declare internal variables to run the model.
+    let decls
     if (outputAllVars) {
-      return `const int numOutputs = ${expandedVarNames().length};`
+      decls = `const int numOutputs = ${expandedVarNames().length};`
     } else {
-      return `const int numOutputs = ${spec.outputVars.length};`
+      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() {
     // Emit a declaration for each array dimension's index numbers.
@@ -312,12 +327,34 @@ ${postStep}
   //
   // Input/output section helpers
   //
-  function outputSection(varNames) {
+  function specOutputSection(varNames) {
     // Emit output calls 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.
+    const code = R.map(info => {
+      let varAccess = info.varName
+      if (info.subscriptCount > 0) {
+        varAccess += '[subIndex0]'
+      }
+      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
+    })
+    const section = R.pipe(code, lines)
+    return section(varIndexInfo)
+  }
   function inputsFromStringImpl() {
     // If there was an I/O spec file, then emit code to parse input variables.
     // The user can replace this with a parser for a different serialization format.

package/src/model/model.js

@@ -330,8 +330,14 @@ function removeUnusedVariables(spec) {
       if (!referencedRefIds.has(refId)) {
         referencedRefIds.add(refId)
         const refVar = varWithRefId(refId)
-        recordUsedVariable(refVar)
-        recordRefsOfVariable(refVar)
+        if (refVar) {
+          recordUsedVariable(refVar)
+          recordRefsOfVariable(refVar)
+        } else {
+          console.error(`No var found for ${refId}`)
+          console.error(v)
+          process.exit(1)
+        }
       }
     }
   }
@@ -1010,6 +1016,105 @@ function printDepsGraph(graph, varType) {
     console.error(`${dep[0]} → ${dep[1]}`)
   }
 }
+
+function allListedVars() {
+  // Put variables into the order that they are evaluated by SDE in the generated model
+  let vars = []
+  vars.push(...constVars())
+  vars.push(...lookupVars())
+  vars.push(...dataVars())
+  vars.push(varWithName('_time'))
+  vars.push(...initVars())
+  vars.push(...auxVars())
+  // TODO: Also levelVars not covered by initVars?
+
+  // Filter out data/lookup variables and variables that are generated/used internally
+  const isInternal = v => {
+    return v.refId.startsWith('__level') || v.refId.startsWith('__aux')
+  }
+
+  return R.filter(v => !isInternal(v), vars)
+}
+
+function filteredListedVars() {
+  // Extract a subset of the available info for each variable and sort all variables
+  // according to the order that they are evaluated by SDE in the generated model
+  return R.map(v => filterVar(v), allListedVars())
+}
+
+function varIndexInfoMap() {
+  // Return a map containing information for each listed variable:
+  //   varName
+  //   varIndex
+  //   subscriptCount
+
+  // Get the filtered variables in the order that they are evaluated by SDE in the
+  // generated model
+  const sortedVars = filteredListedVars()
+
+  // Get the set of unique variable names, and assign a 1-based index
+  // to each; this matches the index number used in `storeOutput()`
+  // in the generated C code
+  const infoMap = new Map()
+  let varIndex = 1
+  for (const v of sortedVars) {
+    if (v.varType === 'data' || v.varType === 'lookup') {
+      // Omit the index for data and lookup variables; at this time, the data for these
+      // cannot be output like for other types of variables
+      continue
+    }
+    const varName = v.varName
+    if (!infoMap.get(varName)) {
+      infoMap.set(varName, {
+        varName,
+        varIndex,
+        subscriptCount: v.families ? v.families.length : 0
+      })
+      varIndex++
+    }
+  }
+
+  return infoMap
+}
+
+function varIndexInfo() {
+  // Return an array, sorted by `varName`, containing information for each
+  // listed variable:
+  //   varName
+  //   varIndex
+  //   subscriptCount
+  return Array.from(varIndexInfoMap().values())
+}
+
+function jsonList() {
+  // Return a stringified JSON object containing variable and subscript information
+  // for the model.
+
+  // Get the set of available subscripts
+  const allDims = [...allDimensions()]
+  const sortedDims = allDims.sort((a, b) => a.name.localeCompare(b.name))
+
+  // Extract a subset of the available info for each variable and put them in eval order
+  const sortedVars = filteredListedVars()
+
+  // Assign a 1-based index for each variable that has data that can be accessed.
+  // This matches the index number used in `storeOutput()` in the generated C code.
+  const infoMap = varIndexInfoMap()
+  for (const v of sortedVars) {
+    const varInfo = infoMap.get(v.varName)
+    if (varInfo) {
+      v.varIndex = varInfo.varIndex
+    }
+  }
+
+  // Convert to JSON
+  const obj = {
+    dimensions: sortedDims,
+    variables: sortedVars
+  }
+  return JSON.stringify(obj, null, 2)
+}
+
 export default {
   addConstantExpr,
   addEquation,
@@ -1026,6 +1131,7 @@ export default {
   initVars,
   isInputVar,
   isNonAtoAName,
+  jsonList,
   levelVars,
   lookupVars,
   printRefGraph,
@@ -1036,6 +1142,7 @@ export default {
   refIdsWithName,
   splitRefId,
   variables,
+  varIndexInfo,
   varNames,
   varsWithName,
   varWithName,

package/src/parse-and-generate.js

@@ -17,7 +17,7 @@ import { generateCode } from './generate/code-gen.js'
  *
  * - If `operation` is 'generateC', the generated C code will be written to `buildDir`.
  * - If `operation` is 'printVarList', variables and subscripts will be written to
- *   txt and yaml files under `buildDir`.
+ *   txt, yaml, and json files under `buildDir`.
  * - If `operation` is 'printRefIdTest', reference identifiers will be printed to the console.
  * - If `operation` is 'convertNames', no output will be generated, but the results of model
  *   analysis will be available.
@@ -85,6 +85,8 @@ export async function parseAndGenerate(input, spec, operation, modelDirname, mod
     writeOutput(`${modelName}_vars.yaml`, Model.yamlVarList())
     // Write subscripts to a YAML file.
     writeOutput(`${modelName}_subs.yaml`, yamlSubsList())
+    // Write variables and subscripts to a JSON file.
+    writeOutput(`${modelName}.json`, Model.jsonList())
   }
 
   return code