@sdeverywhere/compile 0.7.0

package/src/model/subscript-range-reader.js

@@ -0,0 +1,123 @@
+import path from 'path'
+import { ModelParser } from 'antlr4-vensim'
+import R from 'ramda'
+import XLSX from 'xlsx'
+
+import { cFunctionName, matchRegex, readCsv } from '../_shared/helpers.js'
+import { Subscript } from '../_shared/subscript.js'
+import ModelReader from '../parse/model-reader.js'
+
+export default class SubscriptRangeReader extends ModelReader {
+  constructor(modelDirname) {
+    super()
+    // The model directory is required when reading data files for GET DIRECT SUBSCRIPT.
+    this.modelDirname = modelDirname
+    // Index names from a subscript list or GET DIRECT SUBSCRIPT
+    this.indNames = []
+    // Dimension mappings with model names
+    this.modelMappings = []
+  }
+  visitModel(ctx) {
+    let subscriptRanges = ctx.subscriptRange()
+    if (subscriptRanges) {
+      for (let subscriptRange of subscriptRanges) {
+        subscriptRange.accept(this)
+      }
+    }
+  }
+  visitSubscriptRange(ctx) {
+    // When entering a new subscript range definition, reset the properties that will be filled in.
+    this.indNames = []
+    this.modelMappings = []
+    // A subscript alias has two Ids, while a regular subscript range definition has just one.
+    if (ctx.Id().length === 1) {
+      // Subscript range definitions have a dimension name.
+      let modelName = ctx.Id()[0].getText()
+      // Visit children to fill in the subscript range definition.
+      super.visitSubscriptRange(ctx)
+      // Create a new subscript range definition from Vensim-format names.
+      // The family is provisionally set to the dimension name.
+      // It will be updated to the maximal dimension if this is a subdimension.
+      // The mapping value contains dimensions and indices in the toDim.
+      // It will be expanded and inverted to fromDim indices later.
+      Subscript(modelName, this.indNames, modelName, this.modelMappings)
+    } else {
+      let modelName = ctx.Id()[0].getText()
+      let modelFamily = ctx.Id()[1].getText()
+      Subscript(modelName, '', modelFamily, [])
+    }
+  }
+  visitSubscriptList(ctx) {
+    // A subscript list can appear in either a subscript range or mapping.
+    let subscripts = R.map(id => id.getText(), ctx.Id())
+    if (ctx.parentCtx.ruleIndex === ModelParser.RULE_subscriptRange) {
+      this.indNames = subscripts
+    }
+    if (ctx.parentCtx.ruleIndex === ModelParser.RULE_subscriptMapping) {
+      this.mappingValue = subscripts
+    }
+  }
+  visitSubscriptMapping(ctx) {
+    let toDim = ctx.Id().getText()
+    // If a subscript list is part of the mapping, mappingValue will be set by visitSubscriptList.
+    this.mappingValue = []
+    super.visitSubscriptMapping(ctx)
+    this.modelMappings.push({ toDim, value: this.mappingValue })
+  }
+  visitSubscriptSequence(ctx) {
+    // Construct index names from the sequence start and end indices.
+    // This assumes the indices begin with the same string and end with numbers.
+    let r = /^(.*?)(\d+)$/
+    let ids = R.map(id => id.getText(), ctx.Id())
+    let matches = R.map(id => r.exec(id), ids)
+    if (matches[0][1] === matches[1][1]) {
+      let prefix = matches[0][1]
+      let start = parseInt(matches[0][2])
+      let end = parseInt(matches[1][2])
+      for (let i = start; i <= end; i++) {
+        this.indNames.push(prefix + i)
+      }
+    }
+  }
+  visitCall(ctx) {
+    // A subscript range can have a GET DIRECT SUBSCRIPT call on the RHS.
+    let fn = cFunctionName(ctx.Id().getText())
+    if (fn === '_GET_DIRECT_SUBSCRIPT') {
+      super.visitCall(ctx)
+    }
+  }
+  visitExprList(ctx) {
+    // We assume the only call that ends up here is GET DIRECT SUBSCRIPT.
+    let args = R.map(
+      arg => matchRegex(arg, /'(.*)'/),
+      R.map(expr => expr.getText(), ctx.expr())
+    )
+    let pathname = args[0]
+    let delimiter = args[1]
+    let firstCell = args[2]
+    let lastCell = args[3]
+    // let prefix = args[4]
+    // If lastCell is a column letter, scan the column, else scan the row.
+    let dataAddress = XLSX.utils.decode_cell(firstCell)
+    let col = dataAddress.c
+    let row = dataAddress.r
+    let nextCell
+    if (isNaN(parseInt(lastCell))) {
+      nextCell = () => row++
+    } else {
+      nextCell = () => col++
+    }
+    // Read subscript names from the CSV file at the given position.
+    let csvPathname = path.resolve(this.modelDirname, pathname)
+    let data = readCsv(csvPathname, delimiter)
+    if (data) {
+      let indexName = data[row][col]
+      while (indexName != null) {
+        this.indNames.push(indexName)
+        nextCell()
+        indexName = data[row] != null ? data[row][col] : null
+      }
+    }
+    super.visitExprList(ctx)
+  }
+}

package/src/model/toposort.js

@@ -0,0 +1,100 @@
+// Modified from https://github.com/marcelklehr/toposort version 2.0.2
+
+/**
+ * Topological sorting function
+ *
+ * @param {Array} edges
+ * @returns {Array}
+ */
+
+export default function (edges) {
+  return toposort(uniqueNodes(edges), edges)
+}
+
+function toposort(nodes, edges) {
+  var cursor = nodes.length,
+    sorted = new Array(cursor),
+    visited = {},
+    i = cursor,
+    // Better data structures make algorithm much faster.
+    outgoingEdges = makeOutgoingEdges(edges),
+    nodesHash = makeNodesHash(nodes)
+
+  // check for unknown nodes
+  edges.forEach(function (edge) {
+    if (!nodesHash.has(edge[0]) || !nodesHash.has(edge[1])) {
+      throw new Error('Unknown node. There is an unknown node in the supplied edges.')
+    }
+  })
+
+  while (i--) {
+    if (!visited[i]) visit(nodes[i], i, new Set())
+  }
+
+  return sorted
+
+  function visit(node, i, predecessors) {
+    if (predecessors.has(node)) {
+      // debugger
+      var nodeRep
+      try {
+        nodeRep = '\n' + node + '\n'
+      } catch (e) {
+        nodeRep = ''
+      }
+      throw new Error('toposort cyclic dependency:\n' + [...predecessors].join(' →\n') + nodeRep)
+    }
+
+    if (!nodesHash.has(node)) {
+      throw new Error(
+        'Found unknown node. Make sure to provided all involved nodes. Unknown node: ' + JSON.stringify(node)
+      )
+    }
+
+    if (visited[i]) return
+    visited[i] = true
+
+    var outgoing = outgoingEdges.get(node) || new Set()
+    outgoing = Array.from(outgoing)
+
+    if ((i = outgoing.length)) {
+      predecessors.add(node)
+      do {
+        var child = outgoing[--i]
+        visit(child, nodesHash.get(child), predecessors)
+      } while (i)
+      predecessors.delete(node)
+    }
+
+    sorted[--cursor] = node
+  }
+}
+
+function uniqueNodes(arr) {
+  var res = new Set()
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i]
+    res.add(edge[0])
+    res.add(edge[1])
+  }
+  return Array.from(res)
+}
+
+function makeOutgoingEdges(arr) {
+  var edges = new Map()
+  for (var i = 0, len = arr.length; i < len; i++) {
+    var edge = arr[i]
+    if (!edges.has(edge[0])) edges.set(edge[0], new Set())
+    if (!edges.has(edge[1])) edges.set(edge[1], new Set())
+    edges.get(edge[0]).add(edge[1])
+  }
+  return edges
+}
+
+function makeNodesHash(arr) {
+  var res = new Map()
+  for (var i = 0, len = arr.length; i < len; i++) {
+    res.set(arr[i], i)
+  }
+  return res
+}

package/src/model/var-name-reader.js

@@ -0,0 +1,40 @@
+import R from 'ramda'
+
+import { canonicalName } from '../_shared/helpers.js'
+import { sub, isIndex, normalizeSubscripts } from '../_shared/subscript.js'
+import ModelReader from '../parse/model-reader.js'
+import { createParser } from '../parse/parser.js'
+
+//
+// VarNameReader reads a model var name using the parser to get the var name in C format.
+// This is used to generate a variable output in the output section.
+//
+export default class VarNameReader extends ModelReader {
+  constructor() {
+    super()
+    this.varName = ''
+  }
+  read(modelVarName) {
+    // Parse an individual model var name and convert it into a a canonical C var name.
+    // Parse a single var name, which may include subscripts.
+    let parser = createParser(modelVarName)
+    let tree = parser.lhs()
+    // Generate and return the canonical name.
+    this.visitLhs(tree)
+    return this.varName
+  }
+  visitLhs(ctx) {
+    let varName = ctx.Id().getText()
+    this.varName = canonicalName(varName)
+    super.visitLhs(ctx)
+  }
+  visitSubscriptList(ctx) {
+    // Get the canonical form of subscripts found in the var name.
+    let subscripts = R.map(id => canonicalName(id.getText()), ctx.Id())
+    subscripts = normalizeSubscripts(subscripts)
+    // If a subscript is an index, convert it to an index number to match Vensim data exports.
+    this.varName += R.map(subName => {
+      return isIndex(subName) ? `[${sub(subName).value}]` : `[${subName}]`
+    }, subscripts).join('')
+  }
+}

package/src/model/variable-reader.js

@@ -0,0 +1,172 @@
+import { ModelParser } from 'antlr4-vensim'
+import R from 'ramda'
+
+import { canonicalName, vlog, strlist, cartesianProductOf } from '../_shared/helpers.js'
+import {
+  sub,
+  isDimension,
+  isIndex,
+  normalizeSubscripts,
+  subscriptsMatch,
+  isSubdimension
+} from '../_shared/subscript.js'
+import ModelReader from '../parse/model-reader.js'
+
+import Model from './model.js'
+import Variable from './variable.js'
+
+// Set true to print extra debugging information to stderr.
+const DEBUG_LOG = false
+let debugLog = (title, value) => !DEBUG_LOG || vlog(title, value)
+
+export default class VariableReader extends ModelReader {
+  constructor(specialSeparationDims, directData) {
+    super()
+    // specialSeparationDims are var names that need to be separated because of
+    // circular references, mapped to the dimension subscript to separate on.
+    // '{c-variable-name}': '{c-dimension-name}'
+    this.specialSeparationDims = specialSeparationDims || {}
+    this.directData = directData || {}
+  }
+  visitModel(ctx) {
+    let equations = ctx.equation()
+    if (equations) {
+      for (let equation of equations) {
+        equation.accept(this)
+      }
+    }
+  }
+  visitEquation(ctx) {
+    // Start a new variable defined by this equation.
+    this.var = new Variable(ctx)
+    // Allow for an alternate array of variables that are expanded over subdimensions.
+    this.expandedVars = []
+    // Fill in the variable by visiting the equation parse context.
+    super.visitEquation(ctx)
+    if (R.isEmpty(this.expandedVars)) {
+      // Add a single variable defined by the equation.
+      Model.addVariable(this.var)
+    } else {
+      // Add variables expanded over indices to the model.
+      R.forEach(v => Model.addVariable(v), this.expandedVars)
+    }
+  }
+  visitLhs(ctx) {
+    this.var.varName = canonicalName(ctx.Id().getText())
+    super.visitLhs(ctx)
+    // Possibly expand the var on subdimensions.
+    if (!R.isEmpty(this.var.subscripts)) {
+      // Expand on LHS subscripts alone.
+      let expanding = this.subscriptPosToExpand()
+      this.expandVars(expanding)
+    }
+  }
+  subscriptPosToExpand() {
+    // Decide whether we need to expand each subscript on the LHS.
+    // Construct an array of booleans in each subscript position.
+    let expanding = []
+    for (let iLhsSub = 0; iLhsSub < this.var.subscripts.length; iLhsSub++) {
+      let subscript = this.var.subscripts[iLhsSub]
+      let expand = false
+      // Expand a subdimension and special separation dims in the LHS.
+      if (isDimension(subscript)) {
+        expand = isSubdimension(subscript)
+        if (!expand) {
+          let specialSeparationDims = this.specialSeparationDims[this.var.varName] || []
+          expand = specialSeparationDims.includes(subscript)
+        }
+      }
+      if (!expand) {
+        // Direct data vars with subscripts are separated because we generate a lookup for each index.
+        if (
+          isDimension(subscript) &&
+          (this.var.modelFormula.includes('GET DIRECT DATA') || this.var.modelFormula.includes('GET DIRECT LOOKUPS'))
+        ) {
+          expand = true
+        }
+      }
+      // Also expand on exception subscripts that are indices or subdimensions.
+      if (!expand) {
+        for (let exceptSubs of this.var.exceptSubscripts) {
+          expand = isIndex(exceptSubs[iLhsSub]) || isSubdimension(exceptSubs[iLhsSub])
+          if (expand) {
+            break
+          }
+        }
+      }
+      expanding.push(expand)
+    }
+    return expanding
+  }
+  expandVars(expanding) {
+    // Expand the indicated subscripts into variable objects in the expandedVars list.
+    debugLog(`expanding ${this.var.varName}[${strlist(this.var.subscripts)}] subscripts`, strlist(this.var.subscripts))
+    let expansion = []
+    let separationDims = []
+    // Construct an array with an array at each subscript position. If the subscript is expanded at that position,
+    // it will become an array of indices. Otherwise, it remains an index or dimension as a single-valued array.
+    for (let i = 0; i < this.var.subscripts.length; i++) {
+      let subscript = this.var.subscripts[i]
+      let value
+      if (expanding[i]) {
+        separationDims.push(subscript)
+        if (isDimension(subscript)) {
+          value = sub(subscript).value
+        }
+      }
+      expansion.push(value || [subscript])
+    }
+    // Generate an array of fully expanded subscripts, which may be indices or dimensions.
+    let expandedSubs = cartesianProductOf(expansion)
+    let skipExpansion = subs => {
+      // Check the subscripts against each set of except subscripts. Skip expansion if one of them matches.
+      let subsRange = R.range(0, subs.length)
+      for (let exceptSubscripts of this.var.exceptSubscripts) {
+        if (subs.length === exceptSubscripts.length) {
+          if (R.all(i => subscriptsMatch(subs[i], exceptSubscripts[i]), subsRange)) {
+            return true
+          }
+        } else {
+          console.error(`WARNING: expandedSubs length ≠ exceptSubscripts length in ${this.var.varName}`)
+        }
+      }
+      return false
+    }
+    for (let subs of expandedSubs) {
+      // Skip expansions that match exception subscripts.
+      if (!skipExpansion(subs)) {
+        // Add a new variable to the expanded vars.
+        let v = new Variable(this.var.eqnCtx)
+        v.varName = this.var.varName
+        v.subscripts = subs
+        v.separationDims = separationDims
+        debugLog(`  ${strlist(v.subscripts)}`)
+        this.expandedVars.push(v)
+      }
+    }
+  }
+  visitSubscriptList(ctx) {
+    if (ctx.parentCtx.ruleIndex === ModelParser.RULE_lhs) {
+      let subscripts = normalizeSubscripts(R.map(id => canonicalName(id.getText()), ctx.Id()))
+      // Save subscripts in the Variable instance. Subscripts after the first one are exception subscripts.
+      if (R.isEmpty(this.var.subscripts)) {
+        this.var.subscripts = subscripts
+      } else {
+        this.var.exceptSubscripts.push(subscripts)
+      }
+    }
+    super.visitSubscriptList(ctx)
+  }
+  visitConstList(ctx) {
+    // Expand a subscripted equation with a constant list.
+    let exprs = ctx.expr()
+    if (exprs.length > 1) {
+      let expanding = R.map(subscript => isDimension(subscript), this.var.subscripts)
+      // If the var was already expanded, do it over to make sure we expand on all subscripts.
+      if (!R.isEmpty(this.expandedVars)) {
+        this.expandedVars = []
+      }
+      this.expandVars(expanding)
+    }
+  }
+}

package/src/model/variable.js

@@ -0,0 +1,111 @@
+export default class Variable {
+  constructor(eqnCtx) {
+    // The equation rule context allows us to generate code by visiting the parse tree.
+    this.eqnCtx = eqnCtx
+    // Save both sides of the equation text in the model for documentation purposes.
+    this.modelLHS = eqnCtx ? eqnCtx.lhs().getText() : ''
+    this.modelFormula = this.formula(eqnCtx)
+    // An equation defines a variable with a var name, saved in canonical form here.
+    this.varName = ''
+    // Subscripts are canonical dimension or index names on the LHS in normal order.
+    this.subscripts = []
+    // Exception subscripts are subscript lists given in an EXCEPT clause on the LHS.
+    this.exceptSubscripts = []
+    // Array variables that are separated in VariableReader keep the original dimensions here.
+    this.separationDims = []
+    // Direct data function arguments are saved here for use in code generation.
+    this.directDataArgs = null
+    // Direct constants function arguments are saved here for use in code generation.
+    this.directConstArgs = null
+    // Lookup vars have lookup points and an optional range.
+    this.range = []
+    this.points = []
+    // The reference id appears in lists of references.
+    this.refId = ''
+    // The default varType is aux, but may be overridden later.
+    this.varType = 'aux'
+    // The variable subtype accommodates special handling needed by some Vensim functions.
+    this.varSubtype = ''
+    // A variable may reference other variable names at eval time.
+    this.references = []
+    // Levels and certain other variables have an initial value that may reference other variable names.
+    this.initReferences = []
+    // Set true when a variable has an initial value (e.g. levels and initials).
+    this.hasInitValue = false
+    // Lookup args generate vars that are substituted into the call during code generation.
+    this.lookupArgVarName = ''
+    // SMOOTH* calls are expanded into new level vars and substituted during code generation.
+    this.smoothVarRefId = ''
+    // TREND calls are expanded into new level vars and substituted during code generation.
+    this.trendVarName = ''
+    // NPV calls are expanded into new level vars and substituted during code generation.
+    this.npvVarName = ''
+    // DELAY3* calls are expanded into new level vars and substituted during code generation.
+    this.delayVarRefId = ''
+    this.delayTimeVarName = ''
+    // DELAY FIXED calls generate a FixedDelay support var.
+    this.fixedDelayVarName = ''
+    // Variables generated by special expansions are not included in output.
+    this.includeInOutput = true
+  }
+  copy() {
+    let c = new Variable()
+    c.eqnCtx = this.eqnCtx
+    c.modelLHS = this.modelLHS
+    c.modelFormula = this.modelFormula
+    c.varName = this.varName
+    c.subscripts = this.subscripts.slice()
+    c.separationDims = this.separationDims
+    c.range = this.range.slice()
+    c.points = this.points.slice()
+    c.refId = this.refId
+    c.varType = this.varType
+    c.references = this.references.slice()
+    c.initReferences = this.initReferences.slice()
+    c.hasInitValue = this.hasInitValue
+    c.lookupArgVarName = this.lookupArgVarName
+    c.smoothVarRefId = this.smoothVarRefId
+    c.trendVarName = this.trendVarName
+    c.delayVarRefId = this.delayVarRefId
+    c.delayTimeVarName = this.delayTimeVarName
+    c.includeInOutput = this.includeInOutput
+    return c
+  }
+  formula(eqnCtx) {
+    if (eqnCtx) {
+      if (eqnCtx.expr()) {
+        return eqnCtx.expr().getText()
+      } else if (eqnCtx.constList()) {
+        return eqnCtx.constList().getText()
+      }
+    }
+    return ''
+  }
+  hasSubscripts() {
+    return this.subscripts.length > 0
+  }
+  hasPoints() {
+    return this.points.length > 0
+  }
+  isConst() {
+    return this.varType === 'const'
+  }
+  isAux() {
+    return this.varType === 'aux'
+  }
+  isLevel() {
+    return this.varType === 'level'
+  }
+  isFixedDelay() {
+    return this.varSubtype === 'fixedDelay'
+  }
+  isInitial() {
+    return this.varType === 'initial'
+  }
+  isLookup() {
+    return this.varType === 'lookup'
+  }
+  isData() {
+    return this.varType === 'data'
+  }
+}

package/src/parse/model-reader.js

@@ -0,0 +1,141 @@
+import { ModelVisitor } from 'antlr4-vensim'
+
+export default class ModelReader extends ModelVisitor {
+  constructor() {
+    super()
+    // stack of function names and argument indices encountered on the RHS
+    this.callStack = []
+  }
+  currentFunctionName() {
+    // Return the name of the current function on top of the call stack.
+    let n = this.callStack.length
+    return n > 0 ? this.callStack[n - 1].fn : ''
+  }
+  setArgIndex(argIndex) {
+    // Set the argument index in the current function call on top of the call stack.
+    // This may be set in the exprList visitor and picked up in the var visitor to facilitate special argument handling.
+    let n = this.callStack.length
+    if (n > 0) {
+      this.callStack[n - 1].argIndex = argIndex
+    }
+  }
+  argIndexForFunctionName(name) {
+    // Search the call stack for the function name. Return the current argument index or undefined if not found.
+    let argIndex
+    for (let i = this.callStack.length - 1; i >= 0; i--) {
+      if (this.callStack[i].fn === name) {
+        argIndex = this.callStack[i].argIndex
+        break
+      }
+    }
+    return argIndex
+  }
+  visitEquation(ctx) {
+    ctx.lhs().accept(this)
+    if (ctx.expr()) {
+      ctx.expr().accept(this)
+    } else if (ctx.constList()) {
+      ctx.constList().accept(this)
+    } else if (ctx.lookup()) {
+      ctx.lookup().accept(this)
+    } else {
+      this.var.varType = 'data'
+    }
+  }
+  visitLhs(ctx) {
+    // An LHS may have a subscript list after the var name.
+    // If it has an EXCEPT clause, it will have one or more other subscript lists there too.
+    let subscriptLists = ctx.subscriptList()
+    if (subscriptLists.length > 0) {
+      for (let i = 0; i < subscriptLists.length; i++) {
+        subscriptLists[i].accept(this)
+      }
+    }
+  }
+
+  // Function calls and variables
+
+  visitCall(ctx) {
+    if (ctx.exprList()) {
+      ctx.exprList().accept(this)
+    }
+  }
+  visitExprList(ctx) {
+    let exprs = ctx.expr()
+    // Set the argument index in an instance property so derived classes can determine argument position.
+    for (let i = 0; i < exprs.length; i++) {
+      this.setArgIndex(i)
+      exprs[i].accept(this)
+    }
+  }
+  visitVar(ctx) {
+    if (ctx.subscriptList()) {
+      ctx.subscriptList().accept(this)
+    }
+  }
+
+  // Lookups
+
+  visitLookup(ctx) {
+    if (ctx.lookupRange()) {
+      ctx.lookupRange().accept(this)
+    }
+    if (ctx.lookupPointList()) {
+      ctx.lookupPointList().accept(this)
+    }
+  }
+  visitLookupCall(ctx) {
+    if (ctx.subscriptList()) {
+      ctx.subscriptList().accept(this)
+    }
+  }
+
+  // Unary operators
+
+  visitNegative(ctx) {
+    ctx.expr().accept(this)
+  }
+  visitPositive(ctx) {
+    ctx.expr().accept(this)
+  }
+  visitNot(ctx) {
+    ctx.expr().accept(this)
+  }
+
+  // Binary operators
+
+  visitPower(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitMulDiv(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitAddSub(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitRelational(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitEquality(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitAnd(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+  visitOr(ctx) {
+    ctx.expr(0).accept(this)
+    ctx.expr(1).accept(this)
+  }
+
+  // Tokens
+
+  visitParens(ctx) {
+    ctx.expr().accept(this)
+  }
+}