@sdeverywhere/cli 0.7.23 → 0.7.24

package/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2022 Todd Fincannon and Climate Interactive / New Venture Fund
+Copyright (c) 2016-2024 Todd Fincannon and Climate Interactive / New Venture Fund
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sdeverywhere/cli",
-  "version": "0.7.23",
+  "version": "0.7.24",
   "description": "Contains the `sde` command line interface for the SDEverywhere tool suite.",
   "type": "module",
   "files": [
@@ -11,8 +11,8 @@
     "sde": "src/main.js"
   },
   "dependencies": {
-    "@sdeverywhere/build": "^0.3.4",
-    "@sdeverywhere/compile": "^0.7.17",
+    "@sdeverywhere/build": "^0.3.5",
+    "@sdeverywhere/compile": "^0.7.18",
     "bufx": "^1.0.5",
     "byline": "^5.0.0",
     "ramda": "^0.27.0",

package/src/c/model.c

@@ -8,14 +8,6 @@
 struct timespec startTime, finishTime;
 #endif
 
-// For each output variable specified in the indices buffer, there
-// are 4 index values:
-//   varIndex
-//   subIndex0
-//   subIndex1
-//   subIndex2
-#define INDICES_PER_OUTPUT 4
-
 // The special _time variable is not included in .mdl files.
 double _time;
 
@@ -75,13 +67,6 @@ double getSaveper() {
   return _saveper;
 }
 
-/**
- * Return the constant `maxOutputIndices` value.
- */
-int getMaxOutputIndices() {
-  return maxOutputIndices;
-}
-
 char* run_model(const char* inputs) {
   // run_model does everything necessary to run the model with the given inputs.
   // It may be called multiple times. Call finish() after all runs are complete.
@@ -157,18 +142,19 @@ void run() {
       outputVarIndex = 0;
       if (outputIndexBuffer != NULL) {
         // Store the outputs as specified in the current output index buffer
-        for (size_t i = 0; i < maxOutputIndices; i++) {
-          size_t indexBufferOffset = i * INDICES_PER_OUTPUT;
-          size_t varIndex = (size_t)outputIndexBuffer[indexBufferOffset];
-          if (varIndex > 0) {
-            size_t subIndex0 = (size_t)outputIndexBuffer[indexBufferOffset + 1];
-            size_t subIndex1 = (size_t)outputIndexBuffer[indexBufferOffset + 2];
-            size_t subIndex2 = (size_t)outputIndexBuffer[indexBufferOffset + 3];
-            storeOutput(varIndex, subIndex0, subIndex1, subIndex2);
+        size_t indexBufferOffset = 0;
+        size_t outputCount = (size_t)outputIndexBuffer[indexBufferOffset++];
+        for (size_t i = 0; i < outputCount; i++) {
+          size_t varIndex = (size_t)outputIndexBuffer[indexBufferOffset++];
+          size_t subCount = (size_t)outputIndexBuffer[indexBufferOffset++];
+          size_t* subIndices;
+          if (subCount > 0) {
+            subIndices = (size_t*)(outputIndexBuffer + indexBufferOffset);
           } else {
-            // Stop when we reach the first zero index
-            break;
+            subIndices = NULL;
           }
+          indexBufferOffset += subCount;
+          storeOutput(varIndex, subIndices);
         }
       } else {
         // Store the normal outputs

package/src/c/sde.h

@@ -42,7 +42,6 @@ EXTERN double _epsilon;
 
 // Internal variables
 EXTERN const int numOutputs;
-EXTERN const int maxOutputIndices;
 
 // Standard simulation control parameters
 EXTERN double _time;
@@ -67,10 +66,11 @@ void initConstants(void);
 void initLevels(void);
 void setInputs(const char* inputData);
 void setInputsFromBuffer(double *inputData);
+void setLookup(size_t varIndex, size_t* subIndices, double* points, size_t numPoints);
 void evalAux(void);
 void evalLevels(void);
 void storeOutputData(void);
-void storeOutput(size_t varIndex, size_t subIndex0, size_t subIndex1, size_t subIndex2);
+void storeOutput(size_t varIndex, size_t* subIndices);
 const char* getHeader(void);
 
 #ifdef __cplusplus

package/src/c/vensim.c

@@ -94,7 +94,7 @@ double __lookup(Lookup* lookup, double input, bool use_inverted_data, LookupMode
   // Interpolate the y value from an array of (x,y) pairs.
   // NOTE: The x values are assumed to be monotonically increasing.
 
-  if (lookup == NULL) {
+  if (lookup == NULL || lookup->n == 0) {
     return _NA_;
   }
 
@@ -162,9 +162,16 @@ double __lookup(Lookup* lookup, double input, bool use_inverted_data, LookupMode
 // This function is similar to `__lookup` in concept, but Vensim produces results for
 // the GET DATA BETWEEN TIMES function that differ in unexpected ways from normal lookup
 // behavior, so we implement it as a separate function here.
-double __get_data_between_times(double* data, size_t n, double input, LookupMode mode) {
+double __get_data_between_times(Lookup* lookup, double input, LookupMode mode) {
   // Interpolate the y value from an array of (x,y) pairs.
   // NOTE: The x values are assumed to be monotonically increasing.
+
+  if (lookup == NULL || lookup->n == 0) {
+    return _NA_;
+  }
+
+  const double* data = lookup->data;
+  const size_t n = lookup->n;
   const size_t max = n * 2;
 
   switch (mode) {
@@ -253,6 +260,23 @@ double _LOOKUP_INVERT(Lookup* lookup, double y) {
   return __lookup(lookup, y, true, Interpolate);
 }
 
+double _GAME(Lookup* lookup, double default_value) {
+  if (lookup == NULL || lookup->n <= 0) {
+    // The lookup is NULL or empty, so return the default value
+    return default_value;
+  }
+
+  double x0 = lookup->data[0];
+  if (_time < x0) {
+    // The current time is earlier than the first data point, so return the
+    // default value
+    return default_value;
+  }
+
+  // For all other cases, we can use `__lookup` with `Backward` mode
+  return __lookup(lookup, _time, false, Backward);
+}
+
 typedef struct {
   double x;
   int ind;

package/src/c/vensim.h

@@ -21,7 +21,6 @@ extern "C" {
 #define _ARCTAN(x) atan(x)
 #define _COS(x) cos(x)
 #define _EXP(x) exp(x)
-#define _GAME(x) (x)
 #define _GAMMA_LN(x) lgamma(x)
 #define _IF_THEN_ELSE(c, t, f) (bool_cond(c) ? (t) : (f))
 #define _INTEG(value, rate) ((value) + (rate) * _time_step)
@@ -74,9 +73,11 @@ double __lookup(Lookup *lookup, double input, bool use_inverted_data, LookupMode
 #define _WITH_LOOKUP(x, lookup) __lookup(lookup, x, false, Interpolate)
 double _LOOKUP_INVERT(Lookup* lookup, double y);
 
-double __get_data_between_times(double *data, size_t n, double input, LookupMode mode);
+double __get_data_between_times(Lookup* lookup, double input, LookupMode mode);
 #define _GET_DATA_MODE_TO_LOOKUP_MODE(mode) ((mode) >= 1) ? Forward : (((mode) <= -1) ? Backward : Interpolate)
-#define _GET_DATA_BETWEEN_TIMES(lookup, x, mode) __get_data_between_times((lookup)->data, (lookup)->n, x, _GET_DATA_MODE_TO_LOOKUP_MODE(mode))
+#define _GET_DATA_BETWEEN_TIMES(lookup, x, mode) __get_data_between_times(lookup, x, _GET_DATA_MODE_TO_LOOKUP_MODE(mode))
+
+double _GAME(Lookup* lookup, double default_value);
 
 //
 // DELAY FIXED

package/src/sde-build.js

@@ -1,6 +1,11 @@
+import { writeFileSync } from 'fs'
+import { resolve } from 'path'
+
 import { generate } from './sde-generate.js'
 import { compile } from './sde-compile.js'
 
+import { buildDir, modelPathProps } from './utils.js'
+
 export let command = 'build [options] <model>'
 export let describe = 'generate model code and compile it'
 export let builder = {
@@ -9,6 +14,11 @@ export let builder = {
     type: 'string',
     alias: 's'
   },
+  genformat: {
+    describe: 'generated code format',
+    choices: ['js', 'c'],
+    default: 'js'
+  },
   builddir: {
     describe: 'build directory',
     type: 'string',
@@ -20,9 +30,17 @@ export let handler = argv => {
 }
 export let build = async (model, opts) => {
   try {
-    opts.genc = true
+    // Generate code in JS or C format
+    opts.outformat = opts.genformat || 'js'
     await generate(model, opts)
-    compile(model, opts)
+    if (opts.outformat === 'js') {
+      // Write a `main.js` file that can be used by `sde exec` to execute the model
+      // on the command line using Node.js
+      writeMainJs(model, opts)
+    } else if (opts.outformat === 'c') {
+      // Compile the generated C code to a native executable
+      compile(model, opts)
+    }
   } catch (e) {
     // Exit with a non-zero error code if any step failed
     console.error(`ERROR: ${e.message}\n`)
@@ -37,3 +55,19 @@ export default {
   handler,
   build
 }
+
+/**
+ * Write a minimal `main.js` file that can be used by `sde exec` to execute a
+ * generated JS model.
+ */
+let writeMainJs = (model, opts) => {
+  let { modelDirname, modelName } = modelPathProps(model)
+  let buildDirname = buildDir(opts.builddir, modelDirname)
+  const mainJsFile = resolve(buildDirname, 'main.js')
+  let mainJs = ''
+  mainJs += '#!/usr/bin/env node\n'
+  mainJs += `import { execJsModel } from '@sdeverywhere/runtime'\n`
+  mainJs += `import loadJsModel from './${modelName}.js'\n`
+  mainJs += 'execJsModel(await loadJsModel())\n'
+  writeFileSync(mainJsFile, mainJs, { mode: 0o755 })
+}

package/src/sde-causes.js

@@ -21,11 +21,15 @@ let causes = (model, varname, opts) => {
   let directData = new Map()
   let spec = parseSpec(opts.spec)
   // Preprocess model text into parser input.
+  // TODO: The legacy `parseModel` function previously required the `preprocessModel`
+  // step to be performed first, but the new `parseModel` runs the preprocessor
+  // implicitly, so we can remove this step (and can simplify this code to use
+  // `parseAndGenerate` instead)
   let input = preprocessModel(modelPathname, spec)
   // Parse the model to get variable and subscript information.
-  let parseTree = parseModel(input)
+  let parsedModel = parseModel(input, modelDirname)
   let operations = ['printRefGraph']
-  generateCode(parseTree, { spec, operations, extData, directData, modelDirname, varname })
+  generateCode(parsedModel, { spec, operations, extData, directData, modelDirname, varname })
 }
 export default {
   command,

package/src/sde-exec.js

@@ -1,3 +1,4 @@
+import { existsSync } from 'fs'
 import path from 'path'
 
 import { buildDir, execCmd, modelPathProps, outputDir } from './utils.js'
@@ -24,8 +25,22 @@ export let exec = (model, opts) => {
   // Ensure the build and output directories exist.
   let buildDirname = buildDir(opts.builddir, modelDirname)
   let outputDirname = outputDir(opts.outfile, modelDirname)
+  // If `main.js` exists, it means that the generated code format
+  // is JS, so run that file, otherwise we assume the generated
+  // code format is C and that there is a native executable with
+  // the same name as the model.
+  let mainJs = path.join(buildDirname, 'main.js')
+  let mainC = path.join(buildDirname, modelName)
+  let modelCmd
+  if (existsSync(mainJs)) {
+    modelCmd = mainJs
+  } else if (existsSync(mainC)) {
+    modelCmd = mainC
+  } else {
+    console.error('ERROR: No executable model found in build directory')
+    process.exit(1)
+  }
   // Run the model and capture output in the model directory.
-  let modelCmd = `${buildDirname}/${modelName}`
   let outputPathname
   if (opts.outfile) {
     outputPathname = opts.outfile

package/src/sde-flatten.js

@@ -46,7 +46,7 @@ const flatten = async (outFile, inFiles, opts) => {
 
     // Preprocess the mdl file and extract the equations
     const decls = []
-    preprocessModel(inModelProps.modelPathname, undefined, 'genc', false, decls)
+    preprocessModel(inModelProps.modelPathname, undefined, 'runnable', false, decls)
 
     // Associate each declaration with the name of the model from which it came
     for (const decl of decls) {

package/src/sde-generate.js

@@ -8,12 +8,18 @@ import { buildDir, modelPathProps, parseSpec } from './utils.js'
 export let command = 'generate [options] <model>'
 export let describe = 'generate model code'
 export let builder = {
+  // TODO: The old `--genc` option is deprecated and replaced by `--outformat=c`
   genc: {
     describe: 'generate C code for the model',
-    type: 'boolean'
+    type: 'boolean',
+    hidden: true
+  },
+  outformat: {
+    describe: 'write generated code in the given format',
+    choices: ['js', 'c']
   },
   list: {
-    describe: 'list model variables',
+    describe: 'write a file that lists model variables',
     type: 'boolean',
     alias: 'l'
   },
@@ -60,8 +66,8 @@ export let generate = async (model, opts) => {
   let buildDirname = buildDir(opts.builddir, modelDirname)
   // Preprocess model text into parser input. Stop now if that's all we're doing.
   let spec = parseSpec(opts.spec)
-  // Produce a runnable model with the "genc" and "preprocess" options.
-  let profile = opts.analysis ? 'analysis' : 'genc'
+  // Produce a runnable model with the "runnable" and "preprocess" options.
+  let profile = opts.analysis ? 'analysis' : 'runnable'
   // Write the preprocessed model and removals if the option is "analysis" or "preprocess".
   let writeFiles = opts.analysis || opts.preprocess
   let input = preprocessModel(modelPathname, spec, profile, writeFiles)
@@ -73,7 +79,13 @@ export let generate = async (model, opts) => {
   // Parse the model and generate code. If no operation is specified, the code generator will
   // read the model and do nothing else. This is required for the list operation.
   let operations = []
-  if (opts.genc) {
+  if (opts.outformat === 'js') {
+    operations.push('generateJS')
+  }
+  if (opts.genc || opts.outformat === 'c') {
+    if (opts.genc) {
+      console.warn(`WARNING: --genc option is deprecated for the 'sde generate' command; use --outformat=c instead`)
+    }
     operations.push('generateC')
   }
   if (opts.list) {

package/src/sde-run.js

@@ -9,6 +9,11 @@ export let builder = {
     type: 'string',
     alias: 's'
   },
+  genformat: {
+    describe: 'generated code format',
+    choices: ['js', 'c'],
+    default: 'js'
+  },
   builddir: {
     describe: 'build directory',
     type: 'string',

package/src/sde-test.js

@@ -13,6 +13,11 @@ export let builder = {
     type: 'string',
     alias: 's'
   },
+  genformat: {
+    describe: 'generated code format',
+    choices: ['js', 'c'],
+    default: 'js'
+  },
   builddir: {
     describe: 'build directory',
     type: 'string',