@sdeverywhere/compile 0.7.26 → 0.7.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.26",
+  "version": "0.7.27",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",

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,