@sdeverywhere/compile 0.7.20 → 0.7.21

package/package.json

@@ -1,17 +1,16 @@
 {
   "name": "@sdeverywhere/compile",
-  "version": "0.7.20",
+  "version": "0.7.21",
   "description": "The core Vensim to C compiler for the SDEverywhere tool suite.",
   "type": "module",
   "main": "./src/index.js",
   "dependencies": {
-    "@sdeverywhere/parse": "^0.1.1",
+    "@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",
-    "split-string": "^6.0.0",
     "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.2/xlsx-0.20.2.tgz"
   },
   "author": "Climate Interactive",
@@ -32,7 +31,7 @@
     "precommit": "../../scripts/precommit",
     "type-check": "tsc --noEmit -p tsconfig-test.json",
     "test": "vitest run",
-    "test:watch": "vitest",
+    "test:watch": "vitest --hideSkippedTests",
     "test:ci": "vitest run",
     "ci:build": "run-s lint prettier:check type-check test:ci"
   }

package/src/_shared/helpers.js

@@ -3,9 +3,10 @@ import util from 'util'
 import B from 'bufx'
 import { parse as parseCsv } from 'csv-parse/sync'
 import * as R from 'ramda'
-import split from 'split-string'
 import XLSX from 'xlsx'
 
+import { canonicalId, canonicalVarId } from '@sdeverywhere/parse'
+
 // Set true to print a stack trace in vlog
 export const PRINT_VLOG_TRACE = false
 
@@ -40,25 +41,11 @@ export function resetHelperState() {
 }
 
 export let canonicalName = name => {
-  // Format a model variable name into a valid C identifier.
-  return (
-    '_' +
-    name
-      .trim()
-      .replace(/"/g, '_')
-      .replace(/\s+!$/g, '!')
-      .replace(/\s/g, '_')
-      .replace(/,/g, '_')
-      .replace(/-/g, '_')
-      .replace(/\./g, '_')
-      .replace(/\$/g, '_')
-      .replace(/'/g, '_')
-      .replace(/&/g, '_')
-      .replace(/%/g, '_')
-      .replace(/\//g, '_')
-      .replace(/\|/g, '_')
-      .toLowerCase()
-  )
+  // Format a model variable or subscript/dimension name into a valid C identifier.
+  // In the case where you have a full variable name that includes subscripts/dimensions
+  // (e.g., 'Variable name[DimA,B2]'), use `canonicalVensimName` to convert the
+  // base variable name and subscript/dimension parts to canonical form indepdendently.
+  return canonicalId(name)
 }
 export let decanonicalize = name => {
   // Decanonicalize the var name.
@@ -71,9 +58,6 @@ export let decanonicalize = name => {
   }
   return name
 }
-export let cFunctionName = name => {
-  return canonicalName(name).toUpperCase()
-}
 export let isSeparatedVar = v => {
   return v.separationDims.length > 0
 }
@@ -244,22 +228,7 @@ export let readCsv = (pathname, delimiter = ',') => {
 }
 // Convert the var name and subscript names to canonical form separately.
 export let canonicalVensimName = vname => {
-  let result = vname
-  let m = vname.match(/([^[]+)(?:\[([^\]]+)\])?/)
-  if (m) {
-    result = canonicalName(m[1])
-    if (m[2]) {
-      let subscripts = m[2].split(',').map(x => canonicalName(x))
-      result += `[${subscripts.join(',')}]`
-    }
-  }
-  return result
-}
-// Split a model string into an array of equations without the "|" terminator.
-// Allow "|" to occur in quoted variable names across line breaks.
-// Retain the backslash character.
-export let splitEquations = mdl => {
-  return split(mdl, { separator: '|', quotes: ['"'], keep: () => true })
+  return canonicalVarId(vname)
 }
 // Function to map over lists's value and index
 export let mapIndexed = R.addIndex(R.map)

package/src/_shared/subscript.js

@@ -2,7 +2,7 @@ import util from 'util'
 import B from 'bufx'
 import yaml from 'js-yaml'
 import * as R from 'ramda'
-import { canonicalName, asort, vlog } from './helpers.js'
+import { canonicalName, vlog } from './helpers.js'
 
 // A subscript is a dimension or an index.
 // Both have the same properties: model name, canonical name, family, values.
@@ -233,18 +233,6 @@ export function loadSubscriptsFromYaml(yamlSubs) {
     subscripts.set(k, subs[k])
   }
 }
-export function normalizeSubscripts(subscripts) {
-  // Sort a list of subscript names already in canonical form according to the subscript family.
-  let subs = R.map(name => sub(name), subscripts)
-  subs = R.sortBy(R.prop('family'), subs)
-  let normalizedSubs
-  try {
-    normalizedSubs = R.map(R.prop('name'), subs)
-  } catch (e) {
-    console.error(`normalizeSubscripts fails for ${subscripts}`)
-  }
-  return normalizedSubs
-}
 export function extractMarkedDims(subscripts) {
   // Extract all marked dimensions and update subscripts.
   let dims = []
@@ -366,13 +354,3 @@ export function separatedVariableIndex(rhsSub, variable, rhsSubscripts) {
   }
   return null
 }
-// Function to filter canonical dimension names from a list of names
-export let dimensionNames = R.pipe(
-  R.filter(subscript => isDimension(subscript)),
-  asort
-)
-// Function to filter canonical index names from a list of names
-export let indexNames = R.pipe(
-  R.filter(subscript => isIndex(subscript)),
-  asort
-)

package/src/generate/gen-const-list.js

@@ -1,5 +1,5 @@
 import { cartesianProductOf, cdbl } from '../_shared/helpers.js'
-import { isDimension, normalizeSubscripts, sub } from '../_shared/subscript.js'
+import { isDimension, sub } from '../_shared/subscript.js'
 
 /**
  * Generate code for a single element in a const list definition.
@@ -12,12 +12,10 @@ import { isDimension, normalizeSubscripts, sub } from '../_shared/subscript.js'
 export function generateConstListElement(variable, parsedEqn) {
   // In the "read variables" phase, const lists are expanded into separated variable
   // definitions, so `variable` here will have `subscripts` that represent specific
-  // subscript indices in normalized order (alphabetized by parent dimension/family
-  // name).  However, we need to consult the LHS subscripts/dimensions, which will
-  // be in the original order from the model equation.
+  // subscript indices that are ordered according to the dimension positions from the
+  // variable definition.
   //
-  // In the following example,
-  // we have a 2D variable whose original dimensions are not in normal order:
+  // In the following example, we have a 2D variable whose original dimensions are:
   //   DimA: A1, A2 ~~|
   //   DimB: B1, B2, B3 ~~|
   //   x[DimB, DimA] = 1, 2; 3, 4; 5, 6; ~~|
@@ -53,25 +51,17 @@ export function generateConstListElement(variable, parsedEqn) {
   // order of the dimensions from the equation LHS.
   const origCombos = cartesianProductOf(subIdArrays)
 
-  // Now we have the combinations in original order:
+  // Convert to strings to make matching easier.  Now we have the combinations in
+  // original order.
   //   [_b1,_a1]
   //   [_b1,_a2]
   //   [_b2,_a1]
   //   ...
-  // But we need to put them into normalized order so that we can find the index of
-  // `variable.subscripts` (which is already in normalized order).
-  const normalizedCombos = origCombos.map(normalizeSubscripts)
-
-  // Convert to strings to make matching easier.  Now we have the strings in normalized order:
-  //   [_a1,_b1]
-  //   [_a2,_b1]
-  //   [_a1,_b2]
-  //   ...
-  const comboStrings = normalizedCombos.map(combo => combo.map(subId => `[${subId}]`).join(''))
+  const comboStrings = origCombos.map(combo => combo.map(subId => `[${subId}]`).join(''))
 
   // Convert `variable.subscripts` into the same format so that we can do an array lookup,
-  // for example if this separated variable instance is x[_a2,_b1], this will be:
-  //   [_a2,_b1]
+  // for example if this separated variable instance is x[_b1,_a2], this will be:
+  //   [_b1,_a2]
   const lhsComboString = variable.subscripts.map(subId => `[${subId}]`).join('')
 
   // Find the index of the combination that matches `variable.subscripts`

package/src/generate/gen-equation.js

@@ -1,13 +1,4 @@
-import {
-  dimensionNames,
-  hasMapping,
-  isDimension,
-  isIndex,
-  isTrivialDimension,
-  normalizeSubscripts,
-  separatedVariableIndex,
-  sub
-} from '../_shared/subscript.js'
+import { hasMapping, isDimension, isIndex, isTrivialDimension, sub } from '../_shared/subscript.js'
 import { generateConstListElement } from './gen-const-list.js'
 
 import { generateDirectConstInit } from './gen-direct-const.js'
@@ -18,6 +9,9 @@ import { generateLookupFromPoints } from './gen-lookup-from-points.js'
 
 import LoopIndexVars from './loop-index-vars.js'
 
+const loopIndexVarNames = ['i', 'j', 'k', 'l', 'm']
+const arrayIndexVarNames = ['u', 'v', 'w', 's', 't', 'f', 'g', 'h', 'o', 'p', 'q', 'r']
+
 /**
  * Generate C code for the given model equation.
  *
@@ -36,8 +30,22 @@ import LoopIndexVars from './loop-index-vars.js'
  */
 export function generateEquation(variable, mode, extData, directData, modelDir, outFormat) {
   // Maps of LHS subscript families to loop index vars for lookup on the RHS
-  const loopIndexVars = new LoopIndexVars(['i', 'j', 'k', 'l', 'm'])
-  const arrayIndexVars = new LoopIndexVars(['u', 'v', 'w', 's', 't', 'f', 'g', 'h', 'o', 'p', 'q', 'r'])
+  const loopIndexVars = new LoopIndexVars(loopIndexVarNames)
+  const arrayIndexVars = new LoopIndexVars(arrayIndexVarNames)
+
+  // Make the generated loops easier to follow by eagerly determining the order of index
+  // variables based on the order of the LHS dimension names.  For example, if we have:
+  //   x[DimA, DimC, DimB] = y[DimB, DimC, DimA] ~~|
+  // This will generate loop index variable mappings in the following order:
+  //   DimA -> i
+  //   DimC -> j
+  //   DimB -> k
+  const lhsDimIds = variable.subscripts.filter(isDimension)
+  for (const lhsDimId of lhsDimIds) {
+    // We ignore the return value here.  Calling `index` will make `LoopIndexVars` eagerly
+    // set up a mapping from the dimension ID to the loop index variable name.
+    loopIndexVars.index(lhsDimId)
+  }
 
   // Generate the LHS variable reference code
   const parsedEqn = variable.parsedEqn
@@ -64,17 +72,14 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
     return [comment, ...initCode]
   }
 
-  // Get the dimension IDs for the LHS variable
-  const dimIds = dimensionNames(variable.subscripts)
-
   // Turn each dimension ID into a loop with a loop index variable.
   // If the variable has no subscripts, nothing will be emitted here.
   const indexDecl = outFormat === 'js' ? 'let' : 'size_t'
   const openLoops = []
   const closeLoops = []
-  for (const dimId of dimIds) {
-    const indexName = loopIndexVars.index(dimId)
-    const dimLength = sub(dimId).size
+  for (const lhsDimId of lhsDimIds) {
+    const indexName = loopIndexVars.index(lhsDimId)
+    const dimLength = sub(lhsDimId).size
     openLoops.push(`  for (${indexDecl} ${indexName} = 0; ${indexName} < ${dimLength}; ${indexName}++) {`)
     closeLoops.push('  }')
   }
@@ -127,9 +132,6 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
   // Keep a buffer of code that will be included after the generated primary formula
   const postFormulaLines = []
 
-  // Keep track of marked dimensions
-  const markedDimIds = new Set()
-
   // Generate code for an equation with an expression on the RHS
   const genExprCtx = {
     variable,
@@ -138,14 +140,12 @@ export function generateEquation(variable, mode, extData, directData, modelDir,
     cLhs,
     loopIndexVars,
     arrayIndexVars,
-    resetMarkedDims: () => markedDimIds.clear(),
-    addMarkedDim: dimId => markedDimIds.add(dimId),
     emitPreInnerLoop: s => preInnerLoopLines.push(s),
     emitPreFormula: s => preFormulaLines.push(s),
     emitPostFormula: s => postFormulaLines.push(s),
-    cVarRef: varRef => cVarRef(variable, varRef, markedDimIds, loopIndexVars, arrayIndexVars),
+    cVarRef: varRef => cVarRef(variable, varRef, loopIndexVars, arrayIndexVars),
     cVarRefWithLhsSubscripts: baseVarId => cVarRefWithLhsSubscripts(variable, baseVarId, loopIndexVars),
-    cVarIndex: subOrDimId => cVarIndex(variable, [subOrDimId], subOrDimId, markedDimIds, loopIndexVars, arrayIndexVars)
+    cVarIndex: subOrDimId => cVarIndex(variable, subOrDimId, loopIndexVars, arrayIndexVars)
   }
   const cRhs = generateExpr(parsedEqn.rhs.expr, genExprCtx)
   const formula = `  ${cLhs} = ${cRhs};`
@@ -177,9 +177,12 @@ function cVarRefWithLhsSubscripts(lhsVariable, baseVarId, loopIndexVars) {
         // When the dimension is trivial, we can simply emit e.g. `[i]` instead of `[_dim[i]]`
         return `[${i}]`
       } else {
-        return `[${subId}][${i}]`
+        // Otherwise, emit e.g. `[_dim[i]]`
+        return `[${subId}[${i}]]`
       }
     } else {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the subscript
       return `[${sub(subId).value}]`
     }
   })
@@ -191,33 +194,26 @@ function cVarRefWithLhsSubscripts(lhsVariable, baseVarId, loopIndexVars) {
  *
  * @param {*} lhsVariable The LHS `Variable` instance.
  * @param {*} rhsVarRef The `VariableRef` used in a RHS expression.
- * @param {Set<string>} markedDimIds The set of dimension IDs that are marked for use
- * in an array function, for example `SUM(x[DimA!])`.
  * @param {LoopIndexVars} loopIndexVars The loop index state.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions
  * (that use marked dimensions).
  * @returns {string} The C variable reference.
  */
-function cVarRef(lhsVariable, rhsVarRef, markedDimIds, loopIndexVars, arrayIndexVars) {
+function cVarRef(lhsVariable, rhsVarRef, loopIndexVars, arrayIndexVars) {
   if (rhsVarRef.subscriptRefs === undefined) {
     // No subscripts, so return the base variable ID
     return rhsVarRef.varId
   }
 
-  // Normalize the RHS subscripts
-  let rhsSubIds
-  try {
-    // XXX: For now, strip the mark here (need to revisit this)
-    rhsSubIds = normalizeSubscripts(rhsVarRef.subscriptRefs.map(subRef => subRef.subId.replace('!', '')))
-  } catch (e) {
-    throw new Error(`normalizeSubscripts failed in rhsVarRef: refId=${lhsVariable.refId} error=${e}`)
-  }
+  // Get the RHS subscript IDs.  Note that we leave the "!" in place in the case of
+  // marked dimensions; they will be handled specially in `cVarIndex`.
+  const rhsSubIds = rhsVarRef.subscriptRefs.map(subRef => subRef.subId)
 
   // Determine the subscript code (array lookup) for each dimension.  For example, if
   // the RHS variable reference in the model looks like `x[DimA]`, this will convert the
   // `[DimA]` part to `[_dima[i]]` (or simply `[i]` if it is a "trivial" dimension).
   const cSubParts = rhsSubIds.map(rhsSubId => {
-    return cVarIndex(lhsVariable, rhsSubIds, rhsSubId, markedDimIds, loopIndexVars, arrayIndexVars)
+    return cVarIndex(lhsVariable, rhsSubId, loopIndexVars, arrayIndexVars)
   })
 
   return `${rhsVarRef.varId}${cSubParts.map(part => `[${part}]`).join('')}`
@@ -227,57 +223,97 @@ function cVarRef(lhsVariable, rhsVarRef, markedDimIds, loopIndexVars, arrayIndex
  * Return the C code for indexing into a subscripted variable.
  *
  * @param {*} lhsVariable The LHS `Variable` instance.
- * @param {string[]} rhsSubIds The set of all subscript or dimension IDs used on the RHS.
  * @param {string} rhsSubId The specific subscript or dimension ID being evaluated.
- * @param {Set<string>} markedDimIds The set of dimension IDs that are marked for use
- * in an array function, for example `SUM(x[DimA!])`.
  * @param {LoopIndexVars} loopIndexVars The loop index state.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions
  * (that use marked dimensions).
  * @returns {string} The C variable reference.
  */
-function cVarIndex(lhsVariable, rhsSubIds, rhsSubId, markedDimIds, loopIndexVars, arrayIndexVars) {
+function cVarIndex(lhsVariable, rhsSubId, loopIndexVars, arrayIndexVars) {
+  // NOTE: The code in this function follows basically the same steps that are used in
+  // the `resolveRhsSubOrDim` function in the `readEquation` phase.
+  // TODO: Since these two functions are so similar, it would be better to write a
+  // single function that has the common logic, and then write a wrapper function
+  // that converts the resulting subscript or dimension ID to an index
+
+  // Helper function that returns either `indexVarName` or `dimId[indexVarName]` depending
+  // on whether `dimId` is considered "trivial".
+  function optimalIndex(indexVars, dimId) {
+    const indexVarName = indexVars.index(dimId)
+    if (isTrivialDimension(dimId)) {
+      // When the dimension is trivial, we can emit e.g. `[i]` instead of `[_dim[i]]`
+      return `${indexVarName}`
+    } else {
+      // Otherwise, emit e.g. `[_dim[i]]`
+      return `${dimId}[${indexVarName}]`
+    }
+  }
+
+  if (rhsSubId.endsWith('!')) {
+    // The dimension ID at this position is "marked", indicating that the vector function
+    // (e.g., `SUM`) should operate over the elements in this dimension.  Strip the "!"
+    // to get the actual dimension ID, then get the associated array loop index variable.
+    const rhsDimId = rhsSubId.replace('!', '')
+    return optimalIndex(arrayIndexVars, rhsDimId)
+  }
+
   if (isIndex(rhsSubId)) {
     // This is a specific subscript (i.e., an index); dereference the array using the index
     // number of the subscript
     return `${sub(rhsSubId).value}`
   }
 
-  // Otherwise, this is a dimension. Get the corresponding loop index variable used
-  // in the "for" loop.
-  let indexName
-  if (markedDimIds.has(rhsSubId)) {
-    // This is a marked dimension as used in an array function (e.g., `SUM`), so use
-    // the name of the array loop index variable
-    indexName = arrayIndexVars.index(rhsSubId)
-  } else {
-    // Use the single index name for a separated variable if it exists
-    const separatedIndexName = separatedVariableIndex(rhsSubId, lhsVariable, rhsSubIds)
-    if (separatedIndexName) {
-      return `${sub(separatedIndexName).value}`
+  // At this point we know that it is a dimension ID.  Figure out which LHS subscript or
+  // dimension is a match.  First see if there is an exact match.
+  const lhsSubRefs = lhsVariable.parsedEqn.lhs.varDef.subscriptRefs
+  const lhsSubIds = lhsSubRefs?.map(subRef => subRef.subId) || []
+  const lhsDimIndex = lhsSubIds.findIndex(lhsSubId => lhsSubId === rhsSubId)
+  if (lhsDimIndex >= 0) {
+    // There is a match.  If the LHS variable is separated, use the separated subscript
+    // ID at this position (i.e., the value from the `subscripts` array), otherwise we
+    // use the dimension ID at this position.
+    const lhsSubOrDimId = lhsVariable.subscripts[lhsDimIndex]
+    if (isIndex(lhsSubOrDimId)) {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the subscript
+      return `${sub(lhsSubOrDimId).value}`
+    } else {
+      // This is a dimension; use the associated loop index variable
+      return optimalIndex(loopIndexVars, lhsSubOrDimId)
     }
+  }
 
-    // See if we need to apply a mapping because the RHS dim is not found on the LHS
-    const found = lhsVariable.subscripts.findIndex(lhsSubId => sub(lhsSubId).family === sub(rhsSubId).family)
-    if (found < 0) {
-      // Find the mapping from the RHS subscript to a LHS subscript
-      for (const lhsSubId of lhsVariable.subscripts) {
-        if (hasMapping(rhsSubId, lhsSubId)) {
-          indexName = loopIndexVars.index(lhsSubId)
-          return `__map${rhsSubId}${lhsSubId}[${indexName}]`
-        }
+  // There wasn't an exact match by dimension ID.  Find the position of the LHS dimension
+  // that has a mapping to the RHS dimension.
+  const mappedLhsDimIndex = lhsSubIds.findIndex(lhsSubId => hasMapping(rhsSubId, lhsSubId))
+  if (mappedLhsDimIndex >= 0) {
+    // There is a match.  If the LHS variable is separated, use the _mapped_ separated
+    // subscript ID at this position (i.e., the value from the `subscripts` array),
+    // otherwise we use the _mapped_ dimension ID at this position.
+    const mappedLhsSubOrDimId = lhsVariable.subscripts[mappedLhsDimIndex]
+    if (isIndex(mappedLhsSubOrDimId)) {
+      // This is a specific subscript (i.e., an index); dereference the array using the index
+      // number of the _mapped_ subscript
+      const mappedLhsSubId = mappedLhsSubOrDimId
+      const mappedLhsDimId = lhsSubIds[mappedLhsDimIndex]
+      const lhsDim = sub(mappedLhsDimId)
+      const rhsDim = sub(rhsSubId)
+      const lhsSubIndex = lhsDim.value.indexOf(mappedLhsSubId)
+      if (lhsSubIndex >= 0) {
+        const mappedSubId = rhsDim.mappings[mappedLhsDimId][lhsSubIndex]
+        return `${sub(mappedSubId).value}`
+      } else {
+        throw new Error(
+          `Failed to find mapped LHS subscript ${mappedLhsSubId} for RHS dimension ${rhsSubId} in lhs=${lhsVariable.refId}`
+        )
       }
+    } else {
+      // Determine the dimension mapping
+      const mappedLhsDimId = lhsSubIds[mappedLhsDimIndex]
+      const indexVarName = loopIndexVars.index(mappedLhsDimId)
+      return `__map${rhsSubId}${mappedLhsDimId}[${indexVarName}]`
     }
-
-    // There is no mapping, so use the loop index for this dim family on the LHS
-    indexName = loopIndexVars.index(rhsSubId)
-  }
-
-  // Dereference the array using the corresponding loop index variable
-  if (isTrivialDimension(rhsSubId)) {
-    // When the dimension is trivial, we can emit e.g. `[i]` instead of `[_dim[i]]`
-    return `${indexName}`
   } else {
-    return `${rhsSubId}[${indexName}]`
+    throw new Error(`Failed to find LHS dimension for RHS dimension ${rhsSubId} in lhs=${lhsVariable.refId}`)
   }
 }

package/src/generate/gen-expr.js

@@ -1,5 +1,5 @@
 import { cdbl, newTmpVarName } from '../_shared/helpers.js'
-import { extractMarkedDims, isDimension, isIndex, normalizeSubscripts, sub } from '../_shared/subscript.js'
+import { extractMarkedDims, isDimension, isIndex, sub } from '../_shared/subscript.js'
 
 import Model from '../model/model.js'
 
@@ -12,8 +12,6 @@ import Model from '../model/model.js'
  * @param {string} cLhs The C/JS code for the LHS variable reference.
  * @param {LoopIndexVars} loopIndexVars The loop index state used for LHS dimensions.
  * @param {LoopIndexVars} arrayIndexVars The loop index state used for array functions (that use marked dimensions).
- * @param {() => void} resetMarkedDims Function that resets the marked dimension state.
- * @param {(dimId: string) => void} addMarkedDim Function that adds the given dimension to the set of marked dimensions.
  * @param {(s: string) => void} emitPreInnerLoop Function that will cause the given code to be appended to the chunk that
  * precedes the generated inner loop for the equation.
  * @param {(s: string) => void} emitPreFormula Function that will cause the given code to be appended to the chunk that
@@ -69,7 +67,7 @@ export function generateExpr(expr, ctx) {
         // plus one (since Vensim indices are one-based).
         const dimId = expr.varId
         const indexCode = ctx.cVarIndex(dimId)
-        return `(${indexCode} + 1)`
+        return `(${indexExpr(indexCode, ctx)} + 1)`
       } else if (isIndex(expr.varId)) {
         // This is a reference to a subscript/index that is being used in expression position.
         // In place of the subscript, emit the numeric index value of the subscript plus one
@@ -646,7 +644,6 @@ function generateArrayFunctionCall(callExpr, ctx) {
   // Open the array function loop(s)
   const indexDecl = ctx.outFormat === 'js' ? 'let' : 'size_t'
   for (const markedDimId of markedDimIds) {
-    ctx.addMarkedDim(markedDimId)
     const n = sub(markedDimId).size
     const i = ctx.arrayIndexVars.index(markedDimId)
     ctx.emitPreFormula(`  for (${indexDecl} ${i} = 0; ${i} < ${n}; ${i}++) {`)
@@ -691,9 +688,6 @@ function generateArrayFunctionCall(callExpr, ctx) {
     ctx.emitPreFormula(`  }`)
   }
 
-  // Reset marked dim state
-  ctx.resetMarkedDims()
-
   if (returnCode) {
     // Emit the expression defined above in place of the array function
     return returnCode
@@ -747,7 +741,7 @@ function generateVectorElmMapCall(callExpr, ctx) {
 
   // The `VECTOR ELM MAP` function replaces one subscript with a calculated offset from
   // a base index
-  const rhsSubIds = normalizeSubscripts(vecSubIds)
+  const rhsSubIds = vecSubIds
   const cSubscripts = rhsSubIds.map(rhsSubId => {
     if (isIndex(rhsSubId)) {
       let indexDecl
@@ -838,35 +832,55 @@ function generateAllocateAvailableCall(callExpr, ctx) {
     }
   }
 
-  // Process the request argument
+  // Given a C/JS variable reference string (e.g., '_var[i][j]'), return that
+  // string without the last N array index parts
+  function cVarRefWithoutLastIndices(arg, count) {
+    const varRef = ctx.cVarRef(arg)
+    const origIndexParts = Model.splitRefId(varRef).subscripts
+    if (origIndexParts < count) {
+      throw new Error(`ALLOCATE AVAILABLE argument '${arg}' should have at least ${count} subscripts`)
+    }
+    const newIndexParts = origIndexParts.slice(0, -count)
+    if (newIndexParts.length > 0) {
+      return `${arg.varId}${newIndexParts.map(x => `[${x}]`).join('')}`
+    } else {
+      return arg.varId
+    }
+  }
+
+  // Process the request argument.  Only include subscripts up until the last one;
+  // the implementation function will iterate over the requesters array.
   const reqArg = validateArg(0, 'req')
-  const reqRefId = reqArg.varId
-  const reqSubIds = reqArg.subscriptRefs.map(subRef => subRef.subId)
+  const reqRef = cVarRefWithoutLastIndices(reqArg, 1)
 
-  // Process the priority argument
-  const priorityArg = validateArg(1, 'priority')
-  const priorityRefId = priorityArg.varId
+  // Process the pp (priority profile) argument.  Only include subscripts up until the
+  // second to last one; the implementation function will iterate over the priority
+  // profile array.
+  const ppArg = validateArg(1, 'pp')
+  const ppRef = cVarRefWithoutLastIndices(ppArg, 2)
 
-  // Process the avail argument
+  // Process the avail argument; include any subscripts
   const availArg = validateArg(2, 'avail')
-  const availRefId = availArg.varId
+  const availRef = ctx.cVarRef(availArg)
 
-  // The `ALLOCATE AVAILABLE` function iterates over the subscript in its first arg
-  const dimId = reqSubIds[0]
-  const subIndex = ctx.loopIndexVars.index(dimId)
+  // The `ALLOCATE AVAILABLE` function iterates over the last subscript in its first arg.
+  // The `readEquation` process will have already verified that the last dimension matches
+  // the last dimension for the LHS.
+  const allocDimId = reqArg.subscriptRefs[reqArg.subscriptRefs.length - 1].subId
+  const allocLoopIndexVar = ctx.loopIndexVars.index(allocDimId)
 
   // Generate the code that is emitted before the entire block (before any loops are opened)
   const tmpVarId = newTmpVarName()
-  const dimSize = sub(dimId).size
+  const numRequesters = sub(allocDimId).size
   switch (ctx.outFormat) {
     case 'c':
       ctx.emitPreInnerLoop(
-        `  double* ${tmpVarId} = _ALLOCATE_AVAILABLE(${reqRefId}, (double*)${priorityRefId}, ${availRefId}, ${dimSize});`
+        `  double* ${tmpVarId} = _ALLOCATE_AVAILABLE(${reqRef}, (double*)${ppRef}, ${availRef}, ${numRequesters});`
       )
       break
     case 'js':
       ctx.emitPreInnerLoop(
-        `  let ${tmpVarId} = fns.ALLOCATE_AVAILABLE(${reqRefId}, ${priorityRefId}, ${availRefId}, ${dimSize});`
+        `  let ${tmpVarId} = fns.ALLOCATE_AVAILABLE(${reqRef}, ${ppRef}, ${availRef}, ${numRequesters});`
       )
       break
     default:
@@ -874,7 +888,7 @@ function generateAllocateAvailableCall(callExpr, ctx) {
   }
 
   // Generate the RHS expression used in the inner loop
-  return `${tmpVarId}[${dimId}[${subIndex}]]`
+  return `${tmpVarId}[${allocDimId}[${allocLoopIndexVar}]]`
 }
 
 /**
@@ -1006,3 +1020,32 @@ function minFunc(ctx) {
       throw new Error(`Unhandled output format '${ctx.outFormat}'`)
   }
 }
+
+/**
+ * Return the C or JS code for a subscript or dimension (loop index variable) used in
+ * expression position.
+ *
+ * @param {string} indexValue The index number or code.
+ * @param {GenExprContext} ctx The context used when generating code for the expression.
+ * @return {string} The generated C/JS code.
+ */
+function indexExpr(indexValue, ctx) {
+  switch (ctx.outFormat) {
+    case 'c':
+      // In the C case, we need to cast to double since the index variable will be
+      // of type `size_t`, which is an unsigned type, but we want a signed type for
+      // the rare cases where math is involved that makes it go negative
+      if (isNaN(indexValue)) {
+        // This is a (non-numeric) loop index variable reference, so cast to double
+        return `((double)${indexValue})`
+      } else {
+        // This is a numeric index, no cast is necessary
+        return indexValue
+      }
+    case 'js':
+      // In the JS case, no cast is necessary
+      return indexValue
+    default:
+      throw new Error(`Unhandled output format '${ctx.outFormat}'`)
+  }
+}