@sdeverywhere/compile 0.7.17 → 0.7.19

package/src/model/expr-reader.js

@@ -1,202 +0,0 @@
-import { ModelLexer, ModelVisitor } from 'antlr4-vensim'
-
-import { canonicalName } from '../_shared/helpers.js'
-import { createParser } from '../parse/parser.js'
-
-import Model from './model.js'
-
-/**
- * Reads an expression and determines if it resolves to a constant numeric value.
- * This depends on having access to the model variables, so this should be used
- * only after the `readVariables` process has been completed and the spec file
- * has been loaded.
- */
-export default class ExprReader extends ModelVisitor {
-  constructor() {
-    super()
-  }
-
-  read(exprText) {
-    let parser = createParser(exprText)
-    let expr = parser.expr()
-    expr.accept(this)
-
-    return {
-      constantValue: this.constantValue
-    }
-  }
-
-  // Constants
-
-  visitConst(ctx) {
-    const constantValue = parseFloat(ctx.Const().getText())
-    if (!Number.isNaN(constantValue)) {
-      this.constantValue = constantValue
-    } else {
-      this.constantValue = undefined
-    }
-  }
-  visitConstList() {
-    this.constantValue = undefined
-  }
-
-  // Function calls and variables
-
-  visitCall() {
-    // Treat function calls as non-constant (can't easily determine if they
-    // resolve to a constant)
-    this.constantValue = undefined
-  }
-  visitExprList() {
-    // Treat function calls as non-constant (can't easily determine if they
-    // resolve to a constant)
-    this.constantValue = undefined
-  }
-  visitVar(ctx) {
-    // Determine whether this variable has a constant value
-    const varName = ctx.Id().getText().trim()
-    const cName = canonicalName(varName)
-    const v = Model.varWithName(cName)
-    const modelFormula = v?.modelFormula?.trim() || ''
-    const isNumber = modelFormula.match(/^[+-]?\d+(\.\d+)?$/)
-    const canBeOverridden = Model.isInputVar(cName)
-    if (v && isNumber && !canBeOverridden) {
-      const numValue = parseFloat(modelFormula)
-      if (!Number.isNaN(numValue)) {
-        this.constantValue = numValue
-      } else {
-        this.constantValue = undefined
-      }
-    } else {
-      this.constantValue = undefined
-    }
-  }
-
-  // Lookups
-
-  visitLookup() {
-    this.constantValue = undefined
-  }
-  visitLookupCall() {
-    this.constantValue = undefined
-  }
-
-  // Unary operators
-
-  visitNegative(ctx) {
-    super.visitNegative(ctx)
-    if (this.constantValue !== undefined) {
-      this.constantValue = -this.constantValue
-    }
-  }
-  visitPositive(ctx) {
-    super.visitPositive(ctx)
-    if (this.constantValue !== undefined) {
-      this.constantValue = +this.constantValue
-    }
-  }
-  visitNot(ctx) {
-    super.visitNot(ctx)
-    if (this.constantValue !== undefined) {
-      this.constantValue = !this.constantValue
-    }
-  }
-
-  // Binary operators
-
-  visitBinaryArgs(ctx, combine) {
-    ctx.expr(0).accept(this)
-    const constantValue0 = this.constantValue
-    ctx.expr(1).accept(this)
-    const constantValue1 = this.constantValue
-    if (constantValue0 !== undefined && constantValue1 !== undefined) {
-      this.constantValue = combine(constantValue0, constantValue1)
-    } else {
-      this.constantValue = undefined
-    }
-  }
-
-  visitPower(ctx) {
-    this.visitBinaryArgs(ctx, (a, b) => Math.pow(a, b))
-  }
-  visitMulDiv(ctx) {
-    this.visitBinaryArgs(ctx, (a, b) => {
-      if (ctx.op.type === ModelLexer.Star) {
-        return a * b
-      } else {
-        return a / b
-      }
-    })
-  }
-  visitAddSub(ctx) {
-    this.visitBinaryArgs(ctx, (a, b) => {
-      if (ctx.op.type === ModelLexer.Plus) {
-        return a + b
-      } else {
-        return a - b
-      }
-    })
-  }
-  visitRelational(ctx) {
-    this.visitBinaryArgs(ctx, (a, b) => {
-      if (ctx.op.type === ModelLexer.Less) {
-        return a < b ? 1 : 0
-      } else if (ctx.op.type === ModelLexer.Greater) {
-        return a > b ? 1 : 0
-      } else if (ctx.op.type === ModelLexer.LessEqual) {
-        return a <= b ? 1 : 0
-      } else {
-        return a >= b ? 1 : 0
-      }
-    })
-  }
-  visitEquality(ctx) {
-    this.visitBinaryArgs(ctx, (a, b) => {
-      if (ctx.op.type === ModelLexer.Equal) {
-        return a === b ? 1 : 0
-      } else {
-        return a !== b ? 1 : 0
-      }
-    })
-  }
-  visitAnd(ctx) {
-    // For AND expressions, we don't need both sides to have a constant value; as
-    // long as one side is known to be false, then the expression resolves to false
-    ctx.expr(0).accept(this)
-    const constantValue0 = this.constantValue
-    ctx.expr(1).accept(this)
-    const constantValue1 = this.constantValue
-    if (constantValue0 !== undefined && constantValue1 !== undefined) {
-      this.constantValue = constantValue0 && constantValue1
-    } else if (constantValue0 !== undefined && !constantValue0) {
-      this.constantValue = 0
-    } else if (constantValue1 !== undefined && !constantValue1) {
-      this.constantValue = 0
-    } else {
-      this.constantValue = undefined
-    }
-  }
-  visitOr(ctx) {
-    // For OR expressions, we don't need both sides to have a constant value; as
-    // long as one side is known to be true, then the expression resolves to true
-    ctx.expr(0).accept(this)
-    const constantValue0 = this.constantValue
-    ctx.expr(1).accept(this)
-    const constantValue1 = this.constantValue
-    if (constantValue0 !== undefined && constantValue1 !== undefined) {
-      this.constantValue = constantValue0 || constantValue1
-    } else if (constantValue0 !== undefined && constantValue0) {
-      this.constantValue = 1
-    } else if (constantValue1 !== undefined && constantValue1) {
-      this.constantValue = 1
-    } else {
-      this.constantValue = undefined
-    }
-  }
-
-  // Tokens
-
-  visitParens(ctx) {
-    super.visitParens(ctx)
-  }
-}

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

@@ -1,143 +0,0 @@
-import path from 'path'
-import { ModelParser } from 'antlr4-vensim'
-import * as 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) {
-    // Get the subscripts from each subscript index in the list.
-    for (let child of ctx.children) {
-      if (child.symbol?.type === ModelParser.Id) {
-        this.addSubscriptIndex(ctx, child)
-      }
-    }
-  }
-  visitSubscriptDefList(ctx) {
-    // Subscript range definitions can have indices and numeric subscript sequences.
-    for (let child of ctx.children) {
-      if (child.symbol?.type === ModelParser.Id) {
-        this.addSubscriptIndex(ctx, child)
-      } else if (child.ruleIndex === ModelParser.RULE_subscriptSequence) {
-        this.visitSubscriptSequence(child)
-      }
-    }
-  }
-  addSubscriptIndex(ctx, child) {
-    let subscript = child.getText()
-    if (ctx.parentCtx.ruleIndex === ModelParser.RULE_subscriptRange) {
-      this.indNames.push(subscript)
-    } else if (ctx.parentCtx.ruleIndex === ModelParser.RULE_subscriptMapping) {
-      this.mappingValue.push(subscript)
-    }
-  }
-  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])
-      // TODO get this to work with subscript mappings too
-      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.toUpperCase())
-    let col = dataAddress.c
-    let row = dataAddress.r
-    if (col < 0 || row < 0) {
-      throw new Error(`Failed to parse 'firstcell' argument for GET DIRECT SUBSCRIPT call: ${firstCell}`)
-    }
-    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/var-name-reader.js

@@ -1,40 +0,0 @@
-import * as 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

@@ -1,172 +0,0 @@
-import { ModelParser } from 'antlr4-vensim'
-import * as 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/parse/model-reader.js

@@ -1,141 +0,0 @@
-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)
-  }
-}