tla-ts 0.0.3 → 0.0.4-dev.1a3acf6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (381) hide show
  1. package/README.md +46 -115
  2. package/dist/cli.cjs +1 -1
  3. package/dist/cli.js +1 -1
  4. package/dist/deciders.cjs +366 -0
  5. package/dist/deciders.js +366 -0
  6. package/dist/index.cjs +1 -1
  7. package/dist/index.d.cts +194 -8
  8. package/dist/index.d.ts +194 -8
  9. package/dist/index.js +1 -1
  10. package/dist/parallel-worker.cjs +1 -4
  11. package/dist/parallel-worker.js +1 -4
  12. package/dist/prove-worker.cjs +9 -0
  13. package/dist/prove-worker.d.cts +9 -0
  14. package/dist/prove-worker.d.ts +9 -0
  15. package/dist/prove-worker.js +9 -0
  16. package/dist/prove.cjs +1006 -0
  17. package/dist/prove.js +1006 -0
  18. package/dist/run.cjs +45 -0
  19. package/dist/run.js +45 -0
  20. package/dist/tlapm.cjs +10 -0
  21. package/dist/tlapm.js +10 -0
  22. package/dist/transfer.cjs +1377 -18
  23. package/dist/transfer.js +1377 -18
  24. package/dist/worker.cjs +21 -0
  25. package/dist/worker.js +21 -0
  26. package/package.json +24 -11
  27. package/src/ast.ts +149 -8
  28. package/src/bags.ts +26 -30
  29. package/src/builtins.ts +45 -19
  30. package/src/bundled-modules.ts +3 -3
  31. package/src/check.ts +1182 -900
  32. package/src/cli/options.ts +109 -0
  33. package/src/cli/run.ts +63 -0
  34. package/src/cli/shared.ts +106 -0
  35. package/src/cli/tlapm.ts +374 -0
  36. package/src/cli/tlc.ts +941 -0
  37. package/src/cli/xml-exporter.ts +221 -0
  38. package/src/cli.ts +9 -2
  39. package/src/codegen.ts +112 -51
  40. package/src/config.ts +254 -181
  41. package/src/dependencies.ts +5 -7
  42. package/src/environment.ts +579 -184
  43. package/src/errors.ts +287 -4
  44. package/src/evaluate.ts +1095 -365
  45. package/src/exit-codes.ts +22 -43
  46. package/src/fingerprints.ts +49 -14
  47. package/src/index.ts +11 -0
  48. package/src/instances.ts +73 -60
  49. package/src/java-overrides.ts +183 -66
  50. package/src/json.ts +31 -36
  51. package/src/levels.ts +197 -54
  52. package/src/lexer.ts +127 -30
  53. package/src/liveness-checker.ts +894 -0
  54. package/src/liveness.ts +246 -596
  55. package/src/{obligation-action.ts → obligations/action.ts} +248 -74
  56. package/src/{obligation-anon.ts → obligations/anonymize.ts} +55 -57
  57. package/src/obligations/equality.ts +260 -0
  58. package/src/obligations/expression.ts +618 -0
  59. package/src/{obligation-format.ts → obligations/format.ts} +7 -8
  60. package/src/obligations/generate.ts +457 -0
  61. package/src/{obligations.ts → obligations/index.ts} +46 -32
  62. package/src/{obligation-levels.ts → obligations/levels.ts} +44 -40
  63. package/src/obligations/module.ts +445 -0
  64. package/src/obligations/normalize.ts +554 -0
  65. package/src/obligations/operators.ts +176 -0
  66. package/src/obligations/pragma.ts +195 -0
  67. package/src/{obligation-printer.ts → obligations/printer.ts} +65 -230
  68. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -2
  69. package/src/obligations/regroup.ts +100 -0
  70. package/src/{obligation-generate.ts → obligations/simplify.ts} +130 -536
  71. package/src/{obligation-source.ts → obligations/source.ts} +174 -216
  72. package/src/{obligation-deref.ts → obligations/subexpression.ts} +84 -115
  73. package/src/obligations/substitution.ts +261 -0
  74. package/src/obligations/temporal.ts +321 -0
  75. package/src/{obligation-tuples.ts → obligations/tuples.ts} +38 -54
  76. package/src/parallel-worker.ts +184 -235
  77. package/src/parallel.ts +156 -91
  78. package/src/parser.ts +490 -188
  79. package/src/pcal/ast.ts +755 -0
  80. package/src/pcal/parse.ts +1487 -0
  81. package/src/pcal/tokenize.ts +487 -0
  82. package/src/pcal/translate.ts +1151 -0
  83. package/src/pcal/validate.ts +444 -0
  84. package/src/prover/decide-pool.ts +95 -0
  85. package/src/prover/deciders.ts +33 -0
  86. package/src/prover/first-order.ts +175 -0
  87. package/src/prover/isabelle/LICENSE +36 -0
  88. package/src/prover/isabelle/LICENSE-tlapm +26 -0
  89. package/src/prover/isabelle/decide.ts +44 -0
  90. package/src/prover/isabelle/encode.ts +445 -0
  91. package/src/prover/isabelle/isar/inner-syntax.ts +579 -0
  92. package/src/prover/isabelle/isar/method.ts +367 -0
  93. package/src/prover/isabelle/isar/proof.ts +28 -0
  94. package/src/prover/isabelle/isar/statement.ts +57 -0
  95. package/src/prover/isabelle/isar/theory.ts +192 -0
  96. package/src/prover/isabelle/isar/type-check.ts +278 -0
  97. package/src/prover/isabelle/provers/blast/blast.ts +258 -0
  98. package/src/prover/isabelle/provers/blast/branch.ts +322 -0
  99. package/src/prover/isabelle/provers/blast/prove.ts +347 -0
  100. package/src/prover/isabelle/provers/blast/rules.ts +330 -0
  101. package/src/prover/isabelle/provers/blast/state.ts +180 -0
  102. package/src/prover/isabelle/provers/blast/term.ts +546 -0
  103. package/src/prover/isabelle/provers/clasimp.ts +150 -0
  104. package/src/prover/isabelle/provers/classical.ts +389 -0
  105. package/src/prover/isabelle/provers/hypsubst.ts +433 -0
  106. package/src/prover/isabelle/pure/bicompose.ts +174 -0
  107. package/src/prover/isabelle/pure/consts.ts +32 -0
  108. package/src/prover/isabelle/pure/conv.ts +79 -0
  109. package/src/prover/isabelle/pure/drule.ts +264 -0
  110. package/src/prover/isabelle/pure/envir.ts +331 -0
  111. package/src/prover/isabelle/pure/goal.ts +53 -0
  112. package/src/prover/isabelle/pure/interrupt.ts +16 -0
  113. package/src/prover/isabelle/pure/list.ts +12 -0
  114. package/src/prover/isabelle/pure/logic.ts +330 -0
  115. package/src/prover/isabelle/pure/name.ts +98 -0
  116. package/src/prover/isabelle/pure/net.ts +215 -0
  117. package/src/prover/isabelle/pure/object-logic.ts +41 -0
  118. package/src/prover/isabelle/pure/pattern.ts +631 -0
  119. package/src/prover/isabelle/pure/raw-simplifier.ts +338 -0
  120. package/src/prover/isabelle/pure/rewriter.ts +602 -0
  121. package/src/prover/isabelle/pure/search.ts +68 -0
  122. package/src/prover/isabelle/pure/seq.ts +133 -0
  123. package/src/prover/isabelle/pure/simplifier.ts +106 -0
  124. package/src/prover/isabelle/pure/table.ts +201 -0
  125. package/src/prover/isabelle/pure/tactic.ts +168 -0
  126. package/src/prover/isabelle/pure/tactical.ts +264 -0
  127. package/src/prover/isabelle/pure/term-ord.ts +105 -0
  128. package/src/prover/isabelle/pure/term.ts +688 -0
  129. package/src/prover/isabelle/pure/thm.ts +783 -0
  130. package/src/prover/isabelle/pure/type.ts +121 -0
  131. package/src/prover/isabelle/pure/unify.ts +753 -0
  132. package/src/prover/isabelle/pure/variable.ts +25 -0
  133. package/src/prover/isabelle/tla/classical-setup.ts +101 -0
  134. package/src/prover/isabelle/tla/context.ts +74 -0
  135. package/src/prover/isabelle/tla/logic-data.ts +5 -0
  136. package/src/prover/isabelle/tla/logic.ts +215 -0
  137. package/src/prover/isabelle/tla/simpdata.ts +241 -0
  138. package/src/prover/isabelle/tools/intuitionistic.ts +132 -0
  139. package/src/prover/ocaml.ts +22 -0
  140. package/src/prover/prep/action.ts +508 -0
  141. package/src/prover/prep/enabled-axioms.ts +189 -0
  142. package/src/prover/prep/fingerprint.ts +388 -0
  143. package/src/prover/prep/level-comparison.ts +529 -0
  144. package/src/prover/prep/md5.ts +60 -0
  145. package/src/prover/prep/methods.ts +221 -0
  146. package/src/prover/prep/normalize.ts +309 -0
  147. package/src/prover/prove-worker.ts +22 -0
  148. package/src/prover/prove.ts +492 -0
  149. package/src/prover/ptl/decide.ts +68 -0
  150. package/src/prover/ptl/encode.ts +244 -0
  151. package/src/prover/ptl/sat.ts +151 -0
  152. package/src/prover/ptl/tableau.ts +276 -0
  153. package/src/prover/smt/axioms.ts +209 -0
  154. package/src/prover/smt/context.ts +108 -0
  155. package/src/prover/smt/data.ts +636 -0
  156. package/src/prover/smt/encode.ts +275 -0
  157. package/src/prover/smt/extensionality.ts +65 -0
  158. package/src/prover/smt/flatten.ts +112 -0
  159. package/src/prover/smt/format.ts +154 -0
  160. package/src/prover/smt/instances.ts +181 -0
  161. package/src/prover/smt/rewrite.ts +766 -0
  162. package/src/prover/smt/solver/act-cache.ts +265 -0
  163. package/src/prover/smt/solver/arith-rewriter.ts +962 -0
  164. package/src/prover/smt/solver/array.ts +22 -0
  165. package/src/prover/smt/solver/asserted-formulas.ts +469 -0
  166. package/src/prover/smt/solver/ast-lt.ts +157 -0
  167. package/src/prover/smt/solver/ast-util.ts +91 -0
  168. package/src/prover/smt/solver/ast.ts +1315 -0
  169. package/src/prover/smt/solver/auf-solver.ts +572 -0
  170. package/src/prover/smt/solver/case-split-queue.ts +178 -0
  171. package/src/prover/smt/solver/cg-table.ts +175 -0
  172. package/src/prover/smt/solver/clause.ts +276 -0
  173. package/src/prover/smt/solver/conflict-resolution.ts +343 -0
  174. package/src/prover/smt/solver/context.ts +1292 -0
  175. package/src/prover/smt/solver/ctx-simplify.ts +334 -0
  176. package/src/prover/smt/solver/der.ts +224 -0
  177. package/src/prover/smt/solver/dyn-ack.ts +141 -0
  178. package/src/prover/smt/solver/e-matching.ts +659 -0
  179. package/src/prover/smt/solver/enode.ts +259 -0
  180. package/src/prover/smt/solver/expr-ref.ts +21 -0
  181. package/src/prover/smt/solver/expr-safe-replace.ts +172 -0
  182. package/src/prover/smt/solver/fingerprints.ts +92 -0
  183. package/src/prover/smt/solver/flat-literals.ts +51 -0
  184. package/src/prover/smt/solver/goal.ts +138 -0
  185. package/src/prover/smt/solver/hash.ts +173 -0
  186. package/src/prover/smt/solver/hashtable.ts +166 -0
  187. package/src/prover/smt/solver/internalizer.ts +1381 -0
  188. package/src/prover/smt/solver/lbool.ts +5 -0
  189. package/src/prover/smt/solver/literal.ts +24 -0
  190. package/src/prover/smt/solver/lp/bound-propagator.ts +391 -0
  191. package/src/prover/smt/solver/lp/constraints.ts +78 -0
  192. package/src/prover/smt/solver/lp/containers.ts +296 -0
  193. package/src/prover/smt/solver/lp/core-solver.ts +504 -0
  194. package/src/prover/smt/solver/lp/cross-nested.ts +224 -0
  195. package/src/prover/smt/solver/lp/dep-intervals.ts +642 -0
  196. package/src/prover/smt/solver/lp/dependency.ts +51 -0
  197. package/src/prover/smt/solver/lp/dioph-eq.ts +1181 -0
  198. package/src/prover/smt/solver/lp/explanation.ts +46 -0
  199. package/src/prover/smt/solver/lp/gomory.ts +255 -0
  200. package/src/prover/smt/solver/lp/hnf-cutter.ts +125 -0
  201. package/src/prover/smt/solver/lp/hnf.ts +281 -0
  202. package/src/prover/smt/solver/lp/int-cube.ts +295 -0
  203. package/src/prover/smt/solver/lp/int-solver.ts +514 -0
  204. package/src/prover/smt/solver/lp/lar-solver.ts +816 -0
  205. package/src/prover/smt/solver/lp/lar-term.ts +62 -0
  206. package/src/prover/smt/solver/lp/lp-settings.ts +91 -0
  207. package/src/prover/smt/solver/lp/maximize-term.ts +347 -0
  208. package/src/prover/smt/solver/lp/nex-creator.ts +381 -0
  209. package/src/prover/smt/solver/lp/nex.ts +120 -0
  210. package/src/prover/smt/solver/lp/nla-backoff.ts +43 -0
  211. package/src/prover/smt/solver/lp/nla-basics.ts +398 -0
  212. package/src/prover/smt/solver/lp/nla-core.ts +968 -0
  213. package/src/prover/smt/solver/lp/nla-divisions.ts +332 -0
  214. package/src/prover/smt/solver/lp/nla-emonics.ts +373 -0
  215. package/src/prover/smt/solver/lp/nla-factorization.ts +30 -0
  216. package/src/prover/smt/solver/lp/nla-grobner.ts +904 -0
  217. package/src/prover/smt/solver/lp/nla-horner.ts +126 -0
  218. package/src/prover/smt/solver/lp/nla-intervals.ts +265 -0
  219. package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  220. package/src/prover/smt/solver/lp/nla-monotone.ts +59 -0
  221. package/src/prover/smt/solver/lp/nla-order.ts +307 -0
  222. package/src/prover/smt/solver/lp/nla-patcher.ts +112 -0
  223. package/src/prover/smt/solver/lp/nla-tangents.ts +251 -0
  224. package/src/prover/smt/solver/lp/nla-throttle.ts +85 -0
  225. package/src/prover/smt/solver/lp/nla-types.ts +124 -0
  226. package/src/prover/smt/solver/lp/nla-var-eqs.ts +141 -0
  227. package/src/prover/smt/solver/lp/nra-solver.ts +440 -0
  228. package/src/prover/smt/solver/lp/numeric-pair.ts +65 -0
  229. package/src/prover/smt/solver/lp/pdd-interval.ts +31 -0
  230. package/src/prover/smt/solver/lp/pdd-simplifier.ts +184 -0
  231. package/src/prover/smt/solver/lp/pdd-solver.ts +408 -0
  232. package/src/prover/smt/solver/lp/pdd.ts +971 -0
  233. package/src/prover/smt/solver/lp/random-updater.ts +138 -0
  234. package/src/prover/smt/solver/lp/static-matrix.ts +246 -0
  235. package/src/prover/smt/solver/lp/union-find.ts +96 -0
  236. package/src/prover/smt/solver/mam-compiler.ts +847 -0
  237. package/src/prover/smt/solver/mam-interpreter.ts +400 -0
  238. package/src/prover/smt/solver/maximize-ac-sharing.ts +118 -0
  239. package/src/prover/smt/solver/model-checker.ts +347 -0
  240. package/src/prover/smt/solver/model-evaluator.ts +262 -0
  241. package/src/prover/smt/solver/model-finder.ts +155 -0
  242. package/src/prover/smt/solver/model-generator.ts +97 -0
  243. package/src/prover/smt/solver/model-macro-solver.ts +728 -0
  244. package/src/prover/smt/solver/nlsat/algebraic.ts +1161 -0
  245. package/src/prover/smt/solver/nlsat/atoms.ts +238 -0
  246. package/src/prover/smt/solver/nlsat/evaluator.ts +303 -0
  247. package/src/prover/smt/solver/nlsat/explain.ts +607 -0
  248. package/src/prover/smt/solver/nlsat/interval-set.ts +351 -0
  249. package/src/prover/smt/solver/nlsat/levelwise.ts +737 -0
  250. package/src/prover/smt/solver/nlsat/mpbq.ts +161 -0
  251. package/src/prover/smt/solver/nlsat/polynomial.ts +1722 -0
  252. package/src/prover/smt/solver/nlsat/solver.ts +911 -0
  253. package/src/prover/smt/solver/nlsat/types.ts +43 -0
  254. package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  255. package/src/prover/smt/solver/nlsat/upolynomial.ts +996 -0
  256. package/src/prover/smt/solver/nnf.ts +469 -0
  257. package/src/prover/smt/solver/pattern-inference.ts +351 -0
  258. package/src/prover/smt/solver/poly-rewriter.ts +477 -0
  259. package/src/prover/smt/solver/propagate-values.ts +83 -0
  260. package/src/prover/smt/solver/proto-model.ts +551 -0
  261. package/src/prover/smt/solver/pull-quant.ts +139 -0
  262. package/src/prover/smt/solver/qe-lite-der.ts +526 -0
  263. package/src/prover/smt/solver/qe-lite-fm.ts +576 -0
  264. package/src/prover/smt/solver/qe-lite.ts +381 -0
  265. package/src/prover/smt/solver/qi-queue.ts +362 -0
  266. package/src/prover/smt/solver/quant-tactics.ts +117 -0
  267. package/src/prover/smt/solver/quantifier-analyzer.ts +562 -0
  268. package/src/prover/smt/solver/quantifier-manager.ts +186 -0
  269. package/src/prover/smt/solver/random-gen.ts +10 -0
  270. package/src/prover/smt/solver/rational.ts +165 -0
  271. package/src/prover/smt/solver/ref-vector.ts +62 -0
  272. package/src/prover/smt/solver/relevancy.ts +247 -0
  273. package/src/prover/smt/solver/rewriter-tpl.ts +1159 -0
  274. package/src/prover/smt/solver/rewriter.ts +843 -0
  275. package/src/prover/smt/solver/rlimit.ts +79 -0
  276. package/src/prover/smt/solver/smtlib-parser.ts +526 -0
  277. package/src/prover/smt/solver/solver.ts +71 -0
  278. package/src/prover/smt/solver/sort.ts +35 -0
  279. package/src/prover/smt/solver/sticky-generations.ts +69 -0
  280. package/src/prover/smt/solver/theory-lra-axioms.ts +340 -0
  281. package/src/prover/smt/solver/theory-lra-bounds.ts +226 -0
  282. package/src/prover/smt/solver/theory-lra-final-check.ts +252 -0
  283. package/src/prover/smt/solver/theory-lra-internalize.ts +476 -0
  284. package/src/prover/smt/solver/theory-lra-model.ts +243 -0
  285. package/src/prover/smt/solver/theory-lra-propagate.ts +405 -0
  286. package/src/prover/smt/solver/theory-lra-state.ts +43 -0
  287. package/src/prover/smt/solver/theory-lra.ts +56 -0
  288. package/src/prover/smt/solver/var-subst.ts +258 -0
  289. package/src/prover/smt/solver/z3-license.txt +10 -0
  290. package/src/prover/smt/table.ts +170 -0
  291. package/src/prover/tlapm/cache.ts +236 -0
  292. package/src/prover/tlapm/ocaml-marshal.ts +166 -0
  293. package/src/prover/tlapm/tlapm.ts +96 -0
  294. package/src/prover/tlaps-module.ts +510 -0
  295. package/src/prover/verdict.ts +13 -0
  296. package/src/prover/zenon/LICENSE +32 -0
  297. package/src/prover/zenon/check/check.ts +105 -0
  298. package/src/prover/zenon/check/definitions.ts +144 -0
  299. package/src/prover/zenon/check/equality.ts +182 -0
  300. package/src/prover/zenon/check/functions.ts +62 -0
  301. package/src/prover/zenon/check/keys.ts +125 -0
  302. package/src/prover/zenon/check/propositional.ts +104 -0
  303. package/src/prover/zenon/check/records.ts +188 -0
  304. package/src/prover/zenon/check/relations.ts +121 -0
  305. package/src/prover/zenon/check/rewrites.ts +224 -0
  306. package/src/prover/zenon/check/sets.ts +302 -0
  307. package/src/prover/zenon/check/terms.ts +127 -0
  308. package/src/prover/zenon/check/tla.ts +126 -0
  309. package/src/prover/zenon/decide.ts +107 -0
  310. package/src/prover/zenon/encode.ts +378 -0
  311. package/src/prover/zenon/eqrel.ts +300 -0
  312. package/src/prover/zenon/equality-rules.ts +435 -0
  313. package/src/prover/zenon/expr.ts +551 -0
  314. package/src/prover/zenon/index-table.ts +350 -0
  315. package/src/prover/zenon/isar-case.ts +513 -0
  316. package/src/prover/zenon/isar.ts +1249 -0
  317. package/src/prover/zenon/limits.ts +15 -0
  318. package/src/prover/zenon/llproof.ts +173 -0
  319. package/src/prover/zenon/mltoll.ts +1566 -0
  320. package/src/prover/zenon/node.ts +297 -0
  321. package/src/prover/zenon/ocaml.ts +169 -0
  322. package/src/prover/zenon/parse.ts +247 -0
  323. package/src/prover/zenon/phrase.ts +191 -0
  324. package/src/prover/zenon/proof.ts +198 -0
  325. package/src/prover/zenon/propositional-rules.ts +387 -0
  326. package/src/prover/zenon/rules.ts +94 -0
  327. package/src/prover/zenon/search.ts +288 -0
  328. package/src/prover/zenon/tla/functions.ts +151 -0
  329. package/src/prover/zenon/tla/llproof.ts +480 -0
  330. package/src/prover/zenon/tla/records.ts +225 -0
  331. package/src/prover/zenon/tla/rewrites.ts +447 -0
  332. package/src/prover/zenon/tla/sets.ts +304 -0
  333. package/src/prover/zenon/tla/terms.ts +162 -0
  334. package/src/prover/zenon/tla/tla.ts +506 -0
  335. package/src/randomization.ts +39 -27
  336. package/src/resolve.ts +1474 -426
  337. package/src/runtime.ts +25 -7
  338. package/src/sany/builtins.ts +147 -0
  339. package/src/sany/generator.ts +3111 -0
  340. package/src/sany/levels.ts +1205 -0
  341. package/src/sany/lexer.ts +544 -0
  342. package/src/sany/linter.ts +122 -0
  343. package/src/sany/modules.ts +1398 -0
  344. package/src/sany/nodes.ts +463 -0
  345. package/src/sany/parse-error.ts +2161 -0
  346. package/src/sany/report.ts +355 -0
  347. package/src/sany/selectors.ts +736 -0
  348. package/src/sany/source.ts +247 -0
  349. package/src/sany/xml.ts +1016 -0
  350. package/src/search.ts +969 -0
  351. package/src/spec-description.ts +66 -29
  352. package/src/{standard-levels.ts → standard-definitions.ts} +118 -2
  353. package/src/standard-modules.ts +215 -164
  354. package/src/state-graph.ts +181 -0
  355. package/src/subexpressions.ts +231 -171
  356. package/src/substitution-levels.ts +40 -19
  357. package/src/successors.ts +253 -125
  358. package/src/symmetry.ts +194 -54
  359. package/src/tableau.ts +60 -32
  360. package/src/tlc/fingerprint.ts +214 -0
  361. package/src/{tlc-modules.ts → tlc/jar-data.ts} +4 -0
  362. package/src/tlc/messages.ts +441 -0
  363. package/src/{tlc-order.ts → tlc/order.ts} +84 -16
  364. package/src/{tlc-random.ts → tlc/random.ts} +30 -189
  365. package/src/tlc/replay.ts +659 -0
  366. package/src/{tlc-summary.ts → tlc/summary.ts} +20 -5
  367. package/src/{tlc-module.ts → tlc/tlc-operators.ts} +59 -50
  368. package/src/{tlc-ext.ts → tlc/tlcext-operators.ts} +63 -45
  369. package/src/tlc/version.ts +19 -0
  370. package/src/transfer.ts +44 -32
  371. package/src/values.ts +843 -241
  372. package/src/worker.ts +62 -0
  373. package/dist/parallel.cjs +0 -12
  374. package/dist/parallel.js +0 -12
  375. package/dist/run-cli.cjs +0 -28
  376. package/dist/run-cli.js +0 -28
  377. package/src/canonical.ts +0 -39
  378. package/src/cli-options.ts +0 -58
  379. package/src/obligation-expression.ts +0 -1060
  380. package/src/obligation-module.ts +0 -1042
  381. package/src/run-cli.ts +0 -478
@@ -0,0 +1,1151 @@
1
+ import { PcalError, PcalBugError } from "../errors";
2
+ import {
3
+ createNormalizedPcalExpr,
4
+ createPcalBase,
5
+ createPcalExpr,
6
+ createPcalToken,
7
+ getElement,
8
+ getPcalLocation,
9
+ getPcalTokenWidth,
10
+ normalizePcalExpr,
11
+ PCAL_TOKEN,
12
+ substitutePcalExpr,
13
+ toLabeledStmt,
14
+ type PcalAlgorithm,
15
+ type PcalAssign,
16
+ type PcalCall,
17
+ type PcalCallReturn,
18
+ type PcalExpr,
19
+ type PcalLabeledStmt,
20
+ type PcalLabelEither,
21
+ type PcalLabelIf,
22
+ type PcalProcedure,
23
+ type PcalProcess,
24
+ type PcalPVarDecl,
25
+ type PcalReturn,
26
+ type PcalSingleAssign,
27
+ type PcalStmt,
28
+ type PcalToken,
29
+ type PcalVarDecl,
30
+ type PcalWhen,
31
+ type PcalWhile,
32
+ } from "./ast";
33
+
34
+ // PcalSymTab's symbol types, which index PCAL_SYMBOL_TYPE_NAMES.
35
+ const PCAL_SYMBOL = {
36
+ global: 0,
37
+ label: 1,
38
+ procedure: 2,
39
+ process: 3,
40
+ processVar: 4,
41
+ procedureVar: 5,
42
+ parameter: 6,
43
+ } as const;
44
+
45
+ // PcalSymTab.Disambiguate loops one type past the last, as num_vtypes is 7.
46
+ const PCAL_SYMBOL_TYPE_COUNT = 7;
47
+
48
+ const PCAL_SYMBOL_TYPE_NAMES = [
49
+ "Global variable",
50
+ "Label",
51
+ "Procedure",
52
+ "Process",
53
+ "Process variable",
54
+ "Procedure variable",
55
+ "Parameter",
56
+ ];
57
+
58
+ const PCAL_VARIABLE_SYMBOLS = new Set<number>([
59
+ PCAL_SYMBOL.global,
60
+ PCAL_SYMBOL.processVar,
61
+ PCAL_SYMBOL.procedureVar,
62
+ PCAL_SYMBOL.parameter,
63
+ ]);
64
+
65
+ interface PcalSymbol {
66
+ type: number;
67
+ id: string;
68
+ context: string;
69
+ useThis: string;
70
+ }
71
+
72
+ // PcalSymTab.ProcedureEntry. initialPC is the first label, which a body with no statements lacks.
73
+ interface PcalProcedureEntry {
74
+ name: string;
75
+ params: PcalPVarDecl[];
76
+ decls: PcalPVarDecl[];
77
+ initialPC: string | undefined;
78
+ }
79
+
80
+ interface PcalSymbolTable {
81
+ symbols: PcalSymbol[];
82
+ procedures: PcalProcedureEntry[];
83
+ processNames: string[];
84
+ errorReport: string;
85
+ }
86
+
87
+ // A Return or CallReturn outside a procedure has no from, and PcalSymTab.FindSym never matches a
88
+ // null id.
89
+ const findSymbol = (
90
+ table: PcalSymbolTable,
91
+ type: number,
92
+ id: string | undefined,
93
+ context: string,
94
+ ) =>
95
+ table.symbols.find(
96
+ (symbol) => symbol.id === id && symbol.context === context && symbol.type === type,
97
+ );
98
+
99
+ const findSymbolInContext = (table: PcalSymbolTable, id: string, context: string) =>
100
+ table.symbols.find((symbol) => symbol.id === id && symbol.context === context);
101
+
102
+ // PcalSymTab.FindProc returns the number of procedures when it finds none.
103
+ const findProcedureIndex = (table: PcalSymbolTable, name: string) => {
104
+ const index = table.procedures.findIndex((procedure) => procedure.name === name);
105
+ return index === -1 ? table.procedures.length : index;
106
+ };
107
+
108
+ const insertSymbol = (table: PcalSymbolTable, type: number, id: string, context: string) => {
109
+ const isVariable =
110
+ type === PCAL_SYMBOL.procedureVar ||
111
+ type === PCAL_SYMBOL.processVar ||
112
+ type === PCAL_SYMBOL.parameter;
113
+ const isDefined = isVariable
114
+ ? findSymbol(table, PCAL_SYMBOL.global, id, "") !== undefined ||
115
+ findSymbolInContext(table, id, context) !== undefined
116
+ : findSymbol(table, type, id, context) !== undefined;
117
+ if (isDefined) return false;
118
+ table.symbols.push({ type, id, context, useThis: id });
119
+ return true;
120
+ };
121
+
122
+ const useThis = (table: PcalSymbolTable, type: number, id: string, context: string) =>
123
+ findSymbol(table, type, id, context)?.useThis ?? id;
124
+
125
+ const useThisVar = (table: PcalSymbolTable, id: string, context: string) => {
126
+ const symbol = findSymbolInContext(table, id, context);
127
+ if (symbol === undefined) return id;
128
+ return PCAL_VARIABLE_SYMBOLS.has(symbol.type) ? symbol.useThis : id;
129
+ };
130
+
131
+ // The PcalSymTab constructor: collects the algorithm's variables, labels, procedures and processes,
132
+ // reporting every redefinition at once.
133
+ const createPcalSymbolTable = (ast: PcalAlgorithm) => {
134
+ const table: PcalSymbolTable = {
135
+ symbols: [],
136
+ procedures: [],
137
+ processNames: [],
138
+ errorReport: "",
139
+ };
140
+
141
+ const extractLabeledStmt = (labeledStmt: PcalLabeledStmt, context: string) => {
142
+ if (!insertSymbol(table, PCAL_SYMBOL.label, labeledStmt.label, context)) {
143
+ table.errorReport += `\nLabel ${labeledStmt.label} redefined at line ${labeledStmt.line}, column ${labeledStmt.col}`;
144
+ }
145
+ labeledStmt.stmts.forEach((stmt) => extractStmt(stmt, context));
146
+ };
147
+
148
+ const extractStmt = (stmt: PcalStmt, context: string): void => {
149
+ const extractStmts = (stmts: PcalStmt[]) =>
150
+ stmts.forEach((innerStmt) => extractStmt(innerStmt, context));
151
+ const extractLabeledStmts = (stmts: PcalLabeledStmt[]) =>
152
+ stmts.forEach((innerStmt) => extractLabeledStmt(innerStmt, context));
153
+ switch (stmt.kind) {
154
+ case "While":
155
+ extractStmts(stmt.unlabDo);
156
+ extractLabeledStmts(stmt.labDo);
157
+ return;
158
+ case "If":
159
+ extractStmts(stmt.Then);
160
+ extractStmts(stmt.Else);
161
+ return;
162
+ case "With":
163
+ extractStmts(stmt.Do);
164
+ return;
165
+ case "LabelIf":
166
+ extractStmts(stmt.unlabThen);
167
+ extractLabeledStmts(stmt.labThen);
168
+ extractStmts(stmt.unlabElse);
169
+ extractLabeledStmts(stmt.labElse);
170
+ return;
171
+ case "Either":
172
+ stmt.ors.forEach(extractStmts);
173
+ return;
174
+ case "LabelEither":
175
+ stmt.clauses.forEach((clause) => {
176
+ extractStmts(clause.unlabOr);
177
+ extractLabeledStmts(clause.labOr);
178
+ });
179
+ return;
180
+ case "Assign":
181
+ case "When":
182
+ case "PrintS":
183
+ case "Assert":
184
+ case "Skip":
185
+ case "Call":
186
+ case "Return":
187
+ case "CallReturn":
188
+ case "CallGoto":
189
+ case "Goto":
190
+ return;
191
+ default:
192
+ throw new PcalBugError(`Unexpected AST type ${stmt.kind}`);
193
+ }
194
+ };
195
+
196
+ const extractVarDecl = (
197
+ decl: PcalVarDecl | PcalPVarDecl,
198
+ context: string,
199
+ type: number = context === "" ? PCAL_SYMBOL.global : PCAL_SYMBOL.processVar,
200
+ ) => {
201
+ if (!insertSymbol(table, type, decl.var, context)) {
202
+ table.errorReport += `\n${PCAL_SYMBOL_TYPE_NAMES[type]} ${decl.var} redefined at line ${decl.line}, column ${decl.col}`;
203
+ }
204
+ };
205
+
206
+ const extractProcedure = (procedure: PcalProcedure) => {
207
+ const isRedefined = findProcedureIndex(table, procedure.name) < table.procedures.length;
208
+ if (isRedefined) {
209
+ table.errorReport += `\nProcedure ${procedure.name} redefined at line ${procedure.line}, column ${procedure.col}`;
210
+ }
211
+ if (!isRedefined) {
212
+ table.procedures.push({
213
+ name: procedure.name,
214
+ params: procedure.params,
215
+ decls: procedure.decls,
216
+ initialPC: procedure.body.length === 0 ? undefined : toLabeledStmt(procedure.body[0]).label,
217
+ });
218
+ }
219
+ insertSymbol(table, PCAL_SYMBOL.procedure, procedure.name, "");
220
+ procedure.decls.forEach((decl) =>
221
+ extractVarDecl(decl, procedure.name, PCAL_SYMBOL.procedureVar),
222
+ );
223
+ procedure.params.forEach((param) =>
224
+ extractVarDecl(param, procedure.name, PCAL_SYMBOL.parameter),
225
+ );
226
+ procedure.body.forEach((stmt) => extractLabeledStmt(toLabeledStmt(stmt), procedure.name));
227
+ };
228
+
229
+ const extractProcess = (process: PcalProcess) => {
230
+ const isRedefined = table.processNames.includes(process.name);
231
+ if (isRedefined) {
232
+ table.errorReport += `\nProcess ${process.name} redefined at line ${process.line}, column ${process.col}`;
233
+ }
234
+ if (!isRedefined) table.processNames.push(process.name);
235
+ insertSymbol(table, PCAL_SYMBOL.process, process.name, "");
236
+ process.decls.forEach((decl) => extractVarDecl(decl, process.name));
237
+ process.body.forEach((stmt) => extractLabeledStmt(toLabeledStmt(stmt), process.name));
238
+ };
239
+
240
+ insertSymbol(table, PCAL_SYMBOL.global, "pc", "");
241
+ if (ast.prcds.length > 0) insertSymbol(table, PCAL_SYMBOL.global, "stack", "");
242
+ ast.decls.forEach((decl) => extractVarDecl(decl, ""));
243
+ ast.prcds.forEach(extractProcedure);
244
+ if (ast.kind === "Multiprocess") ast.procs.forEach(extractProcess);
245
+ if (ast.kind === "Uniprocess") {
246
+ ast.body.forEach((stmt) => extractLabeledStmt(toLabeledStmt(stmt), ""));
247
+ }
248
+ if (table.errorReport.length > 0) throw new PcalError(table.errorReport);
249
+ return table;
250
+ };
251
+
252
+ // PcalSymTab.Disambiguate: renames each symbol whose name another symbol already uses, by
253
+ // appending "_", then the letters of its context, then its type. Returns whether it renamed any.
254
+ const disambiguatePcalSymbols = (table: PcalSymbolTable) => {
255
+ const isAmbiguous = (id: string) =>
256
+ table.symbols.filter((symbol) => symbol.useThis === id).length > 1;
257
+ const renamed = { isAny: false };
258
+ for (let type = 0; type <= PCAL_SYMBOL_TYPE_COUNT; type += 1) {
259
+ table.symbols.forEach((symbol) => {
260
+ if (symbol.type !== type) return;
261
+ symbol.useThis = symbol.id;
262
+ for (let suffixLength = 1; type > 0 && isAmbiguous(symbol.useThis); suffixLength += 1) {
263
+ symbol.useThis +=
264
+ suffixLength === 1 ? "_" : (symbol.context[suffixLength - 2] ?? String(type));
265
+ }
266
+ if (symbol.id !== symbol.useThis) renamed.isAny = true;
267
+ });
268
+ }
269
+ return renamed.isAny;
270
+ };
271
+
272
+ // PcalSymTab.CheckForDefaultInitValue.
273
+ const checkForDefaultInitValue = (table: PcalSymbolTable) => {
274
+ const uses = table.symbols
275
+ .filter((symbol) => symbol.id === "defaultInitValue")
276
+ .map((symbol) => `${PCAL_SYMBOL_TYPE_NAMES[symbol.type]} name`);
277
+ if (uses.length > 0) {
278
+ throw new PcalError(`Cannot use \`defaultInitValue' as ${uses.join(" or ")}`);
279
+ }
280
+ };
281
+
282
+ // PcalFixIDs.Fix: replaces every identifier with the name PcalSymTab.Disambiguate chose for it, and
283
+ // closes each process's set of called procedures over the procedures they call.
284
+ const fixPcalIds = (ast: PcalAlgorithm, table: PcalSymbolTable, log: (line: string) => void) => {
285
+ const fixExpr = (expr: PcalExpr, context: string) => {
286
+ const names: string[] = [];
287
+ const replacements: PcalExpr[] = [];
288
+ expr.tokens.forEach((line) =>
289
+ line.forEach((token) => {
290
+ if (token.type !== PCAL_TOKEN.ident) return;
291
+ const useMe = useThisVar(table, token.string, context);
292
+ if (names.includes(token.string) || useMe === token.string) return;
293
+ names.push(token.string);
294
+ replacements.push(createNormalizedPcalExpr([[identToken(useMe)]]));
295
+ }),
296
+ );
297
+ if (replacements.length > 0) substitutePcalExpr(expr, replacements, names, false);
298
+ };
299
+
300
+ const fixVarDecl = (decl: PcalVarDecl | PcalPVarDecl, context: string) => {
301
+ decl.var = useThisVar(table, decl.var, context);
302
+ fixExpr(decl.val, context);
303
+ };
304
+
305
+ const fixLabels = (labels: string[], context: string) =>
306
+ labels.forEach((label, index) => {
307
+ labels[index] = useThis(table, PCAL_SYMBOL.label, label, context);
308
+ });
309
+
310
+ const fixProcedureName = (name: string | undefined, context: string) =>
311
+ name === undefined ? undefined : useThis(table, PCAL_SYMBOL.procedure, name, context);
312
+
313
+ const fixLabeledStmt = (labeledStmt: PcalLabeledStmt, context: string) => {
314
+ labeledStmt.label = useThis(table, PCAL_SYMBOL.label, labeledStmt.label, context);
315
+ labeledStmt.stmts.forEach((stmt) => fixStmt(stmt, context));
316
+ };
317
+
318
+ const fixStmt = (stmt: PcalStmt, context: string): void => {
319
+ const fixStmts = (stmts: PcalStmt[]) =>
320
+ stmts.forEach((innerStmt) => fixStmt(innerStmt, context));
321
+ const fixLabeledStmts = (stmts: PcalLabeledStmt[]) =>
322
+ stmts.forEach((innerStmt) => fixLabeledStmt(innerStmt, context));
323
+ const fixExprs = (exprs: PcalExpr[]) => exprs.forEach((expr) => fixExpr(expr, context));
324
+ switch (stmt.kind) {
325
+ case "LabeledStmt":
326
+ fixLabeledStmt(stmt, context);
327
+ return;
328
+ case "While":
329
+ fixStmts(stmt.unlabDo);
330
+ fixLabeledStmts(stmt.labDo);
331
+ fixExpr(stmt.test, context);
332
+ return;
333
+ case "Assign":
334
+ stmt.ass.forEach((assign) => {
335
+ assign.lhs.var = useThisVar(table, assign.lhs.var, context);
336
+ fixExpr(assign.lhs.sub, context);
337
+ fixExpr(assign.rhs, context);
338
+ });
339
+ return;
340
+ case "If":
341
+ fixStmts(stmt.Then);
342
+ fixStmts(stmt.Else);
343
+ fixExpr(stmt.test, context);
344
+ return;
345
+ case "With":
346
+ fixExpr(stmt.exp, context);
347
+ fixStmts(stmt.Do);
348
+ return;
349
+ case "When":
350
+ case "PrintS":
351
+ case "Assert":
352
+ fixExpr(stmt.exp, context);
353
+ return;
354
+ case "Skip":
355
+ return;
356
+ case "LabelIf":
357
+ fixExpr(stmt.test, context);
358
+ fixStmts(stmt.unlabThen);
359
+ fixLabeledStmts(stmt.labThen);
360
+ fixStmts(stmt.unlabElse);
361
+ fixLabeledStmts(stmt.labElse);
362
+ return;
363
+ case "Call":
364
+ stmt.returnTo = useThis(table, PCAL_SYMBOL.procedure, stmt.returnTo, context);
365
+ stmt.to = useThis(table, PCAL_SYMBOL.procedure, stmt.to, context);
366
+ fixExprs(stmt.args);
367
+ return;
368
+ case "Return":
369
+ stmt.from = fixProcedureName(stmt.from, context);
370
+ return;
371
+ case "CallReturn":
372
+ stmt.from = fixProcedureName(stmt.from, context);
373
+ stmt.to = useThis(table, PCAL_SYMBOL.procedure, stmt.to, context);
374
+ fixExprs(stmt.args);
375
+ return;
376
+ case "CallGoto":
377
+ stmt.after = useThis(table, PCAL_SYMBOL.procedure, stmt.after, context);
378
+ stmt.to = useThis(table, PCAL_SYMBOL.procedure, stmt.to, context);
379
+ fixExprs(stmt.args);
380
+ return;
381
+ case "Goto":
382
+ if (
383
+ findSymbol(table, PCAL_SYMBOL.label, stmt.to, context) === undefined &&
384
+ stmt.to !== "Done"
385
+ ) {
386
+ throw new PcalError(
387
+ `goto to non-existent label \`${stmt.to}' at line ${stmt.line}, column ${stmt.col}`,
388
+ );
389
+ }
390
+ stmt.to = useThis(table, PCAL_SYMBOL.label, stmt.to, context);
391
+ return;
392
+ case "Either":
393
+ stmt.ors.forEach(fixStmts);
394
+ return;
395
+ case "LabelEither":
396
+ stmt.clauses.forEach((clause) => {
397
+ fixStmts(clause.unlabOr);
398
+ fixLabeledStmts(clause.labOr);
399
+ });
400
+ return;
401
+ default:
402
+ throw new PcalBugError(`Unexpected AST type${stmt.kind}`);
403
+ }
404
+ };
405
+
406
+ const fixProcedure = (procedure: PcalProcedure) => {
407
+ procedure.decls.forEach((decl) => fixVarDecl(decl, procedure.name));
408
+ procedure.params.forEach((param) => fixVarDecl(param, procedure.name));
409
+ procedure.body.forEach((stmt) => fixLabeledStmt(toLabeledStmt(stmt), procedure.name));
410
+ const entry = getElement(table.procedures, findProcedureIndex(table, procedure.name));
411
+ fixLabels(procedure.plusLabels, procedure.name);
412
+ fixLabels(procedure.minusLabels, procedure.name);
413
+ if (entry.initialPC !== undefined) {
414
+ entry.initialPC = useThis(table, PCAL_SYMBOL.label, entry.initialPC, procedure.name);
415
+ }
416
+ procedure.name = useThis(table, PCAL_SYMBOL.procedure, procedure.name, "");
417
+ entry.name = procedure.name;
418
+ };
419
+
420
+ const fixProcess = (process: PcalProcess) => {
421
+ process.decls.forEach((decl) => fixVarDecl(decl, process.name));
422
+ process.body.forEach((stmt) => fixLabeledStmt(toLabeledStmt(stmt), process.name));
423
+ fixLabels(process.plusLabels, process.name);
424
+ fixLabels(process.minusLabels, process.name);
425
+ process.name = useThis(table, PCAL_SYMBOL.process, process.name, "");
426
+ };
427
+
428
+ // PcalFixIDs.FixMultiprocess: a process calling an unknown procedure stops the fixing of the
429
+ // remaining processes with an error message, but not the translation.
430
+ const fixMultiprocess = (procedures: PcalProcedure[], processes: PcalProcess[]) => {
431
+ procedures.forEach(fixProcedure);
432
+ const procedureNames = procedures.map((procedure) => procedure.name);
433
+ const isCalled = procedures.map((procedure) =>
434
+ procedureNames.map((name) => procedure.proceduresCalled.includes(name)),
435
+ );
436
+ procedureNames.forEach((_, middle) =>
437
+ isCalled.forEach((row) =>
438
+ row.forEach((isPath, end) => {
439
+ row[end] = isPath || (row[middle] && isCalled[middle][end]);
440
+ }),
441
+ ),
442
+ );
443
+ procedures.forEach((procedure, index) => {
444
+ procedure.proceduresCalled = procedureNames.filter(
445
+ (_, calleeIndex) => isCalled[index][calleeIndex],
446
+ );
447
+ });
448
+ for (const process of processes) {
449
+ fixProcess(process);
450
+ const called = process.proceduresCalled;
451
+ // Callees appended below are themselves visited, as the Java loop rereads the size.
452
+ for (let calledIndex = 0; calledIndex < called.length; calledIndex += 1) {
453
+ const procedureIndex = procedureNames.indexOf(called[calledIndex]);
454
+ if (procedureIndex === -1) {
455
+ log(
456
+ `\nUnrecoverable error:\n -- Could not find procedure name \`${called[calledIndex]}'.\n`,
457
+ );
458
+ return;
459
+ }
460
+ procedureNames.forEach((callee, calleeIndex) => {
461
+ if (isCalled[procedureIndex][calleeIndex] && !called.includes(callee))
462
+ called.push(callee);
463
+ });
464
+ }
465
+ }
466
+ };
467
+
468
+ ast.decls.forEach((decl) => fixVarDecl(decl, ""));
469
+ if (ast.kind === "Multiprocess") fixMultiprocess(ast.prcds, ast.procs);
470
+ if (ast.kind === "Uniprocess") {
471
+ ast.prcds.forEach(fixProcedure);
472
+ ast.body.forEach((stmt) => fixLabeledStmt(toLabeledStmt(stmt), ""));
473
+ }
474
+ };
475
+
476
+ // PcalTranslate's token constructors, which leave the column 0.
477
+ const stringToken = (string: string) => createPcalToken(string, 0, PCAL_TOKEN.string);
478
+ const addedToken = (string: string) => createPcalToken(string, 0, PCAL_TOKEN.added);
479
+ const builtInToken = (string: string) => createPcalToken(string, 0, PCAL_TOKEN.builtin);
480
+ const identToken = (string: string) => createPcalToken(string, 0, PCAL_TOKEN.ident);
481
+
482
+ // PcalTranslate.TokVectorToExpr: copies the tokens onto one line, spaces columns apart.
483
+ const tokensToExpr = (tokens: PcalToken[], spaces: number) => {
484
+ const line: PcalToken[] = [];
485
+ tokens.forEach((token) => {
486
+ const previous = line.at(-1);
487
+ const column =
488
+ previous === undefined ? 0 : previous.column + getPcalTokenWidth(previous) + spaces;
489
+ line.push(createPcalToken(token.string, column, token.type));
490
+ });
491
+ return createNormalizedPcalExpr([line]);
492
+ };
493
+
494
+ // PcalTranslate.MakeNewStackTopExprPretty: lays out a pushed stack frame one field per line with
495
+ // the "|->" aligned.
496
+ const prettifyStackTopExpr = (expr: PcalExpr) =>
497
+ expr.tokens.forEach((line, lineIndex) => {
498
+ const cursor = { column: lineIndex === 0 || lineIndex === expr.tokens.length - 1 ? 1 : 6 };
499
+ line.forEach((token) => {
500
+ token.column = cursor.column;
501
+ cursor.column += getPcalTokenWidth(token);
502
+ if (token.type !== PCAL_TOKEN.builtin) return;
503
+ switch (token.string) {
504
+ case "|->":
505
+ case "↦":
506
+ token.column = Math.max(16, token.column + 1);
507
+ cursor.column = token.column + 5;
508
+ return;
509
+ case "[":
510
+ case "<<":
511
+ cursor.column += 1;
512
+ return;
513
+ case "]":
514
+ case ">>":
515
+ token.column += 1;
516
+ cursor.column += 1;
517
+ return;
518
+ case "\\o":
519
+ token.column += 1;
520
+ cursor.column += 2;
521
+ }
522
+ });
523
+ });
524
+
525
+ // A new AST.SingleAssign and AST.Assign, whose line and column default to 0.
526
+ const createSingleAssign = (
527
+ variable: string,
528
+ sub: PcalExpr,
529
+ rhs: PcalExpr,
530
+ line = 0,
531
+ col = 0,
532
+ ): PcalSingleAssign => ({
533
+ ...createPcalBase(),
534
+ kind: "SingleAssign",
535
+ line,
536
+ col,
537
+ lhs: { ...createPcalBase(), kind: "Lhs", var: variable, sub },
538
+ rhs,
539
+ });
540
+
541
+ const createAssign = (assigns: PcalSingleAssign[], line = 0, col = 0): PcalAssign => ({
542
+ ...createPcalBase(),
543
+ kind: "Assign",
544
+ line,
545
+ col,
546
+ ass: assigns,
547
+ });
548
+
549
+ const makeAssign = (variable: string, expr: PcalExpr, line = 0, col = 0) =>
550
+ createAssign(
551
+ [createSingleAssign(variable, createNormalizedPcalExpr([]), expr, line, col)],
552
+ line,
553
+ col,
554
+ );
555
+
556
+ // PcalTranslate.IsTRUE, which indexes the first line of an expression without checking it has one.
557
+ const isTrue = (expr: PcalExpr) => {
558
+ if (expr.tokens.length > 1) return false;
559
+ const line = getElement(expr.tokens, 0);
560
+ if (line.length === 1) return line[0].string === "TRUE";
561
+ if (line.length === 3) {
562
+ return line[0].string === "(" && line[1].string === "TRUE" && line[2].string === ")";
563
+ }
564
+ return false;
565
+ };
566
+
567
+ const checkPC = (label: string): PcalWhen => ({
568
+ ...createPcalBase(),
569
+ kind: "When",
570
+ exp: tokensToExpr([addedToken("pc"), builtInToken("="), stringToken(label)], 1),
571
+ });
572
+
573
+ // HACK: PcalSymTab.ProcedureEntry leaves iPC null for a procedure with no statements, which
574
+ // StringToken keeps and AST.toString prints as "null".
575
+ const updatePC = (next: string | undefined) =>
576
+ makeAssign("pc", createNormalizedPcalExpr([[stringToken(next ?? "null")]]));
577
+
578
+ // `Head(stack).field`.
579
+ const getStackHeadTokens = (field: string) => [
580
+ identToken("Head"),
581
+ builtInToken("("),
582
+ addedToken("stack"),
583
+ builtInToken(")"),
584
+ builtInToken("."),
585
+ identToken(field),
586
+ ];
587
+
588
+ // `Tail(stack)`.
589
+ const getStackTailTokens = () => [
590
+ identToken("Tail"),
591
+ builtInToken("("),
592
+ addedToken("stack"),
593
+ builtInToken(")"),
594
+ ];
595
+
596
+ const createStackHeadExpr = (field: string) =>
597
+ createNormalizedPcalExpr([getStackHeadTokens(field)]);
598
+
599
+ // The `<< [ procedure |-> "name", pc |-> ..., var |-> var ] >> \o ...` that ExplodeCall and
600
+ // ExplodeCallReturn push onto the stack.
601
+ const createStackPushExpr = (
602
+ procedure: string,
603
+ pcTokens: PcalToken[],
604
+ variables: PcalPVarDecl[],
605
+ tailTokens: PcalToken[],
606
+ ) => {
607
+ const tokens: PcalToken[][] = [
608
+ [
609
+ builtInToken("<<"),
610
+ builtInToken("["),
611
+ identToken("procedure"),
612
+ builtInToken("|->"),
613
+ stringToken(procedure),
614
+ builtInToken(","),
615
+ ],
616
+ [identToken("pc"), builtInToken("|->"), ...pcTokens],
617
+ ];
618
+ variables.forEach((variable) => {
619
+ tokens[tokens.length - 1].push(builtInToken(","));
620
+ tokens.push([identToken(variable.var), builtInToken("|->"), identToken(variable.var)]);
621
+ });
622
+ tokens[tokens.length - 1].push(builtInToken("]"), builtInToken(">>"));
623
+ tokens.push(tailTokens);
624
+ const expr = createPcalExpr(tokens);
625
+ prettifyStackTopExpr(expr);
626
+ normalizePcalExpr(expr);
627
+ return expr;
628
+ };
629
+
630
+ // The statements a call explodes into after its stack push: the parameters' and the procedure
631
+ // variables' initial values and the jump to the procedure's first label.
632
+ const createCallStmts = (
633
+ assign: PcalAssign,
634
+ entry: PcalProcedureEntry,
635
+ call: PcalCall | PcalCallReturn,
636
+ ) => {
637
+ if (entry.params.length !== call.args.length) {
638
+ throw new PcalError(`Procedure ${call.to} called with wrong number of arguments`, call);
639
+ }
640
+ entry.params.forEach((param, index) =>
641
+ assign.ass.push(
642
+ createSingleAssign(
643
+ param.var,
644
+ createNormalizedPcalExpr([]),
645
+ call.args[index],
646
+ call.line,
647
+ call.col,
648
+ ),
649
+ ),
650
+ );
651
+ return [
652
+ assign,
653
+ ...entry.decls.map((decl) => makeAssign(decl.var, decl.val, call.line, call.col)),
654
+ updatePC(entry.initialPC),
655
+ ];
656
+ };
657
+
658
+ // CopyAndExplodeLastStmt's triple: the statements with their last one exploded, the labeled
659
+ // statements the explosion split off, and whether control falls off the end needing a pc update.
660
+ interface PcalExplodedStmts {
661
+ stmts: PcalStmt[];
662
+ labeledStmts: PcalLabeledStmt[];
663
+ needsGoto: boolean;
664
+ }
665
+
666
+ // PcalTranslate.Explode: turns each labeled statement into an atomic action that checks and sets
667
+ // pc, and calls, returns and gotos into stack and pc assignments. Statement lists nested in the
668
+ // original AST are exploded in place, as the Java does, so the original AST changes too.
669
+ const explodePcalAlgorithm = (
670
+ ast: PcalAlgorithm,
671
+ table: PcalSymbolTable,
672
+ omitPC: boolean,
673
+ ): PcalAlgorithm => {
674
+ // The procedure being exploded, which a return comes from.
675
+ const context: { procedure: string | undefined } = { procedure: undefined };
676
+
677
+ const explodeCall = (call: PcalCall, next: string) => {
678
+ const procedureIndex = findProcedureIndex(table, call.to);
679
+ if (procedureIndex === table.procedures.length) {
680
+ throw new PcalError(`Call of non-existent procedure ${call.to}`, call);
681
+ }
682
+ const entry = table.procedures[procedureIndex];
683
+ const stackPush = createStackPushExpr(
684
+ call.to,
685
+ [stringToken(next)],
686
+ [...entry.decls, ...entry.params],
687
+ [builtInToken("\\o"), addedToken("stack")],
688
+ );
689
+ return createCallStmts(makeAssign("stack", stackPush, call.line, call.col), entry, call);
690
+ };
691
+
692
+ const explodeReturn = (stmt: PcalReturn) => {
693
+ stmt.from ??= context.procedure;
694
+ const from = stmt.from;
695
+ if (from === undefined) throw new PcalError("`return' statement not in procedure", stmt);
696
+ const procedureIndex = findProcedureIndex(table, from);
697
+ if (procedureIndex >= table.procedures.length) {
698
+ throw new PcalError("Error in procedure (perhaps name used elsewhere)", stmt);
699
+ }
700
+ const entry = table.procedures[procedureIndex];
701
+ const restore = (variable: string, rhs: PcalExpr) =>
702
+ createAssign(
703
+ [createSingleAssign(variable, createPcalExpr(), rhs, stmt.line, stmt.col)],
704
+ stmt.line,
705
+ stmt.col,
706
+ );
707
+ return [
708
+ restore("pc", createStackHeadExpr("pc")),
709
+ ...entry.decls.map((decl) => restore(decl.var, createStackHeadExpr(decl.var))),
710
+ ...entry.params.map((param) => restore(param.var, createStackHeadExpr(param.var))),
711
+ restore("stack", createNormalizedPcalExpr([getStackTailTokens()])),
712
+ ];
713
+ };
714
+
715
+ const explodeCallReturn = (stmt: PcalCallReturn) => {
716
+ const from = stmt.from;
717
+ if (from === undefined) {
718
+ throw new PcalError(
719
+ `\`return' statement following \`call' at ${getPcalLocation(stmt)} not in a procedure`,
720
+ );
721
+ }
722
+ const fromEntry = getElement(table.procedures, findProcedureIndex(table, from));
723
+ const toIndex = findProcedureIndex(table, stmt.to);
724
+ if (toIndex === table.procedures.length) {
725
+ throw new PcalError(`Call of non-existent procedure ${stmt.to}`, stmt);
726
+ }
727
+ const toEntry = table.procedures[toIndex];
728
+ const assign = createAssign([], stmt.line, stmt.col);
729
+ // A tail call to the procedure itself reuses its stack frame.
730
+ if (from !== stmt.to) {
731
+ fromEntry.decls.forEach((decl) =>
732
+ assign.ass.push(
733
+ createSingleAssign(
734
+ decl.var,
735
+ createPcalExpr(),
736
+ createStackHeadExpr(decl.var),
737
+ stmt.line,
738
+ stmt.col,
739
+ ),
740
+ ),
741
+ );
742
+ const stackPush = createStackPushExpr(
743
+ stmt.to,
744
+ getStackHeadTokens("pc"),
745
+ [...toEntry.decls, ...toEntry.params],
746
+ [builtInToken("\\o"), ...getStackTailTokens()],
747
+ );
748
+ assign.ass.push(
749
+ createSingleAssign("stack", createNormalizedPcalExpr([]), stackPush, stmt.line, stmt.col),
750
+ );
751
+ }
752
+ return createCallStmts(assign, toEntry, stmt);
753
+ };
754
+
755
+ // PcalTranslate.CopyAndExplodeLastStmt: explodes the last statement of stmts in place, recursing
756
+ // into the branches of a trailing if, either or with.
757
+ const copyAndExplodeLastStmt = (stmts: PcalStmt[], next: string): PcalExplodedStmts => {
758
+ if (stmts.length === 0) return { stmts: [], labeledStmts: [], needsGoto: !omitPC };
759
+ const result: PcalExplodedStmts = { stmts, labeledStmts: [], needsGoto: false };
760
+ const last = stmts[stmts.length - 1];
761
+ switch (last.kind) {
762
+ case "LabelIf":
763
+ case "LabelEither": {
764
+ const exploded =
765
+ last.kind === "LabelIf" ? explodeLabelIf(last, next) : explodeLabelEither(last, next);
766
+ stmts.pop();
767
+ stmts.push(exploded.stmt);
768
+ result.labeledStmts = exploded.labeledStmts;
769
+ break;
770
+ }
771
+ case "Goto":
772
+ stmts.pop();
773
+ stmts.push(updatePC(last.to));
774
+ break;
775
+ case "Call":
776
+ stmts.pop();
777
+ stmts.push(...explodeCall(last, next));
778
+ break;
779
+ case "Return":
780
+ stmts.pop();
781
+ stmts.push(...explodeReturn(last));
782
+ break;
783
+ case "CallReturn":
784
+ stmts.pop();
785
+ stmts.push(...explodeCallReturn(last));
786
+ break;
787
+ case "CallGoto":
788
+ stmts.pop();
789
+ stmts.push(
790
+ ...explodeCall(
791
+ {
792
+ ...createPcalBase(),
793
+ kind: "Call",
794
+ returnTo: "",
795
+ to: last.to,
796
+ args: last.args,
797
+ line: last.line,
798
+ col: last.col,
799
+ },
800
+ last.after,
801
+ ),
802
+ );
803
+ break;
804
+ case "If": {
805
+ const explodedThen = copyAndExplodeLastStmt(last.Then, next);
806
+ const explodedElse = copyAndExplodeLastStmt(last.Else, next);
807
+ result.labeledStmts.push(...explodedThen.labeledStmts, ...explodedElse.labeledStmts);
808
+ last.Then = explodedThen.stmts;
809
+ last.Else = explodedElse.stmts;
810
+ if (!omitPC) {
811
+ result.needsGoto = explodedThen.needsGoto && explodedElse.needsGoto;
812
+ if (!result.needsGoto) {
813
+ if (explodedThen.needsGoto) last.Then.push(updatePC(next));
814
+ if (explodedElse.needsGoto) last.Else.push(updatePC(next));
815
+ }
816
+ }
817
+ break;
818
+ }
819
+ case "Either": {
820
+ const explodedOrs = last.ors.map((orStmts, index) => {
821
+ const exploded = copyAndExplodeLastStmt(orStmts, next);
822
+ last.ors[index] = exploded.stmts;
823
+ result.labeledStmts.push(...exploded.labeledStmts);
824
+ return exploded;
825
+ });
826
+ result.needsGoto = explodedOrs.every((exploded) => exploded.needsGoto);
827
+ if (!omitPC && !result.needsGoto) {
828
+ explodedOrs.forEach((exploded, index) => {
829
+ if (exploded.needsGoto) last.ors[index].push(updatePC(next));
830
+ });
831
+ }
832
+ break;
833
+ }
834
+ case "With": {
835
+ const exploded = copyAndExplodeLastStmt(last.Do, next);
836
+ last.Do = exploded.stmts;
837
+ result.labeledStmts.push(...exploded.labeledStmts);
838
+ result.needsGoto = exploded.needsGoto;
839
+ break;
840
+ }
841
+ default:
842
+ result.needsGoto = true;
843
+ }
844
+ if (omitPC) result.needsGoto = false;
845
+ return result;
846
+ };
847
+
848
+ const copyAndExplodeLastStmtWithGoto = (stmts: PcalStmt[], next: string) => {
849
+ const exploded = copyAndExplodeLastStmt(stmts, next);
850
+ if (exploded.needsGoto) exploded.stmts.push(updatePC(next));
851
+ return exploded;
852
+ };
853
+
854
+ const explodeLabeledStmt = (labeledStmt: PcalLabeledStmt, next: string): PcalLabeledStmt[] => {
855
+ const first = labeledStmt.stmts.at(0);
856
+ if (first?.kind === "While") return explodeWhile(labeledStmt, first, next);
857
+ const exploded = copyAndExplodeLastStmtWithGoto([...labeledStmt.stmts], next);
858
+ const result: PcalLabeledStmt[] = [];
859
+ // With omitPC, PcalTranslate.ExplodeLabeledStmt drops the labeled statement itself.
860
+ if (!omitPC) {
861
+ exploded.stmts.unshift(checkPC(labeledStmt.label));
862
+ result.push({
863
+ ...createPcalBase(),
864
+ kind: "LabeledStmt",
865
+ col: labeledStmt.col,
866
+ line: labeledStmt.line,
867
+ label: labeledStmt.label,
868
+ stmts: exploded.stmts,
869
+ });
870
+ }
871
+ result.push(...exploded.labeledStmts);
872
+ return result;
873
+ };
874
+
875
+ const explodeLabeledStmtSeq = (seq: PcalLabeledStmt[], next: string) =>
876
+ seq.flatMap((labeledStmt, index) =>
877
+ explodeLabeledStmt(labeledStmt, index < seq.length - 1 ? seq[index + 1].label : next),
878
+ );
879
+
880
+ // PcalTranslate.ExplodeWhile: the loop's label tests the condition, running the unlabeled body
881
+ // or the statements after the loop.
882
+ const explodeWhile = (labeledStmt: PcalLabeledStmt, loop: PcalWhile, next: string) => {
883
+ const unlabDoNext = loop.labDo.length === 0 ? labeledStmt.label : loop.labDo[0].label;
884
+ const explodedBody = copyAndExplodeLastStmtWithGoto([...loop.unlabDo], unlabDoNext);
885
+ const explodedRest = copyAndExplodeLastStmtWithGoto(labeledStmt.stmts.slice(1), next);
886
+ const isForever = isTrue(loop.test);
887
+ const loopStmts: PcalStmt[] = isForever
888
+ ? explodedBody.stmts
889
+ : [
890
+ {
891
+ ...createPcalBase(),
892
+ kind: "If",
893
+ test: loop.test,
894
+ Then: explodedBody.stmts,
895
+ Else: explodedRest.stmts,
896
+ },
897
+ ];
898
+ const newLabeledStmt: PcalLabeledStmt = {
899
+ ...createPcalBase(),
900
+ kind: "LabeledStmt",
901
+ col: labeledStmt.col,
902
+ line: labeledStmt.line,
903
+ label: labeledStmt.label,
904
+ stmts: [...(omitPC ? [] : [checkPC(labeledStmt.label)]), ...loopStmts],
905
+ };
906
+ return [
907
+ newLabeledStmt,
908
+ ...explodeLabeledStmtSeq(loop.labDo, labeledStmt.label),
909
+ ...explodedBody.labeledStmts,
910
+ ...(isForever ? [] : explodedRest.labeledStmts),
911
+ ];
912
+ };
913
+
914
+ const explodeLabelIf = (stmt: PcalLabelIf, next: string) => {
915
+ const explodedThen = copyAndExplodeLastStmtWithGoto(
916
+ stmt.unlabThen,
917
+ stmt.labThen.length === 0 ? next : stmt.labThen[0].label,
918
+ );
919
+ const explodedElse = copyAndExplodeLastStmtWithGoto(
920
+ stmt.unlabElse,
921
+ stmt.labElse.length === 0 ? next : stmt.labElse[0].label,
922
+ );
923
+ const labeledStmts = explodeLabeledStmtSeq(stmt.labThen, next);
924
+ labeledStmts.push(...explodeLabeledStmtSeq(stmt.labElse, next));
925
+ labeledStmts.push(...explodedThen.labeledStmts, ...explodedElse.labeledStmts);
926
+ const newIf: PcalStmt = {
927
+ ...createPcalBase(),
928
+ kind: "If",
929
+ col: stmt.col,
930
+ line: stmt.line,
931
+ test: stmt.test,
932
+ Then: explodedThen.stmts,
933
+ Else: explodedElse.stmts,
934
+ };
935
+ return { stmt: newIf, labeledStmts };
936
+ };
937
+
938
+ const explodeLabelEither = (stmt: PcalLabelEither, next: string) => {
939
+ const ors: PcalStmt[][] = [];
940
+ const labeledStmts: PcalLabeledStmt[] = [];
941
+ stmt.clauses.forEach((clause) => {
942
+ const exploded = copyAndExplodeLastStmtWithGoto(
943
+ clause.unlabOr,
944
+ clause.labOr.length > 0 ? clause.labOr[0].label : next,
945
+ );
946
+ ors.push(exploded.stmts);
947
+ labeledStmts.push(...exploded.labeledStmts);
948
+ labeledStmts.push(...explodeLabeledStmtSeq(clause.labOr, next));
949
+ });
950
+ const newEither: PcalStmt = {
951
+ ...createPcalBase(),
952
+ kind: "Either",
953
+ col: stmt.col,
954
+ line: stmt.line,
955
+ ors,
956
+ };
957
+ return { stmt: newEither, labeledStmts };
958
+ };
959
+
960
+ const explodeBody = (body: PcalStmt[], next: string) =>
961
+ explodeLabeledStmtSeq(body.map(toLabeledStmt), next);
962
+
963
+ const explodeProcedure = (procedure: PcalProcedure): PcalProcedure => {
964
+ context.procedure = procedure.name;
965
+ const body = explodeBody(procedure.body, useThis(table, PCAL_SYMBOL.label, "Error", ""));
966
+ context.procedure = undefined;
967
+ return {
968
+ ...createPcalBase(),
969
+ kind: "Procedure",
970
+ col: procedure.col,
971
+ line: procedure.line,
972
+ name: procedure.name,
973
+ minusLabels: [],
974
+ plusLabels: [],
975
+ proceduresCalled: [],
976
+ params: procedure.params,
977
+ decls: procedure.decls,
978
+ body,
979
+ };
980
+ };
981
+
982
+ const explodeProcess = (process: PcalProcess): PcalProcess => ({
983
+ ...createPcalBase(),
984
+ kind: "Process",
985
+ col: process.col,
986
+ line: process.line,
987
+ name: process.name,
988
+ fairness: 0,
989
+ minusLabels: [],
990
+ plusLabels: [],
991
+ proceduresCalled: [],
992
+ isEq: process.isEq,
993
+ id: process.id,
994
+ decls: process.decls,
995
+ body: explodeBody(process.body, "Done"),
996
+ });
997
+
998
+ const prcds = ast.prcds.map(explodeProcedure);
999
+ if (ast.kind === "Uniprocess") {
1000
+ return {
1001
+ ...createPcalBase(),
1002
+ kind: "Uniprocess",
1003
+ col: ast.col,
1004
+ line: ast.line,
1005
+ name: ast.name,
1006
+ decls: ast.decls,
1007
+ defs: ast.defs,
1008
+ macros: [],
1009
+ prcds,
1010
+ body: explodeBody(ast.body, "Done"),
1011
+ };
1012
+ }
1013
+ return {
1014
+ ...createPcalBase(),
1015
+ kind: "Multiprocess",
1016
+ col: ast.col,
1017
+ line: ast.line,
1018
+ name: ast.name,
1019
+ decls: ast.decls,
1020
+ defs: ast.defs,
1021
+ macros: [],
1022
+ prcds,
1023
+ procs: ast.procs.map(explodeProcess),
1024
+ };
1025
+ };
1026
+
1027
+ // The parts of PcalTLAGen.generate that change the AST or throw: GenVarsAndDefs's check that
1028
+ // there are variables, and GenAssign's sorting of multiple assignments and its checks that each
1029
+ // variable is declared and assigned at most once per step. Changed counts the assignments to each
1030
+ // variable along the paths through a labeled statement.
1031
+ const checkPcalTlaGen = (explodedAst: PcalAlgorithm, omitPC: boolean) => {
1032
+ const vars = omitPC ? [] : ["pc"];
1033
+ vars.push(...explodedAst.decls.map((decl) => decl.var));
1034
+ if (explodedAst.prcds.length > 0) vars.push("stack");
1035
+ explodedAst.prcds.forEach((procedure) => {
1036
+ vars.push(...procedure.params.map((param) => param.var));
1037
+ vars.push(...procedure.decls.map((decl) => decl.var));
1038
+ });
1039
+ if (explodedAst.kind === "Multiprocess") {
1040
+ explodedAst.procs.forEach((process) => vars.push(...process.decls.map((decl) => decl.var)));
1041
+ }
1042
+ if (vars.length === 0) throw new PcalError("The algorithm has no variables.");
1043
+
1044
+ // Changed.Set, which counts only the first of duplicate variable names.
1045
+ const setChanged = (changed: number[], variable: string) => {
1046
+ const index = vars.indexOf(variable);
1047
+ if (index === -1) return 0;
1048
+ changed[index] += 1;
1049
+ return changed[index];
1050
+ };
1051
+
1052
+ const mergeChanged = (changed: number[], other: number[]) =>
1053
+ other.forEach((count, index) => {
1054
+ changed[index] = Math.max(changed[index], count);
1055
+ });
1056
+
1057
+ // PcalTLAGen.SortSass: a stable sort by variable name, in String.compareTo's UTF-16 order.
1058
+ const sortSass = (assigns: PcalSingleAssign[]) =>
1059
+ [...assigns].sort((left, right) =>
1060
+ left.lhs.var < right.lhs.var ? -1 : left.lhs.var > right.lhs.var ? 1 : 0,
1061
+ );
1062
+
1063
+ const genAssign = (assign: PcalAssign, changed: number[]) => {
1064
+ const thisChanged = [...changed];
1065
+ assign.ass = sortSass(assign.ass);
1066
+ // The sort puts the assignments to each variable next to each other.
1067
+ new Set(assign.ass.map((single) => single.lhs.var)).forEach((variable) => {
1068
+ const group = assign.ass.filter((single) => single.lhs.var === variable);
1069
+ if (!vars.includes(variable)) {
1070
+ throw new PcalError(`Assignment to undeclared variable ${variable}`, group[0]);
1071
+ }
1072
+ // GenAssign also notes whether the assignment after the group lacks a subscript, but its
1073
+ // loop ends before reading that, so only the group's own assignments count.
1074
+ const hasAssignmentWithNoSubscript = group.some(
1075
+ (single) => single.lhs.sub.tokens.length === 0,
1076
+ );
1077
+ if (
1078
+ setChanged(thisChanged, variable) > 1 ||
1079
+ (group.length > 1 && hasAssignmentWithNoSubscript)
1080
+ ) {
1081
+ throw new PcalError(`Multiple assignment to ${variable}`, assign);
1082
+ }
1083
+ });
1084
+ mergeChanged(changed, thisChanged);
1085
+ };
1086
+
1087
+ const genStmt = (stmt: PcalStmt, changed: number[]): void => {
1088
+ switch (stmt.kind) {
1089
+ case "Assign":
1090
+ genAssign(stmt, changed);
1091
+ return;
1092
+ case "If": {
1093
+ const thenChanged = [...changed];
1094
+ const elseChanged = [...changed];
1095
+ stmt.Then.forEach((innerStmt) => genStmt(innerStmt, thenChanged));
1096
+ stmt.Else.forEach((innerStmt) => genStmt(innerStmt, elseChanged));
1097
+ mergeChanged(changed, thenChanged);
1098
+ mergeChanged(changed, elseChanged);
1099
+ return;
1100
+ }
1101
+ case "Either": {
1102
+ const allChanged = [...changed];
1103
+ stmt.ors.forEach((orStmts) => {
1104
+ const orChanged = [...changed];
1105
+ orStmts.forEach((innerStmt) => genStmt(innerStmt, orChanged));
1106
+ mergeChanged(allChanged, orChanged);
1107
+ });
1108
+ mergeChanged(changed, allChanged);
1109
+ return;
1110
+ }
1111
+ case "With":
1112
+ stmt.Do.forEach((innerStmt) => genStmt(innerStmt, changed));
1113
+ return;
1114
+ case "When":
1115
+ case "PrintS":
1116
+ case "Assert":
1117
+ case "Skip":
1118
+ return;
1119
+ default:
1120
+ throw new PcalBugError(`Unexpected AST type ${stmt.kind}`);
1121
+ }
1122
+ };
1123
+
1124
+ const genBody = (body: PcalStmt[]) =>
1125
+ body.forEach((stmt) => {
1126
+ const changed = vars.map(() => 0);
1127
+ toLabeledStmt(stmt).stmts.forEach((innerStmt) => genStmt(innerStmt, changed));
1128
+ });
1129
+
1130
+ explodedAst.prcds.forEach((procedure) => genBody(procedure.body));
1131
+ (explodedAst.kind === "Uniprocess"
1132
+ ? [explodedAst.body]
1133
+ : explodedAst.procs.map((process) => process.body)
1134
+ ).forEach(genBody);
1135
+ };
1136
+
1137
+ // PCalTLAGenerator.removeNameConflicts followed by translate, for what they do to the AST and the
1138
+ // errors they report: the symbol table's renaming, PcalFixIDs, PcalTranslate.Explode and the checks
1139
+ // PcalTLAGen makes while generating the TLA+ translation, which SANY discards.
1140
+ export const translatePcalAlgorithm = (
1141
+ ast: PcalAlgorithm,
1142
+ omitPC: boolean,
1143
+ hasDefaultInitialization: boolean,
1144
+ log: (line: string) => void,
1145
+ ) => {
1146
+ const table = createPcalSymbolTable(ast);
1147
+ if (disambiguatePcalSymbols(table)) log("Warning: symbols were renamed.");
1148
+ fixPcalIds(ast, table, log);
1149
+ checkPcalTlaGen(explodePcalAlgorithm(ast, table, omitPC), omitPC);
1150
+ if (hasDefaultInitialization) checkForDefaultInitValue(table);
1151
+ };