@sdeverywhere/compile 0.7.25 → 0.7.27

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.25",
+  "version": "0.7.27",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
     "@sdeverywhere/parse": "^0.1.2",
-    "bufx": "^1.0.5",
     "byline": "^5.0.0",
     "csv-parse": "^5.3.3",
-    "js-yaml": "^3.13.1",
     "ramda": "^0.27.0",
+    "strip-bom": "^5.0.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz"
   },
   "author": "Climate Interactive",

package/src/_shared/bufx.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs'
+import stripBom from 'strip-bom'
+
+// Numeric value of a string or number
+let num = x => (typeof x === 'number' ? x : Number.parseFloat(x))
+// Split a string into lines that may have Windows, Unix, or old Mac line endings.
+let lines = s => s.split(/\r\n|\n|\r/)
+// Print a string to the console
+let print = s => {
+  console.log(s)
+}
+// Read a UTF-8 file into a string. Strip the BOM if present.
+let read = pathname => stripBom(fs.readFileSync(pathname, 'utf8'))
+// Write a string to a UTF-8 file
+let write = (s, pathname) => {
+  fs.writeFileSync(pathname, s, { encoding: 'utf8' })
+}
+
+// Output buffer
+let bufs = { _: '' }
+// Open a buffer for writing
+let open = channel => (bufs[channel] = '')
+// Emit a string to a buffer
+let emit = (a, channel = null) => {
+  channel = channel || '_'
+  bufs[channel] += a
+}
+// Emit a string to a buffer terminated by a newline
+let emitLine = (a, channel = null) => {
+  channel = channel || '_'
+  bufs[channel] += a + '\n'
+}
+// Print a buffer to the console
+let printBuf = (channel = null) => {
+  channel = channel || '_'
+  print(bufs[channel])
+}
+// Write a buffer to a file
+let writeBuf = (pathname, channel = null) => {
+  channel = channel || '_'
+  write(bufs[channel], pathname)
+}
+// Get buffer contents as a string
+let getBuf = (channel = null) => {
+  channel = channel || '_'
+  return bufs[channel]
+}
+// Clear a buffer
+let clearBuf = (channel = null) => {
+  channel = channel || '_'
+  bufs[channel] = ''
+}
+
+export default {
+  clearBuf,
+  emit,
+  emitLine,
+  getBuf,
+  lines,
+  num,
+  open,
+  printBuf,
+  read,
+  write,
+  writeBuf
+}

package/src/_shared/helpers.js

@@ -1,9 +1,9 @@
 import * as fs from 'node:fs'
 import util from 'util'
-import B from 'bufx'
 import { parse as parseCsv } from 'csv-parse/sync'
 import * as R from 'ramda'
 import XLSX from 'xlsx'
+import B from './bufx.js'
 
 import { canonicalId, canonicalVarId } from '@sdeverywhere/parse'
 

package/src/_shared/read-dat.js

@@ -1,8 +1,8 @@
 import fs from 'fs'
-import B from 'bufx'
 import byline from 'byline'
 import * as R from 'ramda'
 
+import B from './bufx.js'
 import { canonicalVensimName } from './helpers.js'
 
 /**

package/src/_shared/subscript.js

@@ -1,7 +1,6 @@
 import util from 'util'
-import B from 'bufx'
-import yaml from 'js-yaml'
 import * as R from 'ramda'
+import B from './bufx.js'
 import { canonicalName, vlog } from './helpers.js'
 
 // A subscript is a dimension or an index.
@@ -218,21 +217,6 @@ export function printSubscripts() {
   }
   return B.getBuf()
 }
-export function yamlSubsList() {
-  let subs = {}
-  for (let [k, v] of subscripts) {
-    subs[k] = v
-  }
-  return yaml.safeDump(subs)
-}
-export function loadSubscriptsFromYaml(yamlSubs) {
-  // Load the subscripts map from subscripts serialized to a YAML file by yamlSubsList.
-  // This function should be called instead of adding subscripts through the constructor.
-  let subs = yaml.safeLoad(yamlSubs)
-  for (const k in subs) {
-    subscripts.set(k, subs[k])
-  }
-}
 export function extractMarkedDims(subscripts) {
   // Extract all marked dimensions and update subscripts.
   let dims = []

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/model/model.js

@@ -1,7 +1,6 @@
-import B from 'bufx'
-import yaml from 'js-yaml'
 import * as R from 'ramda'
 
+import B from '../_shared/bufx.js'
 import { canonicalVensimName, decanonicalize, isIterable, strlist, vlog, vsort } from '../_shared/helpers.js'
 import {
   addIndex,
@@ -946,14 +945,6 @@ function printVarList() {
   }
   return B.getBuf()
 }
-function yamlVarList() {
-  // Print selected properties of all variable objects to a YAML string.
-  let vars = R.sortBy(
-    R.prop('refId'),
-    R.map(v => filterVar(v), variables)
-  )
-  return yaml.safeDump(vars)
-}
 function printVar(v) {
   let nonAtoA = isNonAtoAName(v.varName) ? ' (non-apply-to-all)' : ''
   B.emitLine(`${v.modelLHS}: ${v.varType}${nonAtoA}`)
@@ -1348,6 +1339,5 @@ export default {
   varsWithName,
   varWithName,
   varWithRefId,
-  vensimName,
-  yamlVarList
+  vensimName
 }

package/src/parse-and-generate.js

@@ -1,13 +1,13 @@
 // Copyright (c) 2022 Climate Interactive / New Venture Fund
 
 import path from 'path'
-import B from 'bufx'
 
 import { parseVensimModel } from '@sdeverywhere/parse'
 
+import B from './_shared/bufx.js'
 import { readXlsx } from './_shared/helpers.js'
 import { readDat } from './_shared/read-dat.js'
-import { printSubscripts, yamlSubsList } from './_shared/subscript.js'
+import { printSubscripts } from './_shared/subscript.js'
 import { cName } from './_shared/var-names.js'
 import Model from './model/model.js'
 import { getDirectSubscripts } from './model/read-subscripts.js'
@@ -21,7 +21,7 @@ import { generateCode } from './generate/gen-code.js'
  * - If `operations` has 'generateC', the generated C code will be written to `buildDir`.
  * - If `operations` has 'generateJS', the generated JS code will be written to `buildDir`.
  * - If `operations` has 'printVarList', variables and subscripts will be written to
- *   txt, yaml, and json files under `buildDir`.
+ *   txt and json files under `buildDir`.
  * - If `operations` has 'printRefIdTest', reference identifiers will be printed to the console.
  * - If `operations` has 'convertNames', no output will be generated, but the results of model
  *   analysis will be available.
@@ -92,10 +92,6 @@ export async function parseAndGenerate(input, spec, operations, modelDirname, mo
     writeOutput(`${modelName}_vars.txt`, Model.printVarList())
     // Write subscripts to a text file.
     writeOutput(`${modelName}_subs.txt`, printSubscripts())
-    // Write variables to a YAML file.
-    writeOutput(`${modelName}_vars.yaml`, Model.yamlVarList())
-    // Write subscripts to a YAML file.
-    writeOutput(`${modelName}_subs.yaml`, yamlSubsList())
     // Write variables and subscripts to a JSON file.
     const jsonList = Model.jsonList()
     writeOutput(`${modelName}.json`, JSON.stringify(jsonList.full, null, 2))