@sdeverywhere/compile 0.7.10 → 0.7.12

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

@@ -0,0 +1,312 @@
+import { toPrettyString } from '@sdeverywhere/parse'
+
+import {
+  canonicalName,
+  canonicalVensimName,
+  decanonicalize,
+  isSeparatedVar,
+  newAuxVarName,
+  newLevelVarName
+} from '../_shared/helpers.js'
+
+import { separatedVariableIndex } from '../_shared/subscript.js'
+
+import Model from './model.js'
+
+/**
+ * Generate level and aux variables that implement one of the following `DELAY` function
+ * call variants:
+ * - DELAY1
+ * - DELAY1I
+ * - DELAY3
+ * - DELAY3I
+ *
+ * TODO: Docs
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ */
+export function generateDelayVariables(v, callExpr, context) {
+  // Get the text representation of each argument expression
+  // TODO: Maybe we could skip this step if we built trees for each generated equation instead
+  // of reparsing
+  const args = callExpr.args.map(toPrettyString)
+  let argInput = args[0]
+  let argDelay = args[1]
+
+  let argInit
+  if (args.length === 3) {
+    // Use the explicit initial value argument
+    argInit = `${args[2]}`
+  } else {
+    // Use the input argument as the initial value
+    argInit = `${argInput}`
+  }
+
+  // If the LHS includes subscripts, use those same subscripts when generating
+  // the new level and aux variables
+  let subs
+  if (context.eqnLhs.varDef.subscriptRefs) {
+    const subNames = context.eqnLhs.varDef.subscriptRefs.map(subRef => subRef.subName)
+    subs = `[${subNames.join(',')}]`
+  } else {
+    subs = ''
+  }
+
+  const fnId = callExpr.fnId
+  if (fnId === '_DELAY1' || fnId === '_DELAY1I') {
+    // Generate 1 level and 1 aux variable that will replace the `DELAY1[I]` function call
+    if (isSeparatedVar(v)) {
+      // The LHS variable is separated, so we need to generate separated level variable instances
+      generateDelay1VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit)
+    } else {
+      // The LHS variable is normal (non-separated or apply-to-all), so we can create a single
+      // level variable instance
+      generateDelay1VarsForNormalVar(v, context, subs, argInput, argDelay, argInit)
+    }
+  } else {
+    // Generate 3 level variables and 4 aux variables that will replace the `DELAY3[I]`
+    // function call
+    if (isSeparatedVar(v)) {
+      // The LHS variable is separated, so we need to generate multiple sets of separated level
+      // variable instances
+      generateDelay3VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit)
+    } else {
+      // The LHS variable is normal (non-separated or apply-to-all), so we can create a single
+      // set of level variable instances
+      generateDelay3VarsForNormalVar(v, context, subs, argInput, argDelay, argInit)
+    }
+  }
+}
+
+/**
+ * Generate a single level variable that is used to implement a `DELAY` function call.
+ */
+function generateDelayLevel(context, levelLHS, levelRefId, input, aux, init) {
+  const levelEqn = `${levelLHS} = INTEG(${input} - ${aux}, ${init}) ~~|`
+  context.defineVariable(levelEqn)
+  context.addVarReference(levelRefId)
+}
+
+//
+// DELAY1[I]
+//
+
+/**
+ * TODO: Docs
+ */
+function generateDelay1VarsForNormalVar(v, context, subs, argInput, argDelay, argInit) {
+  // Generate a single level variable instance
+  const varLHS = v.modelLHS
+  const levelVarBaseName = newLevelVarName()
+  const levelVarRefId = canonicalName(levelVarBaseName)
+  const levelLHS = `${levelVarBaseName}${subs}`
+
+  // TODO: There should be parens around the factors in this init expression
+  const argInitTimesDelay = `${argInit} * ${argDelay}`
+  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)
+}
+
+/**
+ * TODO: Docs
+ */
+function generateDelay1VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit) {
+  // XXX: This code that deals with separated variables is largely copied from the legacy
+  // `equation-reader.js` and modified to work with the AST instead of directly depending
+  // on antlr4-vensim constructs.  This logic is pretty complex so we should try to refactor
+  // or at least add some more fine-grained unit tests for it.
+  let varLHS = v.modelLHS
+
+  const levelVarBaseName = newLevelVarName(v.varName, 1)
+  let index
+  let sepDim
+  let r = subs.match(/\[(.*)\]/)
+  if (r) {
+    let rhsSubs = r[1].split(',').map(canonicalName)
+    for (let rhsSub of rhsSubs) {
+      let separatedIndexName = separatedVariableIndex(rhsSub, v, rhsSubs)
+      if (separatedIndexName) {
+        index = decanonicalize(separatedIndexName)
+        sepDim = decanonicalize(rhsSub)
+        break
+      }
+    }
+  }
+
+  if (index) {
+    let re = new RegExp(sepDim, 'gi')
+    subs = subs.replace(re, index)
+    varLHS = varLHS.replace(re, index)
+    argInput = argInput.replace(re, index)
+    argDelay = argDelay.replace(re, index)
+    argInit = argInit.replace(re, index)
+  }
+
+  const levelLHS = `${levelVarBaseName}${subs}`
+  const levelVarRefId = canonicalVensimName(levelLHS)
+  Model.addNonAtoAVar(canonicalName(levelVarBaseName), [true])
+
+  // TODO: There should be parens around the factors in this init expression
+  const argInitTimesDelay = `${argInit} * ${argDelay}`
+  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)
+}
+
+/**
+ * TODO: Docs
+ */
+function generateDelay1Aux(v, context, subs, argDelay) {
+  const delayTimeVarName = newAuxVarName()
+  const delayTimeLHS = `${delayTimeVarName}${subs}`
+  const delayTimeVarRefId = canonicalVensimName(delayTimeLHS)
+
+  v.delayTimeVarName = canonicalName(delayTimeVarName)
+  if (isSeparatedVar(v)) {
+    // Note: We need to mark this generated aux variable as non-apply-to-all before
+    // we define it with `defineVariable` so that the refId is computed correctly
+    Model.addNonAtoAVar(v.delayTimeVarName, [true])
+  }
+
+  const delayTimeEqn = `${delayTimeLHS} = ${argDelay} ~~|`
+  context.defineVariable(delayTimeEqn)
+  context.addVarReference(delayTimeVarRefId)
+}
+
+//
+// DELAY3[I]
+//
+
+/**
+ * TODO: Docs
+ */
+function generateDelay3VarsForNormalVar(v, context, subs, argInput, argDelay, argInit) {
+  // Generate names for the 3 level variables and 4 aux variables
+  const level1 = newLevelVarName()
+  const level2 = newLevelVarName()
+  const level3 = newLevelVarName()
+  const aux1 = newAuxVarName()
+  const aux2 = newAuxVarName()
+  const aux3 = newAuxVarName()
+  const aux4 = newAuxVarName()
+  const level1LHS = `${level1}${subs}`
+  const level2LHS = `${level2}${subs}`
+  const level3LHS = `${level3}${subs}`
+  const aux1LHS = `${aux1}${subs}`
+  const aux2LHS = `${aux2}${subs}`
+  const aux3LHS = `${aux3}${subs}`
+  const aux4LHS = `${aux4}${subs}`
+  const level1RefId = canonicalName(level1)
+  const level2RefId = canonicalName(level2)
+  const level3RefId = canonicalName(level3)
+
+  // Generate level variables
+  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)
+  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} ~~|`)
+
+  // Generate an aux variable to hold the delay time expression
+  v.delayTimeVarName = canonicalName(aux4)
+  const delayTimeVarRefId = canonicalVensimName(aux4LHS)
+  context.defineVariable(`${aux4LHS} = ${delay3Val} ~~|`)
+  context.addVarReference(delayTimeVarRefId)
+}
+
+/**
+ * TODO: Docs
+ */
+function generateDelay3VarsForSeparatedVar(v, context, subs, argInput, argDelay, argInit) {
+  // XXX: This code that deals with separated variables is largely copied from the legacy
+  // `equation-reader.js` and modified to work with the AST instead of directly depending
+  // on antlr4-vensim constructs.  This logic is pretty complex so we should try to refactor
+  // or at least add some more fine-grained unit tests for it.
+
+  // Generate names for the 3 level variables and 4 aux variables
+  const level1 = newLevelVarName(v.varName, 1)
+  const level2 = newLevelVarName(v.varName, 2)
+  const level3 = newLevelVarName(v.varName, 3)
+  const aux1 = newAuxVarName(v.varName, 1)
+  const aux2 = newAuxVarName(v.varName, 2)
+  const aux3 = newAuxVarName(v.varName, 3)
+  const aux4 = newAuxVarName(v.varName, 4)
+
+  let index
+  let sepDim
+  let r = subs.match(/\[(.*)\]/)
+  if (r) {
+    let rhsSubs = r[1].split(',').map(x => canonicalName(x))
+    for (let rhsSub of rhsSubs) {
+      let separatedIndexName = separatedVariableIndex(rhsSub, v, rhsSubs)
+      if (separatedIndexName) {
+        index = decanonicalize(separatedIndexName)
+        sepDim = decanonicalize(rhsSub)
+        break
+      }
+    }
+  }
+
+  let delay3Val = `((${argDelay}) / 3)`
+  if (index) {
+    let re = new RegExp(sepDim, 'gi')
+    subs = subs.replace(re, index)
+    argInput = argInput.replace(re, index)
+    argInit = argInit.replace(re, index)
+    delay3Val = delay3Val.replace(re, index)
+  }
+
+  // TODO: There should be parens around these factors
+  const initArg = `${argInit} * ${delay3Val}`
+
+  const level1LHS = `${level1}${subs}`
+  const level2LHS = `${level2}${subs}`
+  const level3LHS = `${level3}${subs}`
+
+  const aux1LHS = `${aux1}${subs}`
+  const aux2LHS = `${aux2}${subs}`
+  const aux3LHS = `${aux3}${subs}`
+  const aux4LHS = `${aux4}${subs}`
+
+  const level1RefId = canonicalVensimName(level1LHS)
+  const level2RefId = canonicalVensimName(level2LHS)
+  const level3RefId = canonicalVensimName(level3LHS)
+
+  Model.addNonAtoAVar(canonicalName(level1), [true])
+  Model.addNonAtoAVar(canonicalName(level2), [true])
+  Model.addNonAtoAVar(canonicalName(level3), [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)
+  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} ~~|`)
+
+  // Generate an aux variable to hold the delay time expression
+  v.delayTimeVarName = canonicalName(aux4)
+  if (isSeparatedVar(v)) {
+    Model.addNonAtoAVar(v.delayTimeVarName, [true])
+  }
+  const delayTimeVarRefId = canonicalVensimName(aux4LHS)
+  context.defineVariable(`${aux4LHS} = ${delay3Val} ~~|`)
+  context.addVarReference(delayTimeVarRefId)
+}

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

@@ -0,0 +1,67 @@
+import { toPrettyString } from '@sdeverywhere/parse'
+
+import { canonicalName, newAuxVarName, newLevelVarName } from '../_shared/helpers.js'
+
+/**
+ * Generate two level variables and one aux that implement an `NPV` function call.
+ *
+ * TODO: Docs
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ * @returns
+ */
+export function generateNpvVariables(v, callExpr, context) {
+  // Get the text representation of each argument expression
+  // TODO: Maybe we could skip this step if we built trees for each generated equation instead
+  // of reparsing
+  const args = callExpr.args.map(toPrettyString)
+  const argStream = args[0]
+  const argDiscountRate = args[1]
+  const argInitVal = args[2]
+  const argFactor = args[3]
+
+  // TODO: Generate subscripts
+  // const subs = this.genSubs(stream, discountRate, initVal, factor)
+  const subs = ''
+
+  // Level 1:
+  //   df = INTEG((-df * discount rate) / (1 + discount rate * TIME STEP), 1)
+  const dfVarName = newLevelVarName()
+  const dfVarId = canonicalName(dfVarName)
+  const dfLHS = `${dfVarName}${subs}`
+  // 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)
+
+  // Level 2:
+  //   ncum = INTEG(stream * df, init val)
+  const ncumVarName = newLevelVarName()
+  const ncumVarId = canonicalName(ncumVarName)
+  const ncumLHS = `${ncumVarName}${subs}`
+  const ncumEqn = `${ncumLHS} = INTEG(${argStream} * ${dfLHS}, ${argInitVal}) ~~|`
+  context.defineVariable(ncumEqn)
+
+  // Aux:
+  //   npv = (ncum + stream * TIME STEP * df) * factor
+  const auxVarName = newAuxVarName()
+  const auxVarId = canonicalName(auxVarName)
+  const auxLHS = `${auxVarName}${subs}`
+  // 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)
+  v.npvVarName = auxVarId
+
+  // Add references to the generated variables
+  // TODO: These are added in a different order than how the variables were defined because
+  // this is the order that the legacy reader used, and we're trying to be compatible
+  context.addVarReference(ncumVarId)
+  context.addVarReference(dfVarId)
+  context.addVarReference(auxVarId)
+
+  // 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

@@ -0,0 +1,133 @@
+import { toPrettyString } from '@sdeverywhere/parse'
+
+import {
+  canonicalName,
+  canonicalVensimName,
+  decanonicalize,
+  isSeparatedVar,
+  newLevelVarName
+} from '../_shared/helpers.js'
+
+import { separatedVariableIndex } from '../_shared/subscript.js'
+
+import Model from './model.js'
+
+/**
+ * Generate level and aux variables that implement one of the following `SMOOTH` function
+ * call variants:
+ * - SMOOTH
+ * - SMOOTHI
+ * - SMOOTH3
+ * - SMOOTH3I
+ *
+ * TODO: Docs
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ * @returns
+ */
+export function generateSmoothVariables(v, callExpr, context) {
+  // Get the text representation of each argument expression
+  const args = callExpr.args.map(toPrettyString)
+  const argInput = args[0]
+  const argDelay = args[1]
+
+  let argInit
+  if (args.length === 3) {
+    // Use the explicit initial value argument
+    argInit = args[2]
+  } else {
+    // Use the input argument as the initial value
+    argInit = args[0]
+  }
+
+  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)
+    // For `SMOOTH[I]`, the smoothVarRefId is the level var's refId
+    v.smoothVarRefId = levelVarName[0]
+  } 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)
+    // For `SMOOTH3[I]`, the smoothVarRefId is the final level var's refId
+    v.smoothVarRefId = level3VarName[0]
+  }
+}
+
+/**
+ * Generate a single level variable that is used to implement a `SMOOTH` function call.
+ */
+function generateSmoothLevel(v, context, argInput, argDelay, argInit, levelNumber) {
+  // XXX: This code that deals with separated variables is largely copied from the legacy
+  // `equation-reader.js` and modified to work with the AST instead of directly depending
+  // on antlr4-vensim constructs.  This logic is pretty complex so we should try to refactor
+  // or at least add some more fine-grained unit tests for it.
+  let subs = context.extractSubscriptsFromVarNames(argInput, argDelay, argInit)
+
+  // For SMOOTH3, the previous level is the input for level number 2 and 3. Add RHS subscripts.
+  if (levelNumber > 1 && subs.length > 0) {
+    argInput = `${argInput}${subs}`
+  }
+
+  let levelVarBaseName
+  let levelLHS
+  let levelVarRefId
+  if (isSeparatedVar(v)) {
+    // Levels generated by separated vars are also separated. We have to compute the indices here instead
+    // of using the dimension on the LHS and letting addVariable do it, so that the whole array of
+    // separated variables are not added for each visit here by an already-separated index.
+    // Start by getting a level var based on the var name, so it is the same for all separated levels.
+    levelVarBaseName = newLevelVarName(v.varName, levelNumber)
+
+    // Replace the dimension in the generated variable subscript with the separated index from the LHS.
+    // Find the index in the LHS that was expanded from the separation dimension.
+    let index
+    let sepDim
+    let r = subs.match(/\[(.*)\]/)
+    if (r) {
+      let rhsSubs = r[1].split(',').map(x => canonicalName(x))
+      for (let rhsSub of rhsSubs) {
+        let separatedIndexName = separatedVariableIndex(rhsSub, v, rhsSubs)
+        if (separatedIndexName) {
+          index = decanonicalize(separatedIndexName)
+          sepDim = decanonicalize(rhsSub)
+          break
+        }
+      }
+    }
+
+    // Use the Vensim form of the index in the LHS and in all arguments
+    if (index) {
+      let re = new RegExp(`\\[(.*?)${sepDim}(.*?)\\]`, 'gi')
+      let replacement = `[$1${index}$2]`
+      subs = subs.replace(re, replacement)
+      argInput = argInput.replace(re, replacement)
+      argDelay = argDelay.replace(re, replacement)
+      argInit = argInit.replace(re, replacement)
+    }
+    levelLHS = `${levelVarBaseName}${subs}`
+    levelVarRefId = canonicalVensimName(levelLHS)
+  } else {
+    // In the normal case, generate a unique variable name for the level var
+    levelVarBaseName = newLevelVarName()
+    levelLHS = `${levelVarBaseName}${subs}`
+    // If it has subscripts, the refId is still just the var name, because it is an
+    // apply-to-all array
+    levelVarRefId = canonicalName(levelVarBaseName)
+  }
+
+  // Generate the level variable
+  const levelEqn = `${levelLHS} = INTEG((${argInput} - ${levelLHS}) / ${argDelay}, ${argInit}) ~~|`
+  if (isSeparatedVar(v)) {
+    Model.addNonAtoAVar(canonicalName(levelVarBaseName), [true])
+  }
+  context.defineVariable(levelEqn)
+  context.addVarReference(levelVarRefId)
+
+  return [levelVarRefId, levelVarBaseName]
+}

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

@@ -0,0 +1,44 @@
+import { toPrettyString } from '@sdeverywhere/parse'
+
+import { canonicalName, newAuxVarName, newLevelVarName } from '../_shared/helpers.js'
+
+/**
+ * Generate two level variables and one aux that implement an `NPV` function call.
+ *
+ * TODO: Docs
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ * @returns
+ */
+export function generateTrendVariables(v, callExpr, context) {
+  // Get the text representation of each argument expression
+  const args = callExpr.args.map(toPrettyString)
+  const argInput = args[0]
+  const argAvgTime = args[1]
+  const argInitVal = args[2]
+
+  // Generate the subscripts that will be used on the LHS of the generated variables
+  // by examining the subscripts of the variables used in arguments to the `TREND` call
+  const subs = context.extractSubscriptsFromVarNames(argInput, argAvgTime, argInitVal)
+
+  // Generate a level variable that will be used in place of the `TREND` call
+  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)
+  context.addVarReference(canonicalName(levelVarName))
+
+  // Generate a aux variable that will be used in place of the `TREND` call
+  const auxVarName = newAuxVarName()
+  const auxLHS = `${auxVarName}${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 auxEqn = `${auxLHS} = ZIDZ(${argInput} - ${levelLHS}, ${argAvgTime} * ABS(${levelLHS})) ~~|`
+  context.defineVariable(auxEqn)
+  v.trendVarName = canonicalName(auxVarName)
+  context.addVarReference(v.trendVarName)
+}

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

@@ -0,0 +1,37 @@
+import { toPrettyString } from '@sdeverywhere/parse'
+
+import { canonicalName, newLookupVarName } from '../_shared/helpers.js'
+
+/**
+ * Generate a lookup definition to augment a `WITH LOOKUP` function call.
+ *
+ * TODO: Docs
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ * @returns
+ */
+export function generateLookup(v, callExpr, context) {
+  // Extract the lookup data from the second argument
+  const lookupArg = callExpr.args[1]
+  if (lookupArg.kind !== 'lookup-def') {
+    throw new Error(`Expected lookup data as second argument in WITH LOOKUP call, but got ${lookupArg.kind}`)
+  }
+
+  // Generate a new lookup variable using the data points from the lookup argument
+  const lookupVarName = newLookupVarName()
+  const lookupDef = toPrettyString(lookupArg, { compact: true })
+  const lookupEqn = `${lookupVarName}${lookupDef} ~~|`
+  context.defineVariable(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.
+  const lookupArgVarName = canonicalName(lookupVarName)
+  v.lookupArgVarName = lookupArgVarName
+  if (v.referencedLookupVarNames) {
+    v.referencedLookupVarNames.push(lookupArgVarName)
+  } else {
+    v.referencedLookupVarNames = [lookupArgVarName]
+  }
+}