@sdeverywhere/compile 0.7.20 → 0.7.22

package/src/generate/gen-expr.js

@@ -1,5 +1,5 @@
 import { cdbl, newTmpVarName } from '../_shared/helpers.js'
-import { extractMarkedDims, isDimension, isIndex, normalizeSubscripts, sub } from '../_shared/subscript.js'
+import { extractMarkedDims, isDimension, isIndex, sub } from '../_shared/subscript.js'
 
 import Model from '../model/model.js'
 
@@ -12,8 +12,6 @@ import Model from '../model/model.js'
  * @param {string} cLhs The C/JS code for the LHS variable reference.
  * @param {LoopIndexVars} loopIndexVars The loop index state used for LHS dimensions.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions (that use marked dimensions).
- * @param {() => void} resetMarkedDims Function that resets the marked dimension state.
- * @param {(dimId: string) => void} addMarkedDim Function that adds the given dimension to the set of marked dimensions.
  * @param {(s: string) => void} emitPreInnerLoop Function that will cause the given code to be appended to the chunk that
  * precedes the generated inner loop for the equation.
  * @param {(s: string) => void} emitPreFormula Function that will cause the given code to be appended to the chunk that
@@ -69,7 +67,7 @@ export function generateExpr(expr, ctx) {
         // plus one (since Vensim indices are one-based).
         const dimId = expr.varId
         const indexCode = ctx.cVarIndex(dimId)
-        return `(${indexCode} + 1)`
+        return `(${indexExpr(indexCode, ctx)} + 1)`
       } else if (isIndex(expr.varId)) {
         // This is a reference to a subscript/index that is being used in expression position.
         // In place of the subscript, emit the numeric index value of the subscript plus one
@@ -646,7 +644,6 @@ function generateArrayFunctionCall(callExpr, ctx) {
   // Open the array function loop(s)
   const indexDecl = ctx.outFormat === 'js' ? 'let' : 'size_t'
   for (const markedDimId of markedDimIds) {
-    ctx.addMarkedDim(markedDimId)
     const n = sub(markedDimId).size
     const i = ctx.arrayIndexVars.index(markedDimId)
     ctx.emitPreFormula(`  for (${indexDecl} ${i} = 0; ${i} < ${n}; ${i}++) {`)
@@ -691,9 +688,6 @@ function generateArrayFunctionCall(callExpr, ctx) {
     ctx.emitPreFormula(`  }`)
   }
 
-  // Reset marked dim state
-  ctx.resetMarkedDims()
-
   if (returnCode) {
     // Emit the expression defined above in place of the array function
     return returnCode
@@ -747,7 +741,7 @@ function generateVectorElmMapCall(callExpr, ctx) {
 
   // The `VECTOR ELM MAP` function replaces one subscript with a calculated offset from
   // a base index
-  const rhsSubIds = normalizeSubscripts(vecSubIds)
+  const rhsSubIds = vecSubIds
   const cSubscripts = rhsSubIds.map(rhsSubId => {
     if (isIndex(rhsSubId)) {
       let indexDecl
@@ -838,35 +832,55 @@ function generateAllocateAvailableCall(callExpr, ctx) {
     }
   }
 
-  // Process the request argument
+  // Given a C/JS variable reference string (e.g., '_var[i][j]'), return that
+  // string without the last N array index parts
+  function cVarRefWithoutLastIndices(arg, count) {
+    const varRef = ctx.cVarRef(arg)
+    const origIndexParts = Model.splitRefId(varRef).subscripts
+    if (origIndexParts < count) {
+      throw new Error(`ALLOCATE AVAILABLE argument '${arg}' should have at least ${count} subscripts`)
+    }
+    const newIndexParts = origIndexParts.slice(0, -count)
+    if (newIndexParts.length > 0) {
+      return `${arg.varId}${newIndexParts.map(x => `[${x}]`).join('')}`
+    } else {
+      return arg.varId
+    }
+  }
+
+  // Process the request argument.  Only include subscripts up until the last one;
+  // the implementation function will iterate over the requesters array.
   const reqArg = validateArg(0, 'req')
-  const reqRefId = reqArg.varId
-  const reqSubIds = reqArg.subscriptRefs.map(subRef => subRef.subId)
+  const reqRef = cVarRefWithoutLastIndices(reqArg, 1)
 
-  // Process the priority argument
-  const priorityArg = validateArg(1, 'priority')
-  const priorityRefId = priorityArg.varId
+  // Process the pp (priority profile) argument.  Only include subscripts up until the
+  // second to last one; the implementation function will iterate over the priority
+  // profile array.
+  const ppArg = validateArg(1, 'pp')
+  const ppRef = cVarRefWithoutLastIndices(ppArg, 2)
 
-  // Process the avail argument
+  // Process the avail argument; include any subscripts
   const availArg = validateArg(2, 'avail')
-  const availRefId = availArg.varId
+  const availRef = ctx.cVarRef(availArg)
 
-  // The `ALLOCATE AVAILABLE` function iterates over the subscript in its first arg
-  const dimId = reqSubIds[0]
-  const subIndex = ctx.loopIndexVars.index(dimId)
+  // The `ALLOCATE AVAILABLE` function iterates over the last subscript in its first arg.
+  // The `readEquation` process will have already verified that the last dimension matches
+  // the last dimension for the LHS.
+  const allocDimId = reqArg.subscriptRefs[reqArg.subscriptRefs.length - 1].subId
+  const allocLoopIndexVar = ctx.loopIndexVars.index(allocDimId)
 
   // Generate the code that is emitted before the entire block (before any loops are opened)
   const tmpVarId = newTmpVarName()
-  const dimSize = sub(dimId).size
+  const numRequesters = sub(allocDimId).size
   switch (ctx.outFormat) {
     case 'c':
       ctx.emitPreInnerLoop(
-        `  double* ${tmpVarId} = _ALLOCATE_AVAILABLE(${reqRefId}, (double*)${priorityRefId}, ${availRefId}, ${dimSize});`
+        `  double* ${tmpVarId} = _ALLOCATE_AVAILABLE(${reqRef}, (double*)${ppRef}, ${availRef}, ${numRequesters});`
       )
       break
     case 'js':
       ctx.emitPreInnerLoop(
-        `  let ${tmpVarId} = fns.ALLOCATE_AVAILABLE(${reqRefId}, ${priorityRefId}, ${availRefId}, ${dimSize});`
+        `  let ${tmpVarId} = fns.ALLOCATE_AVAILABLE(${reqRef}, ${ppRef}, ${availRef}, ${numRequesters});`
       )
       break
     default:
@@ -874,7 +888,7 @@ function generateAllocateAvailableCall(callExpr, ctx) {
   }
 
   // Generate the RHS expression used in the inner loop
-  return `${tmpVarId}[${dimId}[${subIndex}]]`
+  return `${tmpVarId}[${allocDimId}[${allocLoopIndexVar}]]`
 }
 
 /**
@@ -1006,3 +1020,32 @@ function minFunc(ctx) {
       throw new Error(`Unhandled output format '${ctx.outFormat}'`)
   }
 }
+
+/**
+ * Return the C or JS code for a subscript or dimension (loop index variable) used in
+ * expression position.
+ *
+ * @param {string} indexValue The index number or code.
+ * @param {GenExprContext} ctx The context used when generating code for the expression.
+ * @return {string} The generated C/JS code.
+ */
+function indexExpr(indexValue, ctx) {
+  switch (ctx.outFormat) {
+    case 'c':
+      // In the C case, we need to cast to double since the index variable will be
+      // of type `size_t`, which is an unsigned type, but we want a signed type for
+      // the rare cases where math is involved that makes it go negative
+      if (isNaN(indexValue)) {
+        // This is a (non-numeric) loop index variable reference, so cast to double
+        return `((double)${indexValue})`
+      } else {
+        // This is a numeric index, no cast is necessary
+        return indexValue
+      }
+    case 'js':
+      // In the JS case, no cast is necessary
+      return indexValue
+    default:
+      throw new Error(`Unhandled output format '${ctx.outFormat}'`)
+  }
+}

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/generate/loop-index-vars.js

@@ -1,5 +1,17 @@
 import { isDimension } from '../_shared/subscript.js'
 
+/**
+ * Mapping of dimension IDs to loop index variables.  The `indexVars` is an array
+ * of C/JS loop index variable names that will be generated.  For example, suppose
+ * `indexVars` is ['i', 'j', 'k'] and we have an equation:
+ *   x[DimA, DimB, DimC] = y[DimB, DimC, DimA] ~~|
+ * This class will map the index variables according to the order in which the
+ * `index` method is called:
+ *   const vars = new LoopIndexVars(['i', 'j', 'k'])
+ *   vars.index('_dima') // returns 'i'
+ *   vars.index('_dimb') // returns 'j'
+ *   vars.index('_dimc') // returns 'k'
+ */
 export default class LoopIndexVars {
   constructor(indexVars) {
     this.loopIndexVars = this.loopIndexVarGen(indexVars)

package/src/index.js

@@ -1,8 +1,12 @@
 // Copyright (c) 2022 Climate Interactive / New Venture Fund
 
+// XXX: For now we re-export the preprocess function from the parse package
+// mainly for use by the cli package (so that we don't need to have the cli
+// package directly depend on the parse package)
+export { preprocessVensimModel } from '@sdeverywhere/parse'
+
 export { canonicalName } from './_shared/helpers.js'
 export { readDat } from './_shared/read-dat.js'
-export { preprocessModel } from './preprocess/preprocessor.js'
 export { generateCode } from './generate/gen-code.js'
 export { parseAndGenerate, parseModel, printNames } from './parse-and-generate.js'
 

package/src/model/model.js

@@ -10,7 +10,6 @@ import {
   indexNamesForSubscript,
   isDimension,
   isIndex,
-  normalizeSubscripts,
   sub,
   subscriptFamilies
 } from '../_shared/subscript.js'
@@ -465,7 +464,7 @@ function findNonAtoAVars() {
   // Find variables with multiple instances with the same var name, which makes them
   // elements in a non-apply-to-all array. This function constructs the nonAtoANames list.
   function areSubsEqual(vars, i) {
-    // Scan the subscripts for each var at position i in normal order.
+    // Scan the subscripts for each var at position i in the original order.
     // Return true if the subscript is the same for all vars with that name.
     let subscript = vars[0].subscripts[i]
     for (let v of vars) {
@@ -478,7 +477,7 @@ function findNonAtoAVars() {
   R.forEach(name => {
     let vars = varsWithName(name)
     if (vars.length > 1) {
-      // This is a non-apply-to-all array. Construct the exansion dims array for it.
+      // This is a non-apply-to-all array. Construct the expansion dims array for it.
       // The expansion dim is true at each dim position where the subscript varies.
       let numDims = vars[0].subscripts.length
       let expansionDims = []
@@ -665,8 +664,6 @@ function splitRefId(refId) {
       varName = m[0]
     }
   }
-  // Put subscripts in normal order.
-  subscripts = normalizeSubscripts(subscripts)
   return { varName, subscripts }
 }
 function varWithName(varName) {
@@ -744,7 +741,6 @@ function cName(vensimVarName) {
   if (matches[2]) {
     // The variable name includes subscripts, so split them into individual IDs
     let cSubIds = matches[2].split(',').map(x => canonicalName(x))
-    cSubIds = normalizeSubscripts(cSubIds)
     // If a subscript is an index, convert it to an index number to match Vensim data exports
     let cSubIdParts = cSubIds.map(cSubId => {
       return isIndex(cSubId) ? `[${sub(cSubId).value}]` : `[${cSubId}]`

package/src/model/read-equation-fn-delay.js

@@ -81,12 +81,13 @@ export function generateDelayVariables(v, callExpr, context) {
 }
 
 /**
- * Generate a single level variable that is used to implement a `DELAY` function call.
+ * Generate equation text for a single level variable that is used to implement a `DELAY`
+ * function call, and add a reference to `levelRefId`.
  */
 function generateDelayLevel(context, levelLHS, levelRefId, input, aux, init) {
   const levelEqn = `${levelLHS} = INTEG(${input} - ${aux}, ${init}) ~~|`
-  context.defineVariable(levelEqn)
   context.addVarReference(levelRefId)
+  return levelEqn
 }
 
 //
@@ -94,7 +95,8 @@ function generateDelayLevel(context, levelLHS, levelRefId, input, aux, init) {
 //
 
 /**
- * TODO: Docs
+ * Generate and define variables that are needed to implement a `DELAY1[I]` function call
+ * for a non-subscripted or apply-to-all variable.
  */
 function generateDelay1VarsForNormalVar(v, context, subs, argInput, argDelay, argInit) {
   // Generate a single level variable instance
@@ -103,17 +105,23 @@ function generateDelay1VarsForNormalVar(v, context, subs, argInput, argDelay, ar
   const levelVarRefId = canonicalName(levelVarBaseName)
   const levelLHS = `${levelVarBaseName}${subs}`
 
+  // Generate the equation text for the delay level variable
+  const eqns = []
   // TODO: There should be parens around the factors in this init expression
   const argInitTimesDelay = `${argInit} * ${argDelay}`
-  generateDelayLevel(context, levelLHS, levelVarRefId, argInput, varLHS, argInitTimesDelay)
+  eqns.push(generateDelayLevel(context, levelLHS, levelVarRefId, argInput, varLHS, argInitTimesDelay))
   v.delayVarRefId = levelVarRefId
 
   // Generate an aux variable to hold the delay time expression
-  generateDelay1Aux(v, context, subs, argDelay)
+  eqns.push(generateDelay1Aux(v, context, subs, argDelay))
+
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
 }
 
 /**
- * TODO: Docs
+ * Generate and define variables that are needed to implement a `DELAY1[I]` function call
+ * for a non-apply-to-all variable.
  */
 function generateDelay1VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit) {
   // XXX: This code that deals with separated variables is largely copied from the legacy
@@ -151,17 +159,23 @@ function generateDelay1VarsForSeparatedVar(v, context, subs, argInput, argDelay,
   const levelVarRefId = canonicalVensimName(levelLHS)
   Model.addNonAtoAVar(canonicalName(levelVarBaseName), [true])
 
+  // Generate the equation text for the delay level variable
+  const eqns = []
   // TODO: There should be parens around the factors in this init expression
   const argInitTimesDelay = `${argInit} * ${argDelay}`
-  generateDelayLevel(context, levelLHS, levelVarRefId, argInput, varLHS, argInitTimesDelay)
+  eqns.push(generateDelayLevel(context, levelLHS, levelVarRefId, argInput, varLHS, argInitTimesDelay))
   v.delayVarRefId = levelVarRefId
 
   // Generate an aux variable to hold the delay time expression
-  generateDelay1Aux(v, context, subs, argDelay)
+  eqns.push(generateDelay1Aux(v, context, subs, argDelay))
+
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
 }
 
 /**
- * TODO: Docs
+ * Generate equation text for a single "delay time" aux variable that is used to implement
+ * a `DELAY1[I]` function call, and add a reference to the delay time variable.
  */
 function generateDelay1Aux(v, context, subs, argDelay) {
   const delayTimeVarName = newAuxVarName()
@@ -176,8 +190,8 @@ function generateDelay1Aux(v, context, subs, argDelay) {
   }
 
   const delayTimeEqn = `${delayTimeLHS} = ${argDelay} ~~|`
-  context.defineVariable(delayTimeEqn)
   context.addVarReference(delayTimeVarRefId)
+  return delayTimeEqn
 }
 
 //
@@ -185,7 +199,8 @@ function generateDelay1Aux(v, context, subs, argDelay) {
 //
 
 /**
- * TODO: Docs
+ * Generate and define variables that are needed to implement a `DELAY3[I]` function call
+ * for a non-subscripted or apply-to-all variable.
  */
 function generateDelay3VarsForNormalVar(v, context, subs, argInput, argDelay, argInit) {
   // Generate names for the 3 level variables and 4 aux variables
@@ -208,28 +223,33 @@ function generateDelay3VarsForNormalVar(v, context, subs, argInput, argDelay, ar
   const level3RefId = canonicalName(level3)
 
   // Generate level variables
+  const eqns = []
   const delay3Val = `((${argDelay}) / 3)`
   // TODO: There should be parens around these factors
   const initArg = `${argInit} * ${delay3Val}`
-  generateDelayLevel(context, level3LHS, level3RefId, aux2LHS, aux3LHS, initArg)
-  generateDelayLevel(context, level2LHS, level2RefId, aux1LHS, aux2LHS, initArg)
-  generateDelayLevel(context, level1LHS, level1RefId, argInput, aux1LHS, initArg)
+  eqns.push(generateDelayLevel(context, level3LHS, level3RefId, aux2LHS, aux3LHS, initArg))
+  eqns.push(generateDelayLevel(context, level2LHS, level2RefId, aux1LHS, aux2LHS, initArg))
+  eqns.push(generateDelayLevel(context, level1LHS, level1RefId, argInput, aux1LHS, initArg))
   v.delayVarRefId = canonicalName(level3)
 
   // Generate aux variable equations using the subs in the generated level vars
-  context.defineVariable(`${aux1LHS} = ${level1LHS} / ${delay3Val} ~~|`)
-  context.defineVariable(`${aux2LHS} = ${level2LHS} / ${delay3Val} ~~|`)
-  context.defineVariable(`${aux3LHS} = ${level3LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux1LHS} = ${level1LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux2LHS} = ${level2LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux3LHS} = ${level3LHS} / ${delay3Val} ~~|`)
 
   // Generate an aux variable to hold the delay time expression
   v.delayTimeVarName = canonicalName(aux4)
   const delayTimeVarRefId = canonicalVensimName(aux4LHS)
-  context.defineVariable(`${aux4LHS} = ${delay3Val} ~~|`)
+  eqns.push(`${aux4LHS} = ${delay3Val} ~~|`)
   context.addVarReference(delayTimeVarRefId)
+
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
 }
 
 /**
- * TODO: Docs
+ * Generate and define variables that are needed to implement a `DELAY3[I]` function call
+ * for a non-apply-to-all variable.
  */
 function generateDelay3VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit) {
   // XXX: This code that deals with separated variables is largely copied from the legacy
@@ -290,23 +310,29 @@ function generateDelay3VarsForSeparatedVar(v, context, subs, argInput, argDelay,
   Model.addNonAtoAVar(canonicalName(level2), [true])
   Model.addNonAtoAVar(canonicalName(level3), [true])
 
+  Model.addNonAtoAVar(canonicalName(aux1), [true])
+  Model.addNonAtoAVar(canonicalName(aux2), [true])
+  Model.addNonAtoAVar(canonicalName(aux3), [true])
+
   // Generate level variables
-  generateDelayLevel(context, level3LHS, level3RefId, aux2LHS, aux3LHS, initArg)
-  generateDelayLevel(context, level2LHS, level2RefId, aux1LHS, aux2LHS, initArg)
-  generateDelayLevel(context, level1LHS, level1RefId, argInput, aux1LHS, initArg)
+  const eqns = []
+  eqns.push(generateDelayLevel(context, level3LHS, level3RefId, aux2LHS, aux3LHS, initArg))
+  eqns.push(generateDelayLevel(context, level2LHS, level2RefId, aux1LHS, aux2LHS, initArg))
+  eqns.push(generateDelayLevel(context, level1LHS, level1RefId, argInput, aux1LHS, initArg))
   v.delayVarRefId = level3RefId
 
   // Generate aux variable equations using the subs in the generated level vars
-  context.defineVariable(`${aux1LHS} = ${level1LHS} / ${delay3Val} ~~|`)
-  context.defineVariable(`${aux2LHS} = ${level2LHS} / ${delay3Val} ~~|`)
-  context.defineVariable(`${aux3LHS} = ${level3LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux1LHS} = ${level1LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux2LHS} = ${level2LHS} / ${delay3Val} ~~|`)
+  eqns.push(`${aux3LHS} = ${level3LHS} / ${delay3Val} ~~|`)
 
   // Generate an aux variable to hold the delay time expression
   v.delayTimeVarName = canonicalName(aux4)
-  if (isSeparatedVar(v)) {
-    Model.addNonAtoAVar(v.delayTimeVarName, [true])
-  }
+  Model.addNonAtoAVar(v.delayTimeVarName, [true])
   const delayTimeVarRefId = canonicalVensimName(aux4LHS)
-  context.defineVariable(`${aux4LHS} = ${delay3Val} ~~|`)
+  eqns.push(`${aux4LHS} = ${delay3Val} ~~|`)
   context.addVarReference(delayTimeVarRefId)
+
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
 }

package/src/model/read-equation-fn-game.js

@@ -33,9 +33,9 @@ export function generateGameVariables(v, callExpr, context) {
   }
 
   // Define a variable for the synthesized game inputs lookup
-  const gameLookupVars = context.defineVariable(`${gameLookupVarName}${subs} ~~|`)
+  const gameLookupVars = context.defineVariables([`${gameLookupVarName}${subs} ~~|`])
 
-  // Normally `defineVariable` sets `includeInOutput` to false for generated
+  // Normally `defineVariables` sets `includeInOutput` to false for generated
   // variables, but we want the generated lookup variable to appear in the
   // model listing so that the user can reference it, so set `includeInOutput`
   // to true.  Also change the `varType` to 'lookup' instead of 'data'.  We

package/src/model/read-equation-fn-npv.js

@@ -26,6 +26,10 @@ export function generateNpvVariables(v, callExpr, context) {
   // const subs = this.genSubs(stream, discountRate, initVal, factor)
   const subs = ''
 
+  // Build an array of equation strings; variables will be defined for these at the
+  // end of this step once all equations are known
+  const eqns = []
+
   // Level 1:
   //   df = INTEG((-df * discount rate) / (1 + discount rate * TIME STEP), 1)
   const dfVarName = newLevelVarName()
@@ -34,7 +38,7 @@ export function generateNpvVariables(v, callExpr, context) {
   // TODO: There should be parens around the `discount rate` argument in case it is an expression
   // and not a simple constant
   const dfEqn = `${dfLHS} = INTEG((-${dfLHS} * ${argDiscountRate}) / (1 + ${argDiscountRate} * TIME STEP), 1) ~~|`
-  context.defineVariable(dfEqn)
+  eqns.push(dfEqn)
 
   // Level 2:
   //   ncum = INTEG(stream * df, init val)
@@ -42,7 +46,7 @@ export function generateNpvVariables(v, callExpr, context) {
   const ncumVarId = canonicalName(ncumVarName)
   const ncumLHS = `${ncumVarName}${subs}`
   const ncumEqn = `${ncumLHS} = INTEG(${argStream} * ${dfLHS}, ${argInitVal}) ~~|`
-  context.defineVariable(ncumEqn)
+  eqns.push(ncumEqn)
 
   // Aux:
   //   npv = (ncum + stream * TIME STEP * df) * factor
@@ -52,7 +56,7 @@ export function generateNpvVariables(v, callExpr, context) {
   // TODO: There should be parens around the `stream` argument in case it is an expression
   // and not a simple constant
   const auxEqn = `${auxLHS} = (${ncumVarName} + ${argStream} * TIME STEP * ${dfVarName}) * ${argFactor} ~~|`
-  context.defineVariable(auxEqn)
+  eqns.push(auxEqn)
   v.npvVarName = auxVarId
 
   // Add references to the generated variables
@@ -62,6 +66,9 @@ export function generateNpvVariables(v, callExpr, context) {
   context.addVarReference(dfVarId)
   context.addVarReference(auxVarId)
 
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
+
   // TODO: Check on this comment from the legacy reader to see if it's still applicable:
   // If they have subscripts, the refIds are still just the var name, because they are apply-to-all arrays.
 }

package/src/model/read-equation-fn-smooth.js

@@ -45,17 +45,21 @@ export function generateSmoothVariables(v, callExpr, context) {
   const fnId = callExpr.fnId
   if (fnId === '_SMOOTH' || fnId === '_SMOOTHI') {
     // Generate 1 level variable that will replace the `SMOOTH[I]` function call
-    const levelVarName = generateSmoothLevel(v, context, argInput, argDelay, argInit, 1)
+    const level = generateSmoothLevel(v, context, argInput, argDelay, argInit, 1)
     // For `SMOOTH[I]`, the smoothVarRefId is the level var's refId
-    v.smoothVarRefId = levelVarName[0]
+    v.smoothVarRefId = level.varRefId
+    // Add the generated variable to the model
+    context.defineVariables([level.eqn])
   } else {
     // Generate 3 level variables that will replace the `SMOOTH3[I]` function call
     const delay3Val = `(${argDelay} / 3)`
-    const level1VarName = generateSmoothLevel(v, context, argInput, delay3Val, argInit, 1)
-    const level2VarName = generateSmoothLevel(v, context, level1VarName[1], delay3Val, argInit, 2)
-    const level3VarName = generateSmoothLevel(v, context, level2VarName[1], delay3Val, argInit, 3)
+    const level1 = generateSmoothLevel(v, context, argInput, delay3Val, argInit, 1)
+    const level2 = generateSmoothLevel(v, context, level1.varFullName, delay3Val, argInit, 2)
+    const level3 = generateSmoothLevel(v, context, level2.varFullName, delay3Val, argInit, 3)
     // For `SMOOTH3[I]`, the smoothVarRefId is the final level var's refId
-    v.smoothVarRefId = level3VarName[0]
+    v.smoothVarRefId = level3.varRefId
+    // Add the generated variables to the model
+    context.defineVariables([level1.eqn, level2.eqn, level3.eqn])
   }
 }
 
@@ -126,11 +130,14 @@ function generateSmoothLevel(v, context, argInput, argDelay, argInit, levelNumbe
   if (isSeparatedVar(v)) {
     Model.addNonAtoAVar(canonicalName(levelVarBaseName), [true])
   }
-  context.defineVariable(levelEqn)
   context.addVarReference(levelVarRefId)
 
   // The name of the level variable returned here includes the original subscript/dimension names
   // (not the separated subscript names) so that the `argInput` is correct for the 2nd and 3rd levels
   const levelVarFullName = `${levelVarBaseName}${origSubs}`
-  return [levelVarRefId, levelVarFullName]
+  return {
+    varRefId: levelVarRefId,
+    varFullName: levelVarFullName,
+    eqn: levelEqn
+  }
 }

package/src/model/read-equation-fn-trend.js

@@ -24,12 +24,13 @@ export function generateTrendVariables(v, callExpr, context) {
   const subs = context.extractSubscriptsFromVarNames(argInput, argAvgTime, argInitVal)
 
   // Generate a level variable that will be used in place of the `TREND` call
+  const eqns = []
   const levelVarName = newLevelVarName()
   const levelLHS = `${levelVarName}${subs}`
   // TODO: There should be parens around the arguments in this equation in case any of them
   // is an expression and not a simple constant
   const levelEqn = `${levelLHS} = INTEG((${argInput} - ${levelLHS}) / ${argAvgTime}, ${argInput} / (1 + ${argInitVal} * ${argAvgTime})) ~~|`
-  context.defineVariable(levelEqn)
+  eqns.push(levelEqn)
   context.addVarReference(canonicalName(levelVarName))
 
   // Generate a aux variable that will be used in place of the `TREND` call
@@ -38,7 +39,10 @@ export function generateTrendVariables(v, callExpr, context) {
   // TODO: There should be parens around the arguments in this equation in case any of them
   // is an expression and not a simple constant
   const auxEqn = `${auxLHS} = ZIDZ(${argInput} - ${levelLHS}, ${argAvgTime} * ABS(${levelLHS})) ~~|`
-  context.defineVariable(auxEqn)
+  eqns.push(auxEqn)
   v.trendVarName = canonicalName(auxVarName)
   context.addVarReference(v.trendVarName)
+
+  // Add the generated variables to the model
+  context.defineVariables(eqns)
 }

package/src/model/read-equation-fn-with-lookup.js

@@ -23,7 +23,7 @@ export function generateLookup(v, callExpr, context) {
   const lookupVarName = newLookupVarName()
   const lookupDef = toPrettyString(lookupArg, { compact: true })
   const lookupEqn = `${lookupVarName}${lookupDef} ~~|`
-  context.defineVariable(lookupEqn)
+  context.defineVariables([lookupEqn])
 
   // Keep track of all lookup variables that are referenced.  This will be used later to decide
   // whether a lookup variable needs to be included in generated code.