tla-ts 0.0.9 → 0.0.10-dev.094b9b512
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.
- package/README.md +30 -1
- package/dist/compile.cjs +23 -0
- package/dist/compile.js +23 -0
- package/dist/deciders.cjs +40 -37
- package/dist/deciders.js +47 -44
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +106 -10
- package/dist/index.d.ts +106 -10
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +2658 -410
- package/dist/prove.js +2657 -409
- package/dist/run.cjs +144 -31
- package/dist/run.js +144 -31
- package/dist/tlapm.cjs +2 -2
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +129 -104
- package/dist/transfer.js +129 -104
- package/dist/worker.cjs +6 -6
- package/dist/worker.js +6 -6
- package/package.json +3 -1
- package/src/ast.ts +48 -62
- package/src/bags.ts +99 -102
- package/src/builtins.ts +28 -75
- package/src/bundled-modules.ts +1 -8
- package/src/check-failure.ts +116 -0
- package/src/check-trace.ts +282 -0
- package/src/check.ts +599 -754
- package/src/cli/options.ts +12 -32
- package/src/cli/run.ts +0 -2
- package/src/cli/runtime-invariants.ts +136 -0
- package/src/cli/shared.ts +19 -12
- package/src/cli/tlapm.ts +208 -54
- package/src/cli/tlc-arguments.ts +652 -0
- package/src/cli/tlc-output.ts +687 -0
- package/src/cli/tlc-usage.ts +361 -0
- package/src/cli/tlc.ts +309 -658
- package/src/cli/typescript.ts +23 -0
- package/src/cli/xml-exporter.ts +27 -49
- package/src/cli.ts +0 -1
- package/src/codegen.ts +196 -74
- package/src/config.ts +140 -109
- package/src/coverage.ts +830 -0
- package/src/dependencies.ts +14 -53
- package/src/dfid.ts +618 -0
- package/src/environment-config.ts +315 -0
- package/src/environment.ts +169 -335
- package/src/errors.ts +100 -57
- package/src/evaluate.ts +598 -340
- package/src/exit-codes.ts +37 -3
- package/src/fingerprints.ts +75 -11
- package/src/index.ts +3 -0
- package/src/instances.ts +126 -21
- package/src/java-hash.ts +7 -0
- package/src/java-overrides.ts +4 -19
- package/src/json-reader.ts +455 -0
- package/src/json.ts +252 -139
- package/src/levels.ts +46 -58
- package/src/lexer.ts +83 -101
- package/src/liveness-checker.ts +103 -153
- package/src/liveness.ts +150 -109
- package/src/obligations/action.ts +18 -43
- package/src/obligations/anonymize.ts +119 -90
- package/src/obligations/enabled-axioms.ts +218 -0
- package/src/obligations/equality.ts +2 -2
- package/src/obligations/expression.ts +38 -25
- package/src/obligations/format.ts +1 -9
- package/src/obligations/generate.ts +67 -63
- package/src/obligations/index.ts +38 -20
- package/src/obligations/levels.ts +28 -17
- package/src/obligations/module.ts +29 -54
- package/src/obligations/normalize.ts +31 -36
- package/src/obligations/operators.ts +1 -2
- package/src/obligations/pragma.ts +53 -25
- package/src/obligations/printer.ts +90 -57
- package/src/obligations/proof.ts +4 -5
- package/src/obligations/regroup.ts +1 -4
- package/src/obligations/simplify.ts +58 -62
- package/src/obligations/source.ts +119 -95
- package/src/obligations/subexpression.ts +51 -27
- package/src/obligations/substitution.ts +2 -4
- package/src/obligations/temporal.ts +13 -19
- package/src/obligations/tuples.ts +3 -9
- package/src/parallel-worker.ts +30 -60
- package/src/parallel.ts +57 -71
- package/src/parser.ts +961 -387
- package/src/pcal/ast.ts +53 -86
- package/src/pcal/parse.ts +144 -219
- package/src/pcal/tokenize.ts +91 -131
- package/src/pcal/translate.ts +83 -130
- package/src/pcal/validate.ts +48 -68
- package/src/pretty-print.ts +7 -8
- package/src/prover/decide-pool.ts +8 -13
- package/src/prover/deciders.ts +19 -13
- package/src/prover/first-order.ts +0 -11
- package/src/prover/isabelle/decide.ts +3 -31
- package/src/prover/isabelle/encode.ts +82 -62
- package/src/prover/isabelle/isar/attrib.ts +219 -0
- package/src/prover/isabelle/isar/context.ts +336 -0
- package/src/prover/isabelle/isar/induct.ts +392 -0
- package/src/prover/isabelle/isar/inner-syntax.ts +262 -117
- package/src/prover/isabelle/isar/method.ts +513 -225
- package/src/prover/isabelle/isar/proof.ts +569 -23
- package/src/prover/isabelle/isar/rule-cases.ts +234 -0
- package/src/prover/isabelle/isar/theory.ts +490 -89
- package/src/prover/isabelle/isar/toplevel.ts +341 -0
- package/src/prover/isabelle/isar/type-check.ts +100 -37
- package/src/prover/isabelle/provers/blast/blast.ts +17 -104
- package/src/prover/isabelle/provers/blast/branch.ts +1 -32
- package/src/prover/isabelle/provers/blast/prove.ts +1 -35
- package/src/prover/isabelle/provers/blast/rules.ts +6 -44
- package/src/prover/isabelle/provers/blast/state.ts +2 -28
- package/src/prover/isabelle/provers/blast/term.ts +9 -36
- package/src/prover/isabelle/provers/clasimp.ts +1 -13
- package/src/prover/isabelle/provers/classical.ts +59 -60
- package/src/prover/isabelle/provers/hypsubst.ts +28 -51
- package/src/prover/isabelle/pure/bicompose.ts +25 -38
- package/src/prover/isabelle/pure/consts.ts +1 -7
- package/src/prover/isabelle/pure/conv.ts +3 -17
- package/src/prover/isabelle/pure/drule.ts +96 -44
- package/src/prover/isabelle/pure/envir.ts +3 -52
- package/src/prover/isabelle/pure/goal.ts +2 -8
- package/src/prover/isabelle/pure/interrupt.ts +0 -5
- package/src/prover/isabelle/pure/list.ts +0 -3
- package/src/prover/isabelle/pure/logic.ts +2 -15
- package/src/prover/isabelle/pure/name.ts +2 -9
- package/src/prover/isabelle/pure/net.ts +3 -59
- package/src/prover/isabelle/pure/object-logic.ts +16 -15
- package/src/prover/isabelle/pure/pattern.ts +2 -19
- package/src/prover/isabelle/pure/raw-simplifier.ts +17 -62
- package/src/prover/isabelle/pure/rewriter.ts +32 -73
- package/src/prover/isabelle/pure/search.ts +3 -10
- package/src/prover/isabelle/pure/seq.ts +1 -10
- package/src/prover/isabelle/pure/simplifier.ts +28 -15
- package/src/prover/isabelle/pure/table.ts +3 -32
- package/src/prover/isabelle/pure/tactic.ts +12 -22
- package/src/prover/isabelle/pure/tactical.ts +48 -47
- package/src/prover/isabelle/pure/term-ord.ts +2 -6
- package/src/prover/isabelle/pure/term.ts +2 -43
- package/src/prover/isabelle/pure/thm.ts +27 -47
- package/src/prover/isabelle/pure/type.ts +2 -15
- package/src/prover/isabelle/pure/unify.ts +20 -30
- package/src/prover/isabelle/pure/variable.ts +3 -7
- package/src/prover/isabelle/tla/classical-setup.ts +18 -24
- package/src/prover/isabelle/tla/context.ts +65 -26
- package/src/prover/isabelle/tla/logic-data.ts +1 -1
- package/src/prover/isabelle/tla/logic.ts +53 -32
- package/src/prover/isabelle/tla/simpdata.ts +46 -43
- package/src/prover/isabelle/tools/intuitionistic.ts +29 -20
- package/src/prover/ocaml.ts +0 -6
- package/src/prover/prep/action.ts +32 -66
- package/src/prover/prep/enabled-axioms.ts +22 -20
- package/src/prover/prep/fingerprint.ts +2 -21
- package/src/prover/prep/level-comparison.ts +8 -12
- package/src/prover/prep/md5.ts +0 -2
- package/src/prover/prep/methods.ts +137 -83
- package/src/prover/prep/normalize.ts +38 -36
- package/src/prover/prove-worker.ts +0 -2
- package/src/prover/prove.ts +371 -132
- package/src/prover/ptl/decide.ts +104 -44
- package/src/prover/ptl/encode.ts +15 -38
- package/src/prover/ptl/sat.ts +24 -32
- package/src/prover/ptl/tableau.ts +40 -28
- package/src/prover/smt/arithmetic.ts +310 -0
- package/src/prover/smt/axioms.ts +12 -15
- package/src/prover/smt/context.ts +61 -29
- package/src/prover/smt/data.ts +497 -387
- package/src/prover/smt/encode.ts +156 -85
- package/src/prover/smt/extensionality.ts +5 -13
- package/src/prover/smt/flatten.ts +7 -28
- package/src/prover/smt/format.ts +33 -14
- package/src/prover/smt/instances.ts +7 -11
- package/src/prover/smt/layout.ts +91 -0
- package/src/prover/smt/rewrite.ts +1025 -658
- package/src/prover/smt/simplify.ts +441 -0
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +63 -0
- package/src/prover/smt/solver/ackr-helper.ts +182 -0
- package/src/prover/smt/solver/ackr-model-converter.ts +112 -0
- package/src/prover/smt/solver/act-cache.ts +0 -15
- package/src/prover/smt/solver/add-bounds-tactic.ts +60 -0
- package/src/prover/smt/solver/aig-tactic.ts +43 -0
- package/src/prover/smt/solver/aig.ts +890 -0
- package/src/prover/smt/solver/arith-rewriter.ts +613 -48
- package/src/prover/smt/solver/arith-terms.ts +123 -0
- package/src/prover/smt/solver/array-decl-plugin.ts +176 -0
- package/src/prover/smt/solver/array-rewriter.ts +312 -0
- package/src/prover/smt/solver/array.ts +1 -3
- package/src/prover/smt/solver/asserted-formulas.ts +87 -57
- package/src/prover/smt/solver/ast-lt.ts +166 -21
- package/src/prover/smt/solver/ast-util.ts +161 -7
- package/src/prover/smt/solver/ast.ts +1466 -178
- package/src/prover/smt/solver/auf-solver.ts +8 -44
- package/src/prover/smt/solver/bit-blast-tactic.ts +591 -0
- package/src/prover/smt/solver/bit-blaster.ts +874 -0
- package/src/prover/smt/solver/bound-manager.ts +186 -0
- package/src/prover/smt/solver/bound-simplifier.ts +602 -0
- package/src/prover/smt/solver/bv-bound-chk.ts +500 -0
- package/src/prover/smt/solver/bv-decl-plugin.ts +339 -0
- package/src/prover/smt/solver/bv-divrem-bounds.ts +97 -0
- package/src/prover/smt/solver/bv-rewriter.ts +1905 -0
- package/src/prover/smt/solver/bv1-blast.ts +224 -0
- package/src/prover/smt/solver/bv2fpa-converter.ts +175 -0
- package/src/prover/smt/solver/bv2int-rewriter.ts +545 -0
- package/src/prover/smt/solver/bv2real-rewriter.ts +534 -0
- package/src/prover/smt/solver/card2bv.ts +112 -0
- package/src/prover/smt/solver/case-split-queue.ts +1 -9
- package/src/prover/smt/solver/cg-table.ts +28 -34
- package/src/prover/smt/solver/check-logic.ts +326 -0
- package/src/prover/smt/solver/clause.ts +1 -27
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +280 -0
- package/src/prover/smt/solver/conflict-resolution.ts +79 -12
- package/src/prover/smt/solver/context.ts +510 -175
- package/src/prover/smt/solver/ctx-simplify.ts +34 -50
- package/src/prover/smt/solver/ctx-solver-simplify.ts +124 -0
- package/src/prover/smt/solver/datatype-decl-plugin.ts +575 -0
- package/src/prover/smt/solver/datatype-rewriter.ts +83 -0
- package/src/prover/smt/solver/demodulator.ts +789 -0
- package/src/prover/smt/solver/dependent-expr-state.ts +68 -0
- package/src/prover/smt/solver/der.ts +40 -30
- package/src/prover/smt/solver/diff-neq.ts +207 -0
- package/src/prover/smt/solver/distribute-forall.ts +67 -0
- package/src/prover/smt/solver/dom-simplify.ts +513 -0
- package/src/prover/smt/solver/dt2bv-tactic.ts +267 -0
- package/src/prover/smt/solver/dyn-ack.ts +1 -11
- package/src/prover/smt/solver/e-matching.ts +4 -35
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +130 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +558 -0
- package/src/prover/smt/solver/enode.ts +93 -22
- package/src/prover/smt/solver/eq2bv-tactic.ts +219 -0
- package/src/prover/smt/solver/euf/arith-axioms.ts +404 -0
- package/src/prover/smt/solver/euf/arith-internalize.ts +659 -0
- package/src/prover/smt/solver/euf/arith-solver.ts +895 -0
- package/src/prover/smt/solver/euf/array-axioms.ts +528 -0
- package/src/prover/smt/solver/euf/array-internalize.ts +419 -0
- package/src/prover/smt/solver/euf/array-solver.ts +308 -0
- package/src/prover/smt/solver/euf/bv-ackerman.ts +164 -0
- package/src/prover/smt/solver/euf/bv-internalize.ts +750 -0
- package/src/prover/smt/solver/euf/bv-solver.ts +451 -0
- package/src/prover/smt/solver/euf/dt-solver.ts +620 -0
- package/src/prover/smt/solver/euf/egraph.ts +885 -0
- package/src/prover/smt/solver/euf/euf-solver.ts +1203 -0
- package/src/prover/smt/solver/euf/fpa-solver.ts +333 -0
- package/src/prover/smt/solver/euf/mam.ts +1094 -0
- package/src/prover/smt/solver/euf/q-ematch.ts +900 -0
- package/src/prover/smt/solver/euf/q-mbi.ts +587 -0
- package/src/prover/smt/solver/euf/q-model-fixer.ts +299 -0
- package/src/prover/smt/solver/euf/q-solver.ts +361 -0
- package/src/prover/smt/solver/euf/th-solver.ts +343 -0
- package/src/prover/smt/solver/euf/th-solvers.ts +31 -0
- package/src/prover/smt/solver/expr-ref.ts +1 -5
- package/src/prover/smt/solver/expr-safe-replace.ts +26 -6
- package/src/prover/smt/solver/expr2polynomial.ts +147 -0
- package/src/prover/smt/solver/factor.ts +152 -0
- package/src/prover/smt/solver/fd-solver.ts +269 -0
- package/src/prover/smt/solver/fingerprints.ts +16 -26
- package/src/prover/smt/solver/fix-dl-var.ts +149 -0
- package/src/prover/smt/solver/flat-literals.ts +1 -9
- package/src/prover/smt/solver/fm-tactic.ts +873 -0
- package/src/prover/smt/solver/fpa-decl-plugin.ts +619 -0
- package/src/prover/smt/solver/fpa-rewriter.ts +641 -0
- package/src/prover/smt/solver/fpa2bv-converter.ts +2246 -0
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +349 -0
- package/src/prover/smt/solver/fpa2bv-tactic.ts +75 -0
- package/src/prover/smt/solver/goal.ts +177 -28
- package/src/prover/smt/solver/goal2nlsat.ts +191 -0
- package/src/prover/smt/solver/guard-set.ts +220 -0
- package/src/prover/smt/solver/hash.ts +0 -8
- package/src/prover/smt/solver/hashtable.ts +27 -23
- package/src/prover/smt/solver/inf-eps.ts +64 -0
- package/src/prover/smt/solver/inj-axiom.ts +102 -0
- package/src/prover/smt/solver/internalizer.ts +72 -130
- package/src/prover/smt/solver/lackr.ts +383 -0
- package/src/prover/smt/solver/lbool.ts +1 -2
- package/src/prover/smt/solver/lia2card.ts +269 -0
- package/src/prover/smt/solver/lia2pb.ts +141 -0
- package/src/prover/smt/solver/literal.ts +0 -3
- package/src/prover/smt/solver/logic-tactics.ts +349 -0
- package/src/prover/smt/solver/lp/bound-propagator.ts +8 -26
- package/src/prover/smt/solver/lp/constraints.ts +2 -8
- package/src/prover/smt/solver/lp/containers.ts +12 -30
- package/src/prover/smt/solver/lp/core-solver.ts +24 -27
- package/src/prover/smt/solver/lp/cross-nested.ts +6 -20
- package/src/prover/smt/solver/lp/dep-intervals.ts +7 -22
- package/src/prover/smt/solver/lp/dependency.ts +1 -4
- package/src/prover/smt/solver/lp/dioph-eq.ts +9 -102
- package/src/prover/smt/solver/lp/explanation.ts +1 -6
- package/src/prover/smt/solver/lp/gomory.ts +9 -22
- package/src/prover/smt/solver/lp/hnf-cutter.ts +17 -23
- package/src/prover/smt/solver/lp/hnf.ts +11 -26
- package/src/prover/smt/solver/lp/int-cube.ts +18 -39
- package/src/prover/smt/solver/lp/int-solver.ts +4 -34
- package/src/prover/smt/solver/lp/lar-solver.ts +70 -82
- package/src/prover/smt/solver/lp/lar-term.ts +1 -5
- package/src/prover/smt/solver/lp/lp-settings.ts +1 -14
- package/src/prover/smt/solver/lp/maximize-term.ts +79 -52
- package/src/prover/smt/solver/lp/nex-creator.ts +5 -28
- package/src/prover/smt/solver/lp/nex.ts +1 -6
- package/src/prover/smt/solver/lp/nla-backoff.ts +1 -4
- package/src/prover/smt/solver/lp/nla-basics.ts +5 -30
- package/src/prover/smt/solver/lp/nla-core.ts +69 -132
- package/src/prover/smt/solver/lp/nla-divisions.ts +32 -42
- package/src/prover/smt/solver/lp/nla-emonics.ts +4 -21
- package/src/prover/smt/solver/lp/nla-factorization.ts +1 -4
- package/src/prover/smt/solver/lp/nla-grobner.ts +24 -72
- package/src/prover/smt/solver/lp/nla-horner.ts +3 -11
- package/src/prover/smt/solver/lp/nla-intervals.ts +2 -12
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +16 -41
- package/src/prover/smt/solver/lp/nla-monotone.ts +2 -6
- package/src/prover/smt/solver/lp/nla-order.ts +2 -13
- package/src/prover/smt/solver/lp/nla-patcher.ts +4 -7
- package/src/prover/smt/solver/lp/nla-powers.ts +184 -0
- package/src/prover/smt/solver/lp/nla-tangents.ts +1 -9
- package/src/prover/smt/solver/lp/nla-throttle.ts +1 -6
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +293 -0
- package/src/prover/smt/solver/lp/nla-types.ts +1 -11
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +4 -25
- package/src/prover/smt/solver/lp/nra-solver.ts +30 -54
- package/src/prover/smt/solver/lp/numeric-pair.ts +1 -4
- package/src/prover/smt/solver/lp/pdd-interval.ts +1 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +2 -14
- package/src/prover/smt/solver/lp/pdd-solver.ts +4 -33
- package/src/prover/smt/solver/lp/pdd.ts +7 -70
- package/src/prover/smt/solver/lp/random-updater.ts +1 -8
- package/src/prover/smt/solver/lp/static-matrix.ts +9 -19
- package/src/prover/smt/solver/lp/union-find.ts +6 -5
- package/src/prover/smt/solver/macro-finder.ts +533 -0
- package/src/prover/smt/solver/mam-compiler.ts +117 -126
- package/src/prover/smt/solver/mam-interpreter.ts +1 -21
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +29 -0
- package/src/prover/smt/solver/max-cliques.ts +107 -0
- package/src/prover/smt/solver/maxcore.ts +318 -0
- package/src/prover/smt/solver/maximize-ac-sharing.ts +9 -20
- package/src/prover/smt/solver/maxlex.ts +123 -0
- package/src/prover/smt/solver/maxsmt-base.ts +99 -0
- package/src/prover/smt/solver/maxsmt.ts +93 -0
- package/src/prover/smt/solver/mbp/mbp-arith.ts +477 -0
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +102 -0
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +280 -0
- package/src/prover/smt/solver/mbp/mbp-qel.ts +49 -0
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +280 -0
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +624 -0
- package/src/prover/smt/solver/model-based-opt.ts +845 -0
- package/src/prover/smt/solver/model-checker.ts +20 -62
- package/src/prover/smt/solver/model-evaluator.ts +186 -39
- package/src/prover/smt/solver/model-finder.ts +15 -32
- package/src/prover/smt/solver/model-generator.ts +57 -40
- package/src/prover/smt/solver/model-macro-solver.ts +58 -111
- package/src/prover/smt/solver/model-printer.ts +215 -0
- package/src/prover/smt/solver/mpf.ts +712 -0
- package/src/prover/smt/solver/mus.ts +52 -0
- package/src/prover/smt/solver/muz/dl-context.ts +362 -0
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +98 -0
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +121 -0
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +121 -0
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +305 -0
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +427 -0
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +278 -0
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +158 -0
- package/src/prover/smt/solver/muz/dl-rule-set.ts +303 -0
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +127 -0
- package/src/prover/smt/solver/muz/dl-rule.ts +460 -0
- package/src/prover/smt/solver/muz/hnf.ts +201 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +192 -0
- package/src/prover/smt/solver/muz/rule-properties.ts +179 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +1395 -0
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +41 -0
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +244 -0
- package/src/prover/smt/solver/muz/spacer-manager.ts +133 -0
- package/src/prover/smt/solver/muz/spacer-pdr.ts +219 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +344 -0
- package/src/prover/smt/solver/muz/spacer-util.ts +309 -0
- package/src/prover/smt/solver/muz/substitution.ts +154 -0
- package/src/prover/smt/solver/nla2bv-tactic.ts +286 -0
- package/src/prover/smt/solver/nlqsat.ts +484 -0
- package/src/prover/smt/solver/nlsat/algebraic.ts +179 -159
- package/src/prover/smt/solver/nlsat/atoms.ts +25 -23
- package/src/prover/smt/solver/nlsat/evaluator.ts +17 -22
- package/src/prover/smt/solver/nlsat/explain.ts +61 -69
- package/src/prover/smt/solver/nlsat/interval-set.ts +10 -51
- package/src/prover/smt/solver/nlsat/levelwise.ts +49 -135
- package/src/prover/smt/solver/nlsat/mpbq.ts +48 -14
- package/src/prover/smt/solver/nlsat/polynomial.ts +30 -160
- package/src/prover/smt/solver/nlsat/solver.ts +227 -99
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +311 -0
- package/src/prover/smt/solver/nlsat/transcendentals.ts +369 -0
- package/src/prover/smt/solver/nlsat/types.ts +1 -8
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +2 -45
- package/src/prover/smt/solver/nlsat/upolynomial.ts +11 -92
- package/src/prover/smt/solver/nlsat-tactic.ts +83 -0
- package/src/prover/smt/solver/nnf.ts +108 -60
- package/src/prover/smt/solver/normalize-bounds.ts +54 -0
- package/src/prover/smt/solver/occf.ts +98 -0
- package/src/prover/smt/solver/opt-context.ts +787 -0
- package/src/prover/smt/solver/opt-nlsat.ts +366 -0
- package/src/prover/smt/solver/opt-pareto.ts +284 -0
- package/src/prover/smt/solver/opt-preprocess.ts +102 -0
- package/src/prover/smt/solver/opt-solver.ts +300 -0
- package/src/prover/smt/solver/opt-value.ts +56 -0
- package/src/prover/smt/solver/optsmt.ts +691 -0
- package/src/prover/smt/solver/parallel-tactic.ts +301 -0
- package/src/prover/smt/solver/pattern-inference.ts +19 -23
- package/src/prover/smt/solver/pb-rewriter.ts +296 -0
- package/src/prover/smt/solver/pb2bv-tactic.ts +542 -0
- package/src/prover/smt/solver/poly-rewriter.ts +203 -77
- package/src/prover/smt/solver/probes.ts +514 -0
- package/src/prover/smt/solver/propagate-values.ts +34 -30
- package/src/prover/smt/solver/proto-model.ts +648 -63
- package/src/prover/smt/solver/pull-quant.ts +29 -23
- package/src/prover/smt/solver/purify-arith.ts +598 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +1099 -0
- package/src/prover/smt/solver/qe-lite-der.ts +3 -31
- package/src/prover/smt/solver/qe-lite-fm.ts +5 -28
- package/src/prover/smt/solver/qe-lite.ts +40 -49
- package/src/prover/smt/solver/qe-mbp.ts +281 -0
- package/src/prover/smt/solver/qe.ts +1508 -0
- package/src/prover/smt/solver/qel.ts +26 -0
- package/src/prover/smt/solver/qi-queue.ts +1 -16
- package/src/prover/smt/solver/qsat.ts +840 -0
- package/src/prover/smt/solver/quant-hoist.ts +195 -0
- package/src/prover/smt/solver/quant-tactics.ts +18 -74
- package/src/prover/smt/solver/quantifier-analyzer.ts +27 -47
- package/src/prover/smt/solver/quantifier-manager.ts +9 -23
- package/src/prover/smt/solver/quasi-macros.ts +254 -0
- package/src/prover/smt/solver/random-gen.ts +1 -2
- package/src/prover/smt/solver/rational.ts +29 -8
- package/src/prover/smt/solver/recfun-decl-plugin.ts +248 -0
- package/src/prover/smt/solver/recfun-rewriter.ts +108 -0
- package/src/prover/smt/solver/reduce-args.ts +226 -0
- package/src/prover/smt/solver/reduce-bv-size.ts +120 -0
- package/src/prover/smt/solver/ref-vector.ts +1 -6
- package/src/prover/smt/solver/relevancy.ts +3 -16
- package/src/prover/smt/solver/rewriter-tpl.ts +49 -129
- package/src/prover/smt/solver/rewriter.ts +478 -120
- package/src/prover/smt/solver/rlimit.ts +27 -21
- package/src/prover/smt/solver/sat/asymm-branch.ts +314 -0
- package/src/prover/smt/solver/sat/big.ts +178 -0
- package/src/prover/smt/solver/sat/clause-use-list.ts +79 -0
- package/src/prover/smt/solver/sat/clause.ts +221 -0
- package/src/prover/smt/solver/sat/cleaner.ts +96 -0
- package/src/prover/smt/solver/sat/config.ts +125 -0
- package/src/prover/smt/solver/sat/consequences.ts +204 -0
- package/src/prover/smt/solver/sat/elim-eqs.ts +144 -0
- package/src/prover/smt/solver/sat/goal2sat.ts +528 -0
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +388 -0
- package/src/prover/smt/solver/sat/model-converter.ts +156 -0
- package/src/prover/smt/solver/sat/pb-constraint.ts +264 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +1553 -0
- package/src/prover/smt/solver/sat/probing.ts +169 -0
- package/src/prover/smt/solver/sat/sat-tactic.ts +44 -0
- package/src/prover/smt/solver/sat/sat2goal.ts +171 -0
- package/src/prover/smt/solver/sat/scc.ts +143 -0
- package/src/prover/smt/solver/sat/simplifier.ts +1662 -0
- package/src/prover/smt/solver/sat/solver.ts +2128 -0
- package/src/prover/smt/solver/sat/var-queue.ts +119 -0
- package/src/prover/smt/solver/sat/watch-list.ts +136 -0
- package/src/prover/smt/solver/search-tree.ts +285 -0
- package/src/prover/smt/solver/seq-axioms.ts +1013 -0
- package/src/prover/smt/solver/seq-decl-plugin.ts +823 -0
- package/src/prover/smt/solver/seq-derive.ts +1303 -0
- package/src/prover/smt/solver/seq-eq-approx.ts +238 -0
- package/src/prover/smt/solver/seq-eq-solver.ts +440 -0
- package/src/prover/smt/solver/seq-factory.ts +91 -0
- package/src/prover/smt/solver/seq-monadic.ts +730 -0
- package/src/prover/smt/solver/seq-range-predicate.ts +225 -0
- package/src/prover/smt/solver/seq-re-rewriter.ts +1296 -0
- package/src/prover/smt/solver/seq-re-util.ts +777 -0
- package/src/prover/smt/solver/seq-regex-bisim.ts +145 -0
- package/src/prover/smt/solver/seq-regex-live.ts +202 -0
- package/src/prover/smt/solver/seq-regex-witness.ts +100 -0
- package/src/prover/smt/solver/seq-rewriter.ts +2407 -0
- package/src/prover/smt/solver/seq-skolem.ts +318 -0
- package/src/prover/smt/solver/seq-subset.ts +166 -0
- package/src/prover/smt/solver/seq-view-witness.ts +355 -0
- package/src/prover/smt/solver/smt-consequences.ts +299 -0
- package/src/prover/smt/solver/smt-kernel.ts +85 -0
- package/src/prover/smt/solver/smt-logics.ts +67 -0
- package/src/prover/smt/solver/smt-setup.ts +492 -0
- package/src/prover/smt/solver/smt2-printer.ts +767 -0
- package/src/prover/smt/solver/smtlib-parser.ts +2423 -270
- package/src/prover/smt/solver/smtlib-script.ts +1493 -0
- package/src/prover/smt/solver/solve-eqs.ts +931 -0
- package/src/prover/smt/solver/solver.ts +120 -39
- package/src/prover/smt/solver/sort.ts +1 -5
- package/src/prover/smt/solver/static-features.ts +319 -0
- package/src/prover/smt/solver/sticky-generations.ts +0 -5
- package/src/prover/smt/solver/tactic.ts +1936 -0
- package/src/prover/smt/solver/term-enumeration.ts +206 -0
- package/src/prover/smt/solver/theory-array.ts +1275 -0
- package/src/prover/smt/solver/theory-bv.ts +1239 -0
- package/src/prover/smt/solver/theory-char.ts +356 -0
- package/src/prover/smt/solver/theory-datatype.ts +599 -0
- package/src/prover/smt/solver/theory-finite-set.ts +30 -0
- package/src/prover/smt/solver/theory-fpa.ts +422 -0
- package/src/prover/smt/solver/theory-lra-axioms.ts +56 -25
- package/src/prover/smt/solver/theory-lra-bounds.ts +31 -10
- package/src/prover/smt/solver/theory-lra-final-check.ts +60 -91
- package/src/prover/smt/solver/theory-lra-internalize.ts +87 -53
- package/src/prover/smt/solver/theory-lra-model.ts +24 -53
- package/src/prover/smt/solver/theory-lra-propagate.ts +25 -40
- package/src/prover/smt/solver/theory-lra-state.ts +7 -27
- package/src/prover/smt/solver/theory-lra.ts +194 -8
- package/src/prover/smt/solver/theory-pb.ts +932 -0
- package/src/prover/smt/solver/theory-polymorphism.ts +59 -0
- package/src/prover/smt/solver/theory-recfun.ts +308 -0
- package/src/prover/smt/solver/theory-seq-regex.ts +871 -0
- package/src/prover/smt/solver/theory-seq-solve.ts +1375 -0
- package/src/prover/smt/solver/theory-seq-state.ts +880 -0
- package/src/prover/smt/solver/theory-seq.ts +984 -0
- package/src/prover/smt/solver/theory.ts +175 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +487 -0
- package/src/prover/smt/solver/var-subst.ts +33 -35
- package/src/prover/smt/table.ts +1 -9
- package/src/prover/smt/types.ts +146 -0
- package/src/prover/tlapm/cache.ts +67 -41
- package/src/prover/tlapm/ocaml-marshal.ts +19 -21
- package/src/prover/tlapm/tlapm.ts +21 -20
- package/src/prover/tlapm-library.ts +3208 -0
- package/src/prover/verdict.ts +9 -2
- package/src/prover/zenon/check/check.ts +1 -11
- package/src/prover/zenon/check/definitions.ts +5 -15
- package/src/prover/zenon/check/equality.ts +0 -8
- package/src/prover/zenon/check/functions.ts +0 -4
- package/src/prover/zenon/check/keys.ts +0 -7
- package/src/prover/zenon/check/propositional.ts +0 -3
- package/src/prover/zenon/check/records.ts +1 -6
- package/src/prover/zenon/check/relations.ts +2 -14
- package/src/prover/zenon/check/rewrites.ts +2 -21
- package/src/prover/zenon/check/sets.ts +40 -61
- package/src/prover/zenon/check/terms.ts +1 -19
- package/src/prover/zenon/check/tla.ts +0 -6
- package/src/prover/zenon/decide.ts +10 -15
- package/src/prover/zenon/encode.ts +1 -8
- package/src/prover/zenon/eqrel.ts +2 -13
- package/src/prover/zenon/equality-rules.ts +0 -4
- package/src/prover/zenon/expr.ts +8 -26
- package/src/prover/zenon/index-table.ts +26 -57
- package/src/prover/zenon/isar-case.ts +9 -19
- package/src/prover/zenon/isar.ts +36 -64
- package/src/prover/zenon/limits.ts +0 -4
- package/src/prover/zenon/llproof.ts +2 -20
- package/src/prover/zenon/mltoll.ts +66 -104
- package/src/prover/zenon/node.ts +20 -14
- package/src/prover/zenon/ocaml.ts +1 -17
- package/src/prover/zenon/parse.ts +10 -12
- package/src/prover/zenon/phrase.ts +1 -11
- package/src/prover/zenon/proof.ts +0 -9
- package/src/prover/zenon/propositional-rules.ts +0 -5
- package/src/prover/zenon/rules.ts +2 -6
- package/src/prover/zenon/search.ts +11 -33
- package/src/prover/zenon/tla/functions.ts +59 -31
- package/src/prover/zenon/tla/llproof.ts +67 -76
- package/src/prover/zenon/tla/records.ts +57 -33
- package/src/prover/zenon/tla/rewrites.ts +12 -19
- package/src/prover/zenon/tla/sets.ts +88 -57
- package/src/prover/zenon/tla/terms.ts +0 -6
- package/src/prover/zenon/tla/tla.ts +66 -64
- package/src/randomization.ts +81 -35
- package/src/resolve.ts +67 -184
- package/src/runtime.ts +22 -22
- package/src/sany/builtins.ts +2 -5
- package/src/sany/generation.ts +394 -0
- package/src/sany/generator-def-entries.ts +210 -0
- package/src/sany/generator-definitions.ts +686 -0
- package/src/sany/generator-expressions.ts +1100 -0
- package/src/sany/generator-proofs.ts +662 -0
- package/src/sany/generator.ts +191 -2764
- package/src/sany/levels.ts +6 -34
- package/src/sany/lexer.ts +58 -77
- package/src/sany/linter.ts +1 -9
- package/src/sany/modules.ts +1 -5
- package/src/sany/nodes.ts +5 -43
- package/src/sany/parse-error.ts +39 -117
- package/src/sany/report.ts +32 -69
- package/src/sany/selectors.ts +49 -76
- package/src/sany/source.ts +1 -17
- package/src/sany/xml.ts +35 -117
- package/src/search.ts +541 -163
- package/src/simulate.ts +709 -0
- package/src/spec-description.ts +192 -100
- package/src/standard-definitions.ts +0 -4
- package/src/standard-modules.ts +264 -95
- package/src/state-graph.ts +52 -31
- package/src/subexpressions.ts +69 -52
- package/src/substitution-levels.ts +7 -7
- package/src/successors.ts +266 -99
- package/src/symmetry.ts +33 -25
- package/src/tableau.ts +27 -24
- package/src/tlc/fingerprint.ts +183 -67
- package/src/tlc/jar-data.ts +112 -6
- package/src/tlc/messages.ts +125 -54
- package/src/tlc/order.ts +39 -69
- package/src/tlc/random.ts +37 -49
- package/src/tlc/replay.ts +553 -228
- package/src/tlc/summary.ts +36 -47
- package/src/tlc/tlc-operators.ts +78 -44
- package/src/tlc/tlcext-operators.ts +139 -122
- package/src/tlc/trace-spec.ts +249 -0
- package/src/tlc/value-stream.ts +139 -0
- package/src/tlc/version.ts +1 -4
- package/src/transfer.ts +22 -25
- package/src/typescript/actions.ts +479 -0
- package/src/typescript/collections.ts +614 -0
- package/src/typescript/compile.ts +63 -0
- package/src/typescript/context.ts +94 -0
- package/src/typescript/emit.ts +121 -0
- package/src/typescript/expressions.ts +496 -0
- package/src/typescript/formula.ts +154 -0
- package/src/typescript/functions.ts +284 -0
- package/src/typescript/model.ts +162 -0
- package/src/typescript/names.ts +114 -0
- package/src/typescript/program.ts +48 -0
- package/src/typescript/properties.ts +139 -0
- package/src/typescript/scope.ts +112 -0
- package/src/typescript/steps.ts +167 -0
- package/src/typescript/types.ts +171 -0
- package/src/values.ts +832 -484
- package/src/worker.ts +7 -8
- package/src/prover/isabelle/isar/statement.ts +0 -57
- package/src/prover/tlaps-module.ts +0 -510
|
@@ -1,17 +1,28 @@
|
|
|
1
|
-
// Ported from Z3 (src/parsers/smt2/
|
|
2
|
-
//
|
|
1
|
+
// Ported from Z3 (src/parsers/smt2/smt2scanner.cpp, src/parsers/smt2/smt2parser.cpp,
|
|
2
|
+
// src/cmd_context/cmd_context.cpp), MIT license, see z3-license.txt.
|
|
3
3
|
import { SmtParseError, SmtUnsupportedError } from "../../../errors";
|
|
4
4
|
import {
|
|
5
|
-
AstManager,
|
|
5
|
+
type AstManager,
|
|
6
|
+
getSymbolHash,
|
|
6
7
|
FAMILY_ARITH,
|
|
7
8
|
FAMILY_BASIC,
|
|
9
|
+
FAMILY_DATATYPE,
|
|
8
10
|
KIND_QUANTIFIER,
|
|
9
11
|
KIND_VAR,
|
|
10
12
|
OP_ABS,
|
|
11
13
|
OP_ADD,
|
|
12
14
|
OP_AND,
|
|
15
|
+
OP_AT_LEAST_K,
|
|
16
|
+
OP_AT_MOST_K,
|
|
17
|
+
OP_PB_EQ,
|
|
18
|
+
OP_PB_GE,
|
|
19
|
+
OP_PB_LE,
|
|
20
|
+
OP_ARRAY_DEFAULT,
|
|
21
|
+
OP_ARRAY_MAP,
|
|
22
|
+
OP_CONST_ARRAY,
|
|
13
23
|
OP_DISTINCT,
|
|
14
24
|
OP_DIV,
|
|
25
|
+
OP_DT_ACCESSOR,
|
|
15
26
|
OP_EQ,
|
|
16
27
|
OP_GE,
|
|
17
28
|
OP_GT,
|
|
@@ -22,9 +33,29 @@ import {
|
|
|
22
33
|
OP_LE,
|
|
23
34
|
OP_LT,
|
|
24
35
|
OP_MOD,
|
|
36
|
+
OP_REM,
|
|
25
37
|
OP_MUL,
|
|
26
38
|
OP_NOT,
|
|
27
39
|
OP_OR,
|
|
40
|
+
OP_POWER,
|
|
41
|
+
OP_POWER0,
|
|
42
|
+
OP_SIN,
|
|
43
|
+
OP_COS,
|
|
44
|
+
OP_TAN,
|
|
45
|
+
OP_ASIN,
|
|
46
|
+
OP_ACOS,
|
|
47
|
+
OP_ATAN,
|
|
48
|
+
OP_SINH,
|
|
49
|
+
OP_COSH,
|
|
50
|
+
OP_TANH,
|
|
51
|
+
OP_ASINH,
|
|
52
|
+
OP_ACOSH,
|
|
53
|
+
OP_ATANH,
|
|
54
|
+
OP_EXP,
|
|
55
|
+
OP_ATAN2,
|
|
56
|
+
OP_LOG,
|
|
57
|
+
OP_SELECT,
|
|
58
|
+
OP_STORE,
|
|
28
59
|
OP_SUB,
|
|
29
60
|
OP_TO_INT,
|
|
30
61
|
OP_TO_REAL,
|
|
@@ -32,61 +63,418 @@ import {
|
|
|
32
63
|
OP_FALSE,
|
|
33
64
|
OP_UMINUS,
|
|
34
65
|
OP_UNINTERPRETED,
|
|
66
|
+
OP_FUN_DEFINED,
|
|
35
67
|
OP_XOR,
|
|
36
68
|
SORT_BOOL,
|
|
37
69
|
SORT_INT,
|
|
38
70
|
SORT_REAL,
|
|
39
71
|
isArithSort,
|
|
72
|
+
QUANTIFIER_EXISTS,
|
|
73
|
+
QUANTIFIER_FORALL,
|
|
74
|
+
QUANTIFIER_LAMBDA,
|
|
40
75
|
} from "./ast";
|
|
76
|
+
import { getArraySignature, getMapSignature, mkAsArray } from "./array-decl-plugin";
|
|
77
|
+
import { BV_OP_NAMES, getBvSignature } from "./bv-decl-plugin";
|
|
78
|
+
import {
|
|
79
|
+
type ConstructorDef,
|
|
80
|
+
type DatatypeDef,
|
|
81
|
+
getConstructorAccessors,
|
|
82
|
+
getConstructorIs,
|
|
83
|
+
getConstructorRecognizer,
|
|
84
|
+
getDatatypeConstructors,
|
|
85
|
+
getDatatypeDef,
|
|
86
|
+
instantiateAccessor,
|
|
87
|
+
instantiateConstructor,
|
|
88
|
+
mkDatatypeDef,
|
|
89
|
+
mkDatatypeSort,
|
|
90
|
+
mkDatatypes,
|
|
91
|
+
mkUpdateField,
|
|
92
|
+
removeDatatype,
|
|
93
|
+
substituteSort,
|
|
94
|
+
} from "./datatype-decl-plugin";
|
|
95
|
+
import {
|
|
96
|
+
FPA_OP_NAMES,
|
|
97
|
+
FPA_SORT_NAMES,
|
|
98
|
+
getFloatSortError,
|
|
99
|
+
getFpaSignature,
|
|
100
|
+
mkFpaAppOf,
|
|
101
|
+
} from "./fpa-decl-plugin";
|
|
102
|
+
import { createLogicChecker } from "./check-logic";
|
|
103
|
+
import { ObjMap } from "./hashtable";
|
|
104
|
+
import {
|
|
105
|
+
CHAR_OP_NAMES,
|
|
106
|
+
getSeqSignature,
|
|
107
|
+
mkSeqAppOf,
|
|
108
|
+
parseZstring,
|
|
109
|
+
SEQ_OP_NAMES,
|
|
110
|
+
SEQ_SORT_NAMES,
|
|
111
|
+
} from "./seq-decl-plugin";
|
|
41
112
|
import { Rational } from "./rational";
|
|
42
|
-
import {
|
|
113
|
+
import {
|
|
114
|
+
logicHasArith,
|
|
115
|
+
logicHasArray,
|
|
116
|
+
logicHasBv,
|
|
117
|
+
logicHasFpa,
|
|
118
|
+
logicHasRealsOnly,
|
|
119
|
+
logicHasSeq,
|
|
120
|
+
isSupportedLogic,
|
|
121
|
+
} from "./smt-logics";
|
|
122
|
+
import { setRecFunDefinition } from "./recfun-decl-plugin";
|
|
123
|
+
import { replaceFreeVars, VarSubst } from "./var-subst";
|
|
124
|
+
import { UpolynomialManager } from "./nlsat/upolynomial";
|
|
125
|
+
|
|
126
|
+
export interface ParserOptions {
|
|
127
|
+
isIgnoringBadPatterns: boolean;
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
const DEFAULT_PARSER_OPTIONS: ParserOptions = { isIgnoringBadPatterns: true };
|
|
131
|
+
|
|
132
|
+
// Z3 counts the columns of the first line from 1 and of the others from 0.
|
|
133
|
+
export interface SmtToken {
|
|
134
|
+
kind: "(" | ")" | "symbol" | "keyword" | "string" | "numeral" | "decimal" | "bitvector";
|
|
135
|
+
text: string;
|
|
136
|
+
line: number;
|
|
137
|
+
column: number;
|
|
138
|
+
offset: number;
|
|
139
|
+
endOffset: number;
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
export interface SmtList {
|
|
143
|
+
kind: "list";
|
|
144
|
+
items: SExpr[];
|
|
145
|
+
line: number;
|
|
146
|
+
column: number;
|
|
147
|
+
offset: number;
|
|
148
|
+
// Z3 reports an error in making an application at its closing parenthesis.
|
|
149
|
+
end: SmtToken;
|
|
150
|
+
follower?: SmtToken;
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
export type SExpr = SmtToken | SmtList;
|
|
154
|
+
|
|
155
|
+
interface VarBinding {
|
|
156
|
+
kind: "var";
|
|
157
|
+
depth: number;
|
|
158
|
+
sort: number;
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
interface LetBinding {
|
|
162
|
+
kind: "let";
|
|
163
|
+
depth: number;
|
|
164
|
+
expr: number;
|
|
165
|
+
}
|
|
166
|
+
|
|
167
|
+
type Binding = VarBinding | LetBinding;
|
|
168
|
+
|
|
169
|
+
interface Macro {
|
|
170
|
+
domain: number[];
|
|
171
|
+
range: number;
|
|
172
|
+
body: number;
|
|
173
|
+
}
|
|
174
|
+
|
|
175
|
+
interface ConstantSortDecl {
|
|
176
|
+
kind: "sort";
|
|
177
|
+
sort: number;
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
interface UserSortDecl {
|
|
181
|
+
kind: "user";
|
|
182
|
+
name: string;
|
|
183
|
+
arity: number;
|
|
184
|
+
}
|
|
43
185
|
|
|
44
|
-
|
|
186
|
+
interface DatatypeSortDecl {
|
|
187
|
+
kind: "datatype";
|
|
188
|
+
name: string;
|
|
189
|
+
arity: number;
|
|
190
|
+
siblings: string[];
|
|
191
|
+
instances: Map<string, number>;
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
interface DefinedSortDecl {
|
|
195
|
+
kind: "definition";
|
|
196
|
+
parameters: string[];
|
|
197
|
+
body: SExpr;
|
|
198
|
+
}
|
|
199
|
+
|
|
200
|
+
// Z3's List datatype, which exists when no logic is set, declared here at its first use.
|
|
201
|
+
interface ListSortDecl {
|
|
202
|
+
kind: "list";
|
|
203
|
+
}
|
|
45
204
|
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
205
|
+
type SortDecl = ConstantSortDecl | UserSortDecl | DatatypeSortDecl | DefinedSortDecl | ListSortDecl;
|
|
206
|
+
|
|
207
|
+
const NO_BINDINGS: ReadonlyMap<string, number> = new Map();
|
|
208
|
+
|
|
209
|
+
const UPOLYNOMIALS = new UpolynomialManager();
|
|
51
210
|
|
|
52
211
|
interface SmtProblem {
|
|
53
212
|
assertions: number[];
|
|
54
|
-
// Z3 prints no answer for a script without check-sat.
|
|
55
213
|
hasCheckSat: boolean;
|
|
214
|
+
rlimit: number;
|
|
56
215
|
}
|
|
57
216
|
|
|
58
|
-
// An application that parseTerm is parsing: its name, its list, where its arguments start on the
|
|
59
|
-
// result stack, and its next argument.
|
|
60
217
|
interface ApplicationFrame {
|
|
61
|
-
|
|
62
|
-
|
|
218
|
+
head: SmtToken;
|
|
219
|
+
indices: number[];
|
|
220
|
+
build?: (args: number[]) => number;
|
|
221
|
+
list: SmtList;
|
|
63
222
|
start: number;
|
|
64
223
|
next: number;
|
|
65
224
|
}
|
|
66
225
|
|
|
67
226
|
const BUILTIN_OPS = new Map<string, number>([
|
|
68
227
|
["and", OP_AND],
|
|
228
|
+
["-", OP_SUB],
|
|
69
229
|
["or", OP_OR],
|
|
70
230
|
["not", OP_NOT],
|
|
71
231
|
["=>", OP_IMPLIES],
|
|
72
232
|
["xor", OP_XOR],
|
|
73
233
|
["ite", OP_ITE],
|
|
234
|
+
["if", OP_ITE],
|
|
74
235
|
["distinct", OP_DISTINCT],
|
|
75
236
|
["+", OP_ADD],
|
|
76
237
|
["*", OP_MUL],
|
|
77
238
|
["/", OP_DIV],
|
|
78
239
|
["div", OP_IDIV],
|
|
79
240
|
["mod", OP_MOD],
|
|
241
|
+
["rem", OP_REM],
|
|
80
242
|
["abs", OP_ABS],
|
|
81
243
|
["to_real", OP_TO_REAL],
|
|
82
244
|
["to_int", OP_TO_INT],
|
|
83
245
|
["is_int", OP_IS_INT],
|
|
84
246
|
]);
|
|
85
247
|
|
|
86
|
-
//
|
|
87
|
-
const
|
|
248
|
+
// basic_decl_plugin's aliases, which Z3 knows only when the script sets no logic.
|
|
249
|
+
const LOGIC_FREE_ALIASES = new Map([
|
|
250
|
+
["implies", "=>"],
|
|
251
|
+
["iff", "="],
|
|
252
|
+
["if_then_else", "ite"],
|
|
253
|
+
["&&", "and"],
|
|
254
|
+
["||", "or"],
|
|
255
|
+
["equals", "="],
|
|
256
|
+
["equiv", "="],
|
|
257
|
+
]);
|
|
258
|
+
|
|
259
|
+
// Z3 declares these only without a logic, in ALL or in QF_NTA.
|
|
260
|
+
const TRANSCENDENTAL_OPS = new Map([
|
|
261
|
+
["^", OP_POWER],
|
|
262
|
+
["^0", OP_POWER0],
|
|
263
|
+
["sin", OP_SIN],
|
|
264
|
+
["cos", OP_COS],
|
|
265
|
+
["tan", OP_TAN],
|
|
266
|
+
["asin", OP_ASIN],
|
|
267
|
+
["acos", OP_ACOS],
|
|
268
|
+
["atan", OP_ATAN],
|
|
269
|
+
["sinh", OP_SINH],
|
|
270
|
+
["cosh", OP_COSH],
|
|
271
|
+
["tanh", OP_TANH],
|
|
272
|
+
["asinh", OP_ASINH],
|
|
273
|
+
["acosh", OP_ACOSH],
|
|
274
|
+
["atanh", OP_ATANH],
|
|
275
|
+
["exp", OP_EXP],
|
|
276
|
+
["atan2", OP_ATAN2],
|
|
277
|
+
["arctan2", OP_ATAN2],
|
|
278
|
+
["log", OP_LOG],
|
|
279
|
+
["ln", OP_LOG],
|
|
280
|
+
]);
|
|
281
|
+
const TRANSCENDENTALS = new Set([
|
|
282
|
+
...TRANSCENDENTAL_OPS.keys(),
|
|
283
|
+
"pi",
|
|
284
|
+
"euler",
|
|
285
|
+
"/0",
|
|
286
|
+
"div0",
|
|
287
|
+
"mod0",
|
|
288
|
+
"complex.make",
|
|
289
|
+
"complex.real",
|
|
290
|
+
"complex.imag",
|
|
291
|
+
]);
|
|
292
|
+
|
|
293
|
+
const hasTranscendentals = (logic: string | undefined) =>
|
|
294
|
+
logic === undefined || logic === "ALL" || logic === "QF_NTA";
|
|
295
|
+
|
|
296
|
+
const THEORY_SORTS = new Set([
|
|
297
|
+
"BitVec",
|
|
298
|
+
"Array",
|
|
299
|
+
"Set",
|
|
300
|
+
"Seq",
|
|
301
|
+
"String",
|
|
302
|
+
"StringSequence",
|
|
303
|
+
"RegEx",
|
|
304
|
+
"RegLan",
|
|
305
|
+
"Unicode",
|
|
306
|
+
"FloatingPoint",
|
|
307
|
+
"RoundingMode",
|
|
308
|
+
"Float16",
|
|
309
|
+
"Float32",
|
|
310
|
+
"Float64",
|
|
311
|
+
"Float128",
|
|
312
|
+
"FiniteSet",
|
|
313
|
+
"FiniteField",
|
|
314
|
+
"Complex",
|
|
315
|
+
]);
|
|
316
|
+
const PB_OP_NAMES = new Map([
|
|
317
|
+
["at-most", OP_AT_MOST_K],
|
|
318
|
+
["at-least", OP_AT_LEAST_K],
|
|
319
|
+
["pble", OP_PB_LE],
|
|
320
|
+
["pbge", OP_PB_GE],
|
|
321
|
+
["pbeq", OP_PB_EQ],
|
|
322
|
+
]);
|
|
323
|
+
const THEORY_OPERATOR = /^(bv|fp\.|str\.|seq\.|re\.|char\.|ff\.)/;
|
|
324
|
+
const THEORY_OPERATORS = new Set([
|
|
325
|
+
"bit0",
|
|
326
|
+
"bit1",
|
|
327
|
+
"concat",
|
|
328
|
+
"sign_extend",
|
|
329
|
+
"zero_extend",
|
|
330
|
+
"extract",
|
|
331
|
+
"repeat",
|
|
332
|
+
"rotate_left",
|
|
333
|
+
"rotate_right",
|
|
334
|
+
"ext_rotate_left",
|
|
335
|
+
"ext_rotate_right",
|
|
336
|
+
"bit2bool",
|
|
337
|
+
"ubv_to_int",
|
|
338
|
+
"sbv_to_int",
|
|
339
|
+
"int_to_bv",
|
|
340
|
+
"int2bv",
|
|
341
|
+
"mkbv",
|
|
342
|
+
"store",
|
|
343
|
+
"select",
|
|
344
|
+
"const",
|
|
345
|
+
"map",
|
|
346
|
+
"default",
|
|
347
|
+
"union",
|
|
348
|
+
"intersection",
|
|
349
|
+
"setminus",
|
|
350
|
+
"complement",
|
|
351
|
+
"subset",
|
|
352
|
+
"as-array",
|
|
353
|
+
"choice",
|
|
354
|
+
"array-ext",
|
|
355
|
+
"set-has-size",
|
|
356
|
+
"card",
|
|
357
|
+
"is",
|
|
358
|
+
"update-field",
|
|
359
|
+
"int.to.str",
|
|
360
|
+
"char",
|
|
361
|
+
"fp",
|
|
362
|
+
"to_fp",
|
|
363
|
+
"to_fp_unsigned",
|
|
364
|
+
"to_ieee_bv",
|
|
365
|
+
"+oo",
|
|
366
|
+
"-oo",
|
|
367
|
+
"+zero",
|
|
368
|
+
"-zero",
|
|
369
|
+
"NaN",
|
|
370
|
+
"roundNearestTiesToEven",
|
|
371
|
+
"roundNearestTiesToAway",
|
|
372
|
+
"roundTowardPositive",
|
|
373
|
+
"roundTowardNegative",
|
|
374
|
+
"roundTowardZero",
|
|
375
|
+
"RNE",
|
|
376
|
+
"RNA",
|
|
377
|
+
"RTP",
|
|
378
|
+
"RTN",
|
|
379
|
+
"RTZ",
|
|
380
|
+
"at-most",
|
|
381
|
+
"at-least",
|
|
382
|
+
"pble",
|
|
383
|
+
"pbge",
|
|
384
|
+
"pbeq",
|
|
385
|
+
"linear-order",
|
|
386
|
+
"partial-order",
|
|
387
|
+
"piecewise-linear-order",
|
|
388
|
+
"tree-order",
|
|
389
|
+
"transitive-closure",
|
|
390
|
+
]);
|
|
88
391
|
|
|
89
|
-
|
|
392
|
+
// The operators that are associative but not flat: xor and => nest to the right, the others to the
|
|
393
|
+
// left.
|
|
394
|
+
const NESTED_OPS = new Set([OP_XOR, OP_IMPLIES, OP_SUB, OP_DIV, OP_IDIV]);
|
|
395
|
+
|
|
396
|
+
const COERCING_OPS = new Set([
|
|
397
|
+
OP_ADD,
|
|
398
|
+
OP_SUB,
|
|
399
|
+
OP_UMINUS,
|
|
400
|
+
OP_MUL,
|
|
401
|
+
OP_POWER,
|
|
402
|
+
OP_POWER0,
|
|
403
|
+
OP_LE,
|
|
404
|
+
OP_GE,
|
|
405
|
+
OP_LT,
|
|
406
|
+
OP_GT,
|
|
407
|
+
]);
|
|
408
|
+
|
|
409
|
+
const REAL_FUNCTION_OPS = new Set([
|
|
410
|
+
OP_SIN,
|
|
411
|
+
OP_COS,
|
|
412
|
+
OP_TAN,
|
|
413
|
+
OP_ASIN,
|
|
414
|
+
OP_ACOS,
|
|
415
|
+
OP_ATAN,
|
|
416
|
+
OP_SINH,
|
|
417
|
+
OP_COSH,
|
|
418
|
+
OP_TANH,
|
|
419
|
+
OP_ASINH,
|
|
420
|
+
OP_ACOSH,
|
|
421
|
+
OP_ATANH,
|
|
422
|
+
OP_EXP,
|
|
423
|
+
OP_ATAN2,
|
|
424
|
+
OP_LOG,
|
|
425
|
+
]);
|
|
426
|
+
|
|
427
|
+
const ARITIES = new Map<number, [number, number]>([
|
|
428
|
+
[OP_AND, [0, Infinity]],
|
|
429
|
+
[OP_OR, [0, Infinity]],
|
|
430
|
+
[OP_ITE, [3, 3]],
|
|
431
|
+
[OP_EQ, [2, Infinity]],
|
|
432
|
+
[OP_DISTINCT, [1, Infinity]],
|
|
433
|
+
...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
|
|
434
|
+
.filter((op) => op !== OP_ATAN2)
|
|
435
|
+
.map((op): [number, [number, number]] => [op, [1, 1]]),
|
|
436
|
+
...[
|
|
437
|
+
OP_IMPLIES,
|
|
438
|
+
OP_XOR,
|
|
439
|
+
OP_IDIV,
|
|
440
|
+
OP_MOD,
|
|
441
|
+
OP_REM,
|
|
442
|
+
OP_DIV,
|
|
443
|
+
OP_LE,
|
|
444
|
+
OP_GE,
|
|
445
|
+
OP_LT,
|
|
446
|
+
OP_GT,
|
|
447
|
+
OP_POWER,
|
|
448
|
+
OP_POWER0,
|
|
449
|
+
OP_ATAN2,
|
|
450
|
+
].map((op): [number, [number, number]] => [op, [2, 2]]),
|
|
451
|
+
]);
|
|
452
|
+
|
|
453
|
+
const RANGES = new Map<number, number>([
|
|
454
|
+
[OP_TO_REAL, SORT_REAL],
|
|
455
|
+
[OP_POWER, SORT_REAL],
|
|
456
|
+
[OP_POWER0, SORT_REAL],
|
|
457
|
+
...[...REAL_FUNCTION_OPS].map((op): [number, number] => [op, SORT_REAL]),
|
|
458
|
+
[OP_DIV, SORT_REAL],
|
|
459
|
+
[OP_TO_INT, SORT_INT],
|
|
460
|
+
[OP_IDIV, SORT_INT],
|
|
461
|
+
[OP_MOD, SORT_INT],
|
|
462
|
+
[OP_REM, SORT_INT],
|
|
463
|
+
...[
|
|
464
|
+
OP_EQ,
|
|
465
|
+
OP_DISTINCT,
|
|
466
|
+
OP_AND,
|
|
467
|
+
OP_OR,
|
|
468
|
+
OP_XOR,
|
|
469
|
+
OP_NOT,
|
|
470
|
+
OP_IMPLIES,
|
|
471
|
+
OP_LE,
|
|
472
|
+
OP_GE,
|
|
473
|
+
OP_LT,
|
|
474
|
+
OP_GT,
|
|
475
|
+
].map((op): [number, number] => [op, SORT_BOOL]),
|
|
476
|
+
[OP_IS_INT, SORT_BOOL],
|
|
477
|
+
]);
|
|
90
478
|
|
|
91
479
|
const CHAINABLE_OPS = new Map<string, number>([
|
|
92
480
|
["=", OP_EQ],
|
|
@@ -96,88 +484,563 @@ const CHAINABLE_OPS = new Map<string, number>([
|
|
|
96
484
|
[">", OP_GT],
|
|
97
485
|
]);
|
|
98
486
|
|
|
99
|
-
const
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
116
|
-
|
|
117
|
-
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
|
|
122
|
-
|
|
123
|
-
|
|
124
|
-
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
487
|
+
const BV_EXTENSION_NAMES = new Set([
|
|
488
|
+
"bvumul_noovfl",
|
|
489
|
+
"bvsmul_noovfl",
|
|
490
|
+
"bvsmul_noudfl",
|
|
491
|
+
"bvsdiv0",
|
|
492
|
+
"bvudiv0",
|
|
493
|
+
"bvsrem0",
|
|
494
|
+
"bvurem0",
|
|
495
|
+
"bvsmod0",
|
|
496
|
+
"ext_rotate_left",
|
|
497
|
+
"ext_rotate_right",
|
|
498
|
+
"int2bv",
|
|
499
|
+
"bv2int",
|
|
500
|
+
"bv2nat",
|
|
501
|
+
"mkbv",
|
|
502
|
+
]);
|
|
503
|
+
|
|
504
|
+
const BV_EXTENSION_LOGICS = new Set(["ALL", "QF_FD", "HORN"]);
|
|
505
|
+
|
|
506
|
+
const ARRAY_SORT_NAMES = new Set(["Array", "=>", "->"]);
|
|
507
|
+
|
|
508
|
+
// array_decl_plugin::get_op_names: select and store in every logic with arrays, the others only
|
|
509
|
+
// without a logic or in HORN and ALL.
|
|
510
|
+
const ARRAY_OPS = new Map([
|
|
511
|
+
["select", OP_SELECT],
|
|
512
|
+
["store", OP_STORE],
|
|
513
|
+
]);
|
|
514
|
+
const ARRAY_EXTENSION_OPS = new Map([["default", OP_ARRAY_DEFAULT]]);
|
|
515
|
+
|
|
516
|
+
const UNARY_BOOL_REFS = new Map([["not", OP_NOT]]);
|
|
517
|
+
const BINARY_BOOL_REFS = new Map([
|
|
518
|
+
["and", OP_AND],
|
|
519
|
+
["or", OP_OR],
|
|
520
|
+
["=>", OP_IMPLIES],
|
|
521
|
+
["xor", OP_XOR],
|
|
522
|
+
]);
|
|
523
|
+
|
|
524
|
+
const REAL_RANGE_OPS = new Set([OP_DIV, OP_TO_REAL]);
|
|
525
|
+
const INT_RANGE_OPS = new Set([OP_IDIV, OP_MOD, OP_REM, OP_TO_INT]);
|
|
526
|
+
const DOMAIN_RANGE_OPS = new Set([OP_ADD, OP_SUB, OP_MUL, OP_ABS]);
|
|
527
|
+
|
|
528
|
+
// mk_func_decl of a builtin ignores the range of the reference and gives its own.
|
|
529
|
+
const getBuiltinRange = (op: number, domain: number[]) =>
|
|
530
|
+
op === OP_ITE
|
|
531
|
+
? domain[1]
|
|
532
|
+
: REAL_RANGE_OPS.has(op)
|
|
533
|
+
? SORT_REAL
|
|
534
|
+
: INT_RANGE_OPS.has(op)
|
|
535
|
+
? SORT_INT
|
|
536
|
+
: DOMAIN_RANGE_OPS.has(op)
|
|
537
|
+
? domain[0]
|
|
538
|
+
: SORT_BOOL;
|
|
539
|
+
|
|
540
|
+
interface MappedDecl {
|
|
541
|
+
decl: number;
|
|
542
|
+
domain: readonly number[];
|
|
543
|
+
range: number;
|
|
544
|
+
}
|
|
545
|
+
const ARRAY_EXTENSION_LOGICS = new Set(["HORN", "ALL"]);
|
|
546
|
+
|
|
547
|
+
const BUILTIN_NAMES = new Set([
|
|
548
|
+
"true",
|
|
549
|
+
"false",
|
|
550
|
+
"~",
|
|
551
|
+
...BV_OP_NAMES.keys(),
|
|
552
|
+
...CHAINABLE_OPS.keys(),
|
|
553
|
+
...BUILTIN_OPS.keys(),
|
|
554
|
+
...LOGIC_FREE_ALIASES.keys(),
|
|
555
|
+
...TRANSCENDENTALS,
|
|
556
|
+
...THEORY_OPERATORS,
|
|
557
|
+
...SEQ_OP_NAMES.keys(),
|
|
558
|
+
...CHAR_OP_NAMES.keys(),
|
|
559
|
+
]);
|
|
560
|
+
|
|
561
|
+
const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
|
|
562
|
+
|
|
563
|
+
const createScanner = (text: string) => {
|
|
564
|
+
const state = { index: 0, line: 1, lineStart: -1 };
|
|
565
|
+
const getColumn = () => state.index - state.lineStart - (state.line === 1 ? 0 : 1);
|
|
566
|
+
const advance = () => {
|
|
567
|
+
if (text[state.index] === "\n") {
|
|
568
|
+
state.line++;
|
|
569
|
+
state.lineStart = state.index;
|
|
128
570
|
}
|
|
129
|
-
|
|
130
|
-
|
|
571
|
+
state.index++;
|
|
572
|
+
};
|
|
573
|
+
const readWhile = (pattern: RegExp) => {
|
|
574
|
+
while (state.index < text.length && pattern.test(text[state.index])) advance();
|
|
575
|
+
};
|
|
576
|
+
const next = (): SmtToken | undefined => {
|
|
577
|
+
for (;;) {
|
|
578
|
+
const character = text[state.index];
|
|
579
|
+
if (character === undefined) return undefined;
|
|
580
|
+
if (character === ";") {
|
|
581
|
+
while (state.index < text.length && text[state.index] !== "\n") advance();
|
|
582
|
+
continue;
|
|
583
|
+
}
|
|
584
|
+
if (character === " " || character === "\t" || character === "\r" || character === "\n") {
|
|
585
|
+
advance();
|
|
586
|
+
continue;
|
|
587
|
+
}
|
|
588
|
+
const start = state.index;
|
|
589
|
+
const position = { line: state.line, column: getColumn() };
|
|
590
|
+
const getToken = (kind: SmtToken["kind"], tokenText = text.slice(start, state.index)) => ({
|
|
591
|
+
kind,
|
|
592
|
+
text: tokenText,
|
|
593
|
+
...position,
|
|
594
|
+
offset: start,
|
|
595
|
+
endOffset: state.index,
|
|
596
|
+
});
|
|
597
|
+
if (character === "(" || character === ")") {
|
|
598
|
+
advance();
|
|
599
|
+
return getToken(character);
|
|
600
|
+
}
|
|
601
|
+
if (character === "|" || character === '"') {
|
|
602
|
+
advance();
|
|
603
|
+
for (;;) {
|
|
604
|
+
if (state.index >= text.length)
|
|
605
|
+
throw new SmtParseError(
|
|
606
|
+
character === "|" ? "unexpected end of quoted symbol" : "unexpected end of string",
|
|
607
|
+
{ line: state.line, column: getColumn() },
|
|
608
|
+
);
|
|
609
|
+
const current = text[state.index];
|
|
610
|
+
advance();
|
|
611
|
+
// Z3's scanner starts the line before it reads past a newline in a quoted symbol or a
|
|
612
|
+
// string, so the columns of the rest of the line count one more.
|
|
613
|
+
if (current === "\n") state.lineStart--;
|
|
614
|
+
if (current !== character) continue;
|
|
615
|
+
if (character !== '"' || text[state.index] !== '"') break;
|
|
616
|
+
advance();
|
|
617
|
+
}
|
|
618
|
+
const inner = text.slice(start + 1, state.index - 1);
|
|
619
|
+
return character === "|"
|
|
620
|
+
? getToken("symbol", inner)
|
|
621
|
+
: getToken("string", inner.replaceAll('""', '"'));
|
|
622
|
+
}
|
|
623
|
+
if (/[0-9]/.test(character) || (character === "-" && /[0-9]/.test(text[start + 1] ?? ""))) {
|
|
624
|
+
advance();
|
|
625
|
+
readWhile(/[0-9]/);
|
|
626
|
+
if (text[state.index] !== ".") return getToken("numeral");
|
|
627
|
+
advance();
|
|
628
|
+
readWhile(/[0-9]/);
|
|
629
|
+
return getToken("decimal");
|
|
630
|
+
}
|
|
631
|
+
if (character === "#") {
|
|
632
|
+
advance();
|
|
633
|
+
readWhile(/[0-9A-Za-z]/);
|
|
634
|
+
return getToken("bitvector");
|
|
635
|
+
}
|
|
636
|
+
if (character === ":" || SYMBOL_CHARACTER.test(character)) {
|
|
637
|
+
advance();
|
|
638
|
+
readWhile(SYMBOL_CHARACTER);
|
|
639
|
+
return getToken(character === ":" ? "keyword" : "symbol");
|
|
640
|
+
}
|
|
641
|
+
advance();
|
|
642
|
+
throw new SmtParseError("unexpected character", position);
|
|
643
|
+
}
|
|
644
|
+
};
|
|
645
|
+
return { next, getPosition: () => ({ line: state.line, column: getColumn() }) };
|
|
131
646
|
};
|
|
132
647
|
|
|
133
|
-
const
|
|
134
|
-
const
|
|
135
|
-
|
|
136
|
-
|
|
137
|
-
|
|
138
|
-
|
|
139
|
-
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
|
|
143
|
-
}
|
|
144
|
-
|
|
145
|
-
|
|
648
|
+
export const createCommandReader = (text: string) => {
|
|
649
|
+
const scanner = createScanner(text);
|
|
650
|
+
const state: { lookahead: SmtToken | undefined; depth: number } = {
|
|
651
|
+
lookahead: undefined,
|
|
652
|
+
depth: 0,
|
|
653
|
+
};
|
|
654
|
+
const take = () => {
|
|
655
|
+
const token = state.lookahead ?? scanner.next();
|
|
656
|
+
state.lookahead = undefined;
|
|
657
|
+
return token;
|
|
658
|
+
};
|
|
659
|
+
const readList = (open: SmtToken): SmtList => {
|
|
660
|
+
const stack: SmtList[] = [];
|
|
661
|
+
const root: SmtList = {
|
|
662
|
+
kind: "list",
|
|
663
|
+
items: [],
|
|
664
|
+
line: open.line,
|
|
665
|
+
column: open.column,
|
|
666
|
+
offset: open.offset,
|
|
667
|
+
end: open,
|
|
668
|
+
};
|
|
669
|
+
let rootObject: SmtList | undefined;
|
|
670
|
+
for (let current = root; ;) {
|
|
671
|
+
const token = take();
|
|
672
|
+
if (token === undefined)
|
|
673
|
+
throw new SmtParseError("unexpected end of file", scanner.getPosition());
|
|
674
|
+
if (rootObject !== undefined) rootObject.follower = token;
|
|
675
|
+
rootObject = undefined;
|
|
676
|
+
if (token.kind === "(") {
|
|
677
|
+
const list: SmtList = {
|
|
678
|
+
kind: "list",
|
|
679
|
+
items: [],
|
|
680
|
+
line: token.line,
|
|
681
|
+
column: token.column,
|
|
682
|
+
offset: token.offset,
|
|
683
|
+
end: token,
|
|
684
|
+
};
|
|
685
|
+
current.items.push(list);
|
|
686
|
+
stack.push(current);
|
|
687
|
+
state.depth++;
|
|
688
|
+
current = list;
|
|
689
|
+
continue;
|
|
690
|
+
}
|
|
691
|
+
if (token.kind !== ")") {
|
|
692
|
+
current.items.push(token);
|
|
693
|
+
continue;
|
|
694
|
+
}
|
|
695
|
+
current.end = token;
|
|
696
|
+
if (isSymbol(current.items[0], "root-obj")) rootObject = current;
|
|
697
|
+
state.depth--;
|
|
698
|
+
const parent = stack.pop();
|
|
699
|
+
if (parent === undefined) return root;
|
|
700
|
+
current = parent;
|
|
701
|
+
}
|
|
702
|
+
};
|
|
703
|
+
const read = (): SmtList | undefined => {
|
|
704
|
+
const token = take();
|
|
705
|
+
if (token === undefined) return undefined;
|
|
706
|
+
if (token.kind !== "(") throw new SmtParseError("invalid command, '(' expected", token);
|
|
707
|
+
state.depth = 1;
|
|
708
|
+
return readList(token);
|
|
709
|
+
};
|
|
710
|
+
const skip = (report: (error: SmtParseError) => void) => {
|
|
711
|
+
for (;;) {
|
|
712
|
+
try {
|
|
713
|
+
const token = take();
|
|
714
|
+
if (token === undefined) return;
|
|
715
|
+
if (token.kind === "(" && state.depth === 0) {
|
|
716
|
+
state.lookahead = token;
|
|
717
|
+
return;
|
|
718
|
+
}
|
|
719
|
+
if (token.kind === "(") state.depth++;
|
|
720
|
+
if (token.kind === ")") state.depth = Math.max(0, state.depth - 1);
|
|
721
|
+
} catch (error) {
|
|
722
|
+
if (!(error instanceof SmtParseError)) throw error;
|
|
723
|
+
report(error);
|
|
724
|
+
}
|
|
725
|
+
}
|
|
726
|
+
};
|
|
727
|
+
return { read, skip };
|
|
146
728
|
};
|
|
147
729
|
|
|
148
|
-
const
|
|
149
|
-
|
|
730
|
+
export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
|
|
731
|
+
sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
|
|
732
|
+
|
|
733
|
+
const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtList => {
|
|
734
|
+
if (sexpr?.kind !== "list") throw new SmtParseError(message, sexpr ?? at);
|
|
150
735
|
return sexpr;
|
|
151
736
|
};
|
|
152
737
|
|
|
153
|
-
const expectSymbol = (sexpr: SExpr | undefined
|
|
154
|
-
if (
|
|
738
|
+
const expectSymbol = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtToken => {
|
|
739
|
+
if (!isSymbol(sexpr)) throw new SmtParseError(message, sexpr ?? at);
|
|
155
740
|
return sexpr;
|
|
156
741
|
};
|
|
157
742
|
|
|
158
|
-
|
|
159
|
-
// the next command. Expressions are created in the order of Z3's parser, and live as long as there.
|
|
160
|
-
export const parseSmtlib = (
|
|
161
|
-
text: string,
|
|
743
|
+
export const createSmtlibReader = (
|
|
162
744
|
manager: AstManager,
|
|
163
|
-
|
|
164
|
-
|
|
165
|
-
|
|
166
|
-
|
|
167
|
-
|
|
168
|
-
|
|
745
|
+
logic?: string,
|
|
746
|
+
options: ParserOptions = DEFAULT_PARSER_OPTIONS,
|
|
747
|
+
) => {
|
|
748
|
+
const hasArith = logic === undefined || logicHasArith(logic);
|
|
749
|
+
const hasBv = logic === undefined || logicHasBv(logic);
|
|
750
|
+
const isNumeralAsReal = logic !== undefined && logicHasRealsOnly(logic);
|
|
751
|
+
const logicChecker = createLogicChecker(manager, logic);
|
|
752
|
+
const sortDecls = new Map<string, SortDecl>([
|
|
753
|
+
["Bool", { kind: "sort", sort: SORT_BOOL }],
|
|
754
|
+
...(hasArith
|
|
755
|
+
? [
|
|
756
|
+
["Int", { kind: "sort", sort: SORT_INT }] as const,
|
|
757
|
+
["Real", { kind: "sort", sort: SORT_REAL }] as const,
|
|
758
|
+
]
|
|
759
|
+
: []),
|
|
760
|
+
...(logic === undefined ? [["List", { kind: "list" }] as const] : []),
|
|
169
761
|
]);
|
|
170
|
-
const funcs = new Map<string, number>();
|
|
171
|
-
const
|
|
762
|
+
const funcs = new Map<string, readonly number[]>();
|
|
763
|
+
const macros = new Map<string, Macro>();
|
|
764
|
+
const lastNamed = { name: "", expr: -1 };
|
|
765
|
+
const notifiedSorts = new Set<number>();
|
|
766
|
+
const undo: (() => void)[] = [];
|
|
767
|
+
const scopeStarts: number[] = [];
|
|
172
768
|
const scopes: Map<string, Binding>[] = [];
|
|
173
|
-
|
|
769
|
+
const binders = { depth: 0 };
|
|
770
|
+
|
|
771
|
+
const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
|
|
772
|
+
const previous = names.get(name);
|
|
773
|
+
undo.push(() => {
|
|
774
|
+
if (previous === undefined) names.delete(name);
|
|
775
|
+
else names.set(name, previous);
|
|
776
|
+
});
|
|
777
|
+
names.set(name, value);
|
|
778
|
+
};
|
|
779
|
+
|
|
780
|
+
const hasArrays = logic === undefined || logicHasArray(logic);
|
|
781
|
+
const hasFpa = logic === undefined || logicHasFpa(logic);
|
|
782
|
+
const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
|
|
783
|
+
const hasSeq = logic === undefined || logicHasSeq(logic);
|
|
174
784
|
|
|
175
|
-
const
|
|
176
|
-
|
|
177
|
-
|
|
785
|
+
const getFirstFunc = (name: string) => funcs.get(name)?.[0];
|
|
786
|
+
|
|
787
|
+
const checkDecl = (decl: number, at: SExpr) => {
|
|
788
|
+
const error = logicChecker.checkDecl(decl);
|
|
789
|
+
if (error !== undefined) throw new SmtParseError(error, at);
|
|
790
|
+
};
|
|
791
|
+
|
|
792
|
+
const insertFunc = (decl: number, at: SExpr) => {
|
|
793
|
+
checkDecl(decl, at);
|
|
794
|
+
const funcDecl = manager.funcDecls[decl];
|
|
795
|
+
const name = String(funcDecl.name);
|
|
796
|
+
if (macros.has(name))
|
|
797
|
+
throw new SmtParseError(
|
|
798
|
+
`invalid declaration, named expression already defined with this name ${name}`,
|
|
799
|
+
at,
|
|
800
|
+
);
|
|
801
|
+
const existing = funcs.get(name) ?? [];
|
|
802
|
+
if (existing.includes(decl))
|
|
803
|
+
throw new SmtParseError(
|
|
804
|
+
`invalid declaration, ${funcDecl.domain.length === 0 ? "constant" : "function"} '${name}' (with the given signature) already declared`,
|
|
805
|
+
at,
|
|
806
|
+
);
|
|
807
|
+
declare(funcs, name, [...existing, decl]);
|
|
808
|
+
};
|
|
809
|
+
|
|
810
|
+
const insertDatatypeDecls = (sort: number, at: SExpr) => {
|
|
811
|
+
for (const constructor of getDatatypeConstructors(manager, sort)) {
|
|
812
|
+
insertFunc(constructor, at);
|
|
813
|
+
insertFunc(getConstructorRecognizer(manager, constructor), at);
|
|
814
|
+
for (const accessor of getConstructorAccessors(manager, constructor))
|
|
815
|
+
insertFunc(accessor, at);
|
|
816
|
+
}
|
|
817
|
+
};
|
|
818
|
+
|
|
819
|
+
const notifyDatatype = (sort: number, at: SExpr) => {
|
|
820
|
+
const parameters = manager.getSortParameters(sort);
|
|
821
|
+
if (parameters.length === 0 || notifiedSorts.has(sort)) return;
|
|
822
|
+
if (getDatatypeDef(manager, sort) === undefined) return;
|
|
823
|
+
if (parameters.every((parameter) => manager.getTypeParameterIndex(parameter) === -1))
|
|
824
|
+
insertDatatypeDecls(sort, at);
|
|
825
|
+
notifiedSorts.add(sort);
|
|
826
|
+
undo.push(() => notifiedSorts.delete(sort));
|
|
827
|
+
};
|
|
828
|
+
|
|
829
|
+
const getDatatypeInstance = (decl: DatatypeSortDecl, parameters: number[], at: SExpr) => {
|
|
830
|
+
const key = parameters.join(",");
|
|
831
|
+
const sort = decl.instances.get(key) ?? mkDatatypeSort(manager, decl.name, parameters);
|
|
832
|
+
decl.instances.set(key, sort);
|
|
833
|
+
notifyDatatype(sort, at);
|
|
178
834
|
return sort;
|
|
179
835
|
};
|
|
180
836
|
|
|
837
|
+
const instantiateDatatype = (decl: DatatypeSortDecl, parameters: number[], at: SExpr) => {
|
|
838
|
+
const sort = getDatatypeInstance(decl, parameters, at);
|
|
839
|
+
const def = getDatatypeDef(manager, sort);
|
|
840
|
+
if (def === undefined || parameters.length === 0 || decl.siblings.length === 0) return sort;
|
|
841
|
+
const marked = new Set([sort]);
|
|
842
|
+
for (const constructor of def.constructors)
|
|
843
|
+
for (const accessor of constructor.accessors) {
|
|
844
|
+
const range = accessor.range;
|
|
845
|
+
if (!manager.isDatatypeSort(range) || marked.has(range)) continue;
|
|
846
|
+
marked.add(range);
|
|
847
|
+
const sibling = sortDecls.get(manager.sortNames[range]);
|
|
848
|
+
if (sibling?.kind !== "datatype" || !decl.siblings.includes(sibling.name)) continue;
|
|
849
|
+
const instance = substituteSort(manager, range, def.parameters, parameters);
|
|
850
|
+
getDatatypeInstance(sibling, [...manager.getSortParameters(instance)], at);
|
|
851
|
+
}
|
|
852
|
+
return sort;
|
|
853
|
+
};
|
|
854
|
+
|
|
855
|
+
const getSortDeclArity = (decl: SortDecl) =>
|
|
856
|
+
decl.kind === "sort"
|
|
857
|
+
? 0
|
|
858
|
+
: decl.kind === "list"
|
|
859
|
+
? 1
|
|
860
|
+
: decl.kind === "definition"
|
|
861
|
+
? decl.parameters.length
|
|
862
|
+
: decl.arity;
|
|
863
|
+
|
|
864
|
+
const instantiateSort = (decl: SortDecl, parameters: number[], at: SExpr): number => {
|
|
865
|
+
if (decl.kind === "sort") return decl.sort;
|
|
866
|
+
if (decl.kind === "list") {
|
|
867
|
+
const element = manager.mkTypeParameter(0);
|
|
868
|
+
mkDatatypes(manager, [
|
|
869
|
+
mkDatatypeDef(
|
|
870
|
+
manager,
|
|
871
|
+
"List",
|
|
872
|
+
[element],
|
|
873
|
+
[
|
|
874
|
+
{ name: "nil", recognizer: "is-nil", accessors: [] },
|
|
875
|
+
{
|
|
876
|
+
name: "insert",
|
|
877
|
+
recognizer: "is-insert",
|
|
878
|
+
accessors: [
|
|
879
|
+
{ name: "head", range: element },
|
|
880
|
+
{ name: "tail", range: -1 },
|
|
881
|
+
],
|
|
882
|
+
},
|
|
883
|
+
],
|
|
884
|
+
),
|
|
885
|
+
]);
|
|
886
|
+
const list: DatatypeSortDecl = {
|
|
887
|
+
kind: "datatype",
|
|
888
|
+
name: "List",
|
|
889
|
+
arity: 1,
|
|
890
|
+
siblings: [],
|
|
891
|
+
instances: new Map(),
|
|
892
|
+
};
|
|
893
|
+
sortDecls.set("List", list);
|
|
894
|
+
return instantiateSort(list, parameters, at);
|
|
895
|
+
}
|
|
896
|
+
if (decl.kind === "user") return manager.mkUninterpretedSort(decl.name, parameters);
|
|
897
|
+
if (decl.kind === "datatype") return instantiateDatatype(decl, parameters, at);
|
|
898
|
+
return parseSort(
|
|
899
|
+
decl.body,
|
|
900
|
+
"",
|
|
901
|
+
new Map(decl.parameters.map((name, index) => [name, parameters[index]])),
|
|
902
|
+
);
|
|
903
|
+
};
|
|
904
|
+
|
|
905
|
+
const parseParametricSort = (
|
|
906
|
+
sexpr: SmtList,
|
|
907
|
+
context: string,
|
|
908
|
+
bindings: ReadonlyMap<string, number>,
|
|
909
|
+
): number => {
|
|
910
|
+
const head = sexpr.items[0];
|
|
911
|
+
if (!isSymbol(head)) throw new SmtParseError("invalid sort, symbol or '_' expected", head);
|
|
912
|
+
const isArray = ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && hasArrayExtensions);
|
|
913
|
+
if (isArray && hasArrays) {
|
|
914
|
+
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
915
|
+
if (head.text === "Set" ? parameters.length !== 1 : parameters.length < 2)
|
|
916
|
+
throw new SmtParseError(
|
|
917
|
+
"invalid array sort definition, invalid number of parameters",
|
|
918
|
+
sexpr.end,
|
|
919
|
+
);
|
|
920
|
+
return manager.mkArraySort(head.text === "Set" ? [parameters[0], SORT_BOOL] : parameters);
|
|
921
|
+
}
|
|
922
|
+
const decl = sortDecls.get(head.text);
|
|
923
|
+
if (decl === undefined && hasSeq && (head.text === "Seq" || head.text === "RegEx")) {
|
|
924
|
+
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
925
|
+
if (parameters.length !== 1)
|
|
926
|
+
throw new SmtParseError(
|
|
927
|
+
head.text === "Seq"
|
|
928
|
+
? "Invalid sequence sort, expecting one parameter"
|
|
929
|
+
: "Invalid regex sort, expecting one parameter",
|
|
930
|
+
sexpr.end,
|
|
931
|
+
);
|
|
932
|
+
return head.text === "Seq"
|
|
933
|
+
? manager.mkSeqSort(parameters[0])
|
|
934
|
+
: manager.mkReSort(parameters[0]);
|
|
935
|
+
}
|
|
936
|
+
if (decl === undefined && hasFpa && FPA_SORT_NAMES.has(head.text)) {
|
|
937
|
+
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
938
|
+
if (head.text === "FloatingPoint") return mkFloatSort([], sexpr);
|
|
939
|
+
if (parameters.length > 0)
|
|
940
|
+
throw new SmtUnsupportedError("parameters on a floating-point sort");
|
|
941
|
+
return parseSort(head, context, bindings);
|
|
942
|
+
}
|
|
943
|
+
if (decl === undefined) {
|
|
944
|
+
if (THEORY_SORTS.has(head.text) && !isArray)
|
|
945
|
+
throw new SmtUnsupportedError(`the sort ${head.text}`);
|
|
946
|
+
throw new SmtParseError(`unknown sort '${head.text}'`, head);
|
|
947
|
+
}
|
|
948
|
+
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
949
|
+
if (parameters.length !== getSortDeclArity(decl))
|
|
950
|
+
throw new SmtParseError("invalid number of parameters to sort constructor", sexpr.end);
|
|
951
|
+
return instantiateSort(decl, parameters, sexpr);
|
|
952
|
+
};
|
|
953
|
+
|
|
954
|
+
// parse_psort: Z3 makes the leaves and the indexed sorts of a sort definition, and an application
|
|
955
|
+
// of a builtin sort, which takes any number of parameters, only when the definition is used.
|
|
956
|
+
const checkPsort = (sexpr: SExpr, bindings: ReadonlyMap<string, number>) => {
|
|
957
|
+
const head = sexpr.kind === "list" ? sexpr.items[0] : undefined;
|
|
958
|
+
if (
|
|
959
|
+
head === undefined ||
|
|
960
|
+
!isSymbol(head) ||
|
|
961
|
+
head.text === "_" ||
|
|
962
|
+
sortDecls.has(head.text) ||
|
|
963
|
+
!isBuiltinParametricSort(head.text)
|
|
964
|
+
) {
|
|
965
|
+
parseSort(sexpr, "", bindings);
|
|
966
|
+
return;
|
|
967
|
+
}
|
|
968
|
+
for (const item of (sexpr as SmtList).items.slice(1)) checkPsort(item, bindings);
|
|
969
|
+
};
|
|
970
|
+
|
|
971
|
+
const isBuiltinParametricSort = (name: string) =>
|
|
972
|
+
(hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && hasArrayExtensions))) ||
|
|
973
|
+
(hasSeq && (name === "Seq" || name === "RegEx")) ||
|
|
974
|
+
(hasFpa && FPA_SORT_NAMES.has(name));
|
|
975
|
+
|
|
976
|
+
const mkFloatSort = (indices: SExpr[], at: SExpr) => {
|
|
977
|
+
const ebitsIndex = indices[0];
|
|
978
|
+
const sbitsIndex = indices[1];
|
|
979
|
+
if (indices.length !== 2 || ebitsIndex.kind !== "numeral" || sbitsIndex.kind !== "numeral")
|
|
980
|
+
throw new SmtParseError(
|
|
981
|
+
"expecting two integer parameters to floating point sort (ebits, sbits)",
|
|
982
|
+
at.kind === "list" ? at.end : at,
|
|
983
|
+
);
|
|
984
|
+
const ebits = Number(ebitsIndex.text);
|
|
985
|
+
const sbits = Number(sbitsIndex.text);
|
|
986
|
+
const error = getFloatSortError(ebits, sbits);
|
|
987
|
+
if (error !== undefined) throw new SmtParseError(error, at.kind === "list" ? at.end : at);
|
|
988
|
+
return manager.mkFpSort(ebits, sbits);
|
|
989
|
+
};
|
|
990
|
+
|
|
991
|
+
const parseSort = (
|
|
992
|
+
sexpr: SExpr,
|
|
993
|
+
context: string,
|
|
994
|
+
bindings: ReadonlyMap<string, number> = NO_BINDINGS,
|
|
995
|
+
): number => {
|
|
996
|
+
if (sexpr.kind === "list") {
|
|
997
|
+
if (!isSymbol(sexpr.items[0], "_")) return parseParametricSort(sexpr, context, bindings);
|
|
998
|
+
if (hasFpa && isSymbol(sexpr.items[1], "FloatingPoint"))
|
|
999
|
+
return mkFloatSort(sexpr.items.slice(2), sexpr);
|
|
1000
|
+
const width = sexpr.items[2];
|
|
1001
|
+
if (!hasBv && isSymbol(sexpr.items[1], "BitVec"))
|
|
1002
|
+
throw new SmtParseError("unknown sort 'BitVec'", width ?? sexpr.end);
|
|
1003
|
+
if (
|
|
1004
|
+
!isSymbol(sexpr.items[1], "BitVec") ||
|
|
1005
|
+
sexpr.items.length !== 3 ||
|
|
1006
|
+
width.kind !== "numeral"
|
|
1007
|
+
)
|
|
1008
|
+
throw new SmtUnsupportedError("indexed sorts");
|
|
1009
|
+
if (BigInt(width.text) === 0n)
|
|
1010
|
+
throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
|
|
1011
|
+
return manager.mkBvSort(Number(width.text));
|
|
1012
|
+
}
|
|
1013
|
+
const decl = sortDecls.get(sexpr.text);
|
|
1014
|
+
if (decl !== undefined) {
|
|
1015
|
+
if (getSortDeclArity(decl) !== 0)
|
|
1016
|
+
throw new SmtParseError("sort constructor expects parameters", sexpr);
|
|
1017
|
+
return instantiateSort(decl, [], sexpr);
|
|
1018
|
+
}
|
|
1019
|
+
const bound = bindings.get(sexpr.text);
|
|
1020
|
+
if (bound !== undefined) return bound;
|
|
1021
|
+
if (hasSeq && (SEQ_SORT_NAMES.has(sexpr.text) || sexpr.text === "Unicode")) {
|
|
1022
|
+
if (sexpr.text === "String" || sexpr.text === "StringSequence") return manager.mkStringSort();
|
|
1023
|
+
if (sexpr.text === "RegLan") return manager.mkReSort(manager.mkStringSort());
|
|
1024
|
+
if (sexpr.text === "Unicode") return manager.mkCharSort();
|
|
1025
|
+
throw new SmtParseError(
|
|
1026
|
+
sexpr.text === "Seq"
|
|
1027
|
+
? "Invalid sequence sort, expecting one parameter"
|
|
1028
|
+
: "Invalid regex sort, expecting one parameter",
|
|
1029
|
+
sexpr,
|
|
1030
|
+
);
|
|
1031
|
+
}
|
|
1032
|
+
if (hasFpa && FPA_SORT_NAMES.has(sexpr.text)) {
|
|
1033
|
+
if (sexpr.text === "RoundingMode") return manager.mkRmSort();
|
|
1034
|
+
const bits = FPA_SORT_NAMES.get(sexpr.text);
|
|
1035
|
+
return bits === undefined ? mkFloatSort([], sexpr) : manager.mkFpSort(bits[0], bits[1]);
|
|
1036
|
+
}
|
|
1037
|
+
if (THEORY_SORTS.has(sexpr.text)) throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
|
|
1038
|
+
throw new SmtParseError(
|
|
1039
|
+
`${context === "" ? "" : `${context}: `}unknown sort '${sexpr.text}'`,
|
|
1040
|
+
sexpr,
|
|
1041
|
+
);
|
|
1042
|
+
};
|
|
1043
|
+
|
|
181
1044
|
const lookup = (name: string) => {
|
|
182
1045
|
for (let index = scopes.length - 1; index >= 0; index--) {
|
|
183
1046
|
const binding = scopes[index].get(name);
|
|
@@ -186,40 +1049,22 @@ export const parseSmtlib = (
|
|
|
186
1049
|
return undefined;
|
|
187
1050
|
};
|
|
188
1051
|
|
|
189
|
-
// basic_decl_plugin::join: Int and Real join to Real. Other sorts join only with themselves.
|
|
190
1052
|
const getJoin = (args: number[]) => {
|
|
191
1053
|
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
192
1054
|
if (!argSorts.every(isArithSort)) return argSorts[0];
|
|
193
1055
|
return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
194
1056
|
};
|
|
195
1057
|
|
|
196
|
-
// The sort of the arguments of a builtin, as Z3's decl plugins pick its declaration.
|
|
197
1058
|
const getDomainSort = (op: number, args: number[]) => {
|
|
198
1059
|
if (op === OP_ITE) return getJoin(args.slice(1));
|
|
199
1060
|
if (op === OP_EQ || op === OP_DISTINCT) return getJoin(args);
|
|
200
1061
|
if (COERCING_OPS.has(op)) return getJoin(args) === SORT_REAL ? SORT_REAL : SORT_INT;
|
|
201
1062
|
if (op === OP_ABS || op === OP_TO_REAL || op === OP_TO_INT) return manager.sorts[args[0]];
|
|
202
|
-
if (op === OP_IDIV || op === OP_MOD) return SORT_INT;
|
|
203
|
-
if (op === OP_DIV || op === OP_IS_INT) return SORT_REAL;
|
|
1063
|
+
if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
|
|
1064
|
+
if (op === OP_DIV || op === OP_IS_INT || REAL_FUNCTION_OPS.has(op)) return SORT_REAL;
|
|
204
1065
|
return SORT_BOOL;
|
|
205
1066
|
};
|
|
206
1067
|
|
|
207
|
-
const getRange = (op: number, domainSort: number) =>
|
|
208
|
-
op === OP_TO_REAL || op === OP_DIV
|
|
209
|
-
? SORT_REAL
|
|
210
|
-
: op === OP_TO_INT || op === OP_IDIV || op === OP_MOD
|
|
211
|
-
? SORT_INT
|
|
212
|
-
: op === OP_ITE ||
|
|
213
|
-
op === OP_ABS ||
|
|
214
|
-
op === OP_ADD ||
|
|
215
|
-
op === OP_SUB ||
|
|
216
|
-
op === OP_UMINUS ||
|
|
217
|
-
op === OP_MUL
|
|
218
|
-
? domainSort
|
|
219
|
-
: SORT_BOOL;
|
|
220
|
-
|
|
221
|
-
// ast_manager::coerce_to: an Int argument of a Real position becomes to_real, and a Real argument
|
|
222
|
-
// of an Int position to_int.
|
|
223
1068
|
const coerce = (arg: number, sort: number) => {
|
|
224
1069
|
const argSort = manager.sorts[arg];
|
|
225
1070
|
if (argSort === sort || !isArithSort(argSort) || !isArithSort(sort)) return arg;
|
|
@@ -228,13 +1073,13 @@ export const parseSmtlib = (
|
|
|
228
1073
|
: manager.mkApp(OP_TO_INT, [arg], SORT_INT);
|
|
229
1074
|
};
|
|
230
1075
|
|
|
231
|
-
|
|
232
|
-
// default int_real_coercions, then checks their sorts and number, so the solver only sees
|
|
233
|
-
// well-sorted terms, and that quantifiers occur only under Boolean connectives.
|
|
234
|
-
const mkApp = (decl: number, inputArgs: number[], domainSort?: number) => {
|
|
1076
|
+
const mkApp = (decl: number, inputArgs: number[], at: SExpr, domainSort?: number) => {
|
|
235
1077
|
const op = manager.funcDecls[decl].op;
|
|
236
1078
|
const name = manager.funcDecls[decl].name;
|
|
237
|
-
const isUninterpreted =
|
|
1079
|
+
const isUninterpreted =
|
|
1080
|
+
op === OP_UNINTERPRETED ||
|
|
1081
|
+
op === OP_FUN_DEFINED ||
|
|
1082
|
+
manager.funcDecls[decl].family === FAMILY_DATATYPE;
|
|
238
1083
|
const domain = manager.funcDecls[decl].domain;
|
|
239
1084
|
const builtinSort = isUninterpreted ? -1 : (domainSort ?? getDomainSort(op, inputArgs));
|
|
240
1085
|
const getExpected = (index: number) =>
|
|
@@ -242,73 +1087,55 @@ export const parseSmtlib = (
|
|
|
242
1087
|
const args = inputArgs.map((arg, index) =>
|
|
243
1088
|
getExpected(index) === undefined ? arg : coerce(arg, getExpected(index)),
|
|
244
1089
|
);
|
|
245
|
-
const
|
|
1090
|
+
const arity = ARITIES.get(op) ?? [1, Infinity];
|
|
246
1091
|
const isArityOk = isUninterpreted
|
|
247
1092
|
? args.length === domain.length
|
|
248
|
-
:
|
|
249
|
-
? true
|
|
250
|
-
: op === OP_ITE
|
|
251
|
-
? isArity(3, 3)
|
|
252
|
-
: op === OP_EQ || op === OP_DISTINCT
|
|
253
|
-
? isArity(2, Infinity)
|
|
254
|
-
: op === OP_NOT ||
|
|
255
|
-
op === OP_UMINUS ||
|
|
256
|
-
op === OP_ABS ||
|
|
257
|
-
op === OP_TO_REAL ||
|
|
258
|
-
op === OP_TO_INT ||
|
|
259
|
-
op === OP_IS_INT
|
|
260
|
-
? isArity(1, 1)
|
|
261
|
-
: op === OP_IMPLIES ||
|
|
262
|
-
op === OP_XOR ||
|
|
263
|
-
op === OP_IDIV ||
|
|
264
|
-
op === OP_MOD ||
|
|
265
|
-
op === OP_DIV ||
|
|
266
|
-
op === OP_LE ||
|
|
267
|
-
op === OP_GE ||
|
|
268
|
-
op === OP_LT ||
|
|
269
|
-
op === OP_GT
|
|
270
|
-
? isArity(2, 2)
|
|
271
|
-
: isArity(1, Infinity);
|
|
1093
|
+
: args.length >= arity[0] && args.length <= arity[1];
|
|
272
1094
|
const isBuiltinArith = manager.funcDecls[decl].family === FAMILY_ARITH;
|
|
273
1095
|
const isWellSorted =
|
|
274
1096
|
isArityOk &&
|
|
275
1097
|
(!isBuiltinArith || isArithSort(builtinSort)) &&
|
|
276
1098
|
args.every((arg, index) => manager.sorts[arg] === getExpected(index));
|
|
277
|
-
if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}
|
|
1099
|
+
if (!isWellSorted) throw new SmtParseError(`ill-sorted application of ${name}`, at);
|
|
278
1100
|
return manager.mkApp(
|
|
279
1101
|
decl,
|
|
280
1102
|
args,
|
|
281
|
-
isUninterpreted ? manager.funcDecls[decl].range :
|
|
1103
|
+
isUninterpreted ? manager.funcDecls[decl].range : (RANGES.get(op) ?? builtinSort),
|
|
282
1104
|
);
|
|
283
1105
|
};
|
|
284
1106
|
|
|
285
|
-
const mkChain = (op: number, args: number[]) => {
|
|
1107
|
+
const mkChain = (op: number, args: number[], at: SExpr) => {
|
|
286
1108
|
const domainSort = getDomainSort(op, args);
|
|
287
1109
|
const pairs: number[] = [];
|
|
288
1110
|
for (let index = 0; index + 1 < args.length; index++)
|
|
289
|
-
pairs.push(mkApp(op, [args[index], args[index + 1]], domainSort));
|
|
290
|
-
return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs);
|
|
1111
|
+
pairs.push(mkApp(op, [args[index], args[index + 1]], at, domainSort));
|
|
1112
|
+
return pairs.length === 1 ? pairs[0] : mkApp(OP_AND, pairs, at);
|
|
291
1113
|
};
|
|
292
1114
|
|
|
293
|
-
const
|
|
294
|
-
if (
|
|
295
|
-
return
|
|
1115
|
+
const rejectPattern = (message: string, at: SExpr) => {
|
|
1116
|
+
if (!options.isIgnoringBadPatterns) throw new SmtParseError(message, at);
|
|
1117
|
+
return undefined;
|
|
296
1118
|
};
|
|
297
1119
|
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
1120
|
+
const parsePattern = (sexpr: SExpr, at: SExpr) => {
|
|
1121
|
+
if (sexpr.kind === ")") {
|
|
1122
|
+
// Z3 skips a bad pattern as an s-expression, which cannot start with ')'.
|
|
1123
|
+
if (options.isIgnoringBadPatterns)
|
|
1124
|
+
throw new SmtParseError("invalid s-expression, unexpected ')'", sexpr);
|
|
1125
|
+
throw new SmtParseError("invalid pattern, '(' expected", sexpr);
|
|
1126
|
+
}
|
|
1127
|
+
if (sexpr.kind !== "list") return rejectPattern("invalid pattern, '(' expected", sexpr);
|
|
1128
|
+
if (sexpr.items.length === 0) return rejectPattern("invalid empty pattern", at);
|
|
1129
|
+
const head = sexpr.items[0];
|
|
1130
|
+
if (head.kind === "list") return manager.mkPattern(sexpr.items.map(parseTerm));
|
|
1131
|
+
const decl = head.text === "true" || head.text === "false" ? -1 : getFirstFunc(head.text);
|
|
305
1132
|
if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
|
|
306
|
-
return
|
|
1133
|
+
return rejectPattern("invalid constant pattern", head);
|
|
1134
|
+
if (head.kind !== "symbol")
|
|
1135
|
+
throw new SmtParseError("invalid pattern, '(' or identifier expected", head);
|
|
307
1136
|
return manager.mkPattern([parseTerm(sexpr)]);
|
|
308
1137
|
};
|
|
309
1138
|
|
|
310
|
-
// pattern_validator: a pattern has no Boolean operator other than equality, no quantifier, and
|
|
311
|
-
// every variable of its quantifier.
|
|
312
1139
|
const isValidPattern = (pattern: number, numDecls: number) => {
|
|
313
1140
|
const found = new Set<number>();
|
|
314
1141
|
const isValid = (expr: number): boolean => {
|
|
@@ -331,196 +1158,1522 @@ export const parseSmtlib = (
|
|
|
331
1158
|
return manager.everyArg(pattern, isValid) && found.size === numDecls;
|
|
332
1159
|
};
|
|
333
1160
|
|
|
334
|
-
const
|
|
335
|
-
const
|
|
1161
|
+
const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr) => {
|
|
1162
|
+
const message = "invalid sorted variables, syntax error: ((<symbol> <sort>)*) expected";
|
|
1163
|
+
const declarations = expectList(sexpr, message, at).items.map((declaration) =>
|
|
1164
|
+
expectList(declaration, message, declaration),
|
|
1165
|
+
);
|
|
336
1166
|
const scope = new Map<string, Binding>();
|
|
337
|
-
const names = declarations.map(
|
|
1167
|
+
const names = declarations.map(
|
|
1168
|
+
(declaration) => expectSymbol(declaration.items[0], message, declaration).text,
|
|
1169
|
+
);
|
|
338
1170
|
const varSorts = declarations.map((declaration, index) => {
|
|
339
|
-
|
|
340
|
-
|
|
1171
|
+
if (declaration.items.length !== 2) throw new SmtParseError(message, declaration.end);
|
|
1172
|
+
const sort = parseSort(declaration.items[1], "invalid sorted variables");
|
|
1173
|
+
scope.set(names[index], { kind: "var", depth: binders.depth + index, sort });
|
|
341
1174
|
return sort;
|
|
342
1175
|
});
|
|
343
1176
|
scopes.push(scope);
|
|
344
|
-
depth += varSorts.length;
|
|
1177
|
+
binders.depth += varSorts.length;
|
|
1178
|
+
return { names, varSorts };
|
|
1179
|
+
};
|
|
1180
|
+
|
|
1181
|
+
const unbindSortedVars = (count: number) => {
|
|
1182
|
+
scopes.pop();
|
|
1183
|
+
binders.depth -= count;
|
|
1184
|
+
};
|
|
1185
|
+
|
|
1186
|
+
const parseQuantifier = (list: SmtList, kind: number) => {
|
|
1187
|
+
if (list.items.length !== 3)
|
|
1188
|
+
throw new SmtParseError(
|
|
1189
|
+
"invalid quantified expression, syntax error: (forall|exists ((<symbol> <sort>)*) <expr>) expected",
|
|
1190
|
+
list.end,
|
|
1191
|
+
);
|
|
1192
|
+
const bound = bindSortedVars(list.items[1], list);
|
|
1193
|
+
const varSorts = bound.varSorts;
|
|
345
1194
|
// parse_sorted_vars: the variables are created first, the first declared with the largest index,
|
|
346
1195
|
// and the parser's stack holds them until the quantifier is created.
|
|
347
1196
|
const boundVars = varSorts.map((sort, index) =>
|
|
348
1197
|
manager.mkVar(varSorts.length - 1 - index, sort),
|
|
349
1198
|
);
|
|
350
1199
|
for (const boundVar of boundVars) manager.incRef(boundVar);
|
|
351
|
-
const bodySExpr = list[2];
|
|
352
|
-
const isAnnotated =
|
|
353
|
-
const
|
|
1200
|
+
const bodySExpr = list.items[2];
|
|
1201
|
+
const isAnnotated = bodySExpr.kind === "list" && isSymbol(bodySExpr.items[0], "!");
|
|
1202
|
+
const annotations = bodySExpr.kind === "list" && isAnnotated ? bodySExpr.items : [];
|
|
1203
|
+
const parsedBody = parseTerm(isAnnotated ? annotations[1] : bodySExpr);
|
|
1204
|
+
if (kind !== QUANTIFIER_LAMBDA && manager.sorts[parsedBody] !== SORT_BOOL)
|
|
1205
|
+
throw new SmtParseError("expected a formula", bodySExpr);
|
|
1206
|
+
const attributes = Array.from(
|
|
1207
|
+
{ length: Math.ceil((annotations.length - 2) / 2) },
|
|
1208
|
+
(_unused, index) => ({
|
|
1209
|
+
keyword: annotations[2 + 2 * index],
|
|
1210
|
+
value: annotations[3 + 2 * index],
|
|
1211
|
+
}),
|
|
1212
|
+
);
|
|
1213
|
+
const body = attributes.reduce(
|
|
1214
|
+
(labeled, attribute) =>
|
|
1215
|
+
attribute.keyword.kind === "keyword" &&
|
|
1216
|
+
(attribute.keyword.text === ":lblpos" || attribute.keyword.text === ":lblneg")
|
|
1217
|
+
? mkLabel(labeled, attribute.keyword.text === ":lblpos", attribute.value, bodySExpr)
|
|
1218
|
+
: labeled,
|
|
1219
|
+
parsedBody,
|
|
1220
|
+
);
|
|
354
1221
|
const patterns: number[] = [];
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
const
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
if (pattern !== undefined) {
|
|
364
|
-
manager.incRef(pattern);
|
|
365
|
-
patterns.push(pattern);
|
|
366
|
-
}
|
|
367
|
-
} else if (keyword === ":weight") weight = Number(value);
|
|
368
|
-
else if (keyword === ":qid") qid = expectSymbol(value);
|
|
1222
|
+
const noPatterns: number[] = [];
|
|
1223
|
+
for (const attribute of attributes) {
|
|
1224
|
+
if (attribute.keyword.kind !== "keyword") continue;
|
|
1225
|
+
if (attribute.keyword.text === ":no-pattern") {
|
|
1226
|
+
const noPattern = parseTerm(attribute.value ?? list.end);
|
|
1227
|
+
manager.incRef(noPattern);
|
|
1228
|
+
noPatterns.push(noPattern);
|
|
1229
|
+
continue;
|
|
369
1230
|
}
|
|
370
|
-
|
|
371
|
-
|
|
1231
|
+
if (attribute.keyword.text !== ":pattern") continue;
|
|
1232
|
+
const pattern = parsePattern(
|
|
1233
|
+
attribute.value ?? (bodySExpr.kind === "list" ? bodySExpr.end : list.end),
|
|
1234
|
+
list.end,
|
|
1235
|
+
);
|
|
1236
|
+
if (pattern === undefined) continue;
|
|
1237
|
+
manager.incRef(pattern);
|
|
1238
|
+
patterns.push(pattern);
|
|
1239
|
+
}
|
|
1240
|
+
const getAttribute = (name: string) => {
|
|
1241
|
+
const value = attributes
|
|
1242
|
+
.filter(
|
|
1243
|
+
(attribute) =>
|
|
1244
|
+
attribute.keyword.kind === "keyword" &&
|
|
1245
|
+
attribute.keyword.text === name &&
|
|
1246
|
+
attribute.value?.kind !== "list",
|
|
1247
|
+
)
|
|
1248
|
+
.at(-1)?.value;
|
|
1249
|
+
return value?.kind === "list" ? undefined : value?.text;
|
|
1250
|
+
};
|
|
1251
|
+
const weight = Number(getAttribute(":weight") ?? 1);
|
|
1252
|
+
const qid = getAttribute(":qid") ?? "";
|
|
1253
|
+
const skid = getAttribute(":skolemid");
|
|
1254
|
+
unbindSortedVars(varSorts.length);
|
|
372
1255
|
// pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
|
|
373
1256
|
// and the valid ones after.
|
|
374
1257
|
let numKept = 0;
|
|
375
1258
|
for (const pattern of patterns) {
|
|
376
|
-
if (!isValidPattern(pattern, varSorts.length))
|
|
1259
|
+
if (!isValidPattern(pattern, varSorts.length)) {
|
|
1260
|
+
rejectPattern("invalid pattern", list.end);
|
|
1261
|
+
continue;
|
|
1262
|
+
}
|
|
377
1263
|
manager.incRef(pattern);
|
|
378
1264
|
manager.decRef(patterns[numKept]);
|
|
379
1265
|
patterns[numKept] = pattern;
|
|
380
1266
|
numKept++;
|
|
381
1267
|
}
|
|
382
1268
|
for (const removed of patterns.splice(numKept)) manager.decRef(removed);
|
|
1269
|
+
if (patterns.length > 0 && noPatterns.length > 0)
|
|
1270
|
+
throw new SmtParseError("simultaneous patterns and no-patterns not supported", list.end);
|
|
383
1271
|
const quantifier = manager.mkQuantifier({
|
|
384
|
-
|
|
1272
|
+
kind,
|
|
385
1273
|
sorts: varSorts,
|
|
386
|
-
names,
|
|
1274
|
+
names: bound.names,
|
|
387
1275
|
body,
|
|
388
1276
|
patterns,
|
|
1277
|
+
noPatterns,
|
|
389
1278
|
weight,
|
|
390
1279
|
qid,
|
|
1280
|
+
...(skid === undefined ? {} : { skid }),
|
|
391
1281
|
});
|
|
392
1282
|
for (const pattern of patterns) manager.decRef(pattern);
|
|
1283
|
+
for (const noPattern of noPatterns) manager.decRef(noPattern);
|
|
393
1284
|
for (const boundVar of boundVars) manager.decRef(boundVar);
|
|
394
1285
|
return quantifier;
|
|
395
1286
|
};
|
|
396
1287
|
|
|
397
|
-
const parseLet = (list:
|
|
1288
|
+
const parseLet = (list: SmtList) => {
|
|
1289
|
+
const message = "invalid let declaration, symbol expected";
|
|
398
1290
|
const scope = new Map<string, Binding>();
|
|
399
|
-
|
|
400
|
-
|
|
401
|
-
const
|
|
402
|
-
|
|
1291
|
+
const exprs: number[] = [];
|
|
1292
|
+
for (const binding of expectList(list.items[1], message, list).items) {
|
|
1293
|
+
const pair = expectList(binding, message, binding);
|
|
1294
|
+
const name = expectSymbol(pair.items[0], message, pair);
|
|
1295
|
+
const expr = parseTerm(pair.items[1] ?? pair.end);
|
|
1296
|
+
exprs.push(expr);
|
|
1297
|
+
scope.set(name.text, { kind: "let", depth: binders.depth, expr });
|
|
403
1298
|
}
|
|
404
1299
|
scopes.push(scope);
|
|
405
|
-
|
|
1300
|
+
// Z3 takes the last expression on its stack, so a let without a body is its last binding.
|
|
1301
|
+
for (const body of list.items.slice(2)) exprs.push(parseTerm(body));
|
|
406
1302
|
scopes.pop();
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
413
|
-
|
|
414
|
-
|
|
415
|
-
|
|
416
|
-
|
|
417
|
-
|
|
418
|
-
|
|
419
|
-
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
424
|
-
|
|
425
|
-
|
|
426
|
-
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
1303
|
+
const result = exprs.at(-1);
|
|
1304
|
+
if (result === undefined) throw new SmtParseError("invalid let expression", list.end);
|
|
1305
|
+
return result;
|
|
1306
|
+
};
|
|
1307
|
+
|
|
1308
|
+
const expandMacro = (macro: Macro, args: number[]) =>
|
|
1309
|
+
replaceFreeVars(manager, macro.body, (_variable, index, shift) => {
|
|
1310
|
+
const arg = args[args.length - 1 - index];
|
|
1311
|
+
return shift === 0
|
|
1312
|
+
? arg
|
|
1313
|
+
: replaceFreeVars(manager, arg, (inner, innerIndex, innerShift) =>
|
|
1314
|
+
manager.mkVar(innerIndex + innerShift + shift, manager.sorts[inner]),
|
|
1315
|
+
);
|
|
1316
|
+
});
|
|
1317
|
+
|
|
1318
|
+
const isBvOpName = (name: string) =>
|
|
1319
|
+
hasBv &&
|
|
1320
|
+
BV_OP_NAMES.has(name) &&
|
|
1321
|
+
(!BV_EXTENSION_NAMES.has(name) || logic === undefined || BV_EXTENSION_LOGICS.has(logic));
|
|
1322
|
+
|
|
1323
|
+
const mkBvApp = (name: string, args: number[], indices: number[], at: SExpr) => {
|
|
1324
|
+
const op = BV_OP_NAMES.get(name) ?? -1;
|
|
1325
|
+
const signature = getBvSignature(
|
|
1326
|
+
manager,
|
|
1327
|
+
op,
|
|
1328
|
+
args.map((arg) => manager.sorts[arg]),
|
|
1329
|
+
indices,
|
|
1330
|
+
);
|
|
1331
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1332
|
+
const decl = manager.mkBvDecl(op, signature.name, indices, signature.domain, signature.range);
|
|
1333
|
+
return manager.mkApp(decl, args, signature.range);
|
|
1334
|
+
};
|
|
1335
|
+
|
|
1336
|
+
const isFpaOpName = (name: string) => hasFpa && FPA_OP_NAMES.has(name);
|
|
1337
|
+
|
|
1338
|
+
// pb_decl_plugin::get_op_names and mk_func_decl.
|
|
1339
|
+
const isPbOpName = (name: string) =>
|
|
1340
|
+
PB_OP_NAMES.has(name) &&
|
|
1341
|
+
(logic === undefined || logic === "QF_FD" || logic === "ALL" || logic === "HORN");
|
|
1342
|
+
|
|
1343
|
+
const mkPbTerm = (name: string, args: number[], parameters: Rational[], at: SExpr) => {
|
|
1344
|
+
const op = PB_OP_NAMES.get(name) ?? -1;
|
|
1345
|
+
if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
|
|
1346
|
+
throw new SmtParseError("invalid non-Boolean sort applied to Pseudo-Boolean relation", at);
|
|
1347
|
+
const isCardinality = op === OP_AT_MOST_K || op === OP_AT_LEAST_K;
|
|
1348
|
+
if (isCardinality && parameters.length !== 1)
|
|
1349
|
+
throw new SmtParseError("function expects one non-negative integer parameter", at);
|
|
1350
|
+
if (!isCardinality && parameters.length !== 1 + args.length)
|
|
1351
|
+
throw new SmtParseError("function expects arity+1 rational parameters", at);
|
|
1352
|
+
const decl = manager.mkPbDecl(
|
|
1353
|
+
op,
|
|
1354
|
+
parameters,
|
|
1355
|
+
args.map(() => SORT_BOOL),
|
|
1356
|
+
);
|
|
1357
|
+
return manager.mkApp(decl, args, SORT_BOOL);
|
|
1358
|
+
};
|
|
1359
|
+
|
|
1360
|
+
const mkFpaTerm = (name: string, args: number[], indices: number[], at: SExpr) => {
|
|
1361
|
+
const op = FPA_OP_NAMES.get(name) ?? -1;
|
|
1362
|
+
const getSignature = (innerArgs: number[]) => {
|
|
1363
|
+
const signature = getFpaSignature(
|
|
1364
|
+
manager,
|
|
1365
|
+
op,
|
|
1366
|
+
indices,
|
|
1367
|
+
innerArgs.map((arg) => manager.sorts[arg]),
|
|
1368
|
+
);
|
|
1369
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1370
|
+
return signature;
|
|
1371
|
+
};
|
|
1372
|
+
const signature = getSignature(args);
|
|
1373
|
+
if (signature.domain.length === args.length) return mkFpaAppOf(manager, signature, args);
|
|
1374
|
+
const pairs: number[] = [];
|
|
1375
|
+
for (let index = 0; index + 1 < args.length; index++) {
|
|
1376
|
+
const pair = [args[index], args[index + 1]];
|
|
1377
|
+
pairs.push(mkFpaAppOf(manager, getSignature(pair), pair));
|
|
1378
|
+
}
|
|
1379
|
+
return mkApp(OP_AND, pairs, at);
|
|
1380
|
+
};
|
|
1381
|
+
|
|
1382
|
+
const isSeqOpName = (name: string) =>
|
|
1383
|
+
hasSeq && (SEQ_OP_NAMES.has(name) || CHAR_OP_NAMES.has(name));
|
|
1384
|
+
|
|
1385
|
+
const mkSeqTerm = (
|
|
1386
|
+
name: string,
|
|
1387
|
+
args: number[],
|
|
1388
|
+
indices: number[],
|
|
1389
|
+
at: SExpr,
|
|
1390
|
+
range?: number,
|
|
1391
|
+
) => {
|
|
1392
|
+
const signature = getSeqSignature(
|
|
1393
|
+
manager,
|
|
1394
|
+
SEQ_OP_NAMES.get(name) ?? CHAR_OP_NAMES.get(name) ?? -1,
|
|
1395
|
+
indices,
|
|
1396
|
+
args.map((arg) => manager.sorts[arg]),
|
|
1397
|
+
range,
|
|
1398
|
+
);
|
|
1399
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1400
|
+
return mkSeqAppOf(manager, signature, args);
|
|
1401
|
+
};
|
|
1402
|
+
|
|
1403
|
+
const parseUpolynomial = (sexpr: SExpr): bigint[] => {
|
|
1404
|
+
if (sexpr.kind === "numeral") return UPOLYNOMIALS.set([BigInt(sexpr.text)]);
|
|
1405
|
+
if (sexpr.kind === "decimal") {
|
|
1406
|
+
const parts = sexpr.text.split(".");
|
|
1407
|
+
const value = Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length));
|
|
1408
|
+
if (!value.isInt())
|
|
1409
|
+
throw new SmtParseError(
|
|
1410
|
+
"invalid univariate polynomial, integer coefficient expected",
|
|
1411
|
+
sexpr,
|
|
435
1412
|
);
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
if (
|
|
1413
|
+
return UPOLYNOMIALS.set([value.num]);
|
|
1414
|
+
}
|
|
1415
|
+
if (sexpr.kind === "symbol") {
|
|
1416
|
+
if (sexpr.text !== "x")
|
|
1417
|
+
throw new SmtParseError("invalid univariate polynomial, variable 'x' expected", sexpr);
|
|
1418
|
+
return [0n, 1n];
|
|
1419
|
+
}
|
|
1420
|
+
if (sexpr.kind !== "list")
|
|
1421
|
+
throw new SmtParseError("invalid univariate polynomial, unexpected ", sexpr);
|
|
1422
|
+
const head = sexpr.items[0];
|
|
1423
|
+
if (!isSymbol(head))
|
|
1424
|
+
throw new SmtParseError("invalid univariate polynomial, symbol expected", sexpr);
|
|
1425
|
+
const operands = sexpr.items.slice(1);
|
|
1426
|
+
if (head.text === "^") {
|
|
1427
|
+
if (operands.length !== 2)
|
|
1428
|
+
throw new SmtParseError(
|
|
1429
|
+
"invalid univariate polynomial, '^' operator expects two arguments",
|
|
1430
|
+
sexpr,
|
|
1431
|
+
);
|
|
1432
|
+
const exponent = operands[1];
|
|
1433
|
+
if (exponent.kind !== "numeral" || BigInt(exponent.text) > 0xffffffffn)
|
|
1434
|
+
throw new SmtParseError(
|
|
1435
|
+
"invalid univariate polynomial, exponent must be an unsigned integer",
|
|
1436
|
+
exponent,
|
|
1437
|
+
);
|
|
1438
|
+
return UPOLYNOMIALS.pw(parseUpolynomial(operands[0]), Number(exponent.text));
|
|
1439
|
+
}
|
|
1440
|
+
const combine =
|
|
1441
|
+
head.text === "+"
|
|
1442
|
+
? UPOLYNOMIALS.add
|
|
1443
|
+
: head.text === "-"
|
|
1444
|
+
? UPOLYNOMIALS.sub
|
|
1445
|
+
: head.text === "*"
|
|
1446
|
+
? UPOLYNOMIALS.mul
|
|
1447
|
+
: undefined;
|
|
1448
|
+
if (combine === undefined)
|
|
1449
|
+
throw new SmtParseError(
|
|
1450
|
+
"invalid univariate polynomial, '+', '-', '^' or '*' expected",
|
|
1451
|
+
sexpr,
|
|
1452
|
+
);
|
|
1453
|
+
if (operands.length === 0)
|
|
1454
|
+
throw new SmtParseError(
|
|
1455
|
+
`invalid univariate polynomial, '${head.text}' operator expects at least one argument`,
|
|
1456
|
+
sexpr,
|
|
1457
|
+
);
|
|
1458
|
+
const first = parseUpolynomial(operands[0]);
|
|
1459
|
+
if (head.text === "-" && operands.length === 1) return UPOLYNOMIALS.neg(first);
|
|
1460
|
+
return operands
|
|
1461
|
+
.slice(1)
|
|
1462
|
+
.reduce(
|
|
1463
|
+
(result, operand) => combine.call(UPOLYNOMIALS, result, parseUpolynomial(operand)),
|
|
1464
|
+
first,
|
|
1465
|
+
);
|
|
1466
|
+
};
|
|
1467
|
+
|
|
1468
|
+
const parseRootObj = (list: SmtList) => {
|
|
1469
|
+
const polynomial = list.items[1] ?? list.end;
|
|
1470
|
+
const index = list.items[2] ?? list.end;
|
|
1471
|
+
if (index.kind !== "numeral")
|
|
1472
|
+
throw new SmtParseError("invalid root-obj, (unsigned) integer expected", index);
|
|
1473
|
+
if (BigInt(index.text) > 0xffffffffn)
|
|
1474
|
+
throw new SmtParseError(
|
|
1475
|
+
"invalid root-obj, index must fit in an unsigned machine integer",
|
|
1476
|
+
index,
|
|
1477
|
+
);
|
|
1478
|
+
if (BigInt(index.text) === 0n)
|
|
1479
|
+
throw new SmtParseError("invalid root-obj, index must be >= 1", index);
|
|
1480
|
+
if (list.items.length > 3)
|
|
1481
|
+
throw new SmtParseError("invalid root-obj, ')' expected", list.items[3]);
|
|
1482
|
+
const coeffs = parseUpolynomial(polynomial);
|
|
1483
|
+
const follower = list.follower ?? list.end;
|
|
1484
|
+
if (coeffs.length === 0)
|
|
1485
|
+
throw new SmtParseError(
|
|
1486
|
+
"invalid root object, polynomial must not be the zero polynomial",
|
|
1487
|
+
follower,
|
|
1488
|
+
);
|
|
1489
|
+
const roots = manager.am.isolateUnivariateRoots(coeffs);
|
|
1490
|
+
const root = roots[Number(index.text) - 1];
|
|
1491
|
+
if (root === undefined)
|
|
1492
|
+
throw new SmtParseError(
|
|
1493
|
+
"invalid root object, polynomial does have sufficient roots",
|
|
1494
|
+
follower,
|
|
1495
|
+
);
|
|
1496
|
+
return manager.mkAlgebraicNumeral(root);
|
|
1497
|
+
};
|
|
1498
|
+
|
|
1499
|
+
const parseBvNumeral = (list: SmtList) => {
|
|
1500
|
+
const name = list.items[1];
|
|
1501
|
+
const indices = list.items.slice(2);
|
|
1502
|
+
if (
|
|
1503
|
+
isSymbol(name) &&
|
|
1504
|
+
isSeqOpName(name.text) &&
|
|
1505
|
+
indices.every((index) => index.kind === "numeral")
|
|
1506
|
+
)
|
|
1507
|
+
return mkSeqTerm(
|
|
1508
|
+
name.text,
|
|
1509
|
+
[],
|
|
1510
|
+
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1511
|
+
list.end,
|
|
1512
|
+
);
|
|
1513
|
+
if (
|
|
1514
|
+
isSymbol(name) &&
|
|
1515
|
+
isFpaOpName(name.text) &&
|
|
1516
|
+
indices.every((index) => index.kind === "numeral")
|
|
1517
|
+
) {
|
|
1518
|
+
const signature = getFpaSignature(
|
|
1519
|
+
manager,
|
|
1520
|
+
FPA_OP_NAMES.get(name.text) ?? -1,
|
|
1521
|
+
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1522
|
+
[],
|
|
1523
|
+
);
|
|
1524
|
+
if (typeof signature === "string")
|
|
1525
|
+
throw new SmtParseError(signature, { line: list.end.line, column: list.end.column + 1 });
|
|
1526
|
+
return mkFpaAppOf(manager, signature, []);
|
|
1527
|
+
}
|
|
1528
|
+
const value = isSymbol(name) ? /^bv([0-9]+)$/.exec(name.text) : null;
|
|
1529
|
+
if (value === null) throw new SmtUnsupportedError("indexed identifiers");
|
|
1530
|
+
const width = list.items[2];
|
|
1531
|
+
if (list.items.length !== 3 || width.kind !== "numeral")
|
|
1532
|
+
throw new SmtParseError("invalid bit-vector constant, index expected", list.end);
|
|
1533
|
+
if (BigInt(width.text) === 0n)
|
|
1534
|
+
throw new SmtParseError("bit-vector size must be greater than zero", list.end);
|
|
1535
|
+
return manager.mkBvNumeral(BigInt(value[1]), Number(width.text));
|
|
1536
|
+
};
|
|
1537
|
+
|
|
1538
|
+
const mkArrayTerm = (op: number, inputArgs: number[], parameters: number[], at: SExpr) => {
|
|
1539
|
+
const signature = getArraySignature(
|
|
1540
|
+
manager,
|
|
1541
|
+
op,
|
|
1542
|
+
inputArgs.map((arg) => manager.sorts[arg]),
|
|
1543
|
+
parameters,
|
|
1544
|
+
);
|
|
1545
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1546
|
+
const args = inputArgs.map((arg, index) => coerce(arg, signature.domain[index]));
|
|
1547
|
+
const decl = manager.mkArrayDecl(
|
|
1548
|
+
op,
|
|
1549
|
+
signature.name,
|
|
1550
|
+
parameters,
|
|
1551
|
+
signature.domain,
|
|
1552
|
+
signature.range,
|
|
1553
|
+
);
|
|
1554
|
+
return manager.mkApp(decl, args, signature.range);
|
|
1555
|
+
};
|
|
1556
|
+
|
|
1557
|
+
const findFuncDecl = (sexpr: SmtToken) => {
|
|
1558
|
+
const decls = funcs.get(sexpr.text);
|
|
1559
|
+
if (decls !== undefined && decls.length > 1)
|
|
1560
|
+
throw new SmtParseError(
|
|
1561
|
+
`ambiguous function declaration reference, provide full signature to disambiguate (<symbol> (<sort>*) <sort>) ${sexpr.text}`,
|
|
1562
|
+
sexpr,
|
|
1563
|
+
);
|
|
1564
|
+
return decls?.[0];
|
|
1565
|
+
};
|
|
1566
|
+
|
|
1567
|
+
const throwAmbiguousConstant = (name: string, at: SExpr) => {
|
|
1568
|
+
throw new SmtParseError(
|
|
1569
|
+
`ambiguous constant reference, more than one constant with the same sort, use a qualified expression (as <symbol> <sort>) to disambiguate ${name}`,
|
|
1570
|
+
at,
|
|
1571
|
+
);
|
|
1572
|
+
};
|
|
1573
|
+
|
|
1574
|
+
// An exact signature wins, else the last one that matches once Int and Real coerce.
|
|
1575
|
+
const mkDeclaredApp = (
|
|
1576
|
+
name: string,
|
|
1577
|
+
decls: readonly number[],
|
|
1578
|
+
args: number[],
|
|
1579
|
+
range: number | undefined,
|
|
1580
|
+
at: SExpr,
|
|
1581
|
+
) => {
|
|
1582
|
+
if (args.length === 0 && range === undefined) {
|
|
1583
|
+
if (decls.length > 1) throwAmbiguousConstant(name, at);
|
|
1584
|
+
return manager.funcDecls[decls[0]].domain.length > 0
|
|
1585
|
+
? mkAsArray(manager, decls[0])
|
|
1586
|
+
: mkApp(decls[0], args, at);
|
|
1587
|
+
}
|
|
1588
|
+
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
1589
|
+
const candidates = decls.filter(
|
|
1590
|
+
(decl) =>
|
|
1591
|
+
(range === undefined || manager.funcDecls[decl].range === range) &&
|
|
1592
|
+
manager.funcDecls[decl].domain.length === args.length &&
|
|
1593
|
+
manager.funcDecls[decl].domain.every(
|
|
1594
|
+
(sort, index) =>
|
|
1595
|
+
sort === argSorts[index] || (isArithSort(sort) && isArithSort(argSorts[index])),
|
|
1596
|
+
),
|
|
1597
|
+
);
|
|
1598
|
+
const found =
|
|
1599
|
+
candidates.find((decl) =>
|
|
1600
|
+
manager.funcDecls[decl].domain.every((sort, index) => sort === argSorts[index]),
|
|
1601
|
+
) ?? candidates.at(-1);
|
|
1602
|
+
if (found !== undefined) return mkApp(found, args, at);
|
|
1603
|
+
if (args.length === 0 || range !== undefined) return undefined;
|
|
1604
|
+
if (decls.length > 1) throwAmbiguousConstant(name, at);
|
|
1605
|
+
const array = manager.funcDecls[decls[0]];
|
|
1606
|
+
if (array.domain.length > 0 || !manager.isArraySort(array.range)) return undefined;
|
|
1607
|
+
const parameters = manager.getSortParameters(array.range);
|
|
1608
|
+
if (
|
|
1609
|
+
parameters.length !== args.length + 1 ||
|
|
1610
|
+
argSorts.some((sort, index) => sort !== parameters[index])
|
|
1611
|
+
)
|
|
1612
|
+
return undefined;
|
|
1613
|
+
return mkArrayTerm(OP_SELECT, [mkApp(decls[0], [], at), ...args], [], at);
|
|
1614
|
+
};
|
|
1615
|
+
|
|
1616
|
+
const mkDatatypeInstanceApp = (name: string, args: number[], at: SExpr) => {
|
|
1617
|
+
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
1618
|
+
for (const def of manager.datatypeDefs.values())
|
|
1619
|
+
for (const [index, constructor] of def.constructors.entries()) {
|
|
1620
|
+
if (constructor.name !== name || constructor.accessors.length !== args.length) continue;
|
|
1621
|
+
const binding: number[] = [];
|
|
1622
|
+
const isMatch = constructor.accessors.every((accessor, position) => {
|
|
1623
|
+
if (accessor.range === argSorts[position]) return true;
|
|
1624
|
+
const parameter = manager.getTypeParameterIndex(accessor.range);
|
|
1625
|
+
if (parameter === -1) return false;
|
|
1626
|
+
if (binding[parameter] !== undefined && binding[parameter] !== argSorts[position])
|
|
1627
|
+
return false;
|
|
1628
|
+
binding[parameter] = argSorts[position];
|
|
1629
|
+
return true;
|
|
1630
|
+
});
|
|
1631
|
+
if (
|
|
1632
|
+
!isMatch ||
|
|
1633
|
+
binding.length !== def.parameters.length ||
|
|
1634
|
+
!def.parameters.every((_parameter, parameter) => binding[parameter] !== undefined)
|
|
1635
|
+
)
|
|
1636
|
+
continue;
|
|
1637
|
+
return mkApp(instantiateConstructor(manager, def, index, binding), args, at);
|
|
1638
|
+
}
|
|
1639
|
+
if (args.length !== 1 || !manager.isDatatypeSort(argSorts[0])) return undefined;
|
|
1640
|
+
for (const def of manager.datatypeDefs.values())
|
|
1641
|
+
for (const [index, constructor] of def.constructors.entries()) {
|
|
1642
|
+
const position = constructor.accessors.findIndex((accessor) => accessor.name === name);
|
|
1643
|
+
if (position === -1) continue;
|
|
1644
|
+
const sort = mkDatatypeSort(manager, def.name, [...manager.getSortParameters(argSorts[0])]);
|
|
1645
|
+
return mkApp(instantiateAccessor(manager, sort, index, position), args, at);
|
|
1646
|
+
}
|
|
1647
|
+
return undefined;
|
|
1648
|
+
};
|
|
1649
|
+
|
|
1650
|
+
const mkIsApp = (constructorName: SmtToken, args: number[], at: SExpr) => {
|
|
1651
|
+
const declared = findFuncDecl(constructorName);
|
|
1652
|
+
if (declared !== undefined) return mkApp(getConstructorIs(manager, declared), args, at);
|
|
1653
|
+
const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
|
|
1654
|
+
if (argSort === -1 || !manager.isDatatypeSort(argSort))
|
|
1655
|
+
throw new SmtUnsupportedError("the operator is");
|
|
1656
|
+
const constructor = getDatatypeConstructors(manager, argSort).find(
|
|
1657
|
+
(decl) => manager.funcDecls[decl].name === constructorName.text,
|
|
1658
|
+
);
|
|
1659
|
+
if (constructor === undefined)
|
|
1660
|
+
throw new SmtParseError(
|
|
1661
|
+
`invalid datatype recognizer, unknown constructor ${constructorName.text}`,
|
|
1662
|
+
at,
|
|
1663
|
+
);
|
|
1664
|
+
return mkApp(getConstructorIs(manager, constructor), args, at);
|
|
1665
|
+
};
|
|
1666
|
+
|
|
1667
|
+
const mkUpdateFieldApp = (accessorName: SmtToken, args: number[], at: SExpr) => {
|
|
1668
|
+
const accessor = findFuncDecl(accessorName);
|
|
1669
|
+
if (accessor === undefined)
|
|
1670
|
+
throw new SmtParseError(
|
|
1671
|
+
`invalid function declaration reference, unknown function ${accessorName.text}`,
|
|
1672
|
+
accessorName,
|
|
1673
|
+
);
|
|
1674
|
+
if (manager.funcDecls[accessor].op !== OP_DT_ACCESSOR)
|
|
1675
|
+
throw new SmtUnsupportedError("the operator update-field");
|
|
1676
|
+
return mkApp(mkUpdateField(manager, accessor), args, at);
|
|
1677
|
+
};
|
|
1678
|
+
|
|
1679
|
+
const getUnknownConstantMessage = (name: string, args: number[], range: number | undefined) => {
|
|
1680
|
+
const argSorts =
|
|
1681
|
+
args.length === 0
|
|
1682
|
+
? ""
|
|
1683
|
+
: ` (${args.map((arg) => manager.getSortName(manager.sorts[arg])).join(" ")}) `;
|
|
1684
|
+
const declared = (funcs.get(name) ?? []).map((decl) => {
|
|
1685
|
+
const domain = manager.funcDecls[decl].domain.map((sort) => manager.getSortName(sort));
|
|
1686
|
+
return `\ndeclared: (declare-fun ${name} (${domain.join(" ")}) ${manager.getSortName(manager.funcDecls[decl].range)}) `;
|
|
1687
|
+
});
|
|
1688
|
+
return `unknown constant ${name}${argSorts}${range === undefined ? "" : `${manager.getSortName(range)} `}${declared.join("")}`;
|
|
1689
|
+
};
|
|
1690
|
+
|
|
1691
|
+
const parseFuncDeclRef = (sexpr: SExpr): MappedDecl => {
|
|
1692
|
+
if (sexpr.kind === "symbol") {
|
|
1693
|
+
const decl = findFuncDecl(sexpr);
|
|
1694
|
+
if (decl !== undefined) return { decl, ...manager.funcDecls[decl] };
|
|
1695
|
+
const unary = UNARY_BOOL_REFS.get(sexpr.text);
|
|
1696
|
+
if (unary !== undefined) return { decl: unary, domain: [SORT_BOOL], range: SORT_BOOL };
|
|
1697
|
+
const binary = BINARY_BOOL_REFS.get(sexpr.text);
|
|
1698
|
+
if (binary !== undefined)
|
|
1699
|
+
return { decl: binary, domain: [SORT_BOOL, SORT_BOOL], range: SORT_BOOL };
|
|
1700
|
+
throw new SmtUnsupportedError(`the declaration reference ${sexpr.text}`);
|
|
1701
|
+
}
|
|
1702
|
+
const name = sexpr.kind === "list" ? sexpr.items[0] : undefined;
|
|
1703
|
+
const domainList = sexpr.kind === "list" ? sexpr.items[1] : undefined;
|
|
1704
|
+
const rangeSort = sexpr.kind === "list" ? sexpr.items[2] : undefined;
|
|
1705
|
+
if (!isSymbol(name) || domainList?.kind !== "list" || rangeSort === undefined)
|
|
1706
|
+
throw new SmtUnsupportedError("the declaration reference");
|
|
1707
|
+
const domain = domainList.items.map((item) => parseSort(item, "Invalid function name"));
|
|
1708
|
+
const range = parseSort(rangeSort, "Invalid function name");
|
|
1709
|
+
const declared = funcs
|
|
1710
|
+
.get(name.text)
|
|
1711
|
+
?.find(
|
|
1712
|
+
(decl) =>
|
|
1713
|
+
manager.funcDecls[decl].range === range &&
|
|
1714
|
+
manager.funcDecls[decl].domain.length === domain.length &&
|
|
1715
|
+
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
1716
|
+
);
|
|
1717
|
+
if (declared !== undefined) return { decl: declared, domain, range };
|
|
1718
|
+
const builtin = CHAINABLE_OPS.get(name.text) ?? BUILTIN_OPS.get(name.text);
|
|
1719
|
+
if (builtin === undefined)
|
|
1720
|
+
throw new SmtUnsupportedError(`the declaration reference ${name.text}`);
|
|
1721
|
+
return { decl: builtin, domain, range: getBuiltinRange(builtin, domain) };
|
|
1722
|
+
};
|
|
1723
|
+
|
|
1724
|
+
const mkMapTerm = (mapped: MappedDecl, args: number[], at: SExpr) => {
|
|
1725
|
+
const signature = getMapSignature(
|
|
1726
|
+
manager,
|
|
1727
|
+
mapped,
|
|
1728
|
+
args.map((arg) => manager.sorts[arg]),
|
|
1729
|
+
);
|
|
1730
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1731
|
+
const decl = manager.mkArrayDecl(
|
|
1732
|
+
OP_ARRAY_MAP,
|
|
1733
|
+
signature.name,
|
|
1734
|
+
[mapped.decl],
|
|
1735
|
+
signature.domain,
|
|
1736
|
+
signature.range,
|
|
1737
|
+
);
|
|
1738
|
+
return manager.mkApp(decl, args, signature.range);
|
|
1739
|
+
};
|
|
1740
|
+
|
|
1741
|
+
const getArrayOp = (name: string) =>
|
|
1742
|
+
hasArrays
|
|
1743
|
+
? (ARRAY_OPS.get(name) ?? (hasArrayExtensions ? ARRAY_EXTENSION_OPS.get(name) : undefined))
|
|
1744
|
+
: undefined;
|
|
1745
|
+
|
|
1746
|
+
const parseApp = (
|
|
1747
|
+
head: SmtToken,
|
|
1748
|
+
args: number[],
|
|
1749
|
+
at: SExpr,
|
|
1750
|
+
indices: number[] = [],
|
|
1751
|
+
range?: number,
|
|
1752
|
+
) => {
|
|
1753
|
+
const name = head.text;
|
|
1754
|
+
// A bound variable applied to arguments selects from the array it stands for, one at a time.
|
|
1755
|
+
if (args.length > 0 && lookup(name) !== undefined)
|
|
1756
|
+
return args.reduce(
|
|
1757
|
+
(array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], at),
|
|
1758
|
+
parseLeaf(head),
|
|
1759
|
+
);
|
|
1760
|
+
if (indices.length > 0)
|
|
1761
|
+
return isFpaOpName(name)
|
|
1762
|
+
? mkFpaTerm(name, args, indices, at)
|
|
1763
|
+
: isSeqOpName(name)
|
|
1764
|
+
? mkSeqTerm(name, args, indices, at)
|
|
1765
|
+
: mkBvApp(name, args, indices, at);
|
|
1766
|
+
const macro = macros.get(name);
|
|
1767
|
+
// macros_find: a macro of another arity leaves the name to a declaration.
|
|
1768
|
+
if (macro !== undefined && (macro.domain.length === args.length || !funcs.has(name))) {
|
|
1769
|
+
const coerced = args.map((arg, index) => coerce(arg, macro.domain[index]));
|
|
1770
|
+
if (
|
|
1771
|
+
coerced.length !== macro.domain.length ||
|
|
1772
|
+
coerced.some((arg, index) => manager.sorts[arg] !== macro.domain[index])
|
|
1773
|
+
)
|
|
1774
|
+
throw new SmtParseError(`ill-sorted application of ${name}`, at);
|
|
1775
|
+
return expandMacro(macro, coerced);
|
|
1776
|
+
}
|
|
1777
|
+
const decls = funcs.get(name);
|
|
1778
|
+
const declared = decls === undefined ? undefined : mkDeclaredApp(name, decls, args, range, at);
|
|
1779
|
+
if (declared !== undefined) return declared;
|
|
1780
|
+
if (isSeqOpName(name)) return mkSeqTerm(name, args, indices, at, range);
|
|
1781
|
+
if (range !== undefined)
|
|
1782
|
+
throw new SmtParseError(getUnknownConstantMessage(name, args, range), at);
|
|
1783
|
+
if (isBvOpName(name)) return mkBvApp(name, args, indices, at);
|
|
1784
|
+
if (isFpaOpName(name)) return mkFpaTerm(name, args, indices, at);
|
|
1785
|
+
const arrayOp = getArrayOp(name);
|
|
1786
|
+
if (arrayOp !== undefined) return mkArrayTerm(arrayOp, args, [], at);
|
|
1787
|
+
const builtin = (logic === undefined ? LOGIC_FREE_ALIASES.get(name) : undefined) ?? name;
|
|
1788
|
+
const isTranscendental = TRANSCENDENTALS.has(builtin) && hasTranscendentals(logic);
|
|
1789
|
+
if (isTranscendental && args.length === 0 && builtin === "pi") return manager.piExpr;
|
|
1790
|
+
if (isTranscendental && args.length === 0 && builtin === "euler") return manager.eulerExpr;
|
|
1791
|
+
const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
|
|
1792
|
+
if (isTranscendental && transcendentalOp === undefined)
|
|
1793
|
+
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1794
|
+
const chainable = CHAINABLE_OPS.get(builtin);
|
|
1795
|
+
const arithOp =
|
|
1796
|
+
chainable ?? (builtin === "~" ? OP_UMINUS : (BUILTIN_OPS.get(builtin) ?? transcendentalOp));
|
|
1797
|
+
if (
|
|
1798
|
+
args.length === 0 &&
|
|
1799
|
+
arithOp !== undefined &&
|
|
1800
|
+
manager.funcDecls[arithOp].family === FAMILY_ARITH
|
|
1801
|
+
)
|
|
1802
|
+
throw new SmtParseError("no arguments supplied to arithmetical operator", head);
|
|
1803
|
+
if (chainable === OP_EQ && args.length < 2)
|
|
1804
|
+
throw new SmtParseError(
|
|
1805
|
+
getUnknownConstantMessage(name, args, undefined),
|
|
1806
|
+
args.length === 0 ? head : at,
|
|
1807
|
+
);
|
|
1808
|
+
if (chainable !== undefined) return mkChain(chainable, args, at);
|
|
1809
|
+
if (builtin === "~") return mkApp(OP_UMINUS, args, at);
|
|
1810
|
+
if (builtin === "-" && args.length === 1) return mkApp(OP_UMINUS, args, at);
|
|
1811
|
+
const op = BUILTIN_OPS.get(builtin) ?? transcendentalOp;
|
|
1812
|
+
if (op === undefined) {
|
|
1813
|
+
if (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name))
|
|
1814
|
+
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1815
|
+
const instance = mkDatatypeInstanceApp(name, args, at);
|
|
1816
|
+
if (instance !== undefined) return instance;
|
|
1817
|
+
throw new SmtParseError(
|
|
1818
|
+
getUnknownConstantMessage(name, args, undefined),
|
|
1819
|
+
args.length === 0 ? head : at,
|
|
1820
|
+
);
|
|
1821
|
+
}
|
|
1822
|
+
// xor is associative, so ast_manager::mk_app takes fewer than two arguments, which
|
|
1823
|
+
// bool_rewriter reduces to false or the argument.
|
|
1824
|
+
if (op === OP_XOR && args.length < 2) {
|
|
1825
|
+
if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
|
|
1826
|
+
throw new SmtParseError(`ill-sorted application of ${name}`, at);
|
|
1827
|
+
return args[0] ?? manager.falseExpr;
|
|
1828
|
+
}
|
|
1829
|
+
if (args.length <= 2 || !NESTED_OPS.has(op)) return mkApp(op, args, at);
|
|
1830
|
+
const domainSort = getDomainSort(op, args);
|
|
1831
|
+
return op === OP_XOR || op === OP_IMPLIES
|
|
1832
|
+
? args
|
|
1833
|
+
.slice(0, -1)
|
|
1834
|
+
.reduceRight(
|
|
1835
|
+
(right, left) => mkApp(op, [left, right], at, domainSort),
|
|
1836
|
+
args[args.length - 1],
|
|
1837
|
+
)
|
|
1838
|
+
: args.slice(1).reduce((left, right) => mkApp(op, [left, right], at, domainSort), args[0]);
|
|
1839
|
+
};
|
|
1840
|
+
|
|
1841
|
+
const parseLeaf = (sexpr: SExpr): number => {
|
|
1842
|
+
if (sexpr.kind === "numeral")
|
|
1843
|
+
return isNumeralAsReal
|
|
1844
|
+
? manager.mkRealNumeral(Rational.of(BigInt(sexpr.text), 1n))
|
|
1845
|
+
: manager.mkNumeral(BigInt(sexpr.text));
|
|
1846
|
+
if (sexpr.kind === "decimal") {
|
|
1847
|
+
const parts = sexpr.text.split(".");
|
|
1848
|
+
return manager.mkRealNumeral(
|
|
1849
|
+
Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length)),
|
|
1850
|
+
);
|
|
1851
|
+
}
|
|
1852
|
+
if (sexpr.kind === "bitvector") {
|
|
1853
|
+
const isBinary = sexpr.text[1] === "b";
|
|
1854
|
+
const digits = sexpr.text.slice(2);
|
|
1855
|
+
return manager.mkBvNumeral(
|
|
1856
|
+
BigInt(`0${isBinary ? "b" : "x"}${digits}`),
|
|
1857
|
+
digits.length * (isBinary ? 1 : 4),
|
|
1858
|
+
);
|
|
1859
|
+
}
|
|
1860
|
+
if (sexpr.kind === "string") return manager.mkString(parseZstring(sexpr.text, manager.maxChar));
|
|
1861
|
+
if (sexpr.kind === "symbol") {
|
|
1862
|
+
if (sexpr.text === "true") return manager.trueExpr;
|
|
1863
|
+
if (sexpr.text === "false") return manager.falseExpr;
|
|
1864
|
+
const binding = lookup(sexpr.text);
|
|
1865
|
+
if (binding?.kind === "var")
|
|
1866
|
+
return manager.mkVar(binders.depth - 1 - binding.depth, binding.sort);
|
|
440
1867
|
// Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
|
|
441
1868
|
// holds the terms it makes, but this parser holds no references, so it rebuilds the binding
|
|
442
1869
|
// with replaceFreeVars.
|
|
443
1870
|
if (binding !== undefined)
|
|
444
|
-
return depth === binding.depth
|
|
1871
|
+
return binders.depth === binding.depth
|
|
445
1872
|
? binding.expr
|
|
446
1873
|
: replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
|
|
447
|
-
manager.mkVar(index + shift + depth - binding.depth, manager.sorts[variable]),
|
|
1874
|
+
manager.mkVar(index + shift + binders.depth - binding.depth, manager.sorts[variable]),
|
|
448
1875
|
);
|
|
449
|
-
return parseApp(sexpr, []);
|
|
450
|
-
}
|
|
451
|
-
const head = sexpr[0];
|
|
452
|
-
if (head === "forall" || head === "exists") return parseQuantifier(sexpr, head === "forall");
|
|
453
|
-
if (head === "let") return parseLet(sexpr);
|
|
454
|
-
const named = parseTerm(sexpr[1]);
|
|
455
|
-
// name_expr: cmd_context keeps a named expression as a macro.
|
|
456
|
-
const nameIndex = sexpr.indexOf(":named");
|
|
457
|
-
if (nameIndex !== -1) {
|
|
458
|
-
manager.incRef(named);
|
|
459
|
-
manager.mkMacro(expectSymbol(sexpr[nameIndex + 1]), named);
|
|
1876
|
+
return parseApp(sexpr, [], sexpr);
|
|
460
1877
|
}
|
|
461
|
-
|
|
1878
|
+
if (sexpr.kind !== "list") throw new SmtParseError("invalid expression", sexpr);
|
|
1879
|
+
const head = sexpr.items[0];
|
|
1880
|
+
if (isSymbol(head, "forall") || isSymbol(head, "exists") || isSymbol(head, "lambda"))
|
|
1881
|
+
return parseQuantifier(
|
|
1882
|
+
sexpr,
|
|
1883
|
+
head.text === "forall"
|
|
1884
|
+
? QUANTIFIER_FORALL
|
|
1885
|
+
: head.text === "exists"
|
|
1886
|
+
? QUANTIFIER_EXISTS
|
|
1887
|
+
: QUANTIFIER_LAMBDA,
|
|
1888
|
+
);
|
|
1889
|
+
if (isSymbol(head, "let")) return parseLet(sexpr);
|
|
1890
|
+
// Each attribute applies to the expression the attributes before it made.
|
|
1891
|
+
return sexpr.items.slice(2).reduce(
|
|
1892
|
+
(annotated, keyword, index, attributes) => {
|
|
1893
|
+
if (keyword.kind !== "keyword") return annotated;
|
|
1894
|
+
const value = attributes[index + 1];
|
|
1895
|
+
if (keyword.text === ":lblpos" || keyword.text === ":lblneg")
|
|
1896
|
+
return mkLabel(annotated, keyword.text === ":lblpos", value, sexpr);
|
|
1897
|
+
if (keyword.text !== ":named") return annotated;
|
|
1898
|
+
const name = expectSymbol(value, "invalid attribute value, symbol expected", sexpr).text;
|
|
1899
|
+
manager.incRef(annotated);
|
|
1900
|
+
lastNamed.name = name;
|
|
1901
|
+
lastNamed.expr = annotated;
|
|
1902
|
+
manager.mkMacro(name, annotated);
|
|
1903
|
+
declare(macros, name, { domain: [], range: manager.sorts[annotated], body: annotated });
|
|
1904
|
+
return annotated;
|
|
1905
|
+
},
|
|
1906
|
+
parseTerm(sexpr.items[1] ?? sexpr.end),
|
|
1907
|
+
);
|
|
1908
|
+
};
|
|
1909
|
+
|
|
1910
|
+
const mkLabel = (expr: number, isPositive: boolean, value: SExpr | undefined, at: SExpr) => {
|
|
1911
|
+
const name = expectSymbol(value, "invalid attribute value, symbol expected", at).text;
|
|
1912
|
+
if (manager.sorts[expr] !== SORT_BOOL)
|
|
1913
|
+
throw new SmtParseError("invalid labeled expression, expression must have Bool sort", at);
|
|
1914
|
+
return manager.mkLabel(isPositive, [name], expr);
|
|
462
1915
|
};
|
|
463
1916
|
|
|
464
|
-
// Applications keep their own stack, like Z3's parser, so deeply nested terms do not exhaust the
|
|
465
|
-
// call stack.
|
|
466
1917
|
const parseTerm = (sexpr: SExpr): number => {
|
|
467
1918
|
const frames: ApplicationFrame[] = [];
|
|
468
1919
|
const results: number[] = [];
|
|
469
1920
|
const enter = (current: SExpr) => {
|
|
470
|
-
|
|
471
|
-
if (
|
|
472
|
-
!Array.isArray(current) ||
|
|
473
|
-
head === "forall" ||
|
|
474
|
-
head === "exists" ||
|
|
475
|
-
head === "let" ||
|
|
476
|
-
head === "!"
|
|
477
|
-
)
|
|
1921
|
+
if (current.kind !== "list") {
|
|
478
1922
|
results.push(parseLeaf(current));
|
|
479
|
-
|
|
1923
|
+
return;
|
|
1924
|
+
}
|
|
1925
|
+
const head = current.items[0];
|
|
1926
|
+
if (head === undefined)
|
|
1927
|
+
throw new SmtParseError("invalid expression, unexpected ')'", current.end);
|
|
1928
|
+
if (head.kind === "list") {
|
|
1929
|
+
const name = head.items[1];
|
|
1930
|
+
const indices = head.items.slice(2);
|
|
1931
|
+
if (
|
|
1932
|
+
hasArrays &&
|
|
1933
|
+
isSymbol(head.items[0], "as") &&
|
|
1934
|
+
isSymbol(name, "const") &&
|
|
1935
|
+
head.items.length === 3
|
|
1936
|
+
) {
|
|
1937
|
+
const sort = parseSort(head.items[2], "");
|
|
1938
|
+
frames.push({
|
|
1939
|
+
head: name,
|
|
1940
|
+
indices: [],
|
|
1941
|
+
build: (args) => mkArrayTerm(OP_CONST_ARRAY, args, [sort], current.end),
|
|
1942
|
+
list: current,
|
|
1943
|
+
start: results.length,
|
|
1944
|
+
next: 1,
|
|
1945
|
+
});
|
|
1946
|
+
return;
|
|
1947
|
+
}
|
|
1948
|
+
if (
|
|
1949
|
+
hasArrays &&
|
|
1950
|
+
hasArrayExtensions &&
|
|
1951
|
+
isSymbol(head.items[0], "_") &&
|
|
1952
|
+
isSymbol(name, "map") &&
|
|
1953
|
+
head.items.length === 3
|
|
1954
|
+
) {
|
|
1955
|
+
const mapped = parseFuncDeclRef(head.items[2]);
|
|
1956
|
+
frames.push({
|
|
1957
|
+
head: name,
|
|
1958
|
+
indices: [],
|
|
1959
|
+
build: (args) => mkMapTerm(mapped, args, current.end),
|
|
1960
|
+
list: current,
|
|
1961
|
+
start: results.length,
|
|
1962
|
+
next: 1,
|
|
1963
|
+
});
|
|
1964
|
+
return;
|
|
1965
|
+
}
|
|
1966
|
+
const indexed = head.items[2];
|
|
1967
|
+
if (
|
|
1968
|
+
isSymbol(head.items[0], "_") &&
|
|
1969
|
+
(isSymbol(name, "is") || isSymbol(name, "update-field")) &&
|
|
1970
|
+
isSymbol(indexed) &&
|
|
1971
|
+
head.items.length === 3
|
|
1972
|
+
) {
|
|
1973
|
+
frames.push({
|
|
1974
|
+
head: name,
|
|
1975
|
+
indices: [],
|
|
1976
|
+
build: (args) =>
|
|
1977
|
+
name.text === "is"
|
|
1978
|
+
? mkIsApp(indexed, args, current.end)
|
|
1979
|
+
: mkUpdateFieldApp(indexed, args, current.end),
|
|
1980
|
+
list: current,
|
|
1981
|
+
start: results.length,
|
|
1982
|
+
next: 1,
|
|
1983
|
+
});
|
|
1984
|
+
return;
|
|
1985
|
+
}
|
|
1986
|
+
if (isSymbol(head.items[0], "as") && isSymbol(name) && head.items.length === 3) {
|
|
1987
|
+
const range = parseSort(head.items[2], "Invalid qualified identifier");
|
|
1988
|
+
frames.push({
|
|
1989
|
+
head: name,
|
|
1990
|
+
indices: [],
|
|
1991
|
+
build: (args) => parseApp(name, args, current.end, [], range),
|
|
1992
|
+
list: current,
|
|
1993
|
+
start: results.length,
|
|
1994
|
+
next: 1,
|
|
1995
|
+
});
|
|
1996
|
+
return;
|
|
1997
|
+
}
|
|
1998
|
+
if (
|
|
1999
|
+
isSymbol(head.items[0], "_") &&
|
|
2000
|
+
isSymbol(name) &&
|
|
2001
|
+
isPbOpName(name.text) &&
|
|
2002
|
+
indices.every((index) => index.kind === "numeral")
|
|
2003
|
+
) {
|
|
2004
|
+
const parameters = indices.map((index) =>
|
|
2005
|
+
Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
|
|
2006
|
+
);
|
|
2007
|
+
frames.push({
|
|
2008
|
+
head: name,
|
|
2009
|
+
indices: [],
|
|
2010
|
+
build: (args) => mkPbTerm(name.text, args, parameters, current.end),
|
|
2011
|
+
list: current,
|
|
2012
|
+
start: results.length,
|
|
2013
|
+
next: 1,
|
|
2014
|
+
});
|
|
2015
|
+
return;
|
|
2016
|
+
}
|
|
2017
|
+
if (
|
|
2018
|
+
!isSymbol(head.items[0], "_") ||
|
|
2019
|
+
!isSymbol(name) ||
|
|
2020
|
+
!(isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)) ||
|
|
2021
|
+
!indices.every((index) => index.kind === "numeral")
|
|
2022
|
+
)
|
|
2023
|
+
throw new SmtUnsupportedError("indexed and qualified identifiers");
|
|
2024
|
+
frames.push({
|
|
2025
|
+
head: name,
|
|
2026
|
+
indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
2027
|
+
list: current,
|
|
2028
|
+
start: results.length,
|
|
2029
|
+
next: 1,
|
|
2030
|
+
});
|
|
2031
|
+
return;
|
|
2032
|
+
}
|
|
2033
|
+
if (head.kind !== "symbol")
|
|
2034
|
+
throw new SmtParseError("invalid function application, symbol expected", head);
|
|
2035
|
+
if (head.text === "_") {
|
|
2036
|
+
results.push(parseBvNumeral(current));
|
|
2037
|
+
return;
|
|
2038
|
+
}
|
|
2039
|
+
const qualified = current.items[1];
|
|
2040
|
+
if (head.text === "as" && isSymbol(qualified) && current.items.length === 3) {
|
|
2041
|
+
results.push(
|
|
2042
|
+
parseApp(
|
|
2043
|
+
qualified,
|
|
2044
|
+
[],
|
|
2045
|
+
qualified,
|
|
2046
|
+
[],
|
|
2047
|
+
parseSort(current.items[2], "Invalid qualified identifier"),
|
|
2048
|
+
),
|
|
2049
|
+
);
|
|
2050
|
+
return;
|
|
2051
|
+
}
|
|
2052
|
+
if (head.text === "root-obj") {
|
|
2053
|
+
results.push(parseRootObj(current));
|
|
2054
|
+
return;
|
|
2055
|
+
}
|
|
2056
|
+
if (head.text === "as" || head.text === "match")
|
|
2057
|
+
throw new SmtUnsupportedError(`the expression ${head.text}`);
|
|
2058
|
+
if (["forall", "exists", "lambda", "let", "!"].includes(head.text))
|
|
2059
|
+
results.push(parseLeaf(current));
|
|
2060
|
+
else frames.push({ head, indices: [], list: current, start: results.length, next: 1 });
|
|
480
2061
|
};
|
|
481
2062
|
enter(sexpr);
|
|
482
2063
|
while (frames.length > 0) {
|
|
483
2064
|
const frame = frames[frames.length - 1];
|
|
484
|
-
if (frame.next < frame.list.length) {
|
|
485
|
-
enter(frame.list[frame.next++]);
|
|
2065
|
+
if (frame.next < frame.list.items.length) {
|
|
2066
|
+
enter(frame.list.items[frame.next++]);
|
|
486
2067
|
continue;
|
|
487
2068
|
}
|
|
488
2069
|
frames.pop();
|
|
489
|
-
|
|
2070
|
+
if (frame.list.items.length === 1)
|
|
2071
|
+
throw new SmtParseError("invalid function application, arguments missing", frame.list.end);
|
|
2072
|
+
const args = results.splice(frame.start);
|
|
2073
|
+
results.push(
|
|
2074
|
+
frame.build?.(args) ?? parseApp(frame.head, args, frame.list.end, frame.indices),
|
|
2075
|
+
);
|
|
490
2076
|
}
|
|
491
2077
|
return results[0];
|
|
492
2078
|
};
|
|
493
2079
|
|
|
494
|
-
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
|
|
498
|
-
|
|
499
|
-
|
|
500
|
-
|
|
501
|
-
|
|
502
|
-
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
|
|
506
|
-
|
|
507
|
-
|
|
508
|
-
|
|
509
|
-
|
|
510
|
-
|
|
2080
|
+
const parseDomain = (sexpr: SExpr | undefined, at: SExpr) => {
|
|
2081
|
+
const context = "Parsing function declaration. Expecting sort list '('";
|
|
2082
|
+
return expectList(sexpr, context, at).items.map((item) => parseSort(item, context));
|
|
2083
|
+
};
|
|
2084
|
+
|
|
2085
|
+
const parseSortParameters = (sexpr: SExpr | undefined, message: string, at: SExpr) =>
|
|
2086
|
+
expectList(sexpr, "invalid sort declaration, parameters missing", at).items.map(
|
|
2087
|
+
(item) => expectSymbol(item, message, item).text,
|
|
2088
|
+
);
|
|
2089
|
+
|
|
2090
|
+
const bindTypeParameters = (names: string[]) =>
|
|
2091
|
+
new Map(names.map((name, index) => [name, manager.mkTypeParameter(index)]));
|
|
2092
|
+
|
|
2093
|
+
const parseAccessorSort = (
|
|
2094
|
+
sexpr: SExpr,
|
|
2095
|
+
bindings: ReadonlyMap<string, number>,
|
|
2096
|
+
datatypeIndexes: ReadonlyMap<string, number>,
|
|
2097
|
+
missing: string[],
|
|
2098
|
+
) => {
|
|
2099
|
+
if (sexpr.kind === "list") return parseSort(sexpr, "", bindings);
|
|
2100
|
+
if (sexpr.kind !== "symbol")
|
|
2101
|
+
throw new SmtParseError("invalid sort, symbol, '_' or '(' expected", sexpr);
|
|
2102
|
+
if (sortDecls.has(sexpr.text) || bindings.has(sexpr.text))
|
|
2103
|
+
return parseSort(sexpr, "", bindings);
|
|
2104
|
+
const index = datatypeIndexes.get(sexpr.text);
|
|
2105
|
+
if (index !== undefined) return -1 - index;
|
|
2106
|
+
missing.push(sexpr.text);
|
|
2107
|
+
return SORT_BOOL;
|
|
2108
|
+
};
|
|
2109
|
+
|
|
2110
|
+
const parseConstructors = (
|
|
2111
|
+
items: SExpr[],
|
|
2112
|
+
bindings: ReadonlyMap<string, number>,
|
|
2113
|
+
datatypeIndexes: ReadonlyMap<string, number>,
|
|
2114
|
+
missing: string[],
|
|
2115
|
+
at: SExpr,
|
|
2116
|
+
): ConstructorDef[] => {
|
|
2117
|
+
if (items.length === 0)
|
|
2118
|
+
throw new SmtParseError(
|
|
2119
|
+
"invalid datatype declaration, datatype does not have any constructors",
|
|
2120
|
+
at,
|
|
2121
|
+
);
|
|
2122
|
+
return items.map((item) => {
|
|
2123
|
+
if (isSymbol(item)) return { name: item.text, recognizer: `is-${item.text}`, accessors: [] };
|
|
2124
|
+
const constructor = expectList(
|
|
2125
|
+
item,
|
|
2126
|
+
"invalid datatype declaration, '(' or ')' expected",
|
|
2127
|
+
item,
|
|
2128
|
+
);
|
|
2129
|
+
const name = expectSymbol(
|
|
2130
|
+
constructor.items[0],
|
|
2131
|
+
"invalid constructor declaration, symbol (constructor name) expected",
|
|
2132
|
+
constructor,
|
|
2133
|
+
).text;
|
|
2134
|
+
const accessors = constructor.items.slice(1).map((accessorItem) => {
|
|
2135
|
+
const accessor = expectList(
|
|
2136
|
+
accessorItem,
|
|
2137
|
+
"invalid datatype declaration, '(' or ')' expected",
|
|
2138
|
+
accessorItem,
|
|
2139
|
+
);
|
|
2140
|
+
const accessorName = expectSymbol(
|
|
2141
|
+
accessor.items[0],
|
|
2142
|
+
"invalid accessor declaration, symbol (accessor name) expected",
|
|
2143
|
+
accessor,
|
|
2144
|
+
).text;
|
|
2145
|
+
const range = parseAccessorSort(
|
|
2146
|
+
accessor.items[1] ?? accessor.end,
|
|
2147
|
+
bindings,
|
|
2148
|
+
datatypeIndexes,
|
|
2149
|
+
missing,
|
|
2150
|
+
);
|
|
2151
|
+
if (accessor.items.length > 2)
|
|
2152
|
+
throw new SmtParseError("invalid accessor declaration, ')' expected", accessor.items[2]);
|
|
2153
|
+
return { name: accessorName, range };
|
|
2154
|
+
});
|
|
2155
|
+
return { name, recognizer: `is-${name}`, accessors };
|
|
2156
|
+
});
|
|
2157
|
+
};
|
|
2158
|
+
|
|
2159
|
+
const parseDatatypeBody = (
|
|
2160
|
+
sexpr: SExpr | undefined,
|
|
2161
|
+
datatypeIndexes: ReadonlyMap<string, number>,
|
|
2162
|
+
missing: string[],
|
|
2163
|
+
at: SExpr,
|
|
2164
|
+
) => {
|
|
2165
|
+
const body = expectList(sexpr, "invalid datatype declaration, '(' expected", at);
|
|
2166
|
+
if (!isSymbol(body.items[0], "par"))
|
|
2167
|
+
return {
|
|
2168
|
+
parameters: [],
|
|
2169
|
+
constructors: parseConstructors(body.items, NO_BINDINGS, datatypeIndexes, missing, body),
|
|
2170
|
+
};
|
|
2171
|
+
const parameters = parseSortParameters(
|
|
2172
|
+
body.items[1],
|
|
2173
|
+
"invalid sort parameter, symbol or ')' expected",
|
|
2174
|
+
body,
|
|
2175
|
+
);
|
|
2176
|
+
const constructors = expectList(
|
|
2177
|
+
body.items[2],
|
|
2178
|
+
"invalid constructor declaration after par, '(' expected",
|
|
2179
|
+
body,
|
|
2180
|
+
);
|
|
2181
|
+
return {
|
|
2182
|
+
parameters: parameters.map((_name, index) => manager.mkTypeParameter(index)),
|
|
2183
|
+
constructors: parseConstructors(
|
|
2184
|
+
constructors.items,
|
|
2185
|
+
bindTypeParameters(parameters),
|
|
2186
|
+
datatypeIndexes,
|
|
2187
|
+
missing,
|
|
2188
|
+
constructors,
|
|
2189
|
+
),
|
|
2190
|
+
};
|
|
2191
|
+
};
|
|
2192
|
+
|
|
2193
|
+
const commitDatatypes = (defs: DatatypeDef[], missing: string[], at: SExpr, end: SExpr) => {
|
|
2194
|
+
if (missing.length > 0)
|
|
2195
|
+
throw new SmtParseError(`invalid datatype declaration, unknown sort '${missing[0]}'`, at);
|
|
2196
|
+
const sorts = mkDatatypes(manager, defs);
|
|
2197
|
+
if (typeof sorts === "string") throw new SmtParseError(sorts, end);
|
|
2198
|
+
for (const def of defs) undo.push(() => removeDatatype(manager, def.name));
|
|
2199
|
+
defs.forEach((def, index) => {
|
|
2200
|
+
if (def.parameters.length === 0) insertDatatypeDecls(sorts[index], end);
|
|
2201
|
+
});
|
|
2202
|
+
for (const def of defs) {
|
|
2203
|
+
const names = def.constructors.flatMap((constructor) =>
|
|
2204
|
+
constructor.accessors.map((accessor) => accessor.name),
|
|
2205
|
+
);
|
|
2206
|
+
const duplicated = names.find((name, index) => names.indexOf(name) !== index);
|
|
2207
|
+
if (duplicated !== undefined)
|
|
2208
|
+
throw new SmtParseError(
|
|
2209
|
+
`invalid datatype declaration, repeated accessor identifier '${duplicated}'`,
|
|
2210
|
+
at,
|
|
2211
|
+
);
|
|
2212
|
+
}
|
|
2213
|
+
};
|
|
2214
|
+
|
|
2215
|
+
const declareSortDecl = (name: string, decl: SortDecl, at: SExpr) => {
|
|
2216
|
+
if (sortDecls.has(name)) throw new SmtParseError(`sort already defined ${name}`, at);
|
|
2217
|
+
declare(sortDecls, name, decl);
|
|
2218
|
+
};
|
|
2219
|
+
|
|
2220
|
+
const declareDatatypes = (list: SmtList) => {
|
|
2221
|
+
const declaration = expectList(
|
|
2222
|
+
list.items[1],
|
|
2223
|
+
"invalid sort declaration, parameters missing",
|
|
2224
|
+
list,
|
|
2225
|
+
);
|
|
2226
|
+
const isSmt26 = declaration.items[0]?.kind === "list";
|
|
2227
|
+
const datatypeIndexes = new Map<string, number>();
|
|
2228
|
+
const names: string[] = [];
|
|
2229
|
+
const arities: number[] = [];
|
|
2230
|
+
const parameterNames: string[] = [];
|
|
2231
|
+
declaration.items.forEach((item, index) => {
|
|
2232
|
+
if (!isSmt26) {
|
|
2233
|
+
parameterNames.push(
|
|
2234
|
+
expectSymbol(item, "invalid sort parameter, symbol or ')' expected", item).text,
|
|
2235
|
+
);
|
|
2236
|
+
return;
|
|
2237
|
+
}
|
|
2238
|
+
const sortDeclaration = expectList(item, "invalid sort declaration, '(' expected", item);
|
|
2239
|
+
const name = expectSymbol(
|
|
2240
|
+
sortDeclaration.items[0],
|
|
2241
|
+
"invalid sort name, identified expected",
|
|
2242
|
+
sortDeclaration,
|
|
2243
|
+
).text;
|
|
2244
|
+
const arity = sortDeclaration.items[1];
|
|
2245
|
+
if (arity?.kind !== "numeral")
|
|
2246
|
+
throw new SmtParseError(
|
|
2247
|
+
"invalid sort declaration, arity expected",
|
|
2248
|
+
arity ?? sortDeclaration.end,
|
|
2249
|
+
);
|
|
2250
|
+
if (sortDeclaration.items.length > 2)
|
|
2251
|
+
throw new SmtParseError("invalid sort declaration, ')' expected", sortDeclaration.items[2]);
|
|
2252
|
+
datatypeIndexes.set(name, index);
|
|
2253
|
+
names.push(name);
|
|
2254
|
+
arities.push(Number(arity.text));
|
|
2255
|
+
declareSortDecl(
|
|
2256
|
+
name,
|
|
2257
|
+
{ kind: "datatype", name, arity: Number(arity.text), siblings: [], instances: new Map() },
|
|
2258
|
+
sortDeclaration,
|
|
2259
|
+
);
|
|
2260
|
+
});
|
|
2261
|
+
const bodies = expectList(list.items[2], "invalid datatype declaration, '(' expected", list);
|
|
2262
|
+
// A datatype of the older syntax may refer to any datatype of its declaration.
|
|
2263
|
+
if (!isSmt26)
|
|
2264
|
+
bodies.items.forEach((item, index) => {
|
|
2265
|
+
const datatype = expectList(
|
|
2266
|
+
item,
|
|
2267
|
+
"invalid datatype declaration, '(' or ')' expected",
|
|
2268
|
+
item,
|
|
2269
|
+
);
|
|
2270
|
+
const name = expectSymbol(
|
|
2271
|
+
datatype.items[0],
|
|
2272
|
+
"invalid datatype declaration, symbol (datatype name) expected",
|
|
2273
|
+
datatype,
|
|
2274
|
+
).text;
|
|
2275
|
+
datatypeIndexes.set(name, index);
|
|
2276
|
+
names.push(name);
|
|
2277
|
+
});
|
|
2278
|
+
const missing: string[] = [];
|
|
2279
|
+
const typeParameters = parameterNames.map((_name, index) => manager.mkTypeParameter(index));
|
|
2280
|
+
const bindings = bindTypeParameters(parameterNames);
|
|
2281
|
+
const defs = bodies.items.map((item, index) => {
|
|
2282
|
+
if (isSmt26) {
|
|
2283
|
+
if (index >= names.length)
|
|
2284
|
+
throw new SmtParseError(
|
|
2285
|
+
"invalid datatype declaration, too many data-type bodies defined",
|
|
2286
|
+
item,
|
|
2287
|
+
);
|
|
2288
|
+
return mkDatatypeDef(
|
|
2289
|
+
manager,
|
|
2290
|
+
names[index],
|
|
2291
|
+
Array.from({ length: arities[index] }, (_unused, parameter) =>
|
|
2292
|
+
manager.mkTypeParameter(parameter),
|
|
2293
|
+
),
|
|
2294
|
+
parseDatatypeBody(item, datatypeIndexes, missing, list).constructors,
|
|
2295
|
+
);
|
|
511
2296
|
}
|
|
512
|
-
|
|
2297
|
+
const datatype = expectList(item, "invalid datatype declaration, '(' or ')' expected", item);
|
|
2298
|
+
return mkDatatypeDef(
|
|
2299
|
+
manager,
|
|
2300
|
+
names[index],
|
|
2301
|
+
typeParameters,
|
|
2302
|
+
parseConstructors(datatype.items.slice(1), bindings, datatypeIndexes, missing, datatype),
|
|
2303
|
+
);
|
|
2304
|
+
});
|
|
2305
|
+
if (defs.length < arities.length)
|
|
2306
|
+
throw new SmtParseError(
|
|
2307
|
+
"invalid datatype declaration, too few datatype definitions compared to declared sorts",
|
|
2308
|
+
bodies.end,
|
|
2309
|
+
);
|
|
2310
|
+
if (list.items.length > 3)
|
|
2311
|
+
throw new SmtParseError("invalid datatype declaration", list.items[3]);
|
|
2312
|
+
if (defs.length === 0) return;
|
|
2313
|
+
commitDatatypes(defs, missing, declaration, list.end);
|
|
2314
|
+
if (isSmt26) return;
|
|
2315
|
+
for (const def of defs)
|
|
2316
|
+
declareSortDecl(
|
|
2317
|
+
def.name,
|
|
2318
|
+
{
|
|
2319
|
+
kind: "datatype",
|
|
2320
|
+
name: def.name,
|
|
2321
|
+
arity: def.parameters.length,
|
|
2322
|
+
siblings: defs.length > 1 ? names : [],
|
|
2323
|
+
instances: new Map(),
|
|
2324
|
+
},
|
|
2325
|
+
list.end,
|
|
2326
|
+
);
|
|
2327
|
+
};
|
|
2328
|
+
|
|
2329
|
+
const declareDatatype = (list: SmtList) => {
|
|
2330
|
+
const name = expectSymbol(list.items[1], "unexpected token used as datatype name", list);
|
|
2331
|
+
const missing: string[] = [];
|
|
2332
|
+
const bodyList = list.items[2];
|
|
2333
|
+
const arity =
|
|
2334
|
+
bodyList?.kind === "list" &&
|
|
2335
|
+
isSymbol(bodyList.items[0], "par") &&
|
|
2336
|
+
bodyList.items[1]?.kind === "list"
|
|
2337
|
+
? bodyList.items[1].items.length
|
|
2338
|
+
: 0;
|
|
2339
|
+
declareSortDecl(
|
|
2340
|
+
name.text,
|
|
2341
|
+
{ kind: "datatype", name: name.text, arity, siblings: [], instances: new Map() },
|
|
2342
|
+
name,
|
|
2343
|
+
);
|
|
2344
|
+
const body = parseDatatypeBody(bodyList, new Map([[name.text, 0]]), missing, list);
|
|
2345
|
+
if (list.items.length > 3)
|
|
2346
|
+
throw new SmtParseError("invalid end of datatype declaration, ')' expected", list.items[3]);
|
|
2347
|
+
commitDatatypes(
|
|
2348
|
+
[mkDatatypeDef(manager, name.text, body.parameters, body.constructors)],
|
|
2349
|
+
missing,
|
|
2350
|
+
name,
|
|
2351
|
+
list.end,
|
|
2352
|
+
);
|
|
2353
|
+
};
|
|
2354
|
+
|
|
2355
|
+
// parse_rec_fun_decl: the variables are bound only while the range is parsed.
|
|
2356
|
+
const declareRecFun = (items: SExpr[], at: SExpr) => {
|
|
2357
|
+
const symbol = expectSymbol(
|
|
2358
|
+
items[0],
|
|
2359
|
+
"invalid function/constant definition, symbol expected",
|
|
2360
|
+
at,
|
|
2361
|
+
);
|
|
2362
|
+
const bound = bindSortedVars(items[1], at);
|
|
2363
|
+
const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
|
|
2364
|
+
unbindSortedVars(bound.varSorts.length);
|
|
2365
|
+
return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
|
|
2366
|
+
};
|
|
2367
|
+
|
|
2368
|
+
// parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
|
|
2369
|
+
const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
|
|
2370
|
+
const bound = bindSortedVars(variables, body);
|
|
2371
|
+
const parsed = parseTerm(body);
|
|
2372
|
+
unbindSortedVars(bound.varSorts.length);
|
|
2373
|
+
const range = manager.funcDecls[decl].range;
|
|
2374
|
+
if (manager.sorts[parsed] !== range)
|
|
2375
|
+
throw new SmtParseError(
|
|
2376
|
+
`invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[parsed])}`,
|
|
2377
|
+
next,
|
|
2378
|
+
);
|
|
2379
|
+
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsed);
|
|
2380
|
+
};
|
|
2381
|
+
|
|
2382
|
+
// parse_define and insert_macro: Z3 declares a macro as a recursive function with one case, which
|
|
2383
|
+
// a reference without arguments takes as an array. The reference that the body with its variables
|
|
2384
|
+
// reversed keeps stands for Z3's macro_decls, and those of the variables for the definition's.
|
|
2385
|
+
const defineMacroFunc = (name: string, domain: number[], body: number) => {
|
|
2386
|
+
const count = domain.length;
|
|
2387
|
+
if (count > 1) {
|
|
2388
|
+
const subst = new VarSubst(manager, true);
|
|
2389
|
+
subst.apply(
|
|
2390
|
+
body,
|
|
2391
|
+
domain.map((sort, index) => manager.mkVar(index, sort)),
|
|
2392
|
+
);
|
|
2393
|
+
subst.release();
|
|
2394
|
+
}
|
|
2395
|
+
for (const [index, sort] of domain.entries()) manager.incRef(manager.mkVar(index, sort));
|
|
2396
|
+
const reversedVars = domain.map((_, index) => manager.mkVar(index, domain[count - index - 1]));
|
|
2397
|
+
for (const reversedVar of reversedVars) manager.incRef(reversedVar);
|
|
2398
|
+
const decl = manager.mkRecFuncDecl(name, domain, manager.sorts[body]);
|
|
2399
|
+
for (const reversedVar of reversedVars) manager.decRef(reversedVar);
|
|
2400
|
+
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, true, body);
|
|
2401
|
+
declare(funcs, name, [...(funcs.get(name) ?? []), decl]);
|
|
2402
|
+
};
|
|
2403
|
+
|
|
2404
|
+
const declareCommand = (list: SmtList) => {
|
|
2405
|
+
const name = list.items[0].kind === "list" ? "" : list.items[0].text;
|
|
2406
|
+
if (name === "define-fun-rec") {
|
|
2407
|
+
const decl = declareRecFun(list.items.slice(1), list.end);
|
|
2408
|
+
insertFunc(decl, list.items[4] ?? list.end);
|
|
2409
|
+
defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
|
|
2410
|
+
return;
|
|
2411
|
+
}
|
|
2412
|
+
if (name === "define-funs-rec") {
|
|
2413
|
+
const message = "invalid recursive function definition, '(' expected";
|
|
2414
|
+
const signatures = expectList(list.items[1], message, list.end).items.map((signature) => {
|
|
2415
|
+
const declaration = expectList(signature, message, signature);
|
|
2416
|
+
const items = declaration.items;
|
|
2417
|
+
if (items.length > 3)
|
|
2418
|
+
throw new SmtParseError("invalid recursive function definition, ')' expected", items[3]);
|
|
2419
|
+
return { items, decl: declareRecFun(items, declaration.end) };
|
|
2420
|
+
});
|
|
2421
|
+
for (const signature of signatures) insertFunc(signature.decl, list.items[2] ?? list.end);
|
|
2422
|
+
const bodies = expectList(list.items[2], message, list.end);
|
|
2423
|
+
signatures.forEach((signature, index) => {
|
|
2424
|
+
const body = bodies.items[index];
|
|
2425
|
+
if (body === undefined)
|
|
2426
|
+
throw new SmtParseError(
|
|
2427
|
+
"the number of declarations does not match number of supplied definitions",
|
|
2428
|
+
bodies.end,
|
|
2429
|
+
);
|
|
2430
|
+
defineRecFun(
|
|
2431
|
+
signature.decl,
|
|
2432
|
+
signature.items[1],
|
|
2433
|
+
body,
|
|
2434
|
+
bodies.items[index + 1] ?? bodies.end,
|
|
2435
|
+
);
|
|
2436
|
+
});
|
|
2437
|
+
const extra = bodies.items[signatures.length];
|
|
2438
|
+
if (extra !== undefined)
|
|
2439
|
+
throw new SmtParseError("invalid recursive function definition, ')' expected", extra);
|
|
2440
|
+
return;
|
|
2441
|
+
}
|
|
2442
|
+
if (name === "declare-datatypes") {
|
|
2443
|
+
declareDatatypes(list);
|
|
2444
|
+
return;
|
|
2445
|
+
}
|
|
2446
|
+
if (name === "declare-datatype") {
|
|
2447
|
+
declareDatatype(list);
|
|
2448
|
+
return;
|
|
2449
|
+
}
|
|
2450
|
+
const symbol = expectSymbol(list.items[1], "invalid declaration, symbol expected", list);
|
|
2451
|
+
if (name === "declare-sort") {
|
|
2452
|
+
if (sortDecls.has(symbol.text))
|
|
2453
|
+
throw new SmtParseError("invalid sort declaration, sort already declared/defined", symbol);
|
|
2454
|
+
const arity = list.items[2];
|
|
2455
|
+
if (arity !== undefined && arity.kind !== "numeral")
|
|
2456
|
+
throw new SmtParseError(
|
|
2457
|
+
"invalid sort declaration, arity (<numeral>) or ')' expected",
|
|
2458
|
+
arity,
|
|
2459
|
+
);
|
|
2460
|
+
if (list.items.length > 3)
|
|
2461
|
+
throw new SmtParseError("invalid sort declaration, ')' expected", list.items[3]);
|
|
2462
|
+
declare(
|
|
2463
|
+
sortDecls,
|
|
2464
|
+
symbol.text,
|
|
2465
|
+
arity === undefined || arity.text === "0"
|
|
2466
|
+
? { kind: "sort", sort: manager.mkSort(symbol.text) }
|
|
2467
|
+
: { kind: "user", name: symbol.text, arity: Number(arity.text) },
|
|
2468
|
+
);
|
|
2469
|
+
return;
|
|
2470
|
+
}
|
|
2471
|
+
if (name === "define-sort") {
|
|
2472
|
+
if (sortDecls.has(symbol.text))
|
|
2473
|
+
throw new SmtParseError("invalid sort definition, sort already declared/defined", symbol);
|
|
2474
|
+
const parameters = parseSortParameters(
|
|
2475
|
+
list.items[2],
|
|
2476
|
+
"invalid sort parameter, symbol or ')' expected",
|
|
2477
|
+
list,
|
|
2478
|
+
);
|
|
2479
|
+
const body = list.items[3] ?? list.end;
|
|
2480
|
+
checkPsort(body, bindTypeParameters(parameters));
|
|
2481
|
+
declare(sortDecls, symbol.text, { kind: "definition", parameters, body });
|
|
2482
|
+
return;
|
|
2483
|
+
}
|
|
2484
|
+
if (name === "define-fun" || name === "define-const") {
|
|
2485
|
+
const isConst = name === "define-const";
|
|
2486
|
+
const bound = isConst ? { names: [], varSorts: [] } : bindSortedVars(list.items[2], list);
|
|
2487
|
+
const range = parseSort(
|
|
2488
|
+
list.items[isConst ? 2 : 3] ?? list.end,
|
|
2489
|
+
isConst ? "Invalid constant definition" : "Invalid function definition",
|
|
2490
|
+
);
|
|
2491
|
+
const body = parseTerm(list.items[isConst ? 3 : 4] ?? list.end);
|
|
2492
|
+
if (!isConst) unbindSortedVars(bound.varSorts.length);
|
|
2493
|
+
const coerced = coerce(body, range);
|
|
2494
|
+
if (manager.sorts[coerced] !== range)
|
|
2495
|
+
throw new SmtParseError(
|
|
2496
|
+
isConst
|
|
2497
|
+
? "invalid constant definition, sort mismatch"
|
|
2498
|
+
: "invalid function/constant definition, sort mismatch",
|
|
2499
|
+
list.end,
|
|
2500
|
+
);
|
|
2501
|
+
manager.incRef(coerced);
|
|
2502
|
+
declare(macros, symbol.text, { domain: bound.varSorts, range, body: coerced });
|
|
2503
|
+
defineMacroFunc(symbol.text, bound.varSorts, coerced);
|
|
2504
|
+
return;
|
|
2505
|
+
}
|
|
2506
|
+
const domain = name === "declare-fun" ? parseDomain(list.items[2], list) : [];
|
|
2507
|
+
const range = parseSort(
|
|
2508
|
+
list.items[name === "declare-fun" ? 3 : 2] ?? list.end,
|
|
2509
|
+
name === "declare-fun" ? "Invalid function declaration" : "Invalid constant declaration",
|
|
2510
|
+
);
|
|
2511
|
+
// Z3's builtin_signature_collides and is_transcendental_shadow_decl each make and release fresh variables of the domain.
|
|
2512
|
+
for (let round = 0; round < 2; round++) {
|
|
2513
|
+
const vars = domain.map((sort, index) => manager.mkVar(index, sort));
|
|
2514
|
+
for (const domainVar of vars) manager.incRef(domainVar);
|
|
2515
|
+
for (const domainVar of vars) manager.decRef(domainVar);
|
|
2516
|
+
}
|
|
2517
|
+
const decl = manager.mkFuncDecl(symbol.text, domain, range);
|
|
2518
|
+
checkDecl(decl, list.end);
|
|
2519
|
+
if (macros.has(symbol.text))
|
|
2520
|
+
throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
|
|
2521
|
+
const existing = funcs.get(symbol.text) ?? [];
|
|
2522
|
+
if (
|
|
2523
|
+
existing.some(
|
|
2524
|
+
(decl) =>
|
|
2525
|
+
manager.funcDecls[decl].range === range &&
|
|
2526
|
+
manager.funcDecls[decl].domain.length === domain.length &&
|
|
2527
|
+
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
2528
|
+
)
|
|
2529
|
+
)
|
|
2530
|
+
throw new SmtParseError(
|
|
2531
|
+
`invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
|
|
2532
|
+
list.end,
|
|
2533
|
+
);
|
|
2534
|
+
declare(funcs, symbol.text, [...existing, decl]);
|
|
2535
|
+
};
|
|
2536
|
+
|
|
2537
|
+
const parseFormula = (sexpr: SExpr) => {
|
|
2538
|
+
const assertion = parseTerm(sexpr);
|
|
2539
|
+
if (manager.sorts[assertion] !== SORT_BOOL)
|
|
2540
|
+
throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
|
|
2541
|
+
manager.incRef(assertion);
|
|
2542
|
+
return assertion;
|
|
2543
|
+
};
|
|
2544
|
+
|
|
2545
|
+
// An assertion is named when the last name of its term is its own.
|
|
2546
|
+
const parseAssertion = (sexpr: SExpr) => {
|
|
2547
|
+
lastNamed.expr = -1;
|
|
2548
|
+
const formula = parseFormula(sexpr);
|
|
2549
|
+
return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
|
|
2550
|
+
};
|
|
2551
|
+
|
|
2552
|
+
const push = () => scopeStarts.push(undo.length);
|
|
2553
|
+
|
|
2554
|
+
const pop = () => {
|
|
2555
|
+
const start = scopeStarts.pop() ?? 0;
|
|
2556
|
+
for (const restore of undo.splice(start).reverse()) restore();
|
|
2557
|
+
};
|
|
2558
|
+
|
|
2559
|
+
const isUsed = (name: string) => funcs.has(name) || BUILTIN_NAMES.has(name);
|
|
2560
|
+
|
|
2561
|
+
const isClashing = (decl: number) => {
|
|
2562
|
+
const domain = manager.funcDecls[decl].domain;
|
|
2563
|
+
const decls = funcs.get(String(manager.funcDecls[decl].name)) ?? [];
|
|
2564
|
+
return (
|
|
2565
|
+
decls.includes(decl) &&
|
|
2566
|
+
decls.some(
|
|
2567
|
+
(other) =>
|
|
2568
|
+
other !== decl &&
|
|
2569
|
+
manager.funcDecls[other].domain.length === domain.length &&
|
|
2570
|
+
manager.funcDecls[other].domain.every((sort, index) => sort === domain[index]),
|
|
2571
|
+
)
|
|
2572
|
+
);
|
|
2573
|
+
};
|
|
2574
|
+
|
|
2575
|
+
// The first declaration of each name, in the slot order of cmd_context's dictionary.
|
|
2576
|
+
const getDeclaredFuncs = () => {
|
|
2577
|
+
const table = new ObjMap<true>((decl) => getSymbolHash(manager.funcDecls[decl].name));
|
|
2578
|
+
for (const decls of funcs.values()) table.set(decls[0], true);
|
|
2579
|
+
return [...table.keys()];
|
|
2580
|
+
};
|
|
2581
|
+
|
|
2582
|
+
// Z3 registers each named term and defined function as a recursive function definition.
|
|
2583
|
+
const hasDefinitions = () =>
|
|
2584
|
+
macros.size > 0 ||
|
|
2585
|
+
[...funcs.values()].some((decls) => decls.some((decl) => manager.recFunDefs.has(decl)));
|
|
2586
|
+
|
|
2587
|
+
return {
|
|
2588
|
+
declareCommand,
|
|
2589
|
+
insertFunc,
|
|
2590
|
+
getFuncs: (name: string) => funcs.get(name) ?? [],
|
|
2591
|
+
hasDefinitions,
|
|
2592
|
+
parseTerm,
|
|
2593
|
+
parseSort: (sexpr: SExpr) => parseSort(sexpr, ""),
|
|
2594
|
+
parseFormula,
|
|
2595
|
+
parseAssertion,
|
|
2596
|
+
getLogicError: logicChecker.checkExpr,
|
|
2597
|
+
push,
|
|
2598
|
+
pop,
|
|
2599
|
+
isUsed,
|
|
2600
|
+
isClashing,
|
|
2601
|
+
getDeclaredFuncs,
|
|
2602
|
+
};
|
|
2603
|
+
};
|
|
2604
|
+
|
|
2605
|
+
export type SmtlibReader = ReturnType<typeof createSmtlibReader>;
|
|
2606
|
+
|
|
2607
|
+
export const DECLARATIONS = new Set([
|
|
2608
|
+
"declare-sort",
|
|
2609
|
+
"declare-datatypes",
|
|
2610
|
+
"declare-datatype",
|
|
2611
|
+
"declare-fun",
|
|
2612
|
+
"declare-const",
|
|
2613
|
+
"define-fun",
|
|
2614
|
+
"define-const",
|
|
2615
|
+
"define-sort",
|
|
2616
|
+
"define-fun-rec",
|
|
2617
|
+
"define-funs-rec",
|
|
2618
|
+
]);
|
|
2619
|
+
|
|
2620
|
+
// Z3 reports an error in a command, skips the command and goes on.
|
|
2621
|
+
export const parseSmtlib = (
|
|
2622
|
+
text: string,
|
|
2623
|
+
manager: AstManager,
|
|
2624
|
+
assertExpr: (assertion: number) => void,
|
|
2625
|
+
report: (error: SmtParseError) => void,
|
|
2626
|
+
): SmtProblem => {
|
|
2627
|
+
const commands = createCommandReader(text);
|
|
2628
|
+
const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0 };
|
|
2629
|
+
const assertions: number[] = [];
|
|
2630
|
+
const runCommand = (list: SmtList) => {
|
|
2631
|
+
const name = expectSymbol(list.items[0], "invalid command, symbol expected", list).text;
|
|
2632
|
+
const option = list.items[1];
|
|
2633
|
+
const value = list.items[2];
|
|
2634
|
+
if (
|
|
2635
|
+
name === "set-option" &&
|
|
2636
|
+
option?.kind === "keyword" &&
|
|
2637
|
+
option.text === ":rlimit" &&
|
|
2638
|
+
value?.kind === "numeral"
|
|
2639
|
+
)
|
|
2640
|
+
state.rlimit = Number(value.text);
|
|
2641
|
+
if (name === "set-logic") {
|
|
2642
|
+
if (!isSymbol(option))
|
|
2643
|
+
throw new SmtParseError("invalid logic name, symbol expected", option ?? list.end);
|
|
2644
|
+
if (state.logic !== "") throw new SmtParseError("the logic has already been set", list.end);
|
|
2645
|
+
if (assertions.length > 0)
|
|
2646
|
+
throw new SmtParseError("logic must be set before initialization", list.end);
|
|
2647
|
+
if (!isSupportedLogic(option.text)) return;
|
|
2648
|
+
state.logic = option.text;
|
|
2649
|
+
state.reader = createSmtlibReader(manager, option.text);
|
|
2650
|
+
} else if (DECLARATIONS.has(name)) {
|
|
2651
|
+
if (name.startsWith("define-"))
|
|
2652
|
+
throw new SmtUnsupportedError(`the command ${name} is not supported`);
|
|
2653
|
+
state.reader.declareCommand(list);
|
|
513
2654
|
} else if (name === "assert") {
|
|
514
|
-
|
|
515
|
-
const
|
|
516
|
-
|
|
2655
|
+
const assertion = state.reader.parseFormula(list.items[1] ?? list.end);
|
|
2656
|
+
const logicError = state.reader.getLogicError(assertion);
|
|
2657
|
+
if (logicError !== undefined) {
|
|
2658
|
+
manager.decRef(assertion);
|
|
2659
|
+
throw new SmtParseError(logicError, list.end);
|
|
2660
|
+
}
|
|
517
2661
|
assertions.push(assertion);
|
|
518
2662
|
assertExpr(assertion);
|
|
519
|
-
} else if (name === "
|
|
520
|
-
hasCheckSat = true;
|
|
521
|
-
break;
|
|
522
|
-
} else if (name === "push" || name === "pop" || name === "define-fun" || name === "define-sort")
|
|
2663
|
+
} else if (name === "push" || name === "pop")
|
|
523
2664
|
throw new SmtUnsupportedError(`the command ${name} is not supported`);
|
|
2665
|
+
};
|
|
2666
|
+
for (;;) {
|
|
2667
|
+
try {
|
|
2668
|
+
const list = commands.read();
|
|
2669
|
+
if (list === undefined) return { assertions, hasCheckSat: false, rlimit: state.rlimit };
|
|
2670
|
+
if (isSymbol(list.items[0], "check-sat"))
|
|
2671
|
+
return { assertions, hasCheckSat: true, rlimit: state.rlimit };
|
|
2672
|
+
runCommand(list);
|
|
2673
|
+
} catch (error) {
|
|
2674
|
+
if (!(error instanceof SmtParseError)) throw error;
|
|
2675
|
+
report(error);
|
|
2676
|
+
commands.skip(report);
|
|
2677
|
+
}
|
|
524
2678
|
}
|
|
525
|
-
return { assertions, hasCheckSat };
|
|
526
2679
|
};
|