@sdeverywhere/compile 0.7.16 → 0.7.18

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,19 @@ 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 cachedVarIndexInfo
+let cachedJsonList
 
 // Also keep variables in a map (with `varName` as key) for faster lookup
 const variablesByName = new Map()
@@ -49,6 +46,8 @@ function resetModelState() {
   variablesByName.clear()
   constantExprs.clear()
   nonAtoANames = Object.create(null)
+  cachedVarIndexInfo = undefined
+  cachedJsonList = undefined
 }
 
 /**
@@ -73,38 +72,27 @@ 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) {
-    // If the spec file contains `input/outputVarNames` (with full Vensim variable names)
-    // convert those to C names first.  Otherwise, use `input/outputNames` which are already
-    // assumed to be valid C names.
+    // If the spec file contains `input/outputVarNames`, convert the full Vensim variable
+    // names to C names first so that later phases only need to work with canonical names
     if (spec.inputVarNames) {
       spec.inputVars = R.map(cName, spec.inputVarNames)
     }
@@ -122,7 +110,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)
@@ -131,22 +119,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.
@@ -290,32 +262,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.
@@ -325,23 +271,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) {
@@ -352,22 +292,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`
+            )
           }
         }
       }
@@ -569,28 +496,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
 //
@@ -800,11 +705,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) {
@@ -1165,13 +1066,12 @@ function allListedVars() {
   if (timeVar) {
     vars.push(timeVar)
   }
-  vars.push(...initVars())
   vars.push(...auxVars())
-  // TODO: Also levelVars not covered by initVars?
+  vars.push(...levelVars())
 
-  // Filter out data/lookup variables and variables that are generated/used internally
+  // Filter out variables that are generated/used internally
   const isInternal = v => {
-    return v.refId.startsWith('__level') || v.refId.startsWith('__aux')
+    return v.includeInOutput === false
   }
 
   return R.filter(v => !isInternal(v), vars)
@@ -1186,6 +1086,7 @@ function filteredListedVars() {
 function varIndexInfoMap() {
   // Return a map containing information for each listed variable:
   //   varName
+  //   varType
   //   varIndex
   //   subscriptCount
 
@@ -1193,21 +1094,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
       })
@@ -1222,43 +1119,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,

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

@@ -0,0 +1,50 @@
+import { canonicalName } from '../_shared/helpers.js'
+
+/**
+ * Generate a lookup variable that can be used to provide inputs to a the `GAME`
+ * function at runtime.
+ *
+ * @param {*} v
+ * @param {*} callExpr
+ * @param {*} context
+ */
+export function generateGameVariables(v, callExpr, context) {
+  // If the LHS includes subscripts, use those same subscripts when generating
+  // the new lookup variable
+  let subs
+  if (context.eqnLhs.varDef.subscriptRefs) {
+    const subNames = context.eqnLhs.varDef.subscriptRefs.map(subRef => subRef.subName)
+    subs = `[${subNames.join(',')}]`
+  } else {
+    subs = ''
+  }
+
+  // Synthesize a lookup variable name that is the same as the LHS variable
+  // name with ' game inputs' appended to it
+  const gameLookupVarName = context.eqnLhs.varDef.varName + ' game inputs'
+
+  // Add a reference to the synthesized game inputs lookup
+  const gameLookupVarId = canonicalName(gameLookupVarName)
+  v.gameLookupVarName = gameLookupVarId
+  if (v.referencedLookupVarNames) {
+    v.referencedLookupVarNames.push(gameLookupVarId)
+  } else {
+    v.referencedLookupVarNames = [gameLookupVarId]
+  }
+
+  // Define a variable for the synthesized game inputs lookup
+  const gameLookupVars = context.defineVariable(`${gameLookupVarName}${subs} ~~|`)
+
+  // Normally `defineVariable` 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
+  // will declare a `Lookup` variable in the generated code, but unlike a
+  // normal lookup, we won't initialize it with data by default (it can only
+  // be updated at runtime).
+  gameLookupVars.forEach(v => {
+    v.includeInOutput = true
+    v.varType = 'lookup'
+    v.varSubtype = 'gameInputs'
+  })
+}

package/src/model/read-equations.js

@@ -16,6 +16,7 @@ import {
 
 import Model from './model.js'
 import { generateDelayVariables } from './read-equation-fn-delay.js'
+import { generateGameVariables } from './read-equation-fn-game.js'
 import { generateNpvVariables } from './read-equation-fn-npv.js'
 import { generateSmoothVariables } from './read-equation-fn-smooth.js'
 import { generateTrendVariables } from './read-equation-fn-trend.js'
@@ -128,6 +129,8 @@ class Context {
       // Inhibit output for generated variables
       v.includeInOutput = false
     })
+
+    return vars
   }
 
   /**
@@ -383,16 +386,6 @@ function visitFunctionCall(v, callExpr, context) {
       validateCallArgs(callExpr, 1)
       break
 
-    // TODO: We do not currently have full support for the GAME function, so report a warning for now
-    case '_GAME':
-      if (process.env.SDE_REPORT_UNSUPPORTED_FUNCTIONS !== '0') {
-        console.warn(
-          `WARNING: The GAME function (used in the definition of '${v.modelLHS}') is currently implemented as a no-op (it returns the input value).`
-        )
-      }
-      validateCallArgs(callExpr, 1)
-      break
-
     //
     //
     // 2-argument functions...
@@ -491,6 +484,12 @@ function visitFunctionCall(v, callExpr, context) {
       argModes[2] = 'init'
       break
 
+    case '_GAME':
+      validateCallDepth(callExpr, context)
+      validateCallArgs(callExpr, 1)
+      generateGameVariables(v, callExpr, context)
+      break
+
     case '_GET_DIRECT_CONSTANTS': {
       validateCallDepth(callExpr, context)
       validateCallArgs(callExpr, 3)

package/src/model/read-variables.js

@@ -49,7 +49,7 @@ export function readVariables(parsedModel, specialSeparationDims) {
  */
 function variablesForEquation(eqn, specialSeparationDims) {
   // Start a new variable defined by this equation
-  const variable = new Variable(null)
+  const variable = new Variable()
 
   // Fill in the LHS details
   const lhs = eqn.lhs.varDef
@@ -137,7 +137,7 @@ function variablesForEquation(eqn, specialSeparationDims) {
     // Generate variables expanded over subscripts to the model
     const variables = []
     for (const expansion of expansions) {
-      const v = new Variable(null)
+      const v = new Variable()
       v.varName = baseVarId
       v.modelLHS = lhsText
       v.modelFormula = rhsText