@sdeverywhere/compile 0.7.26 → 0.7.28

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.26",
+  "version": "0.7.28",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
-    "@sdeverywhere/parse": "^0.1.2",
+    "@sdeverywhere/parse": "^0.1.3",
     "byline": "^5.0.0",
     "csv-parse": "^5.3.3",
     "ramda": "^0.27.0",

package/src/generate/gen-code-c.js

@@ -146,6 +146,24 @@ ${chunkedFunctions('evalLevels', Model.levelVars(), '  // Evaluate levels.')}`
   // Input/output section
   //
   function emitIOCode() {
+    // Configure the body of the `setConstant` function depending on the value
+    // of the `customConstants` property in the spec file
+    let setConstantBody
+    if (spec.customConstants === true || Array.isArray(spec.customConstants)) {
+      setConstantBody = `\
+  switch (varIndex) {
+${setConstantImpl(Model.varIndexInfo(), spec.customConstants)}
+    default:
+      fprintf(stderr, "No constant found for var index %zu in setConstant\\n", varIndex);
+      break;
+  }`
+    } else {
+      let msg = 'The setConstant function was not enabled for the generated model. '
+      msg += 'Set the customConstants property in the spec/config file to allow for overriding constants at runtime.'
+      setConstantBody = `\
+  fprintf(stderr, "${msg}\\n");`
+    }
+
     // Configure the body of the `setLookup` function depending on the value
     // of the `customLookups` property in the spec file
     // TODO: The fprintf calls should be replaced with a mechanism that throws
@@ -200,12 +218,12 @@ ${customOutputSection(Model.varIndexInfo(), spec.customOutputs)}
 
     mode = 'io'
     return `\
-void setInputs(const char* inputData) {
-${inputsFromStringImpl()}
+void setInputs(double* inputValues, int32_t* inputIndices) {
+${setInputsImpl()}
 }
 
-void setInputsFromBuffer(double* inputData) {
-${inputsFromBufferImpl()}
+void setConstant(size_t varIndex, size_t* subIndices, double value) {
+${setConstantBody}
 }
 
 void setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints) {
@@ -322,13 +340,19 @@ ${section(chunk)}
   }
   function internalVarsSection() {
     // Declare internal variables to run the model.
-    let decls
+    let numInputsDecl
+    if (spec.inputVars && spec.inputVars.length > 0) {
+      numInputsDecl = `const int numInputs = ${spec.inputVars.length};`
+    } else {
+      numInputsDecl = `const int numInputs = 0;`
+    }
+    let numOutputsDecl
     if (outputAllVars) {
-      decls = `const int numOutputs = ${expandedVarNames().length};`
+      numOutputsDecl = `const int numOutputs = ${expandedVarNames().length};`
     } else {
-      decls = `const int numOutputs = ${spec.outputVars.length};`
+      numOutputsDecl = `const int numOutputs = ${spec.outputVars.length};`
     }
-    return decls
+    return `${numInputsDecl}\n${numOutputsDecl}`
   }
   function arrayDimensionsSection() {
     // Emit a declaration for each array dimension's index numbers.
@@ -402,38 +426,64 @@ ${section(chunk)}
     const section = R.pipe(outputVars, code, lines)
     return section(varIndexInfo)
   }
-  function inputsFromStringImpl() {
-    // If there was an I/O spec file, then emit code to parse input variables.
-    // The user can replace this with a parser for a different serialization format.
-    let inputVars = ''
-    if (spec.inputVars && spec.inputVars.length > 0) {
-      let inputVarPtrs = R.reduce((a, inputVar) => R.concat(a, `    &${inputVar},\n`), '', spec.inputVars)
-      inputVars = `\
-  static double* inputVarPtrs[] = {\n${inputVarPtrs}  };
-  char* inputs = (char*)inputData;
-  char* token = strtok(inputs, " ");
-  while (token) {
-    char* p = strchr(token, ':');
-    if (p) {
-      *p = '\\0';
-      int modelVarIndex = atoi(token);
-      double value = atof(p+1);
-      *inputVarPtrs[modelVarIndex] = value;
+  function setInputsImpl() {
+    if (!spec.inputVars || spec.inputVars.length === 0) {
+      return ''
     }
-    token = strtok(NULL, " ");
-  }`
+    // Build the pointer table for input variables
+    let inputVarPtrs = R.reduce((a, inputVar) => R.concat(a, `    &${inputVar},\n`), '', spec.inputVars)
+    return `\
+  static double* inputVarPtrs[] = {
+${inputVarPtrs}  };
+  if (inputIndices == NULL) {
+    // When inputIndices is NULL, assume that inputValues contains all input values
+    // in the same order that the variables are defined in the model spec
+    for (size_t i = 0; i < numInputs; i++) {
+      *inputVarPtrs[i] = inputValues[i];
     }
-    return inputVars
+  } else {
+    // When inputIndices is non-NULL, set the input values according to the indices
+    // in the inputIndices array, where each index corresponds to the index of the
+    // variable in the model spec
+    size_t numInputsToSet = (size_t)inputIndices[0];
+    for (size_t i = 0; i < numInputsToSet; i++) {
+      size_t inputVarIndex = (size_t)inputIndices[i + 1];
+      *inputVarPtrs[inputVarIndex] = inputValues[i];
+    }
+  }`
   }
-  function inputsFromBufferImpl() {
-    let inputVars = []
-    if (spec.inputVars && spec.inputVars.length > 0) {
-      for (let i = 0; i < spec.inputVars.length; i++) {
-        const inputVar = spec.inputVars[i]
-        inputVars.push(`  ${inputVar} = inputData[${i}];`)
-      }
+  function setConstantImpl(varIndexInfo, customConstants) {
+    // Emit case statements for all const variables that can be overridden at runtime
+    let includeCase
+    if (Array.isArray(customConstants)) {
+      // Only include a case statement if the variable was explicitly included
+      // in the `customConstants` array in the spec file
+      const customConstantVarNames = customConstants.map(varName => {
+        // The developer might specify a variable name that includes subscripts,
+        // but we will ignore the subscript part and only match on the base name
+        return canonicalVensimName(varName.split('[')[0])
+      })
+      includeCase = varName => customConstantVarNames.includes(varName)
+    } else {
+      // Include a case statement for all constant variables
+      includeCase = () => true
     }
-    return inputVars.join('\n')
+    const constVars = R.filter(info => {
+      return info.varType === 'const' && includeCase(info.varName)
+    })
+    const code = R.map(info => {
+      let constVar = info.varName
+      for (let i = 0; i < info.subscriptCount; i++) {
+        constVar += `[subIndices[${i}]]`
+      }
+      let c = ''
+      c += `    case ${info.varIndex}:\n`
+      c += `      ${constVar} = value;\n`
+      c += `      break;`
+      return c
+    })
+    const section = R.pipe(constVars, code, lines)
+    return section(varIndexInfo)
   }
   function setLookupImpl(varIndexInfo, customLookups) {
     // Emit case statements for all lookups and data variables that can be overridden

package/src/generate/gen-code-js.js

@@ -241,6 +241,27 @@ ${chunkedFunctions('evalLevels', true, Model.levelVars(), '  // Evaluate levels'
   function emitIOCode() {
     mode = 'io'
 
+    // Configure the body of the `setConstant` function depending on the value
+    // of the `customConstants` property in the spec file
+    let setConstantBody
+    if (spec.customConstants === true || Array.isArray(spec.customConstants)) {
+      setConstantBody = `\
+  if (!varSpec) {
+    throw new Error('Got undefined varSpec in setConstant');
+  }
+  const varIndex = varSpec.varIndex;
+  const subs = varSpec.subscriptIndices;
+  switch (varIndex) {
+${setConstantImpl(Model.varIndexInfo(), spec.customConstants)}
+    default:
+      throw new Error(\`No constant found for var index \${varIndex} in setConstant\`);
+  }`
+    } else {
+      let msg = 'The setConstant function was not enabled for the generated model. '
+      msg += 'Set the customConstants property in the spec/config file to allow for overriding constants at runtime.'
+      setConstantBody = `  throw new Error('${msg}');`
+    }
+
     // Configure the body of the `setLookup` function depending on the value
     // of the `customLookups` property in the spec file
     let setLookupBody
@@ -312,6 +333,10 @@ ${customOutputSection(Model.varIndexInfo(), spec.customOutputs)}
     return `\
 /*export*/ function setInputs(valueAtIndex /*: (index: number) => number*/) {${inputsFromBufferImpl()}}
 
+/*export*/ function setConstant(varSpec /*: VarSpec*/, value /*: number*/) {
+${setConstantBody}
+}
+
 /*export*/ function setLookup(varSpec /*: VarSpec*/, points /*: Float64Array | undefined*/) {
 ${setLookupBody}
 }
@@ -521,6 +546,39 @@ ${section(chunk)}
     }
     return inputVars
   }
+  function setConstantImpl(varIndexInfo, customConstants) {
+    // Emit case statements for all const variables that can be overridden at runtime
+    let overrideAllowed
+    if (Array.isArray(customConstants)) {
+      // Only include a case statement if the variable was explicitly included
+      // in the `customConstants` array in the spec file
+      const customConstantVarNames = customConstants.map(varName => {
+        // The developer might specify a variable name that includes subscripts,
+        // but we will ignore the subscript part and only match on the base name
+        return canonicalVensimName(varName.split('[')[0])
+      })
+      overrideAllowed = varName => customConstantVarNames.includes(varName)
+    } else {
+      // Include a case statement for all constant variables
+      overrideAllowed = () => true
+    }
+    const constVars = R.filter(info => {
+      return info.varType === 'const' && overrideAllowed(info.varName)
+    })
+    const code = R.map(info => {
+      let constVar = info.varName
+      for (let i = 0; i < info.subscriptCount; i++) {
+        constVar += `[subs[${i}]]`
+      }
+      let c = ''
+      c += `    case ${info.varIndex}:\n`
+      c += `      ${constVar} = value;\n`
+      c += `      break;`
+      return c
+    })
+    const section = R.pipe(constVars, code, lines)
+    return section(varIndexInfo)
+  }
   function setLookupImpl(varIndexInfo, customLookups) {
     // Emit case statements for all lookups and data variables that can be overridden
     // at runtime
@@ -605,6 +663,7 @@ export default async function () {
 
     setTime,
     setInputs,
+    setConstant,
     setLookup,
 
     storeOutputs,

package/src/generate/gen-expr.js

@@ -162,8 +162,28 @@ export function generateExpr(expr, ctx) {
  * @return {string} The generated C/JS code.
  */
 function generateFunctionCall(callExpr, ctx) {
-  const fnId = callExpr.fnId
+  function generateSimpleFunctionCall(fnId) {
+    const args = callExpr.args.map(argExpr => generateExpr(argExpr, ctx))
+    if (ctx.outFormat === 'js' && fnId === '_IF_THEN_ELSE') {
+      // When generating conditional expressions for JS target, since we can't rely on macros like we do for C,
+      // it is better to translate it into a ternary instead of relying on a built-in function (since the latter
+      // would require always evaluating both branches, while the former can be more optimized by the interpreter)
+      return `((${args[0]}) ? (${args[1]}) : (${args[2]}))`
+    } else {
+      // For simple functions, emit a C/JS function call with a generated C/JS expression for each argument
+      return `${fnRef(fnId, ctx)}(${args.join(', ')})`
+    }
+  }
 
+  function generateLookupFunctionCall(fnId) {
+    // For LOOKUP* functions, the first argument must be a reference to the lookup variable.  Emit
+    // a C/JS function call with a generated C/JS expression for each remaining argument.
+    const cVarRef = ctx.cVarRef(callExpr.args[0])
+    const cArgs = callExpr.args.slice(1).map(arg => generateExpr(arg, ctx))
+    return `${fnRef(fnId, ctx)}(${cVarRef}, ${cArgs.join(', ')})`
+  }
+
+  const fnId = callExpr.fnId
   switch (fnId) {
     //
     //
@@ -174,46 +194,54 @@ function generateFunctionCall(callExpr, ctx) {
     //
     //
 
+    // Simple functions that are common to Vensim and XMILE/Stella
     case '_ABS':
     case '_ARCCOS':
     case '_ARCSIN':
     case '_ARCTAN':
     case '_COS':
     case '_EXP':
-    case '_GAMMA_LN':
     case '_IF_THEN_ELSE':
-    case '_INTEGER':
     case '_LN':
     case '_MAX':
     case '_MIN':
-    case '_MODULO':
-    case '_POW':
-    case '_POWER':
-    case '_PULSE':
-    case '_PULSE_TRAIN':
-    case '_QUANTUM':
     case '_RAMP':
     case '_SIN':
     case '_SQRT':
     case '_STEP':
     case '_TAN':
+      return generateSimpleFunctionCall(fnId)
+
+    // Simple functions supported by Vensim only
+    case '_GAMMA_LN':
+    case '_INTEGER':
+    case '_MODULO':
+    case '_POW':
+    case '_POWER':
+    case '_PULSE_TRAIN':
+    case '_PULSE':
+    case '_QUANTUM':
     case '_WITH_LOOKUP':
     case '_XIDZ':
-    case '_ZIDZ': {
-      const args = callExpr.args.map(argExpr => generateExpr(argExpr, ctx))
+    case '_ZIDZ':
       if (ctx.outFormat === 'js' && fnId === '_GAMMA_LN') {
         throw new Error(`${callExpr.fnName} function not yet implemented for JS code gen`)
       }
-      if (ctx.outFormat === 'js' && fnId === '_IF_THEN_ELSE') {
-        // When generating conditional expressions for JS target, since we can't rely on macros like we do for C,
-        // it is better to translate it into a ternary instead of relying on a built-in function (since the latter
-        // would require always evaluating both branches, while the former can be more optimized by the interpreter)
-        return `((${args[0]}) ? (${args[1]}) : (${args[2]}))`
-      } else {
-        // For simple functions, emit a C/JS function call with a generated C/JS expression for each argument
-        return `${fnRef(fnId, ctx)}(${args.join(', ')})`
-      }
-    }
+      return generateSimpleFunctionCall(fnId)
+
+    // Simple functions supported by XMILE/Stella only
+    case '_INT':
+      // XMILE/Stella uses `INT`, but it is the same as the Vensim `INTEGER` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_INTEGER')
+    case '_MOD':
+      // XMILE/Stella uses `MOD`, but it is the same as the Vensim `MODULO` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_MODULO')
+    case '_SAFEDIV':
+      // XMILE/Stella uses `SAFEDIV`, but it is the same as the Vensim `ZIDZ` function,
+      // which is the name used in the runtime function implementation
+      return generateSimpleFunctionCall('_ZIDZ')
 
     //
     //
@@ -225,17 +253,12 @@ function generateFunctionCall(callExpr, ctx) {
     //
     //
 
+    // Lookup functions supported by Vensim only
     case '_GET_DATA_BETWEEN_TIMES':
     case '_LOOKUP_BACKWARD':
     case '_LOOKUP_FORWARD':
-    case '_LOOKUP_INVERT': {
-      // For LOOKUP* functions, the first argument must be a reference to the lookup variable.  Emit
-      // a C/JS function call with a generated C/JS expression for each remaining argument.
-      const cVarRef = ctx.cVarRef(callExpr.args[0])
-      const cArgs = callExpr.args.slice(1).map(arg => generateExpr(arg, ctx))
-      return `${fnRef(fnId, ctx)}(${cVarRef}, ${cArgs.join(', ')})`
-    }
-
+    case '_LOOKUP_INVERT':
+      return generateLookupFunctionCall(fnId)
     case '_GAME': {
       // For the GAME function, emit a C/JS function call that has the synthesized game inputs lookup
       // as the first argument, followed by the default value argument from the function call
@@ -244,6 +267,16 @@ function generateFunctionCall(callExpr, ctx) {
       return `${fnRef(fnId, ctx)}(${cLookupArg}, ${cDefaultArg})`
     }
 
+    // Lookup functions supported by XMILE/Stella only
+    case '_LOOKUP':
+      // XMILE/Stella has an explicit `LOOKUP` function while Vensim uses `x(y)` syntax, but
+      // underneath both are implemented at runtime by the `LOOKUP` function
+      return generateLookupFunctionCall('_LOOKUP')
+    case '_LOOKUPINV':
+      // XMILE/Stella uses `LOOKUPINV`, but it is the same as the Vensim `LOOKUP INVERT` function,
+      // which is the name used in the runtime function implementation
+      return generateLookupFunctionCall('_LOOKUP_INVERT')
+
     //
     //
     // Level functions
@@ -251,12 +284,16 @@ function generateFunctionCall(callExpr, ctx) {
     //
 
     case '_ACTIVE_INITIAL':
+    case '_DELAY':
     case '_DELAY_FIXED':
     case '_DEPRECIATE_STRAIGHTLINE':
     case '_SAMPLE_IF_TRUE':
     case '_INTEG':
       // Split level functions into init and eval expressions
-      if (ctx.outFormat === 'js' && (fnId === '_DELAY_FIXED' || fnId === '_DEPRECIATE_STRAIGHTLINE')) {
+      if (
+        ctx.outFormat === 'js' &&
+        (fnId === '_DELAY' || fnId === '_DELAY_FIXED' || fnId === '_DEPRECIATE_STRAIGHTLINE')
+      ) {
         throw new Error(`${callExpr.fnName} function not yet implemented for JS code gen`)
       }
       if (ctx.mode.startsWith('init')) {
@@ -311,7 +348,12 @@ function generateFunctionCall(callExpr, ctx) {
     case '_SMOOTH':
     case '_SMOOTHI':
     case '_SMOOTH3':
-    case '_SMOOTH3I': {
+    case '_SMOOTH3I':
+    case '_SMTH1':
+    case '_SMTH3': {
+      // Note that Vensim uses `SMOOTH[I]` and `SMOOTH3[I]` while XMILE uses `SMTH1` and
+      // `SMTH3`, but otherwise they have been translated the same way during the read
+      // equations phase
       const smoothVar = Model.varWithRefId(ctx.variable.smoothVarRefId)
       return ctx.cVarRef(smoothVar.parsedEqn.lhs.varDef)
     }
@@ -345,11 +387,13 @@ function generateFunctionCall(callExpr, ctx) {
       }
       return generateAllocateAvailableCall(callExpr, ctx)
 
-    case '_ELMCOUNT': {
-      // Emit the size of the dimension in place of the dimension name
+    case '_ELMCOUNT':
+    case '_SIZE': {
+      // Emit the size of the dimension in place of the dimension name. Note that Vensim uses
+      // `ELMCOUNT` while XMILE uses `SIZE`, but otherwise they are the same.
       const dimArg = callExpr.args[0]
       if (dimArg.kind !== 'variable-ref') {
-        throw new Error('Argument for ELMCOUNT must be a dimension name')
+        throw new Error(`Argument for ${callExpr.fnName} must be a dimension name`)
       }
       const dimId = dimArg.varId
       return `${sub(dimId).size}`
@@ -362,7 +406,9 @@ function generateFunctionCall(callExpr, ctx) {
       throw new Error(`Unexpected function '${fnId}' in code gen for '${ctx.variable.modelLHS}'`)
 
     case '_INITIAL':
-      // In init mode, only emit the initial expression without the INITIAL function call
+    case '_INIT':
+      // Note that Vensim uses `INITIAL` while XMILE uses `INIT`, but otherwise they are the same.
+      // In init mode, only emit the initial expression without the INITIAL function call.
       if (ctx.mode.startsWith('init')) {
         return generateExpr(callExpr.args[0], ctx)
       } else {
@@ -423,6 +469,7 @@ function generateLevelInit(callExpr, ctx) {
     case '_INTEG':
       initialArgIndex = 1
       break
+    case '_DELAY':
     case '_DELAY_FIXED': {
       // Emit the code that initializes the `FixedDelay` support struct
       const fixedDelay = ctx.cVarRefWithLhsSubscripts(ctx.variable.fixedDelayVarName)
@@ -474,12 +521,15 @@ function generateLevelEval(callExpr, ctx) {
       // For ACTIVE INITIAL, emit the first arg without a function call
       return generateExpr(callExpr.args[0], ctx)
 
+    case '_DELAY':
     case '_DELAY_FIXED': {
-      // For DELAY FIXED, emit the first arg followed by the FixedDelay support var
+      // Stella's DELAY function is behaviorally equivalent to Vensim's DELAY FIXED function, so
+      // they use the same `_DELAY_FIXED` runtime function.  For these, emit the first arg
+      // followed by the FixedDelay support var.
       const args = []
       args.push(generateExpr(callExpr.args[0], ctx))
       args.push(ctx.cVarRefWithLhsSubscripts(ctx.variable.fixedDelayVarName))
-      return generateCall(args)
+      return `${fnRef('_DELAY_FIXED', ctx)}(${args.join(', ')})`
     }
 
     case '_DEPRECIATE_STRAIGHTLINE': {

package/src/index.js

@@ -35,7 +35,15 @@ export function parseInlineVensimModel(mdlContent /*: string*/, modelDir /*?: st
   // 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 })
+  return parseModel(mdlContent, 'vensim', 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 parseInlineXmileModel(mdlContent /*: string*/, modelDir /*?: string*/) /*: ParsedModel*/ {
+  return parseModel(mdlContent, 'xmile', modelDir)
 }
 
 /**

package/src/model/model.js

@@ -1,7 +1,9 @@
 import * as R from 'ramda'
 
+import { canonicalVarId, toPrettyString } from '@sdeverywhere/parse'
+
 import B from '../_shared/bufx.js'
-import { canonicalVensimName, decanonicalize, isIterable, strlist, vlog, vsort } from '../_shared/helpers.js'
+import { decanonicalize, isIterable, strlist, vlog, vsort } from '../_shared/helpers.js'
 import {
   addIndex,
   allAliases,
@@ -15,7 +17,7 @@ import {
 import { cName } from '../_shared/var-names.js'
 
 import { expandVar } from './expand-var-instances.js'
-import { readEquation } from './read-equations.js'
+import { readEquation, resolveXmileDimensionWildcards } from './read-equations.js'
 import { readDimensionDefs } from './read-subscripts.js'
 import { readVariables } from './read-variables.js'
 import { reduceVariables } from './reduce-variables.js'
@@ -92,10 +94,80 @@ function read(parsedModel, spec, extData, directData, modelDirname, opts) {
   timeVar.varName = '_time'
   vars.push(timeVar)
 
+  // Helper function to define a control variable for XMILE models
+  function defineXmileControlVar(varName, varId, rhsValue) {
+    let rhsExpr
+    if (typeof rhsValue === 'number') {
+      rhsExpr = {
+        kind: 'number',
+        value: rhsValue,
+        text: rhsValue.toString()
+      }
+    } else {
+      rhsExpr = {
+        kind: 'variable-ref',
+        varName: rhsValue,
+        varId: canonicalVarId(rhsValue)
+      }
+    }
+    const v = new Variable()
+    v.modelLHS = varName
+    v.varName = varId
+    v.parsedEqn = {
+      lhs: {
+        varDef: {
+          varName,
+          varId
+        }
+      },
+      rhs: {
+        kind: 'expr',
+        expr: rhsExpr
+      }
+    }
+    v.modelFormula = toPrettyString(rhsExpr, { compact: true })
+    v.includeInOutput = false
+    vars.push(v)
+  }
+
+  if (parsedModel.kind === 'xmile') {
+    // XXX: Unlike Vensim models, XMILE models do not include the control parameters as
+    // normal model equations; instead, they are defined in the `<sim_specs>` element.
+    // In addition, XMILE allows these values to be accessed in equations (e.g., `<start>`
+    // can be accessed as `STARTTIME`, `<stop>` as `STOPTIME`, and `<dt>` as `DT`).
+    // For compatibility with the existing runtime code (which expects these variables
+    // to be defined using the Vensim names), we will synthesize variables using the
+    // Vensim names (e.g., `INITIAL TIME`) and also synthesize variables that derive
+    // from these using the XMILE names (e.g., `STARTTIME`).
+    defineXmileControlVar('INITIAL TIME', '_initial_time', parsedModel.root.simulationSpec.startTime)
+    defineXmileControlVar('FINAL TIME', '_final_time', parsedModel.root.simulationSpec.endTime)
+    defineXmileControlVar('TIME STEP', '_time_step', parsedModel.root.simulationSpec.timeStep)
+    defineXmileControlVar('STARTTIME', '_starttime', 'INITIAL TIME')
+    defineXmileControlVar('STOPTIME', '_stoptime', 'FINAL TIME')
+    defineXmileControlVar('DT', '_dt', 'TIME STEP')
+    // XXX: For now, also include a `SAVEPER` variable that is the same as `TIME STEP` (is there
+    // an equivalent of this in XMILE?)
+    defineXmileControlVar('SAVEPER', '_saveper', 'TIME STEP')
+  }
+
   // Add the variables to the `Model`
   vars.forEach(addVariable)
   if (opts?.stopAfterReadVariables) return
 
+  if (parsedModel.kind === 'xmile') {
+    // XXX: In the case of XMILE, we need to resolve any wildcards used in dimension
+    // position in the RHS of the equation
+    for (const variable of vars) {
+      if (variable.parsedEqn?.rhs?.kind === 'expr') {
+        const updatedEqn = resolveXmileDimensionWildcards(variable)
+        if (updatedEqn) {
+          variable.parsedEqn = updatedEqn
+          variable.modelFormula = toPrettyString(updatedEqn.rhs.expr, { compact: true })
+        }
+      }
+    }
+  }
+
   if (spec) {
     // 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
@@ -268,7 +340,7 @@ function resolveDimensions(dimensionFamilies) {
   }
 }
 
-function analyze(parsedModelKind, inputVars, opts) {
+function analyze(modelKind, 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.
   findNonAtoAVars()
@@ -284,7 +356,9 @@ function analyze(parsedModelKind, inputVars, opts) {
   if (opts?.stopAfterReduceVariables === true) return
 
   // Read the RHS to list the refIds of vars that are referenced and set the var type.
-  variables.forEach(readEquation)
+  variables.forEach(v => {
+    readEquation(v, modelKind)
+  })
 }
 
 function checkSpecVars(spec) {
@@ -1221,7 +1295,7 @@ function jsonList() {
 
       const varInstances = expandVar(v)
       for (const { varName, subscriptIndices } of varInstances) {
-        const varId = canonicalVensimName(varName)
+        const varId = canonicalVarId(varName)
         const varItem = {
           varId,
           varName,

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

@@ -16,10 +16,12 @@ import Model from './model.js'
 /**
  * Generate level and aux variables that implement one of the following `DELAY` function
  * call variants:
- * - DELAY1
- * - DELAY1I
- * - DELAY3
- * - DELAY3I
+ * - DELAY1 (Vensim)
+ * - DELAY1I (Vensim)
+ * - DELAY3 (Vensim)
+ * - DELAY3I (Vensim)
+ * - DELAY1 (Stella)
+ * - DELAY3 (Stella)
  *
  * TODO: Docs
  *