@sdeverywhere/compile 0.7.27 → 0.7.28

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.27",
+  "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-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
  *

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

@@ -15,10 +15,12 @@ import Model from './model.js'
 /**
  * Generate level and aux variables that implement one of the following `SMOOTH` function
  * call variants:
- * - SMOOTH
- * - SMOOTHI
- * - SMOOTH3
- * - SMOOTH3I
+ * - SMOOTH (Vensim)
+ * - SMOOTHI (Vensim)
+ * - SMOOTH3 (Vensim)
+ * - SMOOTH3I (Vensim)
+ * - SMTH1 (Stella)
+ * - SMTH3 (Stella)
  *
  * TODO: Docs
  *
@@ -43,7 +45,7 @@ export function generateSmoothVariables(v, callExpr, context) {
   }
 
   const fnId = callExpr.fnId
-  if (fnId === '_SMOOTH' || fnId === '_SMOOTHI') {
+  if (fnId === '_SMOOTH' || fnId === '_SMOOTHI' || fnId === '_SMTH1') {
     // Generate 1 level variable that will replace the `SMOOTH[I]` function call
     const level = generateSmoothLevel(v, context, argInput, argDelay, argInit, 1)
     // For `SMOOTH[I]`, the smoothVarRefId is the level var's refId

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

@@ -3,7 +3,7 @@ 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.
+ * Generate two level variables and one aux that implement an `TREND` function call.
  *
  * TODO: Docs
  *