tla-ts 0.0.4-dev.6dec595 → 0.0.4-dev.7b5087a

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 (307) hide show
  1. package/README.md +27 -141
  2. package/dist/deciders.cjs +366 -0
  3. package/dist/deciders.js +366 -0
  4. package/dist/index.cjs +1 -1
  5. package/dist/index.d.cts +35 -1
  6. package/dist/index.d.ts +35 -1
  7. package/dist/index.js +1 -1
  8. package/dist/parallel-worker.cjs +1 -4
  9. package/dist/parallel-worker.js +1 -4
  10. package/dist/prove-worker.cjs +9 -0
  11. package/dist/prove-worker.d.cts +9 -0
  12. package/dist/prove-worker.d.ts +9 -0
  13. package/dist/prove-worker.js +9 -0
  14. package/dist/prove.cjs +996 -0
  15. package/dist/prove.js +996 -0
  16. package/dist/run-cli.cjs +517 -47
  17. package/dist/run-cli.js +517 -47
  18. package/dist/tlapm.cjs +10 -0
  19. package/dist/tlapm.js +10 -0
  20. package/dist/transfer.cjs +38 -44
  21. package/dist/transfer.js +38 -44
  22. package/dist/worker.cjs +21 -0
  23. package/dist/worker.js +21 -0
  24. package/package.json +21 -12
  25. package/src/errors.ts +86 -0
  26. package/src/evaluate.ts +28 -7
  27. package/src/index.ts +10 -0
  28. package/src/{obligation-action.ts → obligations/action.ts} +258 -37
  29. package/src/{obligation-anon.ts → obligations/anon.ts} +13 -7
  30. package/src/obligations/ctx.ts +64 -0
  31. package/src/{obligation-deref.ts → obligations/deref.ts} +2 -2
  32. package/src/{obligation-expression.ts → obligations/expression.ts} +54 -8
  33. package/src/{obligation-format.ts → obligations/format.ts} +6 -5
  34. package/src/{obligation-generate.ts → obligations/generate.ts} +134 -61
  35. package/src/{obligations.ts → obligations/index.ts} +28 -12
  36. package/src/{obligation-levels.ts → obligations/levels.ts} +12 -2
  37. package/src/{obligation-module.ts → obligations/module.ts} +46 -20
  38. package/src/obligations/pickle.ts +100 -0
  39. package/src/obligations/pragma.ts +189 -0
  40. package/src/{obligation-printer.ts → obligations/printer.ts} +9 -63
  41. package/src/{obligation-proof.ts → obligations/proof.ts} +7 -1
  42. package/src/{obligation-source.ts → obligations/source.ts} +91 -35
  43. package/src/obligations/temporal.ts +319 -0
  44. package/src/{obligation-tuples.ts → obligations/tuples.ts} +1 -1
  45. package/src/ocaml-marshal.ts +172 -0
  46. package/src/parallel-worker.ts +2 -18
  47. package/src/parallel.ts +10 -43
  48. package/src/prove/decide-pool.ts +100 -0
  49. package/src/prove/deciders.ts +33 -0
  50. package/src/prove/isabelle/LICENSE +36 -0
  51. package/src/prove/isabelle/LICENSE-tlapm +26 -0
  52. package/src/prove/isabelle/decide.ts +47 -0
  53. package/src/prove/isabelle/encode.ts +512 -0
  54. package/src/prove/isabelle/isar/inner-syntax.ts +579 -0
  55. package/src/prove/isabelle/isar/method.ts +367 -0
  56. package/src/prove/isabelle/isar/proof.ts +28 -0
  57. package/src/prove/isabelle/isar/statement.ts +57 -0
  58. package/src/prove/isabelle/isar/theory.ts +192 -0
  59. package/src/prove/isabelle/isar/type-check.ts +278 -0
  60. package/src/prove/isabelle/provers/blast/blast.ts +258 -0
  61. package/src/prove/isabelle/provers/blast/branch.ts +322 -0
  62. package/src/prove/isabelle/provers/blast/prove.ts +347 -0
  63. package/src/prove/isabelle/provers/blast/rules.ts +330 -0
  64. package/src/prove/isabelle/provers/blast/state.ts +180 -0
  65. package/src/prove/isabelle/provers/blast/term.ts +547 -0
  66. package/src/prove/isabelle/provers/clasimp.ts +150 -0
  67. package/src/prove/isabelle/provers/classical.ts +389 -0
  68. package/src/prove/isabelle/provers/hypsubst.ts +441 -0
  69. package/src/prove/isabelle/pure/bicompose.ts +174 -0
  70. package/src/prove/isabelle/pure/consts.ts +32 -0
  71. package/src/prove/isabelle/pure/conv.ts +79 -0
  72. package/src/prove/isabelle/pure/drule.ts +264 -0
  73. package/src/prove/isabelle/pure/envir.ts +363 -0
  74. package/src/prove/isabelle/pure/goal.ts +53 -0
  75. package/src/prove/isabelle/pure/interrupt.ts +16 -0
  76. package/src/prove/isabelle/pure/list.ts +12 -0
  77. package/src/prove/isabelle/pure/logic.ts +402 -0
  78. package/src/prove/isabelle/pure/name.ts +110 -0
  79. package/src/prove/isabelle/pure/net.ts +262 -0
  80. package/src/prove/isabelle/pure/object-logic.ts +41 -0
  81. package/src/prove/isabelle/pure/pattern.ts +650 -0
  82. package/src/prove/isabelle/pure/raw-simplifier.ts +353 -0
  83. package/src/prove/isabelle/pure/rewriter.ts +602 -0
  84. package/src/prove/isabelle/pure/search.ts +68 -0
  85. package/src/prove/isabelle/pure/seq.ts +156 -0
  86. package/src/prove/isabelle/pure/simplifier.ts +112 -0
  87. package/src/prove/isabelle/pure/table.ts +208 -0
  88. package/src/prove/isabelle/pure/tactic.ts +276 -0
  89. package/src/prove/isabelle/pure/tactical.ts +347 -0
  90. package/src/prove/isabelle/pure/term-ord.ts +159 -0
  91. package/src/prove/isabelle/pure/term.ts +808 -0
  92. package/src/prove/isabelle/pure/thm.ts +806 -0
  93. package/src/prove/isabelle/pure/type.ts +133 -0
  94. package/src/prove/isabelle/pure/unify.ts +753 -0
  95. package/src/prove/isabelle/pure/variable.ts +25 -0
  96. package/src/prove/isabelle/tla/classical-setup.ts +101 -0
  97. package/src/prove/isabelle/tla/context.ts +74 -0
  98. package/src/prove/isabelle/tla/logic-data.ts +5 -0
  99. package/src/prove/isabelle/tla/logic.ts +215 -0
  100. package/src/prove/isabelle/tla/simpdata.ts +241 -0
  101. package/src/prove/isabelle/tools/intuitionistic.ts +132 -0
  102. package/src/prove/ocaml.ts +22 -0
  103. package/src/prove/prep/action.ts +520 -0
  104. package/src/prove/prep/defs.ts +33 -0
  105. package/src/prove/prep/elab.ts +156 -0
  106. package/src/prove/prep/enabled-axioms.ts +189 -0
  107. package/src/prove/prep/enabled.ts +43 -0
  108. package/src/prove/prep/fingerprint.ts +388 -0
  109. package/src/prove/prep/flatten.ts +70 -0
  110. package/src/prove/prep/level-comparison.ts +552 -0
  111. package/src/prove/prep/md5.ts +67 -0
  112. package/src/prove/prep/pragma.ts +221 -0
  113. package/src/prove/prep/trivial.ts +22 -0
  114. package/src/prove/prove-worker.ts +27 -0
  115. package/src/prove/prove.ts +528 -0
  116. package/src/prove/ptl/decide.ts +68 -0
  117. package/src/prove/ptl/encode.ts +256 -0
  118. package/src/prove/ptl/sat.ts +151 -0
  119. package/src/prove/ptl/tableau.ts +276 -0
  120. package/src/prove/smt/axiomatize.ts +69 -0
  121. package/src/prove/smt/axioms.ts +210 -0
  122. package/src/prove/smt/context.ts +108 -0
  123. package/src/prove/smt/data.ts +665 -0
  124. package/src/prove/smt/encode.ts +169 -0
  125. package/src/prove/smt/extensionality.ts +63 -0
  126. package/src/prove/smt/flatten.ts +127 -0
  127. package/src/prove/smt/format.ts +143 -0
  128. package/src/prove/smt/instances.ts +182 -0
  129. package/src/prove/smt/rewrite.ts +784 -0
  130. package/src/prove/smt/simplify.ts +57 -0
  131. package/src/prove/smt/solver/act-cache.ts +265 -0
  132. package/src/prove/smt/solver/arith-rewriter.ts +962 -0
  133. package/src/prove/smt/solver/array.ts +22 -0
  134. package/src/prove/smt/solver/asserted-formulas.ts +469 -0
  135. package/src/prove/smt/solver/ast-lt.ts +157 -0
  136. package/src/prove/smt/solver/ast-util.ts +147 -0
  137. package/src/prove/smt/solver/ast.ts +1315 -0
  138. package/src/prove/smt/solver/auf-solver.ts +572 -0
  139. package/src/prove/smt/solver/case-split-queue.ts +178 -0
  140. package/src/prove/smt/solver/cg-table.ts +175 -0
  141. package/src/prove/smt/solver/clause.ts +276 -0
  142. package/src/prove/smt/solver/conflict-resolution.ts +343 -0
  143. package/src/prove/smt/solver/context.ts +1292 -0
  144. package/src/prove/smt/solver/ctx-simplify.ts +334 -0
  145. package/src/prove/smt/solver/der.ts +224 -0
  146. package/src/prove/smt/solver/dyn-ack.ts +141 -0
  147. package/src/prove/smt/solver/e-matching.ts +659 -0
  148. package/src/prove/smt/solver/enode.ts +259 -0
  149. package/src/prove/smt/solver/expr-ref.ts +21 -0
  150. package/src/prove/smt/solver/expr-safe-replace.ts +172 -0
  151. package/src/prove/smt/solver/fingerprints.ts +92 -0
  152. package/src/prove/smt/solver/flat-literals.ts +51 -0
  153. package/src/prove/smt/solver/goal.ts +138 -0
  154. package/src/prove/smt/solver/hash.ts +173 -0
  155. package/src/prove/smt/solver/hashtable.ts +166 -0
  156. package/src/prove/smt/solver/internalizer.ts +1381 -0
  157. package/src/prove/smt/solver/lbool.ts +5 -0
  158. package/src/prove/smt/solver/literal.ts +24 -0
  159. package/src/prove/smt/solver/lp/bound-propagator.ts +391 -0
  160. package/src/prove/smt/solver/lp/constraints.ts +78 -0
  161. package/src/prove/smt/solver/lp/containers.ts +296 -0
  162. package/src/prove/smt/solver/lp/core-solver.ts +504 -0
  163. package/src/prove/smt/solver/lp/cross-nested.ts +224 -0
  164. package/src/prove/smt/solver/lp/dep-intervals.ts +656 -0
  165. package/src/prove/smt/solver/lp/dependency.ts +51 -0
  166. package/src/prove/smt/solver/lp/dioph-eq.ts +1181 -0
  167. package/src/prove/smt/solver/lp/explanation.ts +46 -0
  168. package/src/prove/smt/solver/lp/gomory.ts +255 -0
  169. package/src/prove/smt/solver/lp/hnf-cutter.ts +125 -0
  170. package/src/prove/smt/solver/lp/hnf.ts +281 -0
  171. package/src/prove/smt/solver/lp/int-cube.ts +295 -0
  172. package/src/prove/smt/solver/lp/int-solver.ts +514 -0
  173. package/src/prove/smt/solver/lp/lar-solver.ts +816 -0
  174. package/src/prove/smt/solver/lp/lar-term.ts +62 -0
  175. package/src/prove/smt/solver/lp/lp-settings.ts +91 -0
  176. package/src/prove/smt/solver/lp/maximize-term.ts +347 -0
  177. package/src/prove/smt/solver/lp/nex-creator.ts +381 -0
  178. package/src/prove/smt/solver/lp/nex.ts +120 -0
  179. package/src/prove/smt/solver/lp/nla-backoff.ts +43 -0
  180. package/src/prove/smt/solver/lp/nla-basics.ts +398 -0
  181. package/src/prove/smt/solver/lp/nla-core.ts +968 -0
  182. package/src/prove/smt/solver/lp/nla-divisions.ts +332 -0
  183. package/src/prove/smt/solver/lp/nla-emonics.ts +373 -0
  184. package/src/prove/smt/solver/lp/nla-factorization.ts +30 -0
  185. package/src/prove/smt/solver/lp/nla-grobner.ts +904 -0
  186. package/src/prove/smt/solver/lp/nla-horner.ts +126 -0
  187. package/src/prove/smt/solver/lp/nla-intervals.ts +265 -0
  188. package/src/prove/smt/solver/lp/nla-monomial-bounds.ts +715 -0
  189. package/src/prove/smt/solver/lp/nla-monotone.ts +59 -0
  190. package/src/prove/smt/solver/lp/nla-order.ts +307 -0
  191. package/src/prove/smt/solver/lp/nla-patcher.ts +112 -0
  192. package/src/prove/smt/solver/lp/nla-tangents.ts +251 -0
  193. package/src/prove/smt/solver/lp/nla-throttle.ts +85 -0
  194. package/src/prove/smt/solver/lp/nla-types.ts +124 -0
  195. package/src/prove/smt/solver/lp/nla-var-eqs.ts +141 -0
  196. package/src/prove/smt/solver/lp/nra-solver.ts +440 -0
  197. package/src/prove/smt/solver/lp/numeric-pair.ts +65 -0
  198. package/src/prove/smt/solver/lp/pdd-interval.ts +31 -0
  199. package/src/prove/smt/solver/lp/pdd-simplifier.ts +184 -0
  200. package/src/prove/smt/solver/lp/pdd-solver.ts +408 -0
  201. package/src/prove/smt/solver/lp/pdd.ts +971 -0
  202. package/src/prove/smt/solver/lp/random-updater.ts +138 -0
  203. package/src/prove/smt/solver/lp/static-matrix.ts +246 -0
  204. package/src/prove/smt/solver/lp/union-find.ts +96 -0
  205. package/src/prove/smt/solver/mam-compiler.ts +847 -0
  206. package/src/prove/smt/solver/mam-interpreter.ts +400 -0
  207. package/src/prove/smt/solver/maximize-ac-sharing.ts +118 -0
  208. package/src/prove/smt/solver/model-checker.ts +347 -0
  209. package/src/prove/smt/solver/model-evaluator.ts +262 -0
  210. package/src/prove/smt/solver/model-finder.ts +155 -0
  211. package/src/prove/smt/solver/model-generator.ts +97 -0
  212. package/src/prove/smt/solver/model-macro-solver.ts +728 -0
  213. package/src/prove/smt/solver/nlsat/algebraic.ts +1161 -0
  214. package/src/prove/smt/solver/nlsat/atoms.ts +238 -0
  215. package/src/prove/smt/solver/nlsat/evaluator.ts +303 -0
  216. package/src/prove/smt/solver/nlsat/explain.ts +607 -0
  217. package/src/prove/smt/solver/nlsat/interval-set.ts +351 -0
  218. package/src/prove/smt/solver/nlsat/levelwise.ts +740 -0
  219. package/src/prove/smt/solver/nlsat/mpbq.ts +161 -0
  220. package/src/prove/smt/solver/nlsat/polynomial.ts +1722 -0
  221. package/src/prove/smt/solver/nlsat/solver.ts +911 -0
  222. package/src/prove/smt/solver/nlsat/types.ts +43 -0
  223. package/src/prove/smt/solver/nlsat/upolynomial-factorization.ts +648 -0
  224. package/src/prove/smt/solver/nlsat/upolynomial.ts +996 -0
  225. package/src/prove/smt/solver/nnf.ts +469 -0
  226. package/src/prove/smt/solver/pattern-inference.ts +351 -0
  227. package/src/prove/smt/solver/poly-rewriter.ts +477 -0
  228. package/src/prove/smt/solver/propagate-values.ts +83 -0
  229. package/src/prove/smt/solver/proto-model.ts +551 -0
  230. package/src/prove/smt/solver/pull-quant.ts +139 -0
  231. package/src/prove/smt/solver/qe-lite-der.ts +526 -0
  232. package/src/prove/smt/solver/qe-lite-fm.ts +576 -0
  233. package/src/prove/smt/solver/qe-lite.ts +381 -0
  234. package/src/prove/smt/solver/qi-queue.ts +362 -0
  235. package/src/prove/smt/solver/quant-tactics.ts +117 -0
  236. package/src/prove/smt/solver/quantifier-analyzer.ts +562 -0
  237. package/src/prove/smt/solver/quantifier-manager.ts +186 -0
  238. package/src/prove/smt/solver/random-gen.ts +10 -0
  239. package/src/prove/smt/solver/rational.ts +165 -0
  240. package/src/prove/smt/solver/ref-vector.ts +62 -0
  241. package/src/prove/smt/solver/relevancy.ts +247 -0
  242. package/src/prove/smt/solver/rewriter-tpl.ts +1159 -0
  243. package/src/prove/smt/solver/rewriter.ts +843 -0
  244. package/src/prove/smt/solver/rlimit.ts +79 -0
  245. package/src/prove/smt/solver/smtlib-parser.ts +526 -0
  246. package/src/prove/smt/solver/solver.ts +71 -0
  247. package/src/prove/smt/solver/sort.ts +35 -0
  248. package/src/prove/smt/solver/sticky-generations.ts +69 -0
  249. package/src/prove/smt/solver/theory-lra-axioms.ts +340 -0
  250. package/src/prove/smt/solver/theory-lra-bounds.ts +226 -0
  251. package/src/prove/smt/solver/theory-lra-final-check.ts +252 -0
  252. package/src/prove/smt/solver/theory-lra-internalize.ts +476 -0
  253. package/src/prove/smt/solver/theory-lra-model.ts +243 -0
  254. package/src/prove/smt/solver/theory-lra-propagate.ts +405 -0
  255. package/src/prove/smt/solver/theory-lra-state.ts +43 -0
  256. package/src/prove/smt/solver/theory-lra.ts +56 -0
  257. package/src/prove/smt/solver/var-subst.ts +258 -0
  258. package/src/prove/smt/solver/z3-license.txt +10 -0
  259. package/src/prove/smt/table.ts +170 -0
  260. package/src/prove/tlapm/tlapm.ts +97 -0
  261. package/src/prove/tlaps-module.ts +510 -0
  262. package/src/prove/verdict.ts +19 -0
  263. package/src/prove/zenon/LICENSE +32 -0
  264. package/src/prove/zenon/check/check.ts +105 -0
  265. package/src/prove/zenon/check/definitions.ts +144 -0
  266. package/src/prove/zenon/check/equality.ts +182 -0
  267. package/src/prove/zenon/check/functions.ts +62 -0
  268. package/src/prove/zenon/check/keys.ts +125 -0
  269. package/src/prove/zenon/check/propositional.ts +104 -0
  270. package/src/prove/zenon/check/records.ts +188 -0
  271. package/src/prove/zenon/check/relations.ts +121 -0
  272. package/src/prove/zenon/check/rewrites.ts +224 -0
  273. package/src/prove/zenon/check/sets.ts +302 -0
  274. package/src/prove/zenon/check/terms.ts +127 -0
  275. package/src/prove/zenon/check/tla.ts +126 -0
  276. package/src/prove/zenon/decide.ts +113 -0
  277. package/src/prove/zenon/encode.ts +444 -0
  278. package/src/prove/zenon/eqrel.ts +300 -0
  279. package/src/prove/zenon/equality-rules.ts +435 -0
  280. package/src/prove/zenon/expr.ts +551 -0
  281. package/src/prove/zenon/index-table.ts +350 -0
  282. package/src/prove/zenon/isar-case.ts +513 -0
  283. package/src/prove/zenon/isar.ts +1249 -0
  284. package/src/prove/zenon/limits.ts +15 -0
  285. package/src/prove/zenon/llproof.ts +173 -0
  286. package/src/prove/zenon/mltoll.ts +1566 -0
  287. package/src/prove/zenon/node.ts +297 -0
  288. package/src/prove/zenon/ocaml.ts +169 -0
  289. package/src/prove/zenon/parse.ts +247 -0
  290. package/src/prove/zenon/phrase.ts +191 -0
  291. package/src/prove/zenon/proof.ts +198 -0
  292. package/src/prove/zenon/propositional-rules.ts +387 -0
  293. package/src/prove/zenon/rules.ts +94 -0
  294. package/src/prove/zenon/search.ts +288 -0
  295. package/src/prove/zenon/tla/functions.ts +151 -0
  296. package/src/prove/zenon/tla/llproof.ts +480 -0
  297. package/src/prove/zenon/tla/records.ts +225 -0
  298. package/src/prove/zenon/tla/rewrites.ts +447 -0
  299. package/src/prove/zenon/tla/sets.ts +304 -0
  300. package/src/prove/zenon/tla/terms.ts +181 -0
  301. package/src/prove/zenon/tla/tla.ts +506 -0
  302. package/src/run-cli.ts +338 -52
  303. package/src/tlapm-cache.ts +250 -0
  304. package/src/values.ts +8 -3
  305. package/src/worker.ts +65 -0
  306. package/dist/parallel.cjs +0 -12
  307. package/dist/parallel.js +0 -12
@@ -0,0 +1,847 @@
1
+ // Ported from Z3 (src/smt/mam.cpp), MIT license, see z3-license.txt. The code trees of Z3's matching
2
+ // abstract machine and the compiler that builds them: each pattern becomes a sequence of
3
+ // instructions, and the patterns that start with the same label share the instructions they have
4
+ // in common, so a term is matched against all of them at once and the matches come in Z3's order.
5
+ import { KIND_VAR, type AstManager } from "./ast";
6
+ import type { Context } from "./context";
7
+ import type { Enode } from "./enode";
8
+
9
+ export const OP_INIT = 0;
10
+ export const OP_BIND = 1;
11
+ export const OP_YIELD = 2;
12
+ export const OP_COMPARE = 3;
13
+ export const OP_CHECK = 4;
14
+ export const OP_FILTER = 5;
15
+ export const OP_CFILTER = 6;
16
+ export const OP_PFILTER = 7;
17
+ export const OP_CHOOSE = 8;
18
+ export const OP_NOOP = 9;
19
+ export const OP_CONTINUE = 10;
20
+ export const OP_GET_ENODE = 11;
21
+ export const OP_GET_CGR = 12;
22
+ export const OP_IS_CGR = 13;
23
+
24
+ const JOINT_NULL = 0;
25
+ export const JOINT_GROUND = 1;
26
+ export const JOINT_VAR = 2;
27
+ export const JOINT_NESTED = 3;
28
+
29
+ // A joint of a CONTINUE argument: a ground term, the register of a bound variable, or a depth-2
30
+ // joint (f ... (g ... X ...) ...), with g, the position of X in it, and X's register.
31
+ export interface Joint {
32
+ kind: number;
33
+ enode: Enode | null;
34
+ reg: number;
35
+ decl: number;
36
+ argPos: number;
37
+ }
38
+
39
+ // instruction and its subclasses in one shape. The fields an opcode does not use keep their
40
+ // defaults. reg is the register of CHECK, COMPARE (m_reg1), the filters, and the input register of
41
+ // BIND and IS_CGR. regs holds the input registers of GET_CGR and IS_CGR and the bindings of YIELD.
42
+ export interface Instruction {
43
+ op: number;
44
+ next: Instruction | null;
45
+ numArgs: number;
46
+ reg: number;
47
+ reg2: number;
48
+ oreg: number;
49
+ label: number;
50
+ enode: Enode | null;
51
+ lblLow: number;
52
+ lblHigh: number;
53
+ alt: Instruction | null;
54
+ quantifier: number;
55
+ regs: number[];
56
+ joints: Joint[];
57
+ }
58
+
59
+ export interface CodeTree {
60
+ rootLabel: number;
61
+ numArgs: number;
62
+ isFilteringCandidates: boolean;
63
+ numRegs: number;
64
+ numChoices: number;
65
+ root: Instruction;
66
+ candidates: Enode[];
67
+ // code_tree::m_candidate_gc_threshold: the number of candidates at which duplicates are dropped.
68
+ candidateGcThreshold: number;
69
+ }
70
+
71
+ // What the compiler needs from the matching abstract machine.
72
+ export interface LabelHasher {
73
+ // label_hasher.
74
+ getLabelHash(decl: number): number;
75
+ // mk_enode: the enode of a ground term, internalized at the quantifier's generation if needed.
76
+ getGroundEnode(expr: number, quantifier: number): Enode | null;
77
+ // The label hash of a ground term's enode, which set_lbl_hash gives it if it has none.
78
+ getLblHash(node: Enode): number;
79
+ }
80
+
81
+ const NOT_CHECKED = 0;
82
+ const CHECK_SET = 1;
83
+ const CHECK_SINGLETON = 2;
84
+
85
+ // FIND_BEST_CHILD_THRESHOLD and SIMPLE_SEQ_THRESHOLD.
86
+ const FIND_BEST_CHILD_THRESHOLD = 64;
87
+ const SIMPLE_SEQ_THRESHOLD = 4;
88
+
89
+ const mkInstruction = (op: number): Instruction => ({
90
+ op,
91
+ next: null,
92
+ numArgs: 0,
93
+ reg: 0,
94
+ reg2: 0,
95
+ oreg: 0,
96
+ label: -1,
97
+ enode: null,
98
+ lblLow: 0,
99
+ lblHigh: 0,
100
+ alt: null,
101
+ quantifier: -1,
102
+ regs: [],
103
+ joints: [],
104
+ });
105
+
106
+ // approx_set over 64 bits, in two words.
107
+ export const hasHash = (low: number, high: number, hash: number) =>
108
+ ((hash < 32 ? low : high) & (1 << hash)) !== 0;
109
+
110
+ const countBits = (word: number) => {
111
+ let count = 0;
112
+ for (let rest = word; rest !== 0; rest &= rest - 1) count++;
113
+ return count;
114
+ };
115
+
116
+ const setHash = (instr: Instruction, hash: number) => {
117
+ if (hash < 32) instr.lblLow |= 1 << hash;
118
+ else instr.lblHigh |= 1 << hash;
119
+ };
120
+
121
+ const mkFilter = (op: number, reg: number, low: number, high: number) => {
122
+ const instr = mkInstruction(op);
123
+ instr.reg = reg;
124
+ instr.lblLow = low;
125
+ instr.lblHigh = high;
126
+ return instr;
127
+ };
128
+
129
+ const mkSingletonFilter = (op: number, reg: number, hash: number) => {
130
+ const instr = mkFilter(op, reg, 0, 0);
131
+ setHash(instr, hash);
132
+ return instr;
133
+ };
134
+
135
+ const mkCompare = (reg1: number, reg2: number) => {
136
+ const instr = mkInstruction(OP_COMPARE);
137
+ instr.reg = reg1;
138
+ instr.reg2 = reg2;
139
+ return instr;
140
+ };
141
+
142
+ const mkCheck = (reg: number, enode: Enode | null) => {
143
+ const instr = mkInstruction(OP_CHECK);
144
+ instr.reg = reg;
145
+ instr.enode = enode;
146
+ return instr;
147
+ };
148
+
149
+ const mkChoose = (alt: Instruction | null) => {
150
+ const instr = mkInstruction(OP_CHOOSE);
151
+ instr.alt = alt;
152
+ return instr;
153
+ };
154
+
155
+ const mkInit = (numArgs: number) => {
156
+ const instr = mkInstruction(OP_INIT);
157
+ instr.numArgs = numArgs;
158
+ return instr;
159
+ };
160
+
161
+ // The patterns are the terms of a multi-pattern, and firstIndex picks the one the tree starts with.
162
+ export class Compiler {
163
+ // The pattern each register holds, -1 for none.
164
+ private registers: number[] = [];
165
+ // m_todo: the registers whose patterns are still to be processed.
166
+ private todo: number[] = [];
167
+ private aux: number[] = [];
168
+ // The register of each variable by de Bruijn index, -1 while it is unbound.
169
+ private vars: number[] = [];
170
+ private quantifier = -1;
171
+ private patterns: number[] = [];
172
+ private tree: CodeTree = {
173
+ rootLabel: -1,
174
+ numArgs: 0,
175
+ isFilteringCandidates: false,
176
+ numRegs: 0,
177
+ numChoices: 0,
178
+ root: mkInit(0),
179
+ candidates: [],
180
+ candidateGcThreshold: 0,
181
+ };
182
+ private numChoices = 0;
183
+ private isTmpTree = false;
184
+ private isMpAlreadyProcessed: boolean[] = [];
185
+ private matchedExprs = new Map<number, number>();
186
+ private marks: number[] = [];
187
+ private toReset: number[] = [];
188
+ private compatible: Instruction[] = [];
189
+ private incompatible: Instruction[] = [];
190
+ private seq: Instruction[] = [];
191
+
192
+ constructor(
193
+ private manager: AstManager,
194
+ private context: Context,
195
+ private hasher: LabelHasher,
196
+ ) {}
197
+
198
+ private getRegister(reg: number) {
199
+ return this.registers[reg] ?? -1;
200
+ }
201
+
202
+ private getMark(reg: number) {
203
+ return this.marks[reg] ?? NOT_CHECKED;
204
+ }
205
+
206
+ private setMark(reg: number, mark: number) {
207
+ this.marks[reg] = mark;
208
+ }
209
+
210
+ private isApp(expr: number) {
211
+ return expr !== -1 && this.manager.kinds[expr] !== KIND_VAR;
212
+ }
213
+
214
+ private init(tree: CodeTree, quantifier: number, patterns: number[], firstIndex: number) {
215
+ const manager = this.manager;
216
+ this.tree = tree;
217
+ this.quantifier = quantifier;
218
+ this.patterns = patterns;
219
+ this.numChoices = 0;
220
+ this.todo = [];
221
+ this.registers.fill(-1);
222
+ const first = patterns[firstIndex];
223
+ for (let index = 0; index < manager.getNumArgs(first); index++) {
224
+ this.registers[index + 1] = manager.getArg(first, index);
225
+ this.todo.push(index + 1);
226
+ }
227
+ const numDecls = manager.getQuantifier(quantifier).sorts.length;
228
+ while (this.vars.length < numDecls) this.vars.push(-1);
229
+ this.vars.fill(-1, 0, numDecls);
230
+ }
231
+
232
+ // all_args_are_bound_vars.
233
+ private isAllArgsBoundVars(expr: number) {
234
+ const manager = this.manager;
235
+ return manager.everyArg(
236
+ expr,
237
+ (arg) => manager.kinds[arg] === KIND_VAR && this.vars[manager.values[arg]] !== -1,
238
+ );
239
+ }
240
+
241
+ // get_stats: the size of a pattern and its number of unbound variables.
242
+ private getStats(expr: number) {
243
+ const manager = this.manager;
244
+ let size = 0;
245
+ let numUnboundVars = 0;
246
+ const visit = (term: number) => {
247
+ size++;
248
+ if (manager.isGround(term)) return;
249
+ for (let index = 0; index < manager.getNumArgs(term); index++) {
250
+ const arg = manager.getArg(term, index);
251
+ if (manager.kinds[arg] === KIND_VAR) {
252
+ size++;
253
+ if (this.vars[manager.values[arg]] === -1) numUnboundVars++;
254
+ } else visit(arg);
255
+ }
256
+ };
257
+ visit(expr);
258
+ return { size, numUnboundVars };
259
+ }
260
+
261
+ // linearise_core: the registers in m_todo that do not need a BIND are processed first, then a
262
+ // single BIND or IS_CGR is produced, and the registers left and the new ones become m_todo.
263
+ private lineariseCore() {
264
+ const manager = this.manager;
265
+ const hasher = this.hasher;
266
+ this.aux.length = 0;
267
+ let firstApp = -1;
268
+ let firstAppReg = 0;
269
+ let firstAppSize = 0;
270
+ let firstAppNumUnboundVars = 0;
271
+ for (const reg of this.todo) {
272
+ const pattern = this.registers[reg];
273
+ if (manager.kinds[pattern] === KIND_VAR) {
274
+ const varIndex = manager.values[pattern];
275
+ if (this.vars[varIndex] !== -1) this.seq.push(mkCompare(this.vars[varIndex], reg));
276
+ else this.vars[varIndex] = reg;
277
+ continue;
278
+ }
279
+ if (manager.isGround(pattern)) {
280
+ this.seq.push(mkCheck(reg, hasher.getGroundEnode(pattern, this.quantifier)));
281
+ this.setMark(reg, NOT_CHECKED);
282
+ continue;
283
+ }
284
+ const matchedReg = this.matchedExprs.get(pattern);
285
+ if (matchedReg !== undefined && reg !== matchedReg) {
286
+ this.seq.push(mkCompare(matchedReg, reg));
287
+ this.setMark(reg, NOT_CHECKED);
288
+ continue;
289
+ }
290
+ this.matchedExprs.set(pattern, reg);
291
+ if (this.getMark(reg) !== CHECK_SINGLETON) {
292
+ this.seq.push(
293
+ mkSingletonFilter(OP_FILTER, reg, hasher.getLabelHash(manager.decls[pattern])),
294
+ );
295
+ this.setMark(reg, CHECK_SINGLETON);
296
+ }
297
+ if (firstApp === -1) {
298
+ firstApp = pattern;
299
+ firstAppReg = reg;
300
+ const stats = this.getStats(pattern);
301
+ firstAppSize = stats.size;
302
+ firstAppNumUnboundVars = stats.numUnboundVars;
303
+ } else if (firstAppNumUnboundVars === 0) this.aux.push(reg);
304
+ else {
305
+ const stats = this.getStats(pattern);
306
+ if (
307
+ stats.numUnboundVars === 0 ||
308
+ stats.size > firstAppSize ||
309
+ (stats.size === firstAppSize && stats.numUnboundVars < firstAppNumUnboundVars)
310
+ ) {
311
+ this.aux.push(firstAppReg);
312
+ firstApp = pattern;
313
+ firstAppReg = reg;
314
+ firstAppSize = stats.size;
315
+ firstAppNumUnboundVars = stats.numUnboundVars;
316
+ } else this.aux.push(reg);
317
+ }
318
+ }
319
+ if (firstApp !== -1) {
320
+ const label = manager.decls[firstApp];
321
+ const numArgs = manager.getNumArgs(firstApp);
322
+ if (this.isAllArgsBoundVars(firstApp)) {
323
+ const instr = mkInstruction(OP_IS_CGR);
324
+ instr.label = label;
325
+ instr.reg = firstAppReg;
326
+ instr.numArgs = numArgs;
327
+ instr.regs = manager.mapArgs(firstApp, (arg) => this.vars[manager.values[arg]]);
328
+ this.seq.push(instr);
329
+ } else {
330
+ const oreg = this.tree.numRegs;
331
+ this.tree.numRegs += numArgs;
332
+ for (let index = 0; index < numArgs; index++) {
333
+ this.registers[oreg + index] = manager.getArg(firstApp, index);
334
+ this.aux.push(oreg + index);
335
+ }
336
+ const instr = mkInstruction(OP_BIND);
337
+ instr.label = label;
338
+ instr.numArgs = numArgs;
339
+ instr.reg = firstAppReg;
340
+ instr.oreg = oreg;
341
+ this.seq.push(instr);
342
+ this.numChoices++;
343
+ }
344
+ this.setMark(firstAppReg, NOT_CHECKED);
345
+ }
346
+ const todo = this.todo;
347
+ this.todo = this.aux;
348
+ this.aux = todo;
349
+ }
350
+
351
+ // get_num_bound_vars: the number of bound variables in a pattern, and whether it has unbound ones.
352
+ private getNumBoundVars(expr: number) {
353
+ const manager = this.manager;
354
+ let count = 0;
355
+ let hasUnboundVars = false;
356
+ const visit = (term: number) => {
357
+ if (manager.isGround(term)) return;
358
+ for (let index = 0; index < manager.getNumArgs(term); index++) {
359
+ const arg = manager.getArg(term, index);
360
+ if (manager.kinds[arg] !== KIND_VAR) visit(arg);
361
+ else if (this.vars[manager.values[arg]] !== -1) count++;
362
+ else hasUnboundVars = true;
363
+ }
364
+ };
365
+ visit(expr);
366
+ return { count, hasUnboundVars };
367
+ }
368
+
369
+ // gen_mp_filter: compiles a pattern whose variables are all bound, and returns the register that
370
+ // gets the enode congruent to it.
371
+ private genMpFilter(expr: number): number {
372
+ const manager = this.manager;
373
+ if (manager.isGround(expr)) {
374
+ const oreg = this.tree.numRegs;
375
+ this.tree.numRegs += 1;
376
+ const instr = mkInstruction(OP_GET_ENODE);
377
+ instr.oreg = oreg;
378
+ instr.enode = this.hasher.getGroundEnode(expr, this.quantifier);
379
+ this.seq.push(instr);
380
+ return oreg;
381
+ }
382
+ const iregs = manager.mapArgs(expr, (arg) =>
383
+ manager.kinds[arg] === KIND_VAR ? this.vars[manager.values[arg]] : this.genMpFilter(arg),
384
+ );
385
+ const oreg = this.tree.numRegs;
386
+ this.tree.numRegs += 1;
387
+ const instr = mkInstruction(OP_GET_CGR);
388
+ instr.label = manager.decls[expr];
389
+ instr.numArgs = iregs.length;
390
+ instr.oreg = oreg;
391
+ instr.regs = iregs;
392
+ setHash(instr, this.hasher.getLabelHash(instr.label));
393
+ this.seq.push(instr);
394
+ return oreg;
395
+ }
396
+
397
+ // linearise_multi_pattern: the other patterns of a multi-pattern, the one with the most bound
398
+ // variables first.
399
+ private lineariseMultiPattern() {
400
+ const manager = this.manager;
401
+ const patterns = this.patterns;
402
+ for (let round = 1; round < patterns.length; round++) {
403
+ let best = -1;
404
+ let bestNumBoundVars = 0;
405
+ let bestIndex = 0;
406
+ let isFoundBoundedMp = false;
407
+ for (let index = 0; index < patterns.length; index++) {
408
+ if (this.isMpAlreadyProcessed[index]) continue;
409
+ const pattern = patterns[index];
410
+ const counted = this.getNumBoundVars(pattern);
411
+ if (!counted.hasUnboundVars) {
412
+ best = pattern;
413
+ bestIndex = index;
414
+ isFoundBoundedMp = true;
415
+ break;
416
+ }
417
+ if (best === -1 || counted.count > bestNumBoundVars) {
418
+ best = pattern;
419
+ bestNumBoundVars = counted.count;
420
+ bestIndex = index;
421
+ }
422
+ }
423
+ if (best === -1) continue;
424
+ this.isMpAlreadyProcessed[bestIndex] = true;
425
+ if (isFoundBoundedMp) {
426
+ this.genMpFilter(best);
427
+ continue;
428
+ }
429
+ const oreg = this.tree.numRegs;
430
+ this.tree.numRegs += manager.getNumArgs(best);
431
+ let hasDepth1Joint = false;
432
+ for (let index = 0; index < manager.getNumArgs(best); index++) {
433
+ const arg = manager.getArg(best, index);
434
+ this.registers[oreg + index] = arg;
435
+ this.todo.push(oreg + index);
436
+ if (
437
+ (manager.kinds[arg] === KIND_VAR && this.vars[manager.values[arg]] >= 0) ||
438
+ (manager.kinds[arg] !== KIND_VAR && manager.isGround(arg))
439
+ )
440
+ hasDepth1Joint = true;
441
+ }
442
+ const nullJoint = (): Joint => ({
443
+ kind: JOINT_NULL,
444
+ enode: null,
445
+ reg: 0,
446
+ decl: -1,
447
+ argPos: 0,
448
+ });
449
+ const joints = manager.mapArgs(best, (arg): Joint => {
450
+ if (hasDepth1Joint) {
451
+ if (manager.kinds[arg] === KIND_VAR) {
452
+ const reg = this.vars[manager.values[arg]];
453
+ return reg >= 0 ? { ...nullJoint(), kind: JOINT_VAR, reg } : nullJoint();
454
+ }
455
+ if (manager.isGround(arg))
456
+ return {
457
+ ...nullJoint(),
458
+ kind: JOINT_GROUND,
459
+ enode: this.hasher.getGroundEnode(arg, this.quantifier),
460
+ };
461
+ return nullJoint();
462
+ }
463
+ if (manager.kinds[arg] === KIND_VAR) return nullJoint();
464
+ let argPos = -1;
465
+ for (let index = 0; index < manager.getNumArgs(arg) && argPos === -1; index++) {
466
+ const innerArg = manager.getArg(arg, index);
467
+ if (manager.kinds[innerArg] === KIND_VAR && this.vars[manager.values[innerArg]] >= 0)
468
+ argPos = index;
469
+ }
470
+ if (argPos === -1) return nullJoint();
471
+ return {
472
+ kind: JOINT_NESTED,
473
+ enode: null,
474
+ reg: this.vars[manager.values[manager.getArg(arg, argPos)]],
475
+ decl: manager.decls[arg],
476
+ argPos,
477
+ };
478
+ });
479
+ const instr = mkInstruction(OP_CONTINUE);
480
+ instr.label = manager.decls[best];
481
+ instr.numArgs = manager.getNumArgs(best);
482
+ instr.oreg = oreg;
483
+ instr.joints = joints;
484
+ setHash(instr, this.hasher.getLabelHash(instr.label));
485
+ this.seq.push(instr);
486
+ this.numChoices++;
487
+ while (this.todo.length > 0) this.lineariseCore();
488
+ }
489
+ }
490
+
491
+ // linearise: the instructions for the registers in m_todo, appended after head.
492
+ private linearise(head: Instruction, firstIndex: number) {
493
+ this.seq = [];
494
+ this.matchedExprs.clear();
495
+ while (this.todo.length > 0) this.lineariseCore();
496
+ if (this.patterns.length > 1) {
497
+ this.isMpAlreadyProcessed = this.patterns.map((_pattern, index) => index === firstIndex);
498
+ this.lineariseMultiPattern();
499
+ }
500
+ const numDecls = this.manager.getQuantifier(this.quantifier).sorts.length;
501
+ for (let index = 0; index < numDecls; index++) if (this.vars[index] === -1) return;
502
+ const instr = mkInstruction(OP_YIELD);
503
+ instr.quantifier = this.quantifier;
504
+ instr.numArgs = numDecls;
505
+ instr.regs = this.vars.slice(0, numDecls);
506
+ this.seq.push(instr);
507
+ let curr = head;
508
+ for (const next of this.seq) {
509
+ curr.next = next;
510
+ curr = next;
511
+ }
512
+ }
513
+
514
+ private setNext(instr: Instruction, next: Instruction | null) {
515
+ if (!this.isTmpTree) {
516
+ const old = instr.next;
517
+ this.context.pushTrail(() => {
518
+ instr.next = old;
519
+ });
520
+ }
521
+ instr.next = next;
522
+ }
523
+
524
+ private findBestChild(firstChild: Instruction) {
525
+ let numTooSimple = 0;
526
+ let bestChild: Instruction | null = null;
527
+ let maxCompatibility = 0;
528
+ for (let child: Instruction | null = firstChild; child !== null; child = child.alt) {
529
+ const measure = this.getCompatibilityMeasure(child);
530
+ if (measure.isSimple) {
531
+ numTooSimple++;
532
+ if (numTooSimple > FIND_BEST_CHILD_THRESHOLD) return null;
533
+ }
534
+ if (measure.weight > maxCompatibility) {
535
+ bestChild = child;
536
+ maxCompatibility = measure.weight;
537
+ }
538
+ }
539
+ return bestChild;
540
+ }
541
+
542
+ private isBindCompatible(instr: Instruction) {
543
+ const manager = this.manager;
544
+ const expr = this.getRegister(instr.reg);
545
+ return (
546
+ this.isApp(expr) &&
547
+ !manager.isGround(expr) &&
548
+ manager.decls[expr] === instr.label &&
549
+ manager.getNumArgs(expr) === instr.numArgs
550
+ );
551
+ }
552
+
553
+ private isCompareCompatible(instr: Instruction) {
554
+ const expr = this.getRegister(instr.reg);
555
+ return expr !== -1 && expr === this.getRegister(instr.reg2);
556
+ }
557
+
558
+ private isCheckCompatible(instr: Instruction) {
559
+ const expr = this.getRegister(instr.reg);
560
+ if (!this.isApp(expr) || !this.manager.isGround(expr)) return false;
561
+ const node = this.hasher.getGroundEnode(expr, this.quantifier);
562
+ return instr.enode !== null && node !== null && instr.enode.root === node.root;
563
+ }
564
+
565
+ // get_pat_lbl_hash: a ground pattern is a constant, hashed by its enode.
566
+ private getPatLblHash(reg: number) {
567
+ const expr = this.registers[reg];
568
+ if (this.manager.isGround(expr)) {
569
+ const node = this.hasher.getGroundEnode(expr, this.quantifier);
570
+ return node === null ? -1 : this.hasher.getLblHash(node);
571
+ }
572
+ return this.hasher.getLabelHash(this.manager.decls[expr]);
573
+ }
574
+
575
+ private isCheckSemiCompatible(instr: Instruction) {
576
+ if (instr.enode !== null) this.hasher.getLblHash(instr.enode);
577
+ const expr = this.getRegister(instr.reg);
578
+ return (
579
+ expr !== -1 &&
580
+ this.getMark(instr.reg) === NOT_CHECKED &&
581
+ this.manager.isGround(expr) &&
582
+ instr.enode !== null &&
583
+ this.getPatLblHash(instr.reg) === instr.enode.lblHash
584
+ );
585
+ }
586
+
587
+ private isFilterCompatible(instr: Instruction) {
588
+ const expr = this.getRegister(instr.reg);
589
+ return (
590
+ this.isApp(expr) &&
591
+ !this.manager.isGround(expr) &&
592
+ hasHash(instr.lblLow, instr.lblHigh, this.getPatLblHash(instr.reg))
593
+ );
594
+ }
595
+
596
+ private isCfilterCompatible(instr: Instruction) {
597
+ const expr = this.getRegister(instr.reg);
598
+ return (
599
+ expr !== -1 &&
600
+ this.manager.isGround(expr) &&
601
+ hasHash(instr.lblLow, instr.lblHigh, this.getPatLblHash(instr.reg))
602
+ );
603
+ }
604
+
605
+ private isFilterSemiCompatible(instr: Instruction) {
606
+ const expr = this.getRegister(instr.reg);
607
+ return (
608
+ this.getMark(instr.reg) === NOT_CHECKED && this.isApp(expr) && !this.manager.isGround(expr)
609
+ );
610
+ }
611
+
612
+ // get_compatibility_measure: how many instructions of the branch at child are compatible with the
613
+ // patterns in the registers, and whether the branch is too simple to look at.
614
+ private getCompatibilityMeasure(child: Instruction) {
615
+ const manager = this.manager;
616
+ this.toReset.length = 0;
617
+ let weight = 0;
618
+ let numInstructions = 0;
619
+ let curr = child.next;
620
+ while (curr !== null && curr.op !== OP_CHOOSE && curr.op !== OP_NOOP) {
621
+ numInstructions++;
622
+ switch (curr.op) {
623
+ case OP_BIND:
624
+ if (this.isBindCompatible(curr)) {
625
+ weight += 4;
626
+ const expr = this.registers[curr.reg];
627
+ for (let index = 0; index < curr.numArgs; index++) {
628
+ this.registers[curr.oreg + index] = manager.getArg(expr, index);
629
+ this.toReset.push(curr.oreg + index);
630
+ }
631
+ }
632
+ break;
633
+ case OP_COMPARE:
634
+ if (this.isCompareCompatible(curr)) weight += 2;
635
+ break;
636
+ case OP_CHECK:
637
+ if (this.isCheckCompatible(curr)) weight += 2;
638
+ else if (this.isCheckSemiCompatible(curr)) weight += 1;
639
+ break;
640
+ case OP_CFILTER:
641
+ if (this.isCfilterCompatible(curr)) weight += 2;
642
+ break;
643
+ case OP_FILTER:
644
+ if (this.isFilterCompatible(curr)) weight += 2;
645
+ else if (this.isFilterSemiCompatible(curr)) weight += 1;
646
+ break;
647
+ }
648
+ curr = curr.next;
649
+ }
650
+ const isSimple = !(
651
+ numInstructions > SIMPLE_SEQ_THRESHOLD ||
652
+ (curr !== null && curr.op === OP_CHOOSE)
653
+ );
654
+ for (const reg of this.toReset) this.registers[reg] = -1;
655
+ return { weight, isSimple };
656
+ }
657
+
658
+ private eraseTodo(reg: number) {
659
+ const index = this.todo.indexOf(reg);
660
+ if (index !== -1) this.todo.splice(index, 1);
661
+ }
662
+
663
+ // compiler::insert: follows the instructions compatible with the new pattern, then branches off
664
+ // with a CHOOSE where they stop.
665
+ private insertAt(start: Instruction, firstIndex: number) {
666
+ const manager = this.manager;
667
+ let head = start;
668
+ for (;;) {
669
+ const compatible = this.compatible;
670
+ const incompatible = this.incompatible;
671
+ compatible.length = 0;
672
+ incompatible.length = 0;
673
+ let curr = head.next;
674
+ let last = head;
675
+ while (curr !== null && curr.op !== OP_CHOOSE && curr.op !== OP_NOOP) {
676
+ switch (curr.op) {
677
+ case OP_BIND:
678
+ if (this.isBindCompatible(curr)) {
679
+ this.eraseTodo(curr.reg);
680
+ this.setMark(curr.reg, NOT_CHECKED);
681
+ compatible.push(curr);
682
+ const expr = this.registers[curr.reg];
683
+ for (let index = 0; index < curr.numArgs; index++) {
684
+ this.registers[curr.oreg + index] = manager.getArg(expr, index);
685
+ this.todo.push(curr.oreg + index);
686
+ }
687
+ } else incompatible.push(curr);
688
+ break;
689
+ case OP_CHECK:
690
+ if (this.isCheckCompatible(curr)) {
691
+ this.eraseTodo(curr.reg);
692
+ this.setMark(curr.reg, NOT_CHECKED);
693
+ compatible.push(curr);
694
+ } else if (this.isCheckSemiCompatible(curr) && curr.enode !== null) {
695
+ const filter = mkFilter(OP_CFILTER, curr.reg, 0, 0);
696
+ setHash(filter, this.hasher.getLblHash(curr.enode));
697
+ setHash(filter, this.getPatLblHash(curr.reg));
698
+ this.setMark(curr.reg, CHECK_SET);
699
+ compatible.push(filter);
700
+ incompatible.push(curr);
701
+ } else incompatible.push(curr);
702
+ break;
703
+ case OP_COMPARE:
704
+ if (this.isCompareCompatible(curr)) {
705
+ this.eraseTodo(curr.reg2);
706
+ this.setMark(curr.reg2, NOT_CHECKED);
707
+ const expr = this.registers[curr.reg];
708
+ if (manager.kinds[expr] === KIND_VAR) {
709
+ this.eraseTodo(curr.reg);
710
+ this.setMark(curr.reg, NOT_CHECKED);
711
+ const varIndex = manager.values[expr];
712
+ if (this.vars[varIndex] === -1) this.vars[varIndex] = curr.reg;
713
+ }
714
+ compatible.push(curr);
715
+ } else incompatible.push(curr);
716
+ break;
717
+ case OP_CFILTER:
718
+ if (this.isCfilterCompatible(curr)) {
719
+ this.setMark(curr.reg, CHECK_SINGLETON);
720
+ compatible.push(curr);
721
+ } else incompatible.push(curr);
722
+ break;
723
+ case OP_FILTER:
724
+ if (this.isFilterCompatible(curr)) {
725
+ const isSingleton = countBits(curr.lblLow) + countBits(curr.lblHigh) === 1;
726
+ this.setMark(curr.reg, isSingleton ? CHECK_SINGLETON : CHECK_SET);
727
+ compatible.push(curr);
728
+ } else if (this.isFilterSemiCompatible(curr)) {
729
+ const hash = this.getPatLblHash(curr.reg);
730
+ this.setMark(curr.reg, CHECK_SET);
731
+ if (countBits(curr.lblLow) + countBits(curr.lblHigh) > 1) {
732
+ // insert_new_lbl_hash.
733
+ const filter = curr;
734
+ const low = filter.lblLow;
735
+ const high = filter.lblHigh;
736
+ this.context.pushTrail(() => {
737
+ filter.lblLow = low;
738
+ filter.lblHigh = high;
739
+ });
740
+ setHash(filter, hash);
741
+ compatible.push(curr);
742
+ } else {
743
+ const filter = mkFilter(OP_FILTER, curr.reg, curr.lblLow, curr.lblHigh);
744
+ setHash(filter, hash);
745
+ compatible.push(filter);
746
+ incompatible.push(curr);
747
+ }
748
+ } else incompatible.push(curr);
749
+ break;
750
+ default:
751
+ incompatible.push(curr);
752
+ }
753
+ last = curr;
754
+ curr = curr.next;
755
+ }
756
+ if (incompatible.length === 0) {
757
+ if (curr === null) return;
758
+ const bestChild = this.findBestChild(curr);
759
+ if (bestChild === null) {
760
+ // head -> ... -> last -> new_child: CHOOSE(first_child) -> linearise.
761
+ const newChild = mkChoose(curr);
762
+ this.numChoices++;
763
+ this.setNext(last, newChild);
764
+ this.linearise(newChild, firstIndex);
765
+ return;
766
+ }
767
+ head = bestChild;
768
+ continue;
769
+ }
770
+ // head -> compatible -> new_child_head1: CHOOSE(new_child_head2) -> incompatible -> curr, and
771
+ // new_child_head2: NOOP -> linearise.
772
+ const firstChildHead = curr;
773
+ const newChildHead2 = mkInstruction(OP_NOOP);
774
+ const newChildHead1 = mkChoose(newChildHead2);
775
+ this.numChoices++;
776
+ let tail = head;
777
+ for (const instr of compatible) {
778
+ this.setNext(tail, instr);
779
+ tail = instr;
780
+ }
781
+ this.setNext(tail, newChildHead1);
782
+ tail = newChildHead1;
783
+ for (const instr of incompatible) {
784
+ if (tail === newChildHead1) tail.next = instr;
785
+ else this.setNext(tail, instr);
786
+ tail = instr;
787
+ }
788
+ this.setNext(tail, firstChildHead);
789
+ this.linearise(newChildHead2, firstIndex);
790
+ return;
791
+ }
792
+ }
793
+
794
+ // mk_tree: a new code tree for a quantifier, which starts with the pattern at firstIndex.
795
+ mkTree(
796
+ quantifier: number,
797
+ patterns: number[],
798
+ firstIndex: number,
799
+ isFilteringCandidates: boolean,
800
+ ) {
801
+ const pattern = patterns[firstIndex];
802
+ const numArgs = this.manager.getNumArgs(pattern);
803
+ const tree: CodeTree = {
804
+ rootLabel: this.manager.decls[pattern],
805
+ numArgs,
806
+ isFilteringCandidates,
807
+ numRegs: numArgs + 1,
808
+ numChoices: 0,
809
+ root: mkInit(numArgs),
810
+ candidates: [],
811
+ candidateGcThreshold: 10000,
812
+ };
813
+ this.init(tree, quantifier, patterns, firstIndex);
814
+ this.linearise(tree.root, firstIndex);
815
+ tree.numChoices = this.numChoices;
816
+ return tree;
817
+ }
818
+
819
+ // insert: adds a pattern to a code tree. A temporary tree records no trail.
820
+ insert(
821
+ tree: CodeTree,
822
+ quantifier: number,
823
+ patterns: number[],
824
+ firstIndex: number,
825
+ isTmpTree: boolean,
826
+ ) {
827
+ if (tree.numArgs !== this.manager.getNumArgs(patterns[firstIndex])) return;
828
+ this.isTmpTree = isTmpTree;
829
+ if (!isTmpTree) {
830
+ const numRegs = tree.numRegs;
831
+ this.context.pushTrail(() => {
832
+ tree.numRegs = numRegs;
833
+ });
834
+ }
835
+ this.init(tree, quantifier, patterns, firstIndex);
836
+ this.numChoices = tree.numChoices;
837
+ this.insertAt(tree.root, firstIndex);
838
+ if (this.numChoices <= tree.numChoices) return;
839
+ if (!isTmpTree) {
840
+ const numChoices = tree.numChoices;
841
+ this.context.pushTrail(() => {
842
+ tree.numChoices = numChoices;
843
+ });
844
+ }
845
+ tree.numChoices = this.numChoices;
846
+ }
847
+ }