@sdeverywhere/compile 0.7.17 → 0.7.19

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

@@ -10,11 +10,12 @@ import { pointsString } from './gen-lookup-from-points.js'
  * @param {*} variable The `Variable` instance to process.
  * @param {'decl' | 'init-lookups'} mode The code generation mode.
  * @param {Map<string, any>} extData The map of datasets from external `.dat` files.
- * @param {string} varLhs The C code for the LHS variable reference.
- * @return {string[]} An array of strings containing the generated C code for the variable,
+ * @param {string} varLhs The C/JS code for the LHS variable reference.
+ * @param {'c' | 'js'} outFormat The output format.
+ * @return {string[]} An array of strings containing the generated C/JS code for the variable,
  * one string per line of code.
  */
-export function generateLookupsFromExternalData(variable, mode, extData, varLhs) {
+export function generateLookupsFromExternalData(variable, mode, extData, varLhs, outFormat) {
   if (mode !== 'decl' && mode !== 'init-lookups') {
     throw new Error(`Invalid code gen mode '${mode}' for data variable ${variable.modelLHS}`)
   }
@@ -37,10 +38,24 @@ export function generateLookupsFromExternalData(variable, mode, extData, varLhs)
       // In decl mode, declare a static data array that will be used to create the associated `Lookup`
       // at init time
       const points = pointsString(Array.from(data.entries()))
-      return `double ${dataName}[${data.size * 2}] = { ${points} };`
+      switch (outFormat) {
+        case 'c':
+          return `double ${dataName}[${data.size * 2}] = { ${points} };`
+        case 'js':
+          return `const ${dataName} = [${points}];`
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
     } else if (mode === 'init-lookups') {
       // In init mode, create the `Lookup`, passing in a pointer to the static data array declared in decl mode.
-      return `  ${lhs} = __new_lookup(${data.size}, /*copy=*/false, ${dataName});`
+      switch (outFormat) {
+        case 'c':
+          return `  ${lhs} = __new_lookup(${data.size}, /*copy=*/false, ${dataName});`
+        case 'js':
+          return `  ${lhs} = fns.createLookup(${data.size}, ${dataName});`
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
     } else {
       return []
     }

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

@@ -8,12 +8,13 @@ import { isDimension, isTrivialDimension, sub } from '../_shared/subscript.js'
  * @param {'decl' | 'init-lookups'} mode The code generation mode.
  * @param {boolean} copy If false, a static data array will be used (good for larger data sets).
  * If true, the data will inlined and copied when initializing the lookup (good for smaller data sets).
- * @param {string} varLhs The C code for the LHS variable reference.
+ * @param {string} varLhs The C/JS code for the LHS variable reference.
  * @param {LoopIndexVars} loopIndexVars The loop index state.
- * @return {string[]} An array of strings containing the generated C code for the variable,
+ * @param {'c' | 'js'} outFormat The output format.
+ * @return {string[]} An array of strings containing the generated C/JS code for the variable,
  * one string per line of code.
  */
-export function generateLookupFromPoints(variable, mode, copy, varLhs, loopIndexVars) {
+export function generateLookupFromPoints(variable, mode, copy, varLhs, loopIndexVars, outFormat) {
   if (variable.points.length === 0) {
     throw new Error(`Empty lookup data array for ${variable.modelLHS}`)
   }
@@ -26,7 +27,14 @@ export function generateLookupFromPoints(variable, mode, copy, varLhs, loopIndex
     } else if (mode === 'init-lookups') {
       // In init mode, generate a new lookup using the data points from the variable
       const points = pointsString(variable.points)
-      return [`  ${varLhs} = __new_lookup(${variable.points.length}, /*copy=*/true, (double[]){ ${points} });`]
+      switch (outFormat) {
+        case 'c':
+          return [`  ${varLhs} = __new_lookup(${variable.points.length}, /*copy=*/true, (double[]){ ${points} });`]
+        case 'js':
+          return [`  ${varLhs} = fns.createLookup(${variable.points.length}, [${points}]);`]
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
     }
   } else {
     // Construct the name of the data array, which is based on the associated lookup var name,
@@ -38,11 +46,25 @@ export function generateLookupFromPoints(variable, mode, copy, varLhs, loopIndex
       // the data in memory, and seems to perform much better when compiled to wasm when compared to the
       // previous approach that used varargs + copying, especially on constrained (e.g. iOS) devices.
       const points = pointsString(variable.points)
-      return [`double ${dataName}[${variable.points.length * 2}] = { ${points} };`]
+      switch (outFormat) {
+        case 'c':
+          return [`double ${dataName}[${variable.points.length * 2}] = { ${points} };`]
+        case 'js':
+          return [`const ${dataName} = [${points}];`]
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
     } else if (mode === 'init-lookups') {
       // In init mode, create the `Lookup`, passing in a pointer to the static data array declared earlier.
       // TODO: Make use of the lookup range
-      return [`  ${varLhs} = __new_lookup(${variable.points.length}, /*copy=*/false, ${dataName});`]
+      switch (outFormat) {
+        case 'c':
+          return [`  ${varLhs} = __new_lookup(${variable.points.length}, /*copy=*/false, ${dataName});`]
+        case 'js':
+          return [`  ${varLhs} = fns.createLookup(${variable.points.length}, ${dataName});`]
+        default:
+          throw new Error(`Unhandled output format '${outFormat}'`)
+      }
     }
   }
 

package/src/index.js

@@ -3,6 +3,41 @@
 export { canonicalName } from './_shared/helpers.js'
 export { readDat } from './_shared/read-dat.js'
 export { preprocessModel } from './preprocess/preprocessor.js'
-export { parseModel } from './parse/parser.js'
-export { generateCode } from './generate/code-gen.js'
-export { parseAndGenerate, printNames } from './parse-and-generate.js'
+export { generateCode } from './generate/gen-code.js'
+export { parseAndGenerate, parseModel, printNames } from './parse-and-generate.js'
+
+import { resetHelperState } from './_shared/helpers.js'
+import { resetSubscriptsAndDimensions } from './_shared/subscript.js'
+import Model from './model/model.js'
+import { parseModel } from './parse-and-generate.js'
+
+/**
+ * @hidden This is not yet part of the public API; it is exposed only for use
+ * in the experimental playground app.
+ */
+export function resetState() {
+  // XXX: These steps are needed due to subs/dims and variables being in module-level storage
+  resetHelperState()
+  resetSubscriptsAndDimensions()
+  Model.resetModelState()
+}
+
+/**
+ * @hidden This is not yet part of the public API; it is exposed only for use
+ * in the experimental playground app.
+ */
+export function parseInlineVensimModel(mdlContent /*: string*/, modelDir /*?: string*/) /*: ParsedModel*/ {
+  // For tests that parse inline model text, in the case of the legacy parser, don't run
+  // the preprocess step, and in the case of the new parser (which implicitly runs the
+  // preprocess step), don't sort the definitions.  This makes it easier to do apples
+  // to apples comparisons on the outputs from the two parser implementations.
+  return parseModel(mdlContent, modelDir, { sort: false })
+}
+
+/**
+ * @hidden This is not yet part of the public API; it is exposed only for use
+ * in the experimental playground app.
+ */
+export function getModelListing() /*: string*/ {
+  return Model.jsonList()
+}

package/src/model/model.js

@@ -2,7 +2,7 @@ import B from 'bufx'
 import yaml from 'js-yaml'
 import * as R from 'ramda'
 
-import { canonicalName, decanonicalize, isIterable, listConcat, strlist, vlog, vsort } from '../_shared/helpers.js'
+import { canonicalName, decanonicalize, isIterable, /*listConcat,*/ strlist, vlog, vsort } from '../_shared/helpers.js'
 import {
   addIndex,
   allAliases,
@@ -14,22 +14,20 @@ import {
   sub,
   subscriptFamilies
 } from '../_shared/subscript.js'
-import { createParser } from '../parse/parser.js'
 
-import EquationReader from './equation-reader.js'
 import { readEquation } from './read-equations.js'
 import { readDimensionDefs } from './read-subscripts.js'
-import { readVariables as readVariables2 } from './read-variables.js'
+import { readVariables } from './read-variables.js'
 import { reduceVariables } from './reduce-variables.js'
-import SubscriptRangeReader from './subscript-range-reader.js'
 import toposort from './toposort.js'
-import VarNameReader from './var-name-reader.js'
 import Variable from './variable.js'
-import VariableReader from './variable-reader.js'
 
 let variables = []
 let inputVars = []
 let constantExprs = new Map()
+let cachedSortedVarsByType = new Map()
+let cachedVarIndexInfo
+let cachedJsonList
 
 // Also keep variables in a map (with `varName` as key) for faster lookup
 const variablesByName = new Map()
@@ -49,6 +47,9 @@ function resetModelState() {
   variablesByName.clear()
   constantExprs.clear()
   nonAtoANames = Object.create(null)
+  cachedSortedVarsByType.clear()
+  cachedVarIndexInfo = undefined
+  cachedJsonList = undefined
 }
 
 /**
@@ -73,32 +74,22 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   let specialSeparationDims = spec.specialSeparationDims
 
   // Dimensions must be defined before reading variables that use them.
-  if (parsedModel.kind === 'vensim-legacy') {
-    readSubscriptRanges(parsedModel.parseTree, modelDirname)
-  } else {
-    readDimensionDefs(parsedModel, modelDirname)
-  }
+  readDimensionDefs(parsedModel, modelDirname)
   if (opts?.stopAfterReadSubscripts) return
   resolveDimensions(spec.dimensionFamilies)
   if (opts?.stopAfterResolveSubscripts) return
 
   // Read variables from the model parse tree.
-  if (parsedModel.kind === 'vensim-legacy') {
-    // TODO: directData is actually unused in VariableReader
-    readVariables(parsedModel.parseTree, specialSeparationDims, directData)
-  } else {
-    // Read the variables
-    const vars = readVariables2(parsedModel, specialSeparationDims)
+  const vars = readVariables(parsedModel, specialSeparationDims)
 
-    // Include a placeholder variable for the exogenous `Time` variable
-    const timeVar = new Variable(null)
-    timeVar.modelLHS = 'Time'
-    timeVar.varName = '_time'
-    vars.push(timeVar)
+  // Include a placeholder variable for the exogenous `Time` variable
+  const timeVar = new Variable()
+  timeVar.modelLHS = 'Time'
+  timeVar.varName = '_time'
+  vars.push(timeVar)
 
-    // Add the variables to the `Model`
-    vars.forEach(addVariable)
-  }
+  // Add the variables to the `Model`
+  vars.forEach(addVariable)
   if (opts?.stopAfterReadVariables) return
 
   if (spec) {
@@ -121,7 +112,7 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   if (opts?.stopAfterAnalyze) return
 
   // Check that all input and output vars in the spec actually exist in the model.
-  checkSpecVars(spec, extData)
+  checkSpecVars(spec)
 
   // Remove variables that are not referenced by an input or output variable.
   removeUnusedVariables(spec)
@@ -130,22 +121,6 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   resolveDuplicateDeclarations()
 }
 
-/**
- * Read subscript ranges from the given model.
- *
- * Note that this function currently does not return anything and instead stores the parsed subscript
- * range definitions in the `subscript` module.
- *
- * @param {import('../parse/parser.js').VensimModelParseTree} parseTree The Vensim parse tree.
- * @param {string} modelDirname The path to the directory containing the model (used for resolving data
- * files for `GET DIRECT SUBSCRIPT`).
- */
-function readSubscriptRanges(parseTree, modelDirname) {
-  // Read subscript ranges from the model.
-  let subscriptRangeReader = new SubscriptRangeReader(modelDirname)
-  subscriptRangeReader.visitModel(parseTree)
-}
-
 /**
  * Process the previously read subscript/dimension definitions (stored in the `subscript` module) to
  * resolve aliases, families, and indices.
@@ -289,32 +264,6 @@ function resolveDimensions(dimensionFamilies) {
   }
 }
 
-/**
- * Read equations from the given model and generate `Variable` instances for all variables that
- * are encountered while parsing.
- *
- * Note that this function currently does not return anything and instead stores the parsed
- * variable definitions in the `model` module.
- *
- * @param {import('../parse/parser.js').VensimModelParseTree} tree The Vensim parse tree.
- * @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.
- * @param {Map<string, any>} directData The mapping of dataset name used in a `GET DIRECT DATA`
- * call (e.g., `?data`) to the tabular data contained in the loaded data file.
- */
-function readVariables(tree, specialSeparationDims, directData) {
-  // Read all variables in the model parse tree.
-  // This populates the variables table with basic information for each variable
-  // such as the var name and subscripts.
-  let variableReader = new VariableReader(specialSeparationDims, directData)
-  variableReader.visitModel(tree)
-  // Add a placeholder variable for the exogenous variable Time.
-  let v = new Variable(null)
-  v.modelLHS = 'Time'
-  v.varName = '_time'
-  addVariable(v)
-}
 function analyze(parsedModelKind, inputVars, opts) {
   // Analyze the RHS of each equation in stages after all the variables are read.
   // Find non-apply-to-all vars that are defined with more than one equation.
@@ -324,23 +273,17 @@ function analyze(parsedModelKind, inputVars, opts) {
   setRefIds()
 
   // If enabled, reduce expressions used in variable definitions.
-  if (parsedModelKind !== 'vensim-legacy') {
-    if (opts?.reduceVariables !== false && process.env.SDE_NONPUBLIC_REDUCE_VARIABLES !== '0') {
-      let reduceMode = opts?.reduceVariables || process.env.SDE_NONPUBLIC_REDUCE_VARIABLES || 'default'
-      reduceVariables(variables, inputVars || [], reduceMode)
-    }
+  if (opts?.reduceVariables !== false && process.env.SDE_NONPUBLIC_REDUCE_VARIABLES !== '0') {
+    let reduceMode = opts?.reduceVariables || process.env.SDE_NONPUBLIC_REDUCE_VARIABLES || 'default'
+    reduceVariables(variables, inputVars || [], reduceMode)
   }
   if (opts?.stopAfterReduceVariables === true) return
 
   // Read the RHS to list the refIds of vars that are referenced and set the var type.
-  if (parsedModelKind === 'vensim-legacy') {
-    readEquations()
-  } else {
-    variables.forEach(readEquation)
-  }
+  variables.forEach(readEquation)
 }
 
-function checkSpecVars(spec, extData) {
+function checkSpecVars(spec) {
   // Look up each var in the spec and issue and throw error if it does not exist.
 
   function check(varNames, specType) {
@@ -351,22 +294,9 @@ function checkSpecVars(spec, extData) {
         // out of the valid range)
         if (!R.contains('[', varName)) {
           if (!varWithRefId(varName)) {
-            // Look for a variable in external data.
-            if (extData?.has(varName)) {
-              // console.error(`found ${specType} ${varName} in extData`)
-              // Copy data from an external file to an equation that does a lookup.
-              let lookup = R.reduce(
-                (a, p) => listConcat(a, `(${p[0]}, ${p[1]})`, true),
-                '',
-                Array.from(extData.get(varName))
-              )
-              let modelEquation = `${decanonicalize(varName)} = WITH LOOKUP(Time, (${lookup}))`
-              addEquation(modelEquation)
-            } else {
-              throw new Error(
-                `The ${specType} variable ${varName} was declared in spec.json, but no matching variable was found in the model or external data sources`
-              )
-            }
+            throw new Error(
+              `The ${specType} variable ${varName} was declared in spec.json, but no matching variable was found in the model or external data sources`
+            )
           }
         }
       }
@@ -511,8 +441,8 @@ function resolveDuplicateDeclarations() {
   // Least and greatest safe double values in C rounded to convenient consts
   const MIN_SAFE_DBL = -1e308
   const MAX_SAFE_DBL = 1e308
-  let data = dataVars()
-  for (let constVar of constVars()) {
+  let data = varsOfType('data')
+  for (let constVar of varsOfType('const')) {
     if (data.find(d => d.varName === constVar.varName)) {
       // Change the var type from const to data and add lookup data points.
       // For a constant, the equivalent lookup has the same value over the entire x axis.
@@ -568,28 +498,6 @@ function setRefIds() {
     v.refId = refIdForVar(v)
   }, variables)
 }
-function readEquations() {
-  // Augment variables with information from their equations.
-  // This requires a refId for each var so that actual refIds can be resolved for the reference list.
-  R.forEach(v => {
-    let equationReader = new EquationReader(v)
-    equationReader.read()
-  }, variables)
-}
-function addEquation(modelEquation) {
-  // Add an equation in Vensim model format.
-  let parser = createParser(modelEquation)
-  let tree = parser.equation()
-  // Read the var and add it to the Model var table.
-  let variableReader = new VariableReader()
-  variableReader.visitEquation(tree)
-  let v = variableReader.var
-  // Fill in the refId.
-  v.refId = refIdForVar(v)
-  // Finish the variable by parsing the RHS.
-  let equationReader = new EquationReader(v)
-  equationReader.read()
-}
 //
 // Model API
 //
@@ -618,26 +526,53 @@ function allVars() {
   }
   return R.filter(isNotPlaceholderVar, variables)
 }
+function cachedSortedVars(varType, generate) {
+  // Return the cached array of sorted variables for the given type if
+  // available, otherwise call the `generate` function to generate the
+  // array and cache it in the map.
+  let vars = cachedSortedVarsByType.get(varType)
+  if (!vars) {
+    vars = generate()
+    cachedSortedVarsByType.set(varType, vars)
+  }
+  return vars
+}
 function constVars() {
-  return vsort(varsOfType('const'))
+  // Return an array of vars of type `const`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('const', () => vsort(varsOfType('const')))
 }
 function lookupVars() {
-  return vsort(varsOfType('lookup'))
+  // Return an array of vars of type `lookup`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('lookup', () => vsort(varsOfType('lookup')))
 }
 function dataVars() {
-  return vsort(varsOfType('data'))
+  // Return an array of vars of type `data`, sorted by LHS variable name.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('data', () => vsort(varsOfType('data')))
 }
 function auxVars() {
-  // console.error('AUX VARS');
-  return sortVarsOfType('aux')
+  // Return an array of vars of type `aux`, sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('aux', () => sortVarsOfType('aux'))
 }
 function levelVars() {
-  // console.error('LEVEL VARS');
-  return sortVarsOfType('level')
+  // Return an array of vars of type `level`, sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('level', () => sortVarsOfType('level'))
 }
 function initVars() {
-  // console.error('INIT VARS');
-  return sortInitVars()
+  // Return an array of all vars that have the `hasInitValue` flag set to true,
+  // sorted according to the dependency graph.
+  // Note that this caches the result, so should only be called after the
+  // model has been fully read and analyzed.
+  return cachedSortedVars('init', () => sortInitVars())
 }
 function varWithRefId(refId) {
   const findVarWithRefId = rid => {
@@ -799,11 +734,7 @@ function vensimName(cVarName) {
 function cName(vensimVarName) {
   // Convert a Vensim variable name to a C name.
   // This function requires model analysis to be completed first when the variable has subscripts.
-  if (process.env.SDE_NONPUBLIC_USE_NEW_PARSE === '0') {
-    // TODO: For now we use the legacy VarNameReader when the old parser is active; this
-    // code will be removed once the old parser is removed
-    return new VarNameReader().read(vensimVarName)
-  }
+
   // Split the variable name from the subscripts
   let matches = vensimVarName.match(/([^[]+)(?:\[([^\]]+)\])?/)
   if (!matches) {
@@ -1153,27 +1084,52 @@ function printDepsGraph(graph, varType) {
 
 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())
+  const listedVars = []
+  const visitedRefIds = new Set()
+  function addUnique(vars) {
+    for (const v of vars) {
+      // Skip variables that have already been visited
+      if (visitedRefIds.has(v.refId)) {
+        continue
+      }
+      visitedRefIds.add(v.refId)
+
+      // Filter out variables that are generated/used internally
+      if (v.includeInOutput === false) {
+        continue
+      }
+
+      // Include the variable
+      listedVars.push(v)
+    }
+  }
+
+  // The order of execution/evaluation in the generated model is:
+  //   initConstants (vars of type `const` only)
+  //   initLookups (vars of type `lookup` only)
+  //   initData (vars of type `data` only)
+  //   initLevels (vars returned by `initVars`, a mix of initial, aux, and level vars)
+  //   evalAux (vars of type `aux` only)
+  //   evalLevels (vars of type `level` only)
+  // So to make the ordering in the listing better match the order of evaluation,
+  // we emit variables in the above order, but filter to avoid having duplicates.
+  addUnique(constVars())
+  addUnique(lookupVars())
+  addUnique(dataVars())
   // The special exogenous `Time` variable may have already been removed by
   // `removeUnusedVariables` if it is not referenced explicitly in the model,
-  // so we will only include it in the listing if it is defined here
+  // so we will only include it in the listing if it is defined here.  Note
+  // that `_time` is set to `_initial_time` as the first step in the
+  // `initLevels` function, which is why it is included here.
   const timeVar = varWithName('_time')
   if (timeVar) {
-    vars.push(timeVar)
+    addUnique([timeVar])
   }
-  vars.push(...initVars())
-  vars.push(...auxVars())
-  // TODO: Also levelVars not covered by initVars?
+  addUnique(initVars())
+  addUnique(auxVars())
+  addUnique(levelVars())
 
-  // 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)
+  return listedVars
 }
 
 function filteredListedVars() {
@@ -1185,6 +1141,7 @@ function filteredListedVars() {
 function varIndexInfoMap() {
   // Return a map containing information for each listed variable:
   //   varName
+  //   varType
   //   varIndex
   //   subscriptCount
 
@@ -1192,21 +1149,17 @@ function varIndexInfoMap() {
   // 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
+  // Get the set of unique variable names, and assign a 1-based index to each.
+  // This matches the index number used in `storeOutput` and `setLookup` in the
+  // generated C/JS 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,
+        varType: v.varType,
         varIndex,
         subscriptCount: v.families ? v.families.length : 0
       })
@@ -1221,43 +1174,89 @@ function varIndexInfo() {
   // Return an array, sorted by `varName`, containing information for each
   // listed variable:
   //   varName
+  //   varType
   //   varIndex
   //   subscriptCount
-  return Array.from(varIndexInfoMap().values())
+  if (cachedVarIndexInfo) {
+    return cachedVarIndexInfo
+  }
+  cachedVarIndexInfo = Array.from(varIndexInfoMap().values())
+  return cachedVarIndexInfo
 }
 
 function jsonList() {
-  // Return a stringified JSON object containing variable and subscript information
-  // for the model.
+  // Return an object containing variable and subscript information for the model
+  // that will be used to write the JSON model listing files.
+  if (cachedJsonList) {
+    return cachedJsonList
+  }
 
   // Get the set of available subscripts
   const allDims = [...allDimensions()]
-  const sortedDims = allDims.sort((a, b) => a.name.localeCompare(b.name))
+  const sortedFullDims = 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()
+  const sortedFullVars = 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.
+  // This matches the index number used in `storeOutput` and `setLookup` in the
+  // generated C/JS code
   const infoMap = varIndexInfoMap()
-  for (const v of sortedVars) {
+  for (const v of sortedFullVars) {
     const varInfo = infoMap.get(v.varName)
     if (varInfo) {
       v.varIndex = varInfo.varIndex
     }
   }
 
-  // Convert to JSON
-  const obj = {
-    dimensions: sortedDims,
-    variables: sortedVars
+  // Derive minimal versions of the full arrays; these only contain the minimal
+  // subset of fields that are needed by the `ModelListing` class from the
+  // runtime package.  The property names in the minimal objects are slightly
+  // different than the full ones to better match the latest naming used in the
+  // compile and runtime packages.
+  const sortedMinimalDims = sortedFullDims.map(d => {
+    return {
+      id: d.name,
+      subIds: d.value
+    }
+  })
+
+  // Note that `sortedFullVars` may contain duplicates in the case of separated
+  // variables, but for the minimal listing we only want to have one entry per
+  // index (i.e., one entry for each base variable ID), so we filter out the
+  // duplicates here.
+  const baseIds = new Set()
+  const sortedMinimalVars = []
+  for (const v of sortedFullVars) {
+    const baseId = v.varName
+    if (!baseIds.has(baseId)) {
+      baseIds.add(baseId)
+
+      const varInfo = {}
+      varInfo.id = baseId
+      if (v.families) {
+        varInfo.dimIds = v.families
+      }
+      varInfo.index = v.varIndex
+      sortedMinimalVars.push(varInfo)
+    }
+  }
+
+  cachedJsonList = {
+    full: {
+      dimensions: sortedFullDims,
+      variables: sortedFullVars
+    },
+    minimal: {
+      dimensions: sortedMinimalDims,
+      variables: sortedMinimalVars
+    }
   }
-  return JSON.stringify(obj, null, 2)
+  return cachedJsonList
 }
 
 export default {
   addConstantExpr,
-  addEquation,
   addNonAtoAVar,
   addVariable,
   allVars,