tla-ts 0.0.10-dev.8aec06f77 → 0.0.10-dev.8be00045c
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/dist/deciders.cjs +37 -36
- package/dist/deciders.js +55 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +4 -1
- package/dist/index.d.ts +4 -1
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove.cjs +146 -58
- package/dist/prove.js +143 -55
- package/dist/run.cjs +43 -43
- package/dist/run.js +45 -45
- package/dist/transfer.cjs +29 -26
- package/dist/transfer.js +43 -40
- package/dist/worker.cjs +1 -1
- package/dist/worker.js +1 -1
- package/package.json +1 -1
- package/src/ast.ts +3 -3
- package/src/bags.ts +46 -28
- package/src/check-trace.ts +2 -16
- package/src/check.ts +336 -88
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlapm.ts +261 -68
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +4 -5
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +26 -7
- package/src/dependencies.ts +23 -2
- package/src/dfid.ts +9 -2
- package/src/environment.ts +27 -5
- package/src/errors.ts +1 -1
- package/src/evaluate.ts +9 -3
- package/src/exit-codes.ts +5 -2
- package/src/instances.ts +1 -1
- package/src/levels.ts +134 -86
- package/src/liveness-checker.ts +572 -204
- package/src/liveness.ts +47 -32
- package/src/obligations/action.ts +0 -2
- package/src/obligations/anonymize.ts +2 -6
- package/src/obligations/equality.ts +0 -2
- package/src/obligations/expression.ts +0 -2
- package/src/obligations/format.ts +0 -2
- package/src/obligations/generate.ts +0 -2
- package/src/obligations/index.ts +5 -3
- package/src/obligations/levels.ts +0 -2
- package/src/obligations/module.ts +0 -2
- package/src/obligations/normalize.ts +0 -2
- package/src/obligations/operators.ts +0 -2
- package/src/obligations/pragma.ts +2 -2
- package/src/obligations/printer.ts +0 -2
- package/src/obligations/proof.ts +0 -2
- package/src/obligations/regroup.ts +0 -2
- package/src/obligations/simplify.ts +0 -2
- package/src/obligations/subexpression.ts +0 -2
- package/src/obligations/substitution.ts +0 -2
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel-worker.ts +8 -2
- package/src/parallel.ts +7 -2
- package/src/parser.ts +224 -82
- package/src/pretty-print.ts +1 -1
- package/src/prover/deciders.ts +1 -8
- package/src/prover/isabelle/encode.ts +0 -2
- package/src/prover/isabelle/isar/attrib.ts +86 -49
- package/src/prover/isabelle/isar/context.ts +25 -26
- package/src/prover/isabelle/isar/induct.ts +2 -9
- package/src/prover/isabelle/isar/method.ts +5 -9
- package/src/prover/isabelle/isar/proof.ts +33 -18
- package/src/prover/isabelle/isar/rule-cases.ts +14 -22
- package/src/prover/isabelle/isar/theory.ts +16 -17
- package/src/prover/isabelle/isar/toplevel.ts +46 -56
- package/src/prover/isabelle/isar/type-check.ts +0 -2
- package/src/prover/isabelle/provers/blast/blast.ts +0 -2
- package/src/prover/isabelle/provers/blast/branch.ts +0 -2
- package/src/prover/isabelle/provers/blast/prove.ts +0 -2
- package/src/prover/isabelle/provers/blast/rules.ts +0 -2
- package/src/prover/isabelle/provers/blast/state.ts +0 -2
- package/src/prover/isabelle/provers/blast/term.ts +0 -2
- package/src/prover/isabelle/provers/clasimp.ts +1 -3
- package/src/prover/isabelle/provers/classical.ts +1 -3
- package/src/prover/isabelle/provers/hypsubst.ts +2 -4
- package/src/prover/isabelle/pure/bicompose.ts +0 -2
- package/src/prover/isabelle/pure/consts.ts +0 -2
- package/src/prover/isabelle/pure/conv.ts +0 -2
- package/src/prover/isabelle/pure/drule.ts +0 -2
- package/src/prover/isabelle/pure/envir.ts +0 -2
- package/src/prover/isabelle/pure/goal.ts +0 -2
- package/src/prover/isabelle/pure/logic.ts +0 -2
- package/src/prover/isabelle/pure/name.ts +0 -2
- package/src/prover/isabelle/pure/net.ts +0 -2
- package/src/prover/isabelle/pure/object-logic.ts +0 -2
- package/src/prover/isabelle/pure/pattern.ts +0 -2
- package/src/prover/isabelle/pure/raw-simplifier.ts +0 -2
- package/src/prover/isabelle/pure/rewriter.ts +0 -2
- package/src/prover/isabelle/pure/search.ts +0 -2
- package/src/prover/isabelle/pure/seq.ts +0 -2
- package/src/prover/isabelle/pure/simplifier.ts +0 -2
- package/src/prover/isabelle/pure/table.ts +0 -2
- package/src/prover/isabelle/pure/tactic.ts +0 -2
- package/src/prover/isabelle/pure/tactical.ts +0 -2
- package/src/prover/isabelle/pure/term-ord.ts +0 -2
- package/src/prover/isabelle/pure/term.ts +0 -2
- package/src/prover/isabelle/pure/thm.ts +0 -2
- package/src/prover/isabelle/pure/type.ts +0 -2
- package/src/prover/isabelle/pure/unify.ts +0 -2
- package/src/prover/isabelle/pure/variable.ts +0 -2
- package/src/prover/isabelle/tla/classical-setup.ts +0 -2
- package/src/prover/isabelle/tla/simpdata.ts +0 -2
- package/src/prover/isabelle/tools/intuitionistic.ts +0 -2
- package/src/prover/ocaml.ts +4 -1
- package/src/prover/prep/action.ts +1 -0
- package/src/prover/prep/methods.ts +50 -3
- package/src/prover/prep/normalize.ts +4 -1
- package/src/prover/prove.ts +58 -32
- package/src/prover/ptl/decide.ts +43 -63
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +3 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/ackermannize-bv-tactic.ts +0 -2
- package/src/prover/smt/solver/ackr-helper.ts +0 -3
- package/src/prover/smt/solver/ackr-model-converter.ts +0 -1
- package/src/prover/smt/solver/act-cache.ts +0 -1
- package/src/prover/smt/solver/add-bounds-tactic.ts +0 -1
- package/src/prover/smt/solver/aig-tactic.ts +25 -16
- package/src/prover/smt/solver/aig.ts +2 -3
- package/src/prover/smt/solver/arith-rewriter.ts +3 -6
- package/src/prover/smt/solver/arith-terms.ts +0 -2
- package/src/prover/smt/solver/array-decl-plugin.ts +0 -1
- package/src/prover/smt/solver/array-rewriter.ts +0 -1
- package/src/prover/smt/solver/asserted-formulas.ts +9 -3
- package/src/prover/smt/solver/ast-lt.ts +1 -2
- package/src/prover/smt/solver/ast-util.ts +3 -3
- package/src/prover/smt/solver/ast.ts +112 -156
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +0 -3
- package/src/prover/smt/solver/bit-blaster.ts +0 -3
- package/src/prover/smt/solver/bound-manager.ts +39 -29
- package/src/prover/smt/solver/bound-simplifier.ts +0 -2
- package/src/prover/smt/solver/bv-bound-chk.ts +2 -10
- package/src/prover/smt/solver/bv-decl-plugin.ts +0 -1
- package/src/prover/smt/solver/bv-divrem-bounds.ts +0 -2
- package/src/prover/smt/solver/bv-rewriter.ts +15 -19
- package/src/prover/smt/solver/bv1-blast.ts +1 -11
- package/src/prover/smt/solver/bv2fpa-converter.ts +0 -1
- package/src/prover/smt/solver/bv2int-rewriter.ts +0 -1
- package/src/prover/smt/solver/bv2real-rewriter.ts +0 -1
- package/src/prover/smt/solver/card2bv.ts +1 -4
- package/src/prover/smt/solver/case-split-queue.ts +0 -2
- package/src/prover/smt/solver/cg-table.ts +19 -16
- package/src/prover/smt/solver/check-logic.ts +6 -2
- package/src/prover/smt/solver/clause.ts +0 -1
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +0 -2
- package/src/prover/smt/solver/conflict-resolution.ts +0 -1
- package/src/prover/smt/solver/context.ts +41 -14
- package/src/prover/smt/solver/ctx-simplify.ts +1 -3
- package/src/prover/smt/solver/ctx-solver-simplify.ts +0 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +0 -1
- package/src/prover/smt/solver/datatype-rewriter.ts +0 -1
- package/src/prover/smt/solver/demodulator.ts +2 -5
- package/src/prover/smt/solver/dependent-expr-state.ts +16 -3
- package/src/prover/smt/solver/der.ts +0 -1
- package/src/prover/smt/solver/diff-neq.ts +1 -3
- package/src/prover/smt/solver/distribute-forall.ts +1 -11
- package/src/prover/smt/solver/dom-simplify.ts +1 -3
- package/src/prover/smt/solver/dt2bv-tactic.ts +2 -9
- package/src/prover/smt/solver/dyn-ack.ts +0 -1
- package/src/prover/smt/solver/e-matching.ts +6 -7
- package/src/prover/smt/solver/elim-small-bv-tactic.ts +0 -1
- package/src/prover/smt/solver/elim-uncnstr.ts +7 -23
- package/src/prover/smt/solver/enode.ts +15 -2
- package/src/prover/smt/solver/eq2bv-tactic.ts +0 -1
- package/src/prover/smt/solver/euf/arith-axioms.ts +0 -1
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -3
- package/src/prover/smt/solver/euf/arith-solver.ts +0 -1
- package/src/prover/smt/solver/euf/array-axioms.ts +0 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +20 -11
- package/src/prover/smt/solver/euf/array-solver.ts +0 -2
- package/src/prover/smt/solver/euf/bv-ackerman.ts +0 -2
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -3
- package/src/prover/smt/solver/euf/bv-solver.ts +0 -2
- package/src/prover/smt/solver/euf/dt-solver.ts +19 -21
- package/src/prover/smt/solver/euf/egraph.ts +68 -43
- package/src/prover/smt/solver/euf/euf-solver.ts +36 -23
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -53
- package/src/prover/smt/solver/euf/mam.ts +7 -55
- package/src/prover/smt/solver/euf/q-ematch.ts +21 -97
- package/src/prover/smt/solver/euf/q-mbi.ts +4 -4
- package/src/prover/smt/solver/euf/q-model-fixer.ts +1 -4
- package/src/prover/smt/solver/euf/q-solver.ts +2 -2
- package/src/prover/smt/solver/euf/th-solver.ts +1 -10
- package/src/prover/smt/solver/euf/th-solvers.ts +0 -1
- package/src/prover/smt/solver/expr-ref.ts +0 -1
- package/src/prover/smt/solver/expr-safe-replace.ts +0 -1
- package/src/prover/smt/solver/expr2polynomial.ts +204 -80
- package/src/prover/smt/solver/factor.ts +37 -26
- package/src/prover/smt/solver/fd-solver.ts +3 -5
- package/src/prover/smt/solver/fingerprints.ts +0 -1
- package/src/prover/smt/solver/fix-dl-var.ts +1 -3
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +19 -14
- package/src/prover/smt/solver/fpa-decl-plugin.ts +0 -1
- package/src/prover/smt/solver/fpa-rewriter.ts +2 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +13 -8
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +0 -1
- package/src/prover/smt/solver/fpa2bv-tactic.ts +0 -2
- package/src/prover/smt/solver/goal.ts +3 -2
- package/src/prover/smt/solver/goal2nlsat.ts +57 -32
- package/src/prover/smt/solver/guard-set.ts +0 -1
- package/src/prover/smt/solver/hash.ts +0 -1
- package/src/prover/smt/solver/hashtable.ts +0 -1
- package/src/prover/smt/solver/inf-eps.ts +1 -2
- package/src/prover/smt/solver/inj-axiom.ts +0 -1
- package/src/prover/smt/solver/internalizer.ts +41 -3
- package/src/prover/smt/solver/lackr.ts +0 -2
- package/src/prover/smt/solver/lbool.ts +0 -1
- package/src/prover/smt/solver/lia2card.ts +0 -1
- package/src/prover/smt/solver/lia2pb.ts +18 -5
- package/src/prover/smt/solver/literal.ts +0 -1
- package/src/prover/smt/solver/logic-tactics.ts +0 -4
- package/src/prover/smt/solver/lp/bound-propagator.ts +0 -1
- package/src/prover/smt/solver/lp/constraints.ts +0 -1
- package/src/prover/smt/solver/lp/containers.ts +7 -2
- package/src/prover/smt/solver/lp/core-solver.ts +0 -3
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -4
- package/src/prover/smt/solver/lp/dep-intervals.ts +0 -3
- package/src/prover/smt/solver/lp/dependency.ts +0 -2
- package/src/prover/smt/solver/lp/dioph-eq.ts +0 -2
- package/src/prover/smt/solver/lp/explanation.ts +0 -1
- package/src/prover/smt/solver/lp/gomory.ts +0 -1
- package/src/prover/smt/solver/lp/hnf-cutter.ts +0 -1
- package/src/prover/smt/solver/lp/hnf.ts +0 -3
- package/src/prover/smt/solver/lp/int-cube.ts +0 -1
- package/src/prover/smt/solver/lp/int-solver.ts +0 -2
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -2
- package/src/prover/smt/solver/lp/lar-term.ts +0 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +0 -1
- package/src/prover/smt/solver/lp/maximize-term.ts +0 -3
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -3
- package/src/prover/smt/solver/lp/nex.ts +2 -2
- package/src/prover/smt/solver/lp/nla-backoff.ts +0 -2
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -3
- package/src/prover/smt/solver/lp/nla-core.ts +26 -7
- package/src/prover/smt/solver/lp/nla-divisions.ts +0 -2
- package/src/prover/smt/solver/lp/nla-emonics.ts +0 -1
- package/src/prover/smt/solver/lp/nla-factorization.ts +0 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -82
- package/src/prover/smt/solver/lp/nla-horner.ts +0 -2
- package/src/prover/smt/solver/lp/nla-intervals.ts +0 -1
- package/src/prover/smt/solver/lp/nla-monomial-bounds.ts +0 -2
- package/src/prover/smt/solver/lp/nla-monotone.ts +0 -1
- package/src/prover/smt/solver/lp/nla-order.ts +0 -2
- package/src/prover/smt/solver/lp/nla-patcher.ts +0 -1
- package/src/prover/smt/solver/lp/nla-powers.ts +144 -108
- package/src/prover/smt/solver/lp/nla-tangents.ts +0 -2
- package/src/prover/smt/solver/lp/nla-throttle.ts +0 -1
- package/src/prover/smt/solver/lp/nla-transcendentals.ts +50 -19
- package/src/prover/smt/solver/lp/nla-types.ts +0 -2
- package/src/prover/smt/solver/lp/nla-var-eqs.ts +0 -1
- package/src/prover/smt/solver/lp/nra-solver.ts +138 -97
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -3
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -21
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -41
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- package/src/prover/smt/solver/lp/random-updater.ts +0 -2
- package/src/prover/smt/solver/lp/static-matrix.ts +0 -1
- package/src/prover/smt/solver/lp/union-find.ts +1 -2
- package/src/prover/smt/solver/macro-finder.ts +1 -4
- package/src/prover/smt/solver/mam-compiler.ts +14 -15
- package/src/prover/smt/solver/mam-interpreter.ts +0 -1
- package/src/prover/smt/solver/max-bv-sharing-tactic.ts +1 -13
- package/src/prover/smt/solver/max-cliques.ts +0 -2
- package/src/prover/smt/solver/maxcore.ts +5 -14
- package/src/prover/smt/solver/maximize-ac-sharing.ts +0 -1
- package/src/prover/smt/solver/maxlex.ts +0 -8
- package/src/prover/smt/solver/maxsmt-base.ts +7 -1
- package/src/prover/smt/solver/maxsmt.ts +0 -1
- package/src/prover/smt/solver/mbp/mbp-arith.ts +2 -12
- package/src/prover/smt/solver/mbp/mbp-basic-tg.ts +0 -1
- package/src/prover/smt/solver/mbp/mbp-plugin.ts +9 -2
- package/src/prover/smt/solver/mbp/mbp-qel.ts +0 -1
- package/src/prover/smt/solver/mbp/mbp-solve-plugin.ts +1 -10
- package/src/prover/smt/solver/mbp/mbp-term-graph.ts +0 -1
- package/src/prover/smt/solver/model-based-opt.ts +1 -2
- package/src/prover/smt/solver/model-checker.ts +0 -1
- package/src/prover/smt/solver/model-evaluator.ts +9 -6
- package/src/prover/smt/solver/model-finder.ts +0 -1
- package/src/prover/smt/solver/model-generator.ts +3 -2
- package/src/prover/smt/solver/model-macro-solver.ts +3 -4
- package/src/prover/smt/solver/model-printer.ts +0 -1
- package/src/prover/smt/solver/mpf.ts +2 -5
- package/src/prover/smt/solver/mus.ts +1 -3
- package/src/prover/smt/solver/muz/dl-context.ts +67 -9
- package/src/prover/smt/solver/muz/dl-mk-bit-blast.ts +0 -1
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +68 -22
- package/src/prover/smt/solver/muz/dl-mk-elim-term-ite.ts +7 -3
- package/src/prover/smt/solver/muz/dl-mk-interp-tail-simplifier.ts +0 -2
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -11
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +78 -16
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -4
- package/src/prover/smt/solver/muz/dl-rule-set.ts +0 -1
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -4
- package/src/prover/smt/solver/muz/dl-rule.ts +95 -33
- package/src/prover/smt/solver/muz/hnf.ts +6 -6
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +176 -0
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -6
- package/src/prover/smt/solver/muz/rule-properties.ts +194 -37
- package/src/prover/smt/solver/muz/spacer-context.ts +104 -89
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -3
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +0 -3
- package/src/prover/smt/solver/muz/spacer-manager.ts +0 -2
- package/src/prover/smt/solver/muz/spacer-pdr.ts +4 -4
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +3 -9
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -3
- package/src/prover/smt/solver/muz/substitution.ts +88 -39
- package/src/prover/smt/solver/nla2bv-tactic.ts +0 -1
- package/src/prover/smt/solver/nlqsat.ts +4 -4
- package/src/prover/smt/solver/nlsat/algebraic.ts +194 -93
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -35
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +379 -217
- package/src/prover/smt/solver/nlsat/interval-set.ts +0 -1
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -241
- package/src/prover/smt/solver/nlsat/mpbq.ts +0 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -683
- package/src/prover/smt/solver/nlsat/solver.ts +112 -99
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +2 -3
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -19
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -7
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -20
- package/src/prover/smt/solver/nlsat-tactic.ts +0 -1
- package/src/prover/smt/solver/nnf.ts +0 -1
- package/src/prover/smt/solver/normalize-bounds.ts +0 -1
- package/src/prover/smt/solver/occf.ts +0 -1
- package/src/prover/smt/solver/opt-context.ts +15 -10
- package/src/prover/smt/solver/opt-nlsat.ts +97 -77
- package/src/prover/smt/solver/opt-pareto.ts +0 -2
- package/src/prover/smt/solver/opt-preprocess.ts +0 -1
- package/src/prover/smt/solver/opt-solver.ts +22 -11
- package/src/prover/smt/solver/opt-value.ts +0 -1
- package/src/prover/smt/solver/optsmt.ts +13 -12
- package/src/prover/smt/solver/parallel-tactic.ts +0 -2
- package/src/prover/smt/solver/pattern-inference.ts +2 -3
- package/src/prover/smt/solver/pb-rewriter.ts +14 -20
- package/src/prover/smt/solver/pb2bv-tactic.ts +0 -2
- package/src/prover/smt/solver/poly-rewriter.ts +2 -3
- package/src/prover/smt/solver/probes.ts +4 -7
- package/src/prover/smt/solver/propagate-values.ts +4 -1
- package/src/prover/smt/solver/proto-model.ts +6 -7
- package/src/prover/smt/solver/pull-quant.ts +0 -1
- package/src/prover/smt/solver/purify-arith.ts +50 -16
- package/src/prover/smt/solver/qe-arith-plugin.ts +4 -7
- package/src/prover/smt/solver/qe-lite-der.ts +0 -1
- package/src/prover/smt/solver/qe-lite-fm.ts +0 -1
- package/src/prover/smt/solver/qe-lite.ts +0 -1
- package/src/prover/smt/solver/qe-mbp.ts +13 -24
- package/src/prover/smt/solver/qe.ts +48 -57
- package/src/prover/smt/solver/qel.ts +0 -1
- package/src/prover/smt/solver/qi-queue.ts +0 -1
- package/src/prover/smt/solver/qsat.ts +70 -91
- package/src/prover/smt/solver/quant-hoist.ts +0 -1
- package/src/prover/smt/solver/quant-tactics.ts +0 -1
- package/src/prover/smt/solver/quantifier-analyzer.ts +9 -10
- package/src/prover/smt/solver/quantifier-manager.ts +14 -10
- package/src/prover/smt/solver/quasi-macros.ts +9 -20
- package/src/prover/smt/solver/random-gen.ts +0 -1
- package/src/prover/smt/solver/rational.ts +17 -1
- package/src/prover/smt/solver/recfun-decl-plugin.ts +35 -21
- package/src/prover/smt/solver/recfun-rewriter.ts +1 -2
- package/src/prover/smt/solver/reduce-args.ts +0 -1
- package/src/prover/smt/solver/reduce-bv-size.ts +0 -1
- package/src/prover/smt/solver/ref-vector.ts +0 -1
- package/src/prover/smt/solver/relevancy.ts +0 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +6 -3
- package/src/prover/smt/solver/rewriter.ts +1 -2
- package/src/prover/smt/solver/rlimit.ts +13 -1
- package/src/prover/smt/solver/sat/asymm-branch.ts +59 -48
- package/src/prover/smt/solver/sat/big.ts +0 -1
- package/src/prover/smt/solver/sat/clause-use-list.ts +0 -8
- package/src/prover/smt/solver/sat/clause.ts +1 -6
- package/src/prover/smt/solver/sat/cleaner.ts +0 -2
- package/src/prover/smt/solver/sat/config.ts +4 -7
- package/src/prover/smt/solver/sat/consequences.ts +1 -2
- package/src/prover/smt/solver/sat/elim-eqs.ts +0 -2
- package/src/prover/smt/solver/sat/goal2sat.ts +1 -3
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +4 -13
- package/src/prover/smt/solver/sat/model-converter.ts +2 -18
- package/src/prover/smt/solver/sat/pb-constraint.ts +0 -3
- package/src/prover/smt/solver/sat/pb-solver.ts +50 -26
- package/src/prover/smt/solver/sat/probing.ts +22 -21
- package/src/prover/smt/solver/sat/sat-tactic.ts +2 -2
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -12
- package/src/prover/smt/solver/sat/scc.ts +0 -1
- package/src/prover/smt/solver/sat/simplifier.ts +16 -60
- package/src/prover/smt/solver/sat/solver.ts +45 -68
- package/src/prover/smt/solver/sat/var-queue.ts +0 -2
- package/src/prover/smt/solver/sat/watch-list.ts +7 -3
- package/src/prover/smt/solver/search-tree.ts +0 -1
- package/src/prover/smt/solver/seq-axioms.ts +20 -36
- package/src/prover/smt/solver/seq-decl-plugin.ts +7 -8
- package/src/prover/smt/solver/seq-derive.ts +9 -15
- package/src/prover/smt/solver/seq-eq-approx.ts +0 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +9 -10
- package/src/prover/smt/solver/seq-factory.ts +0 -1
- package/src/prover/smt/solver/seq-monadic.ts +7 -7
- package/src/prover/smt/solver/seq-range-predicate.ts +14 -3
- package/src/prover/smt/solver/seq-re-rewriter.ts +3 -12
- package/src/prover/smt/solver/seq-re-util.ts +2 -5
- package/src/prover/smt/solver/seq-regex-bisim.ts +2 -3
- package/src/prover/smt/solver/seq-regex-live.ts +6 -8
- package/src/prover/smt/solver/seq-rewriter.ts +31 -34
- package/src/prover/smt/solver/seq-skolem.ts +0 -24
- package/src/prover/smt/solver/seq-subset.ts +0 -1
- package/src/prover/smt/solver/seq-view-witness.ts +4 -6
- package/src/prover/smt/solver/smt-consequences.ts +0 -2
- package/src/prover/smt/solver/smt-kernel.ts +8 -3
- package/src/prover/smt/solver/smt-logics.ts +0 -1
- package/src/prover/smt/solver/smt-setup.ts +18 -14
- package/src/prover/smt/solver/smt2-printer.ts +0 -2
- package/src/prover/smt/solver/smtlib-parser.ts +1187 -592
- package/src/prover/smt/solver/smtlib-script.ts +957 -750
- package/src/prover/smt/solver/solve-eqs.ts +11 -19
- package/src/prover/smt/solver/solver.ts +1 -2
- package/src/prover/smt/solver/static-features.ts +0 -2
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +77 -18
- package/src/prover/smt/solver/term-enumeration.ts +0 -1
- package/src/prover/smt/solver/theory-array.ts +25 -60
- package/src/prover/smt/solver/theory-bv.ts +15 -54
- package/src/prover/smt/solver/theory-char.ts +0 -1
- package/src/prover/smt/solver/theory-datatype.ts +0 -1
- package/src/prover/smt/solver/theory-finite-set.ts +2 -2
- package/src/prover/smt/solver/theory-fpa.ts +46 -79
- package/src/prover/smt/solver/theory-lra-axioms.ts +0 -1
- package/src/prover/smt/solver/theory-lra-bounds.ts +0 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +0 -2
- package/src/prover/smt/solver/theory-lra-internalize.ts +8 -1
- package/src/prover/smt/solver/theory-lra-model.ts +0 -1
- package/src/prover/smt/solver/theory-lra-propagate.ts +0 -3
- package/src/prover/smt/solver/theory-lra-state.ts +0 -1
- package/src/prover/smt/solver/theory-lra.ts +0 -2
- package/src/prover/smt/solver/theory-pb.ts +12 -11
- package/src/prover/smt/solver/theory-polymorphism.ts +3 -4
- package/src/prover/smt/solver/theory-recfun.ts +2 -3
- package/src/prover/smt/solver/theory-seq-regex.ts +3 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +6 -8
- package/src/prover/smt/solver/theory-seq-state.ts +8 -26
- package/src/prover/smt/solver/theory-seq.ts +32 -55
- package/src/prover/smt/solver/theory.ts +16 -2
- package/src/prover/smt/solver/tseitin-cnf.ts +3 -5
- package/src/prover/smt/solver/var-subst.ts +2 -3
- package/src/prover/smt/table.ts +3 -2
- package/src/prover/zenon/decide.ts +9 -13
- package/src/prover/zenon/encode.ts +0 -2
- package/src/prover/zenon/eqrel.ts +0 -2
- package/src/prover/zenon/equality-rules.ts +24 -2
- package/src/prover/zenon/expr.ts +21 -2
- package/src/prover/zenon/index-table.ts +7 -4
- package/src/prover/zenon/isar-case.ts +1 -3
- package/src/prover/zenon/isar.ts +2 -4
- package/src/prover/zenon/llproof.ts +0 -2
- package/src/prover/zenon/mltoll.ts +0 -2
- package/src/prover/zenon/node.ts +12 -13
- package/src/prover/zenon/parse.ts +0 -2
- package/src/prover/zenon/phrase.ts +1 -3
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +2 -3
- package/src/prover/zenon/search.ts +0 -2
- package/src/prover/zenon/tla/functions.ts +0 -2
- package/src/prover/zenon/tla/llproof.ts +0 -2
- package/src/prover/zenon/tla/records.ts +0 -2
- package/src/prover/zenon/tla/rewrites.ts +0 -2
- package/src/prover/zenon/tla/sets.ts +1 -3
- package/src/prover/zenon/tla/terms.ts +0 -2
- package/src/prover/zenon/tla/tla.ts +0 -2
- package/src/resolve.ts +264 -77
- package/src/runtime.ts +6 -0
- package/src/sany/generation.ts +1 -13
- package/src/sany/generator-definitions.ts +2 -1
- package/src/sany/generator-expressions.ts +30 -27
- package/src/sany/generator-proofs.ts +1 -1
- package/src/sany/generator.ts +2 -1
- package/src/sany/levels.ts +0 -2
- package/src/sany/linter.ts +0 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +6 -5
- package/src/search.ts +198 -45
- package/src/simulate.ts +3 -0
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- package/src/subexpressions.ts +165 -78
- package/src/successors.ts +1 -1
- package/src/symmetry.ts +2 -2
- package/src/tableau.ts +2 -2
- package/src/tlc/fingerprint.ts +81 -9
- package/src/tlc/jar-data.ts +12 -0
- package/src/tlc/order.ts +14 -3
- package/src/tlc/summary.ts +29 -14
- package/src/tlc/tlcext-operators.ts +61 -16
- package/src/tlc/trace-spec.ts +2 -3
- package/src/typed-tier.ts +6541 -0
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +1 -1
- package/src/prover/smt/solver/seq-regex-witness.ts +0 -100
- package/src/prover/smt/solver/z3-license.txt +0 -10
- package/src/prover/zenon/LICENSE +0 -32
|
@@ -1,12 +1,10 @@
|
|
|
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
1
|
import { SmtParseError, SmtUnsupportedError } from "../../../errors";
|
|
4
2
|
import {
|
|
5
3
|
type AstManager,
|
|
6
4
|
getSymbolHash,
|
|
7
5
|
FAMILY_ARITH,
|
|
8
6
|
FAMILY_BASIC,
|
|
9
|
-
|
|
7
|
+
KIND_APP,
|
|
10
8
|
KIND_QUANTIFIER,
|
|
11
9
|
KIND_VAR,
|
|
12
10
|
OP_ABS,
|
|
@@ -23,6 +21,7 @@ import {
|
|
|
23
21
|
OP_DISTINCT,
|
|
24
22
|
OP_DIV,
|
|
25
23
|
OP_DT_ACCESSOR,
|
|
24
|
+
OP_DT_CONSTRUCTOR,
|
|
26
25
|
OP_EQ,
|
|
27
26
|
OP_GE,
|
|
28
27
|
OP_GT,
|
|
@@ -37,6 +36,7 @@ import {
|
|
|
37
36
|
OP_MUL,
|
|
38
37
|
OP_NOT,
|
|
39
38
|
OP_OR,
|
|
39
|
+
OP_PATTERN,
|
|
40
40
|
OP_POWER,
|
|
41
41
|
OP_POWER0,
|
|
42
42
|
OP_SIN,
|
|
@@ -62,8 +62,6 @@ import {
|
|
|
62
62
|
OP_TRUE,
|
|
63
63
|
OP_FALSE,
|
|
64
64
|
OP_UMINUS,
|
|
65
|
-
OP_UNINTERPRETED,
|
|
66
|
-
OP_FUN_DEFINED,
|
|
67
65
|
OP_XOR,
|
|
68
66
|
SORT_BOOL,
|
|
69
67
|
SORT_INT,
|
|
@@ -100,6 +98,7 @@ import {
|
|
|
100
98
|
mkFpaAppOf,
|
|
101
99
|
} from "./fpa-decl-plugin";
|
|
102
100
|
import { createLogicChecker } from "./check-logic";
|
|
101
|
+
import { shrink } from "./array";
|
|
103
102
|
import { ObjMap } from "./hashtable";
|
|
104
103
|
import {
|
|
105
104
|
CHAR_OP_NAMES,
|
|
@@ -120,6 +119,7 @@ import {
|
|
|
120
119
|
isSupportedLogic,
|
|
121
120
|
} from "./smt-logics";
|
|
122
121
|
import { setRecFunDefinition } from "./recfun-decl-plugin";
|
|
122
|
+
import { DEFAULT_PRINT_OPTIONS, printExpr } from "./smt2-printer";
|
|
123
123
|
import { replaceFreeVars, VarSubst } from "./var-subst";
|
|
124
124
|
import { UpolynomialManager } from "./nlsat/upolynomial";
|
|
125
125
|
|
|
@@ -147,25 +147,27 @@ export interface SmtList {
|
|
|
147
147
|
offset: number;
|
|
148
148
|
// Z3 reports an error in making an application at its closing parenthesis.
|
|
149
149
|
end: SmtToken;
|
|
150
|
+
// The token after a root-obj or an indexed or qualified identifier, where Z3 reports an error in
|
|
151
|
+
// making it.
|
|
150
152
|
follower?: SmtToken;
|
|
153
|
+
// The command that a list a command reader read is part of.
|
|
154
|
+
root?: SmtList;
|
|
151
155
|
}
|
|
152
156
|
|
|
153
157
|
export type SExpr = SmtToken | SmtList;
|
|
154
158
|
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
+
// smt2parser's local: a term, and the number of binders around it where it was bound.
|
|
160
|
+
interface Local {
|
|
161
|
+
expr: number;
|
|
162
|
+
level: number;
|
|
159
163
|
}
|
|
160
164
|
|
|
161
|
-
interface
|
|
162
|
-
kind: "let";
|
|
163
|
-
depth: number;
|
|
165
|
+
interface ParsedTerm {
|
|
164
166
|
expr: number;
|
|
167
|
+
isOwned: boolean;
|
|
168
|
+
root: SmtList | undefined;
|
|
165
169
|
}
|
|
166
170
|
|
|
167
|
-
type Binding = VarBinding | LetBinding;
|
|
168
|
-
|
|
169
171
|
interface Macro {
|
|
170
172
|
domain: number[];
|
|
171
173
|
range: number;
|
|
@@ -206,23 +208,109 @@ type SortDecl = ConstantSortDecl | UserSortDecl | DatatypeSortDecl | DefinedSort
|
|
|
206
208
|
|
|
207
209
|
const NO_BINDINGS: ReadonlyMap<string, number> = new Map();
|
|
208
210
|
|
|
209
|
-
const UPOLYNOMIALS = new UpolynomialManager();
|
|
210
|
-
|
|
211
211
|
interface SmtProblem {
|
|
212
212
|
assertions: number[];
|
|
213
213
|
hasCheckSat: boolean;
|
|
214
214
|
rlimit: number;
|
|
215
215
|
}
|
|
216
216
|
|
|
217
|
-
interface
|
|
217
|
+
interface QualifiedHead {
|
|
218
218
|
head: SmtToken;
|
|
219
219
|
indices: number[];
|
|
220
220
|
build?: (args: number[]) => number;
|
|
221
|
+
}
|
|
222
|
+
|
|
223
|
+
interface ApplicationFrame extends QualifiedHead {
|
|
224
|
+
kind: "application";
|
|
221
225
|
list: SmtList;
|
|
226
|
+
isTail: boolean;
|
|
222
227
|
start: number;
|
|
223
228
|
next: number;
|
|
224
229
|
}
|
|
225
230
|
|
|
231
|
+
// An application whose head is a term, which selects from the array it stands for.
|
|
232
|
+
interface SelectionFrame {
|
|
233
|
+
kind: "selection";
|
|
234
|
+
list: SmtList;
|
|
235
|
+
isTail: boolean;
|
|
236
|
+
start: number;
|
|
237
|
+
next: number;
|
|
238
|
+
}
|
|
239
|
+
|
|
240
|
+
interface LetFrame {
|
|
241
|
+
kind: "let";
|
|
242
|
+
list: SmtList;
|
|
243
|
+
bindings: SmtList;
|
|
244
|
+
names: string[];
|
|
245
|
+
isInDecls: boolean;
|
|
246
|
+
isTail: boolean;
|
|
247
|
+
start: number;
|
|
248
|
+
next: number;
|
|
249
|
+
}
|
|
250
|
+
|
|
251
|
+
interface LetDeclFrame {
|
|
252
|
+
kind: "let-decl";
|
|
253
|
+
list: SmtList;
|
|
254
|
+
next: number;
|
|
255
|
+
}
|
|
256
|
+
|
|
257
|
+
interface QuantifierFrame {
|
|
258
|
+
kind: "quantifier";
|
|
259
|
+
list: SmtList;
|
|
260
|
+
quantifierKind: number;
|
|
261
|
+
names: string[];
|
|
262
|
+
varSorts: number[];
|
|
263
|
+
weight: number;
|
|
264
|
+
qid: string;
|
|
265
|
+
skid: string | undefined;
|
|
266
|
+
isTail: boolean;
|
|
267
|
+
start: number;
|
|
268
|
+
patternStart: number;
|
|
269
|
+
noPatternStart: number;
|
|
270
|
+
next: number;
|
|
271
|
+
}
|
|
272
|
+
|
|
273
|
+
interface AttributeFrame {
|
|
274
|
+
kind: "attribute";
|
|
275
|
+
list: SmtList;
|
|
276
|
+
quantifier: QuantifierFrame | undefined;
|
|
277
|
+
lastKeyword: string;
|
|
278
|
+
isTail: boolean;
|
|
279
|
+
start: number;
|
|
280
|
+
next: number;
|
|
281
|
+
}
|
|
282
|
+
|
|
283
|
+
interface PatternFrame {
|
|
284
|
+
kind: "pattern";
|
|
285
|
+
list: SmtList;
|
|
286
|
+
start: number;
|
|
287
|
+
next: number;
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
// smt2parser.cpp's expr_frame.
|
|
291
|
+
type TermFrame =
|
|
292
|
+
| ApplicationFrame
|
|
293
|
+
| SelectionFrame
|
|
294
|
+
| LetFrame
|
|
295
|
+
| LetDeclFrame
|
|
296
|
+
| QuantifierFrame
|
|
297
|
+
| AttributeFrame
|
|
298
|
+
| PatternFrame;
|
|
299
|
+
|
|
300
|
+
const QUANTIFIER_KINDS = new Map([
|
|
301
|
+
["forall", QUANTIFIER_FORALL],
|
|
302
|
+
["exists", QUANTIFIER_EXISTS],
|
|
303
|
+
["lambda", QUANTIFIER_LAMBDA],
|
|
304
|
+
]);
|
|
305
|
+
|
|
306
|
+
const LET_MESSAGE = "invalid let declaration, symbol expected";
|
|
307
|
+
|
|
308
|
+
// The attributes that consume_attributes takes only in the body of a quantifier.
|
|
309
|
+
const QUANTIFIER_ATTRIBUTES = new Set([":weight", ":skolemid", ":qid", ":pattern", ":no-pattern"]);
|
|
310
|
+
|
|
311
|
+
const IS_PARAMETER_MESSAGE =
|
|
312
|
+
"invalid parameter to datatype function arity == 1 && num_parameters == 1 && parameters[0].is_ast() && is_func_decl(parameters[0].get_ast())";
|
|
313
|
+
|
|
226
314
|
const BUILTIN_OPS = new Map<string, number>([
|
|
227
315
|
["and", OP_AND],
|
|
228
316
|
["-", OP_SUB],
|
|
@@ -389,17 +477,19 @@ const THEORY_OPERATORS = new Set([
|
|
|
389
477
|
"transitive-closure",
|
|
390
478
|
]);
|
|
391
479
|
|
|
392
|
-
//
|
|
393
|
-
// left.
|
|
394
|
-
const
|
|
480
|
+
// func_decl_info of the builtin declarations: associative to both sides, flat, and associative to
|
|
481
|
+
// the left only. => alone is associative to the right only.
|
|
482
|
+
const ASSOCIATIVE_OPS = new Set([OP_AND, OP_OR, OP_XOR, OP_ADD, OP_MUL]);
|
|
483
|
+
const FLAT_OPS = new Set([OP_AND, OP_OR, OP_ADD, OP_MUL]);
|
|
484
|
+
const LEFT_ASSOCIATIVE_OPS = new Set([OP_SUB, OP_DIV, OP_IDIV]);
|
|
395
485
|
|
|
486
|
+
// arith_decl_plugin's use_coercion.
|
|
396
487
|
const COERCING_OPS = new Set([
|
|
397
488
|
OP_ADD,
|
|
398
489
|
OP_SUB,
|
|
399
490
|
OP_UMINUS,
|
|
400
491
|
OP_MUL,
|
|
401
492
|
OP_POWER,
|
|
402
|
-
OP_POWER0,
|
|
403
493
|
OP_LE,
|
|
404
494
|
OP_GE,
|
|
405
495
|
OP_LT,
|
|
@@ -424,30 +514,12 @@ const REAL_FUNCTION_OPS = new Set([
|
|
|
424
514
|
OP_LOG,
|
|
425
515
|
]);
|
|
426
516
|
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
[
|
|
430
|
-
[OP_ITE, [3, 3]],
|
|
431
|
-
[OP_EQ, [2, Infinity]],
|
|
432
|
-
[OP_DISTINCT, [1, Infinity]],
|
|
517
|
+
// The arity of each builtin declaration but distinct, which takes the arguments it is given.
|
|
518
|
+
const ARITIES = new Map<number, number>([
|
|
519
|
+
[OP_ITE, 3],
|
|
433
520
|
...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
|
|
434
521
|
.filter((op) => op !== OP_ATAN2)
|
|
435
|
-
.map((op): [number,
|
|
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]]),
|
|
522
|
+
.map((op): [number, number] => [op, 1]),
|
|
451
523
|
]);
|
|
452
524
|
|
|
453
525
|
const RANGES = new Map<number, number>([
|
|
@@ -483,6 +555,7 @@ const CHAINABLE_OPS = new Map<string, number>([
|
|
|
483
555
|
["<", OP_LT],
|
|
484
556
|
[">", OP_GT],
|
|
485
557
|
]);
|
|
558
|
+
const CHAINABLE_DECLS = new Set(CHAINABLE_OPS.values());
|
|
486
559
|
|
|
487
560
|
const BV_EXTENSION_NAMES = new Set([
|
|
488
561
|
"bvumul_noovfl",
|
|
@@ -544,6 +617,9 @@ interface MappedDecl {
|
|
|
544
617
|
}
|
|
545
618
|
const ARRAY_EXTENSION_LOGICS = new Set(["HORN", "ALL"]);
|
|
546
619
|
|
|
620
|
+
// arith_decl_plugin::get_sort_names gives these logics no Int.
|
|
621
|
+
const INT_FREE_LOGICS = new Set(["NRA", "QF_NRA", "QF_NTA", "QF_UFNRA"]);
|
|
622
|
+
|
|
547
623
|
const BUILTIN_NAMES = new Set([
|
|
548
624
|
"true",
|
|
549
625
|
"false",
|
|
@@ -558,6 +634,14 @@ const BUILTIN_NAMES = new Set([
|
|
|
558
634
|
...CHAR_OP_NAMES.keys(),
|
|
559
635
|
]);
|
|
560
636
|
|
|
637
|
+
const FOLLOWED_HEADS = new Set(["root-obj", "_", "as"]);
|
|
638
|
+
|
|
639
|
+
const FF_LITERAL = /^#f-?[0-9]+m[0-9]+$/;
|
|
640
|
+
const FF_LOGICS = new Set(["QF_FF", "QF_FFA", "ALL", "HO_ALL"]);
|
|
641
|
+
|
|
642
|
+
// rational::is_unsigned of a numeral token.
|
|
643
|
+
const isUnsigned = (numeral: string) => BigInt(numeral) >= 0n && BigInt(numeral) <= 0xffffffffn;
|
|
644
|
+
|
|
561
645
|
const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
|
|
562
646
|
|
|
563
647
|
const createScanner = (text: string) => {
|
|
@@ -607,6 +691,11 @@ const createScanner = (text: string) => {
|
|
|
607
691
|
{ line: state.line, column: getColumn() },
|
|
608
692
|
);
|
|
609
693
|
const current = text[state.index];
|
|
694
|
+
if (character === "|" && current === "\\")
|
|
695
|
+
throw new SmtParseError("invalid character '\\' in quoted symbol", {
|
|
696
|
+
line: state.line,
|
|
697
|
+
column: getColumn(),
|
|
698
|
+
});
|
|
610
699
|
advance();
|
|
611
700
|
// Z3's scanner starts the line before it reads past a newline in a quoted symbol or a
|
|
612
701
|
// string, so the columns of the rest of the line count one more.
|
|
@@ -695,13 +784,13 @@ export const createCommandReader = (text: string) => {
|
|
|
695
784
|
offset: open.offset,
|
|
696
785
|
end: open,
|
|
697
786
|
};
|
|
698
|
-
let
|
|
787
|
+
let followed: SmtList | undefined;
|
|
699
788
|
for (let current = root; ;) {
|
|
700
789
|
const token = take();
|
|
701
790
|
if (token === undefined)
|
|
702
791
|
throw new SmtParseError("unexpected end of file", scanner.getPosition());
|
|
703
|
-
if (
|
|
704
|
-
|
|
792
|
+
if (followed !== undefined) followed.follower = token;
|
|
793
|
+
followed = undefined;
|
|
705
794
|
if (token.kind === "(") {
|
|
706
795
|
const list: SmtList = {
|
|
707
796
|
kind: "list",
|
|
@@ -710,6 +799,7 @@ export const createCommandReader = (text: string) => {
|
|
|
710
799
|
column: token.column,
|
|
711
800
|
offset: token.offset,
|
|
712
801
|
end: token,
|
|
802
|
+
root,
|
|
713
803
|
};
|
|
714
804
|
current.items.push(list);
|
|
715
805
|
stack.push(current);
|
|
@@ -722,7 +812,8 @@ export const createCommandReader = (text: string) => {
|
|
|
722
812
|
continue;
|
|
723
813
|
}
|
|
724
814
|
current.end = token;
|
|
725
|
-
if (isSymbol(current.items[0]
|
|
815
|
+
if (isSymbol(current.items[0]) && FOLLOWED_HEADS.has(current.items[0].text))
|
|
816
|
+
followed = current;
|
|
726
817
|
state.depth--;
|
|
727
818
|
const parent = stack.pop();
|
|
728
819
|
if (parent === undefined) return root;
|
|
@@ -759,6 +850,28 @@ export const createCommandReader = (text: string) => {
|
|
|
759
850
|
export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
|
|
760
851
|
sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
|
|
761
852
|
|
|
853
|
+
// The identifier Z3's scanner read last, which check_next prints after "got".
|
|
854
|
+
const getLastId = (sexpr: SExpr | undefined): string | undefined => {
|
|
855
|
+
if (sexpr === undefined) return undefined;
|
|
856
|
+
if (sexpr.kind !== "list")
|
|
857
|
+
return sexpr.kind === "symbol" || sexpr.kind === "keyword" ? sexpr.text : undefined;
|
|
858
|
+
return getLastIdBefore(sexpr.items, sexpr.items.length);
|
|
859
|
+
};
|
|
860
|
+
|
|
861
|
+
const getLastIdBefore = (items: SExpr[], end: number): string | undefined => {
|
|
862
|
+
for (let index = end - 1; index >= 0; index--) {
|
|
863
|
+
const id = getLastId(items[index]);
|
|
864
|
+
if (id !== undefined) return id;
|
|
865
|
+
}
|
|
866
|
+
return undefined;
|
|
867
|
+
};
|
|
868
|
+
|
|
869
|
+
const isSimpleIndex = (index: SExpr) =>
|
|
870
|
+
index.kind === "numeral" ||
|
|
871
|
+
index.kind === "bitvector" ||
|
|
872
|
+
index.kind === "decimal" ||
|
|
873
|
+
index.kind === "keyword";
|
|
874
|
+
|
|
762
875
|
const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtList => {
|
|
763
876
|
if (sexpr?.kind !== "list") throw new SmtParseError(message, sexpr ?? at);
|
|
764
877
|
return sexpr;
|
|
@@ -776,16 +889,13 @@ export const createSmtlibReader = (
|
|
|
776
889
|
) => {
|
|
777
890
|
const hasArith = logic === undefined || logicHasArith(logic);
|
|
778
891
|
const hasBv = logic === undefined || logicHasBv(logic);
|
|
779
|
-
const isNumeralAsReal = logic !== undefined && logicHasRealsOnly(logic);
|
|
780
892
|
const logicChecker = createLogicChecker(manager, logic);
|
|
781
893
|
const sortDecls = new Map<string, SortDecl>([
|
|
782
894
|
["Bool", { kind: "sort", sort: SORT_BOOL }],
|
|
783
|
-
...(hasArith
|
|
784
|
-
? [
|
|
785
|
-
["Int", { kind: "sort", sort: SORT_INT }] as const,
|
|
786
|
-
["Real", { kind: "sort", sort: SORT_REAL }] as const,
|
|
787
|
-
]
|
|
895
|
+
...(hasArith && !(logic !== undefined && INT_FREE_LOGICS.has(logic))
|
|
896
|
+
? [["Int", { kind: "sort", sort: SORT_INT }] as const]
|
|
788
897
|
: []),
|
|
898
|
+
...(hasArith ? [["Real", { kind: "sort", sort: SORT_REAL }] as const] : []),
|
|
789
899
|
...(logic === undefined ? [["List", { kind: "list" }] as const] : []),
|
|
790
900
|
]);
|
|
791
901
|
const funcs = new Map<string, readonly number[]>();
|
|
@@ -794,8 +904,25 @@ export const createSmtlibReader = (
|
|
|
794
904
|
const notifiedSorts = new Set<number>();
|
|
795
905
|
const undo: (() => void)[] = [];
|
|
796
906
|
const scopeStarts: number[] = [];
|
|
797
|
-
|
|
907
|
+
// smt2parser's m_env, a scoped symbol table: one map, and the trail of what each scope shadowed.
|
|
908
|
+
const locals = new Map<string, Local>();
|
|
909
|
+
const shadowedNames: string[] = [];
|
|
910
|
+
const shadowedLocals: (Local | undefined)[] = [];
|
|
911
|
+
const localScopes: number[] = [];
|
|
798
912
|
const binders = { depth: 0 };
|
|
913
|
+
// smt2parser's expr_stack, pattern_stack and nopattern_stack, which hold a reference to each term.
|
|
914
|
+
// -1 on the first stands for a pattern that Z3 ignores.
|
|
915
|
+
const exprStack: number[] = [];
|
|
916
|
+
const patternStack: number[] = [];
|
|
917
|
+
const noPatternStack: number[] = [];
|
|
918
|
+
// The term that parseTerm returns leaves the stack before its caller takes a reference. One that
|
|
919
|
+
// only the stack held keeps a reference in pending until a term of another command is parsed, and
|
|
920
|
+
// one that nothing held, in floating or, where its command is not known, in unrooted, gets one
|
|
921
|
+
// there when another term is parsed while its caller may still read it.
|
|
922
|
+
const parsed: ParsedTerm = { expr: -1, isOwned: false, root: undefined };
|
|
923
|
+
const floating: number[] = [];
|
|
924
|
+
const unrooted: number[] = [];
|
|
925
|
+
const pending: number[] = [];
|
|
799
926
|
|
|
800
927
|
const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
|
|
801
928
|
const previous = names.get(name);
|
|
@@ -810,9 +937,20 @@ export const createSmtlibReader = (
|
|
|
810
937
|
const hasFpa = logic === undefined || logicHasFpa(logic);
|
|
811
938
|
const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
|
|
812
939
|
const hasSeq = logic === undefined || logicHasSeq(logic);
|
|
940
|
+
const restricted = {
|
|
941
|
+
isNumeralAsReal: logic !== undefined && logicHasRealsOnly(logic),
|
|
942
|
+
hasSetSort: hasArrayExtensions,
|
|
943
|
+
hasFf: logic === undefined || FF_LOGICS.has(logic),
|
|
944
|
+
};
|
|
813
945
|
|
|
814
946
|
const getFirstFunc = (name: string) => funcs.get(name)?.[0];
|
|
815
947
|
|
|
948
|
+
// func_decls::signatures_collide: the domain, and the range unless it is -1.
|
|
949
|
+
const hasSignature = (decl: number, domain: readonly number[], range: number) =>
|
|
950
|
+
(range === -1 || manager.funcDecls[decl].range === range) &&
|
|
951
|
+
manager.funcDecls[decl].domain.length === domain.length &&
|
|
952
|
+
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]);
|
|
953
|
+
|
|
816
954
|
const checkDecl = (decl: number, at: SExpr) => {
|
|
817
955
|
const error = logicChecker.checkDecl(decl);
|
|
818
956
|
if (error !== undefined) throw new SmtParseError(error, at);
|
|
@@ -938,7 +1076,8 @@ export const createSmtlibReader = (
|
|
|
938
1076
|
): number => {
|
|
939
1077
|
const head = sexpr.items[0];
|
|
940
1078
|
if (!isSymbol(head)) throw new SmtParseError("invalid sort, symbol or '_' expected", head);
|
|
941
|
-
const isArray =
|
|
1079
|
+
const isArray =
|
|
1080
|
+
ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && restricted.hasSetSort);
|
|
942
1081
|
if (isArray && hasArrays) {
|
|
943
1082
|
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
944
1083
|
if (head.text === "Set" ? parameters.length !== 1 : parameters.length < 2)
|
|
@@ -970,7 +1109,7 @@ export const createSmtlibReader = (
|
|
|
970
1109
|
return parseSort(head, context, bindings);
|
|
971
1110
|
}
|
|
972
1111
|
if (decl === undefined) {
|
|
973
|
-
if (THEORY_SORTS.has(head.text) && !
|
|
1112
|
+
if (THEORY_SORTS.has(head.text) && !isLackingSort(head.text))
|
|
974
1113
|
throw new SmtUnsupportedError(`the sort ${head.text}`);
|
|
975
1114
|
throw new SmtParseError(`unknown sort '${head.text}'`, head);
|
|
976
1115
|
}
|
|
@@ -997,8 +1136,20 @@ export const createSmtlibReader = (
|
|
|
997
1136
|
for (const item of (sexpr as SmtList).items.slice(1)) checkPsort(item, bindings);
|
|
998
1137
|
};
|
|
999
1138
|
|
|
1139
|
+
// Z3 does not know the sorts of a theory that the logic lacks.
|
|
1140
|
+
const isLackingSort = (name: string) =>
|
|
1141
|
+
name === "Set"
|
|
1142
|
+
? !hasArrays || !restricted.hasSetSort
|
|
1143
|
+
: ARRAY_SORT_NAMES.has(name)
|
|
1144
|
+
? !hasArrays
|
|
1145
|
+
: name === "BitVec"
|
|
1146
|
+
? !hasBv
|
|
1147
|
+
: SEQ_SORT_NAMES.has(name) || name === "Unicode"
|
|
1148
|
+
? !hasSeq
|
|
1149
|
+
: FPA_SORT_NAMES.has(name) && !hasFpa;
|
|
1150
|
+
|
|
1000
1151
|
const isBuiltinParametricSort = (name: string) =>
|
|
1001
|
-
(hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" &&
|
|
1152
|
+
(hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && restricted.hasSetSort))) ||
|
|
1002
1153
|
(hasSeq && (name === "Seq" || name === "RegEx")) ||
|
|
1003
1154
|
(hasFpa && FPA_SORT_NAMES.has(name));
|
|
1004
1155
|
|
|
@@ -1022,19 +1173,31 @@ export const createSmtlibReader = (
|
|
|
1022
1173
|
context: string,
|
|
1023
1174
|
bindings: ReadonlyMap<string, number> = NO_BINDINGS,
|
|
1024
1175
|
): number => {
|
|
1176
|
+
if (sexpr.kind === ")")
|
|
1177
|
+
throw new SmtParseError(`${context} invalid sort, unexpected ')'`, sexpr);
|
|
1025
1178
|
if (sexpr.kind === "list") {
|
|
1026
1179
|
if (!isSymbol(sexpr.items[0], "_")) return parseParametricSort(sexpr, context, bindings);
|
|
1027
|
-
|
|
1028
|
-
|
|
1029
|
-
|
|
1030
|
-
|
|
1031
|
-
|
|
1032
|
-
|
|
1033
|
-
|
|
1034
|
-
|
|
1035
|
-
|
|
1036
|
-
)
|
|
1037
|
-
|
|
1180
|
+
// parse_indexed_sort.
|
|
1181
|
+
const name = sexpr.items[1];
|
|
1182
|
+
if (!isSymbol(name))
|
|
1183
|
+
throw new SmtParseError("invalid indexed sort, symbol expected", name ?? sexpr.end);
|
|
1184
|
+
if (hasFpa && name.text === "FloatingPoint") return mkFloatSort(sexpr.items.slice(2), sexpr);
|
|
1185
|
+
const indices = sexpr.items.slice(2);
|
|
1186
|
+
if (isLackingSort(name.text) || !(THEORY_SORTS.has(name.text) || sortDecls.has(name.text)))
|
|
1187
|
+
throw new SmtParseError(`unknown sort '${name.text}'`, indices[0] ?? sexpr.end);
|
|
1188
|
+
if (name.text !== "BitVec") throw new SmtUnsupportedError("indexed sorts");
|
|
1189
|
+
for (const index of indices) {
|
|
1190
|
+
if (index.kind !== "numeral")
|
|
1191
|
+
throw new SmtParseError("invalid indexed sort, integer or ')' expected", index);
|
|
1192
|
+
if (!isUnsigned(index.text))
|
|
1193
|
+
throw new SmtParseError(
|
|
1194
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
1195
|
+
index,
|
|
1196
|
+
);
|
|
1197
|
+
}
|
|
1198
|
+
const width = indices[0];
|
|
1199
|
+
if (indices.length !== 1 || width.kind !== "numeral")
|
|
1200
|
+
throw new SmtParseError("expecting one integer parameter to bit-vector sort", sexpr.end);
|
|
1038
1201
|
if (BigInt(width.text) === 0n)
|
|
1039
1202
|
throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
|
|
1040
1203
|
return manager.mkBvSort(Number(width.text));
|
|
@@ -1063,106 +1226,222 @@ export const createSmtlibReader = (
|
|
|
1063
1226
|
const bits = FPA_SORT_NAMES.get(sexpr.text);
|
|
1064
1227
|
return bits === undefined ? mkFloatSort([], sexpr) : manager.mkFpSort(bits[0], bits[1]);
|
|
1065
1228
|
}
|
|
1066
|
-
if (THEORY_SORTS.has(sexpr.text)
|
|
1229
|
+
if (THEORY_SORTS.has(sexpr.text) && !isLackingSort(sexpr.text))
|
|
1230
|
+
throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
|
|
1067
1231
|
throw new SmtParseError(
|
|
1068
1232
|
`${context === "" ? "" : `${context}: `}unknown sort '${sexpr.text}'`,
|
|
1069
1233
|
sexpr,
|
|
1070
1234
|
);
|
|
1071
1235
|
};
|
|
1072
1236
|
|
|
1073
|
-
const
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1237
|
+
const beginScope = () => localScopes.push(shadowedNames.length);
|
|
1238
|
+
|
|
1239
|
+
const insertLocal = (name: string, expr: number) => {
|
|
1240
|
+
shadowedNames.push(name);
|
|
1241
|
+
shadowedLocals.push(locals.get(name));
|
|
1242
|
+
locals.set(name, { expr, level: binders.depth });
|
|
1243
|
+
};
|
|
1244
|
+
|
|
1245
|
+
const endScope = () => {
|
|
1246
|
+
const start = localScopes.pop() ?? 0;
|
|
1247
|
+
for (let index = shadowedNames.length - 1; index >= start; index--) {
|
|
1248
|
+
const shadowed = shadowedLocals[index];
|
|
1249
|
+
if (shadowed === undefined) locals.delete(shadowedNames[index]);
|
|
1250
|
+
else locals.set(shadowedNames[index], shadowed);
|
|
1077
1251
|
}
|
|
1078
|
-
|
|
1252
|
+
shrink(shadowedNames, start);
|
|
1253
|
+
shrink(shadowedLocals, start);
|
|
1079
1254
|
};
|
|
1080
1255
|
|
|
1081
|
-
const
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
1256
|
+
const pushRef = (stack: number[], expr: number) => {
|
|
1257
|
+
if (expr !== -1) manager.incRef(expr);
|
|
1258
|
+
stack.push(expr);
|
|
1085
1259
|
};
|
|
1086
1260
|
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
|
|
1261
|
+
// ref_vector::shrink, which releases from the new end on.
|
|
1262
|
+
const shrinkRefs = (stack: number[], size: number) => {
|
|
1263
|
+
for (let index = size; index < stack.length; index++)
|
|
1264
|
+
if (stack[index] !== -1) manager.decRef(stack[index]);
|
|
1265
|
+
shrink(stack, size);
|
|
1266
|
+
};
|
|
1267
|
+
|
|
1268
|
+
const releasePending = () => {
|
|
1269
|
+
for (const expr of pending) manager.decRef(expr);
|
|
1270
|
+
shrink(pending, 0);
|
|
1271
|
+
};
|
|
1272
|
+
|
|
1273
|
+
const protect = (exprs: number[]) => {
|
|
1274
|
+
for (const expr of exprs)
|
|
1275
|
+
if (manager.ids[expr] !== -1 && manager.getRefCount(expr) === 0) pushRef(pending, expr);
|
|
1276
|
+
shrink(exprs, 0);
|
|
1277
|
+
};
|
|
1278
|
+
|
|
1279
|
+
// push_local: var_shifter moves the free variables of a term that was bound under fewer binders.
|
|
1280
|
+
// Its cache holds the terms it makes, which replaceFreeVars rebuilds.
|
|
1281
|
+
const getLocalTerm = (local: Local) => {
|
|
1282
|
+
if (local.level === binders.depth) return local.expr;
|
|
1283
|
+
if (manager.kinds[local.expr] === KIND_VAR)
|
|
1284
|
+
return manager.mkVar(
|
|
1285
|
+
manager.values[local.expr] + binders.depth - local.level,
|
|
1286
|
+
manager.sorts[local.expr],
|
|
1287
|
+
);
|
|
1288
|
+
return replaceFreeVars(manager, local.expr, (variable, index, shift) =>
|
|
1289
|
+
manager.mkVar(index + shift + binders.depth - local.level, manager.sorts[variable]),
|
|
1290
|
+
);
|
|
1291
|
+
};
|
|
1292
|
+
|
|
1293
|
+
// basic_decl_plugin::join.
|
|
1294
|
+
const getJoin = (left: number, right: number, at: SExpr) => {
|
|
1295
|
+
if (left === right) return left;
|
|
1296
|
+
if (isArithSort(left) && isArithSort(right)) return left === SORT_REAL ? left : right;
|
|
1297
|
+
if (left === SORT_BOOL && isArithSort(right)) return right;
|
|
1298
|
+
if (right === SORT_BOOL && isArithSort(left)) return left;
|
|
1299
|
+
throw new SmtParseError(
|
|
1300
|
+
`Sorts ${manager.getSortName(left)} and ${manager.getSortName(right)} are incompatible`,
|
|
1301
|
+
at,
|
|
1302
|
+
);
|
|
1303
|
+
};
|
|
1304
|
+
|
|
1305
|
+
const getJoinOfArgs = (args: number[], at: SExpr) =>
|
|
1306
|
+
args.reduce((join, arg) => getJoin(join, manager.sorts[arg], at), manager.sorts[args[0]]);
|
|
1307
|
+
|
|
1308
|
+
// basic_decl_plugin::mk_func_decl and arith_decl_plugin::mk_func_decl: the sort of the arguments
|
|
1309
|
+
// that the declaration takes, the condition of ite aside, or -1 where the plugin makes none.
|
|
1310
|
+
const getDomainSort = (op: number, args: number[], at: SExpr) => {
|
|
1311
|
+
if (op === OP_ITE)
|
|
1312
|
+
return args.length === 3 ? getJoin(manager.sorts[args[1]], manager.sorts[args[2]], at) : -1;
|
|
1313
|
+
if (op === OP_EQ) return args.length >= 2 ? getJoinOfArgs(args, at) : -1;
|
|
1314
|
+
if (op === OP_DISTINCT) return args.length === 0 ? SORT_BOOL : getJoinOfArgs(args, at);
|
|
1315
|
+
if (manager.funcDecls[op].family === FAMILY_BASIC) return SORT_BOOL;
|
|
1316
|
+
if (COERCING_OPS.has(op))
|
|
1317
|
+
return args.some((arg) => manager.sorts[arg] === SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
1093
1318
|
if (op === OP_DIV || op === OP_IS_INT || REAL_FUNCTION_OPS.has(op)) return SORT_REAL;
|
|
1094
|
-
return
|
|
1319
|
+
if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
|
|
1320
|
+
return manager.sorts[args[0]] === SORT_REAL ? SORT_REAL : SORT_INT;
|
|
1095
1321
|
};
|
|
1096
1322
|
|
|
1323
|
+
// ast_manager::coerce_to.
|
|
1097
1324
|
const coerce = (arg: number, sort: number) => {
|
|
1098
1325
|
const argSort = manager.sorts[arg];
|
|
1099
|
-
if (argSort === sort || !isArithSort(
|
|
1100
|
-
|
|
1101
|
-
|
|
1102
|
-
|
|
1103
|
-
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
|
|
1107
|
-
|
|
1108
|
-
|
|
1109
|
-
|
|
1110
|
-
|
|
1111
|
-
|
|
1112
|
-
|
|
1113
|
-
|
|
1114
|
-
|
|
1115
|
-
|
|
1116
|
-
|
|
1117
|
-
|
|
1326
|
+
if (argSort === sort || !isArithSort(sort)) return arg;
|
|
1327
|
+
if (isArithSort(argSort))
|
|
1328
|
+
return sort === SORT_REAL
|
|
1329
|
+
? manager.mkApp(OP_TO_REAL, [arg], SORT_REAL)
|
|
1330
|
+
: manager.mkApp(OP_TO_INT, [arg], SORT_INT);
|
|
1331
|
+
if (argSort !== SORT_BOOL) return arg;
|
|
1332
|
+
const one = manager.mkNumeralOfSort(Rational.of(1n), sort);
|
|
1333
|
+
return manager.mkApp(OP_ITE, [arg, one, manager.mkNumeralOfSort(Rational.of(0n), sort)], sort);
|
|
1334
|
+
};
|
|
1335
|
+
|
|
1336
|
+
// A declaration of the script has its own domain, and a builtin one takes domainSort.
|
|
1337
|
+
const getArity = (decl: number, numArgs: number, domainSort: number) =>
|
|
1338
|
+
domainSort === -1
|
|
1339
|
+
? manager.funcDecls[decl].domain.length
|
|
1340
|
+
: decl === OP_DISTINCT
|
|
1341
|
+
? numArgs
|
|
1342
|
+
: (ARITIES.get(decl) ?? 2);
|
|
1343
|
+
|
|
1344
|
+
const getExpectedSort = (decl: number, index: number, domainSort: number) =>
|
|
1345
|
+
domainSort === -1
|
|
1346
|
+
? manager.funcDecls[decl].domain[index]
|
|
1347
|
+
: decl === OP_ITE && index === 0
|
|
1348
|
+
? SORT_BOOL
|
|
1349
|
+
: domainSort;
|
|
1350
|
+
|
|
1351
|
+
const formatDecl = (decl: number, numArgs: number, domainSort: number) => {
|
|
1352
|
+
const domain = Array.from({ length: getArity(decl, numArgs, domainSort) }, (_unused, index) =>
|
|
1353
|
+
manager.getSortName(getExpectedSort(decl, index, domainSort)),
|
|
1118
1354
|
);
|
|
1119
|
-
const
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
|
|
1127
|
-
|
|
1128
|
-
|
|
1355
|
+
const range =
|
|
1356
|
+
domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort);
|
|
1357
|
+
return `(declare-fun ${String(manager.funcDecls[decl].name)} (${domain.join(" ")}) ${manager.getSortName(range)})`;
|
|
1358
|
+
};
|
|
1359
|
+
|
|
1360
|
+
// ast_manager::mk_app_core: coercion_needed, coerce_to and check_args.
|
|
1361
|
+
const mkAppCore = (decl: number, args: number[], at: SExpr, domainSort: number) => {
|
|
1362
|
+
const isAssociative = domainSort !== -1 && ASSOCIATIVE_OPS.has(decl);
|
|
1363
|
+
const isCoercing =
|
|
1364
|
+
(isAssociative || getArity(decl, args.length, domainSort) === args.length) &&
|
|
1365
|
+
args.some((arg, index) => {
|
|
1366
|
+
const expected = getExpectedSort(decl, index, domainSort);
|
|
1367
|
+
return isArithSort(expected) && expected !== manager.sorts[arg];
|
|
1368
|
+
});
|
|
1369
|
+
const coerced = isCoercing
|
|
1370
|
+
? args.map((arg, index) => coerce(arg, getExpectedSort(decl, index, domainSort)))
|
|
1371
|
+
: args;
|
|
1372
|
+
for (let index = 0; index < coerced.length; index++) {
|
|
1373
|
+
const sort = manager.sorts[coerced[index]];
|
|
1374
|
+
if (sort !== getExpectedSort(decl, index, domainSort))
|
|
1375
|
+
throw new SmtParseError(
|
|
1376
|
+
`Sort mismatch at argument #${index + 1} for function ${formatDecl(decl, args.length, domainSort)} supplied sort is ${manager.getSortName(sort)}`,
|
|
1377
|
+
at,
|
|
1378
|
+
);
|
|
1379
|
+
}
|
|
1380
|
+
// Z3 keeps xor, / and div of fewer than two arguments until its rewriters make false or the
|
|
1381
|
+
// argument of them, which those of this port do not.
|
|
1382
|
+
if (
|
|
1383
|
+
coerced.length < 2 &&
|
|
1384
|
+
domainSort !== -1 &&
|
|
1385
|
+
(decl === OP_XOR || LEFT_ASSOCIATIVE_OPS.has(decl))
|
|
1386
|
+
)
|
|
1387
|
+
return coerced[0] ?? manager.falseExpr;
|
|
1129
1388
|
return manager.mkApp(
|
|
1130
1389
|
decl,
|
|
1131
|
-
|
|
1132
|
-
|
|
1390
|
+
coerced,
|
|
1391
|
+
domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort),
|
|
1133
1392
|
);
|
|
1134
1393
|
};
|
|
1135
1394
|
|
|
1136
|
-
|
|
1137
|
-
|
|
1395
|
+
// ast_manager::mk_app.
|
|
1396
|
+
const mkApp = (decl: number, args: number[], at: SExpr, domainSort = -1): number => {
|
|
1397
|
+
const isBuiltin = domainSort !== -1;
|
|
1398
|
+
const isAssociative = isBuiltin && ASSOCIATIVE_OPS.has(decl);
|
|
1399
|
+
const isLeftAssociative = isAssociative || (isBuiltin && LEFT_ASSOCIATIVE_OPS.has(decl));
|
|
1400
|
+
const isRightAssociative = isAssociative || (isBuiltin && decl === OP_IMPLIES);
|
|
1401
|
+
const isChainable = isBuiltin && CHAINABLE_DECLS.has(decl);
|
|
1402
|
+
if (
|
|
1403
|
+
getArity(decl, args.length, domainSort) !== args.length &&
|
|
1404
|
+
((!isLeftAssociative && !isRightAssociative && !isChainable) ||
|
|
1405
|
+
(args.length < 2 && manager.funcDecls[decl].family === FAMILY_BASIC && !isAssociative))
|
|
1406
|
+
) {
|
|
1407
|
+
const environment = { options: DEFAULT_PRINT_OPTIONS, isUsed, isClashing };
|
|
1408
|
+
// Z3 prints an error without the newlines that end it.
|
|
1409
|
+
throw new SmtParseError(
|
|
1410
|
+
`Wrong number of arguments (${args.length}) passed to function ${formatDecl(decl, args.length, domainSort)} ${args
|
|
1411
|
+
.map((arg) => `\narg: ${printExpr(manager, environment, arg)}\n`)
|
|
1412
|
+
.join("")}`.replace(/\n+$/, ""),
|
|
1413
|
+
at,
|
|
1414
|
+
);
|
|
1415
|
+
}
|
|
1416
|
+
if (args.length === 1 && isChainable) return manager.trueExpr;
|
|
1417
|
+
if (args.length <= 2 || (isBuiltin && FLAT_OPS.has(decl)))
|
|
1418
|
+
return mkAppCore(decl, args, at, domainSort);
|
|
1419
|
+
if (isRightAssociative)
|
|
1420
|
+
return args
|
|
1421
|
+
.slice(0, -2)
|
|
1422
|
+
.reduceRight(
|
|
1423
|
+
(right, left) => mkAppCore(decl, [left, right], at, domainSort),
|
|
1424
|
+
mkAppCore(decl, args.slice(-2), at, domainSort),
|
|
1425
|
+
);
|
|
1426
|
+
if (isLeftAssociative)
|
|
1427
|
+
return args
|
|
1428
|
+
.slice(2)
|
|
1429
|
+
.reduce(
|
|
1430
|
+
(left, right) => mkAppCore(decl, [left, right], at, domainSort),
|
|
1431
|
+
mkAppCore(decl, args.slice(0, 2), at, domainSort),
|
|
1432
|
+
);
|
|
1433
|
+
if (!isChainable) return mkAppCore(decl, args, at, domainSort);
|
|
1138
1434
|
const pairs: number[] = [];
|
|
1139
|
-
for (let index =
|
|
1140
|
-
pairs.push(
|
|
1141
|
-
return
|
|
1142
|
-
};
|
|
1143
|
-
|
|
1144
|
-
const rejectPattern = (message: string, at: SExpr) => {
|
|
1145
|
-
if (!options.isIgnoringBadPatterns) throw new SmtParseError(message, at);
|
|
1146
|
-
return undefined;
|
|
1435
|
+
for (let index = 1; index < args.length; index++)
|
|
1436
|
+
pairs.push(mkAppCore(decl, [args[index - 1], args[index]], at, domainSort));
|
|
1437
|
+
return mkApp(OP_AND, pairs, at, SORT_BOOL);
|
|
1147
1438
|
};
|
|
1148
1439
|
|
|
1149
|
-
|
|
1150
|
-
|
|
1151
|
-
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
throw new SmtParseError("invalid pattern, '(' expected", sexpr);
|
|
1155
|
-
}
|
|
1156
|
-
if (sexpr.kind !== "list") return rejectPattern("invalid pattern, '(' expected", sexpr);
|
|
1157
|
-
if (sexpr.items.length === 0) return rejectPattern("invalid empty pattern", at);
|
|
1158
|
-
const head = sexpr.items[0];
|
|
1159
|
-
if (head.kind === "list") return manager.mkPattern(sexpr.items.map(parseTerm));
|
|
1160
|
-
const decl = head.text === "true" || head.text === "false" ? -1 : getFirstFunc(head.text);
|
|
1161
|
-
if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
|
|
1162
|
-
return rejectPattern("invalid constant pattern", head);
|
|
1163
|
-
if (head.kind !== "symbol")
|
|
1164
|
-
throw new SmtParseError("invalid pattern, '(' or identifier expected", head);
|
|
1165
|
-
return manager.mkPattern([parseTerm(sexpr)]);
|
|
1440
|
+
// ast_manager::mk_pattern.
|
|
1441
|
+
const mkPattern = (terms: number[], at: SExpr) => {
|
|
1442
|
+
if (terms.some((term) => manager.kinds[term] !== KIND_APP))
|
|
1443
|
+
throw new SmtParseError("patterns cannot be variables or quantifiers", at);
|
|
1444
|
+
return manager.mkPattern(terms);
|
|
1166
1445
|
};
|
|
1167
1446
|
|
|
1168
1447
|
const isValidPattern = (pattern: number, numDecls: number) => {
|
|
@@ -1187,151 +1466,90 @@ export const createSmtlibReader = (
|
|
|
1187
1466
|
return manager.everyArg(pattern, isValid) && found.size === numDecls;
|
|
1188
1467
|
};
|
|
1189
1468
|
|
|
1190
|
-
|
|
1191
|
-
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
const varSorts =
|
|
1200
|
-
|
|
1201
|
-
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
1205
|
-
|
|
1469
|
+
// parse_sorted_vars: the variables are created the first declared with the largest index, and
|
|
1470
|
+
// the stack holds them. previousId is the identifier before the list.
|
|
1471
|
+
const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr, previousId: string) => {
|
|
1472
|
+
if (sexpr?.kind !== "list")
|
|
1473
|
+
throw new SmtParseError(
|
|
1474
|
+
`invalid list of sorted variables, '(' expected got ${getLastId(sexpr) ?? previousId}`,
|
|
1475
|
+
sexpr ?? at,
|
|
1476
|
+
);
|
|
1477
|
+
const names: string[] = [];
|
|
1478
|
+
const varSorts: number[] = [];
|
|
1479
|
+
for (const [index, declaration] of sexpr.items.entries()) {
|
|
1480
|
+
if (declaration.kind !== "list")
|
|
1481
|
+
throw new SmtParseError(
|
|
1482
|
+
`invalid sorted variable, '(' expected got ${getLastId(declaration) ?? getLastIdBefore(sexpr.items, index) ?? previousId}`,
|
|
1483
|
+
declaration,
|
|
1484
|
+
);
|
|
1485
|
+
const name = declaration.items[0];
|
|
1486
|
+
if (!isSymbol(name))
|
|
1487
|
+
throw new SmtParseError(
|
|
1488
|
+
"invalid sorted variable, symbol expected",
|
|
1489
|
+
name ?? declaration.end,
|
|
1490
|
+
);
|
|
1491
|
+
names.push(name.text);
|
|
1492
|
+
varSorts.push(parseSort(declaration.items[1] ?? declaration.end, "invalid sorted variables"));
|
|
1493
|
+
const extra = declaration.items[2];
|
|
1494
|
+
if (extra !== undefined)
|
|
1495
|
+
throw new SmtParseError(
|
|
1496
|
+
`invalid sorted variable, ')' expected got ${getLastId(extra) ?? getLastId(declaration.items[1]) ?? name.text}`,
|
|
1497
|
+
extra,
|
|
1498
|
+
);
|
|
1499
|
+
}
|
|
1500
|
+
beginScope();
|
|
1206
1501
|
binders.depth += varSorts.length;
|
|
1502
|
+
for (const [index, sort] of varSorts.entries()) {
|
|
1503
|
+
const boundVar = manager.mkVar(varSorts.length - 1 - index, sort);
|
|
1504
|
+
pushRef(exprStack, boundVar);
|
|
1505
|
+
insertLocal(names[index], boundVar);
|
|
1506
|
+
}
|
|
1207
1507
|
return { names, varSorts };
|
|
1208
1508
|
};
|
|
1209
1509
|
|
|
1210
1510
|
const unbindSortedVars = (count: number) => {
|
|
1211
|
-
|
|
1511
|
+
endScope();
|
|
1212
1512
|
binders.depth -= count;
|
|
1213
1513
|
};
|
|
1214
1514
|
|
|
1215
|
-
|
|
1216
|
-
|
|
1515
|
+
// pop_quant_frame, up to the quantifier.
|
|
1516
|
+
const mkParsedQuantifier = (frame: QuantifierFrame) => {
|
|
1517
|
+
const list = frame.list;
|
|
1518
|
+
const numDecls = frame.varSorts.length;
|
|
1519
|
+
if (exprStack.length - frame.start !== numDecls + 1)
|
|
1217
1520
|
throw new SmtParseError(
|
|
1218
1521
|
"invalid quantified expression, syntax error: (forall|exists ((<symbol> <sort>)*) <expr>) expected",
|
|
1219
1522
|
list.end,
|
|
1220
1523
|
);
|
|
1221
|
-
|
|
1222
|
-
|
|
1223
|
-
|
|
1224
|
-
|
|
1225
|
-
|
|
1226
|
-
manager.mkVar(varSorts.length - 1 - index, sort),
|
|
1227
|
-
);
|
|
1228
|
-
for (const boundVar of boundVars) manager.incRef(boundVar);
|
|
1229
|
-
const bodySExpr = list.items[2];
|
|
1230
|
-
const isAnnotated = bodySExpr.kind === "list" && isSymbol(bodySExpr.items[0], "!");
|
|
1231
|
-
const annotations = bodySExpr.kind === "list" && isAnnotated ? bodySExpr.items : [];
|
|
1232
|
-
const parsedBody = parseTerm(isAnnotated ? annotations[1] : bodySExpr);
|
|
1233
|
-
if (kind !== QUANTIFIER_LAMBDA && manager.sorts[parsedBody] !== SORT_BOOL)
|
|
1234
|
-
throw new SmtParseError("expected a formula", bodySExpr);
|
|
1235
|
-
const attributes = Array.from(
|
|
1236
|
-
{ length: Math.ceil((annotations.length - 2) / 2) },
|
|
1237
|
-
(_unused, index) => ({
|
|
1238
|
-
keyword: annotations[2 + 2 * index],
|
|
1239
|
-
value: annotations[3 + 2 * index],
|
|
1240
|
-
}),
|
|
1241
|
-
);
|
|
1242
|
-
const body = attributes.reduce(
|
|
1243
|
-
(labeled, attribute) =>
|
|
1244
|
-
attribute.keyword.kind === "keyword" &&
|
|
1245
|
-
(attribute.keyword.text === ":lblpos" || attribute.keyword.text === ":lblneg")
|
|
1246
|
-
? mkLabel(labeled, attribute.keyword.text === ":lblpos", attribute.value, bodySExpr)
|
|
1247
|
-
: labeled,
|
|
1248
|
-
parsedBody,
|
|
1249
|
-
);
|
|
1250
|
-
const patterns: number[] = [];
|
|
1251
|
-
const noPatterns: number[] = [];
|
|
1252
|
-
for (const attribute of attributes) {
|
|
1253
|
-
if (attribute.keyword.kind !== "keyword") continue;
|
|
1254
|
-
if (attribute.keyword.text === ":no-pattern") {
|
|
1255
|
-
const noPattern = parseTerm(attribute.value ?? list.end);
|
|
1256
|
-
manager.incRef(noPattern);
|
|
1257
|
-
noPatterns.push(noPattern);
|
|
1258
|
-
continue;
|
|
1259
|
-
}
|
|
1260
|
-
if (attribute.keyword.text !== ":pattern") continue;
|
|
1261
|
-
const pattern = parsePattern(
|
|
1262
|
-
attribute.value ?? (bodySExpr.kind === "list" ? bodySExpr.end : list.end),
|
|
1263
|
-
list.end,
|
|
1264
|
-
);
|
|
1265
|
-
if (pattern === undefined) continue;
|
|
1266
|
-
manager.incRef(pattern);
|
|
1267
|
-
patterns.push(pattern);
|
|
1268
|
-
}
|
|
1269
|
-
const getAttribute = (name: string) => {
|
|
1270
|
-
const value = attributes
|
|
1271
|
-
.filter(
|
|
1272
|
-
(attribute) =>
|
|
1273
|
-
attribute.keyword.kind === "keyword" &&
|
|
1274
|
-
attribute.keyword.text === name &&
|
|
1275
|
-
attribute.value?.kind !== "list",
|
|
1276
|
-
)
|
|
1277
|
-
.at(-1)?.value;
|
|
1278
|
-
return value?.kind === "list" ? undefined : value?.text;
|
|
1279
|
-
};
|
|
1280
|
-
const weight = Number(getAttribute(":weight") ?? 1);
|
|
1281
|
-
const qid = getAttribute(":qid") ?? "";
|
|
1282
|
-
const skid = getAttribute(":skolemid");
|
|
1283
|
-
unbindSortedVars(varSorts.length);
|
|
1284
|
-
// pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
|
|
1285
|
-
// and the valid ones after.
|
|
1286
|
-
let numKept = 0;
|
|
1287
|
-
for (const pattern of patterns) {
|
|
1288
|
-
if (!isValidPattern(pattern, varSorts.length)) {
|
|
1289
|
-
rejectPattern("invalid pattern", list.end);
|
|
1524
|
+
let numKept = frame.patternStart;
|
|
1525
|
+
for (let index = frame.patternStart; index < patternStack.length; index++) {
|
|
1526
|
+
const pattern = patternStack[index];
|
|
1527
|
+
if (!isValidPattern(pattern, numDecls)) {
|
|
1528
|
+
if (!options.isIgnoringBadPatterns) throw new SmtParseError("invalid pattern", list.end);
|
|
1290
1529
|
continue;
|
|
1291
1530
|
}
|
|
1292
1531
|
manager.incRef(pattern);
|
|
1293
|
-
manager.decRef(
|
|
1294
|
-
|
|
1532
|
+
manager.decRef(patternStack[numKept]);
|
|
1533
|
+
patternStack[numKept] = pattern;
|
|
1295
1534
|
numKept++;
|
|
1296
1535
|
}
|
|
1297
|
-
|
|
1298
|
-
|
|
1536
|
+
shrinkRefs(patternStack, numKept);
|
|
1537
|
+
const body = exprStack[exprStack.length - 1];
|
|
1538
|
+
if (frame.quantifierKind !== QUANTIFIER_LAMBDA && manager.sorts[body] !== SORT_BOOL)
|
|
1539
|
+
throw new SmtParseError("quantifier body must be a Boolean expression", list.end);
|
|
1540
|
+
if (patternStack.length > frame.patternStart && noPatternStack.length > frame.noPatternStart)
|
|
1299
1541
|
throw new SmtParseError("simultaneous patterns and no-patterns not supported", list.end);
|
|
1300
|
-
|
|
1301
|
-
kind,
|
|
1302
|
-
sorts: varSorts,
|
|
1303
|
-
names:
|
|
1542
|
+
return manager.mkQuantifier({
|
|
1543
|
+
kind: frame.quantifierKind,
|
|
1544
|
+
sorts: frame.varSorts,
|
|
1545
|
+
names: frame.names,
|
|
1304
1546
|
body,
|
|
1305
|
-
patterns,
|
|
1306
|
-
noPatterns,
|
|
1307
|
-
weight,
|
|
1308
|
-
qid,
|
|
1309
|
-
...(skid === undefined ? {} : { skid }),
|
|
1547
|
+
patterns: patternStack.slice(frame.patternStart),
|
|
1548
|
+
noPatterns: noPatternStack.slice(frame.noPatternStart),
|
|
1549
|
+
weight: frame.weight,
|
|
1550
|
+
qid: frame.qid,
|
|
1551
|
+
...(frame.skid === undefined ? {} : { skid: frame.skid }),
|
|
1310
1552
|
});
|
|
1311
|
-
for (const pattern of patterns) manager.decRef(pattern);
|
|
1312
|
-
for (const noPattern of noPatterns) manager.decRef(noPattern);
|
|
1313
|
-
for (const boundVar of boundVars) manager.decRef(boundVar);
|
|
1314
|
-
return quantifier;
|
|
1315
|
-
};
|
|
1316
|
-
|
|
1317
|
-
const parseLet = (list: SmtList) => {
|
|
1318
|
-
const message = "invalid let declaration, symbol expected";
|
|
1319
|
-
const scope = new Map<string, Binding>();
|
|
1320
|
-
const exprs: number[] = [];
|
|
1321
|
-
for (const binding of expectList(list.items[1], message, list).items) {
|
|
1322
|
-
const pair = expectList(binding, message, binding);
|
|
1323
|
-
const name = expectSymbol(pair.items[0], message, pair);
|
|
1324
|
-
const expr = parseTerm(pair.items[1] ?? pair.end);
|
|
1325
|
-
exprs.push(expr);
|
|
1326
|
-
scope.set(name.text, { kind: "let", depth: binders.depth, expr });
|
|
1327
|
-
}
|
|
1328
|
-
scopes.push(scope);
|
|
1329
|
-
// Z3 takes the last expression on its stack, so a let without a body is its last binding.
|
|
1330
|
-
for (const body of list.items.slice(2)) exprs.push(parseTerm(body));
|
|
1331
|
-
scopes.pop();
|
|
1332
|
-
const result = exprs.at(-1);
|
|
1333
|
-
if (result === undefined) throw new SmtParseError("invalid let expression", list.end);
|
|
1334
|
-
return result;
|
|
1335
1553
|
};
|
|
1336
1554
|
|
|
1337
1555
|
const expandMacro = (macro: Macro, args: number[]) =>
|
|
@@ -1405,7 +1623,7 @@ export const createSmtlibReader = (
|
|
|
1405
1623
|
const pair = [args[index], args[index + 1]];
|
|
1406
1624
|
pairs.push(mkFpaAppOf(manager, getSignature(pair), pair));
|
|
1407
1625
|
}
|
|
1408
|
-
return mkApp(OP_AND, pairs, at);
|
|
1626
|
+
return mkApp(OP_AND, pairs, at, SORT_BOOL);
|
|
1409
1627
|
};
|
|
1410
1628
|
|
|
1411
1629
|
const isSeqOpName = (name: string) =>
|
|
@@ -1429,8 +1647,10 @@ export const createSmtlibReader = (
|
|
|
1429
1647
|
return mkSeqAppOf(manager, signature, args);
|
|
1430
1648
|
};
|
|
1431
1649
|
|
|
1650
|
+
const upolynomials = new UpolynomialManager(manager.limit);
|
|
1651
|
+
|
|
1432
1652
|
const parseUpolynomial = (sexpr: SExpr): bigint[] => {
|
|
1433
|
-
if (sexpr.kind === "numeral") return
|
|
1653
|
+
if (sexpr.kind === "numeral") return upolynomials.set([BigInt(sexpr.text)]);
|
|
1434
1654
|
if (sexpr.kind === "decimal") {
|
|
1435
1655
|
const parts = sexpr.text.split(".");
|
|
1436
1656
|
const value = Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length));
|
|
@@ -1439,7 +1659,7 @@ export const createSmtlibReader = (
|
|
|
1439
1659
|
"invalid univariate polynomial, integer coefficient expected",
|
|
1440
1660
|
sexpr,
|
|
1441
1661
|
);
|
|
1442
|
-
return
|
|
1662
|
+
return upolynomials.set([value.num]);
|
|
1443
1663
|
}
|
|
1444
1664
|
if (sexpr.kind === "symbol") {
|
|
1445
1665
|
if (sexpr.text !== "x")
|
|
@@ -1464,15 +1684,15 @@ export const createSmtlibReader = (
|
|
|
1464
1684
|
"invalid univariate polynomial, exponent must be an unsigned integer",
|
|
1465
1685
|
exponent,
|
|
1466
1686
|
);
|
|
1467
|
-
return
|
|
1687
|
+
return upolynomials.pw(parseUpolynomial(operands[0]), Number(exponent.text));
|
|
1468
1688
|
}
|
|
1469
1689
|
const combine =
|
|
1470
1690
|
head.text === "+"
|
|
1471
|
-
?
|
|
1691
|
+
? upolynomials.add
|
|
1472
1692
|
: head.text === "-"
|
|
1473
|
-
?
|
|
1693
|
+
? upolynomials.sub
|
|
1474
1694
|
: head.text === "*"
|
|
1475
|
-
?
|
|
1695
|
+
? upolynomials.mul
|
|
1476
1696
|
: undefined;
|
|
1477
1697
|
if (combine === undefined)
|
|
1478
1698
|
throw new SmtParseError(
|
|
@@ -1485,11 +1705,11 @@ export const createSmtlibReader = (
|
|
|
1485
1705
|
sexpr,
|
|
1486
1706
|
);
|
|
1487
1707
|
const first = parseUpolynomial(operands[0]);
|
|
1488
|
-
if (head.text === "-" && operands.length === 1) return
|
|
1708
|
+
if (head.text === "-" && operands.length === 1) return upolynomials.neg(first);
|
|
1489
1709
|
return operands
|
|
1490
1710
|
.slice(1)
|
|
1491
1711
|
.reduce(
|
|
1492
|
-
(result, operand) => combine.call(
|
|
1712
|
+
(result, operand) => combine.call(upolynomials, result, parseUpolynomial(operand)),
|
|
1493
1713
|
first,
|
|
1494
1714
|
);
|
|
1495
1715
|
};
|
|
@@ -1525,43 +1745,136 @@ export const createSmtlibReader = (
|
|
|
1525
1745
|
return manager.mkAlgebraicNumeral(root);
|
|
1526
1746
|
};
|
|
1527
1747
|
|
|
1528
|
-
const
|
|
1748
|
+
const isKnownOperator = (name: string) => BUILTIN_NAMES.has(name) || THEORY_OPERATOR.test(name);
|
|
1749
|
+
|
|
1750
|
+
// parse_indexed_identifier_core.
|
|
1751
|
+
const getIndexedName = (list: SmtList) => {
|
|
1529
1752
|
const name = list.items[1];
|
|
1753
|
+
if (!isSymbol(name))
|
|
1754
|
+
throw new SmtParseError("invalid indexed identifier, symbol expected", name ?? list.end);
|
|
1755
|
+
for (const index of list.items.slice(2)) {
|
|
1756
|
+
if (index.kind === "string")
|
|
1757
|
+
throw new SmtParseError(
|
|
1758
|
+
"invalid indexed identifier, integer, identifier or '(' expected",
|
|
1759
|
+
index,
|
|
1760
|
+
);
|
|
1761
|
+
// parse_func_decl_ref of an index that is a symbol.
|
|
1762
|
+
if (
|
|
1763
|
+
index.kind === "symbol" &&
|
|
1764
|
+
name.text !== "is" &&
|
|
1765
|
+
!isUsed(index.text) &&
|
|
1766
|
+
!macros.has(index.text)
|
|
1767
|
+
)
|
|
1768
|
+
throw new SmtParseError(
|
|
1769
|
+
`invalid function declaration reference, unknown function ${index.text}`,
|
|
1770
|
+
index,
|
|
1771
|
+
);
|
|
1772
|
+
}
|
|
1773
|
+
return name;
|
|
1774
|
+
};
|
|
1775
|
+
|
|
1776
|
+
// parse_qualified_identifier_core on (as <identifier> <sort>), up to the sort.
|
|
1777
|
+
const parseQualifierSort = (list: SmtList) => {
|
|
1778
|
+
const target = list.items[1];
|
|
1779
|
+
if (target === undefined || (target.kind !== "symbol" && target.kind !== "list"))
|
|
1780
|
+
throw new SmtParseError(
|
|
1781
|
+
`invalid (indexed) identifier, '(_' or symbol expected got ${getLastId(target) ?? "as"}`,
|
|
1782
|
+
target ?? list.end,
|
|
1783
|
+
);
|
|
1784
|
+
if (target.kind === "list") {
|
|
1785
|
+
if (!isSymbol(target.items[0], "_"))
|
|
1786
|
+
throw new SmtParseError(
|
|
1787
|
+
"invalid indexed identifier, '_' expected",
|
|
1788
|
+
target.items[0] ?? target.end,
|
|
1789
|
+
);
|
|
1790
|
+
getIndexedName(target);
|
|
1791
|
+
}
|
|
1792
|
+
const sort = parseSort(list.items[2] ?? list.end, "Invalid qualified identifier");
|
|
1793
|
+
const extra = list.items[3];
|
|
1794
|
+
if (extra !== undefined)
|
|
1795
|
+
throw new SmtParseError(
|
|
1796
|
+
`invalid qualified identifier, ')' expected got ${getLastId(extra) ?? getLastIdBefore(list.items, 3) ?? "as"}`,
|
|
1797
|
+
extra,
|
|
1798
|
+
);
|
|
1799
|
+
return sort;
|
|
1800
|
+
};
|
|
1801
|
+
|
|
1802
|
+
// parse_qualified_name on (_ <symbol> <index>*). Z3 makes the term once it has read past the
|
|
1803
|
+
// closing parenthesis, where at is.
|
|
1804
|
+
const parseIndexedTerm = (list: SmtList, at: SExpr, range?: number) => {
|
|
1805
|
+
const name = getIndexedName(list);
|
|
1530
1806
|
const indices = list.items.slice(2);
|
|
1531
|
-
|
|
1532
|
-
|
|
1533
|
-
|
|
1534
|
-
|
|
1535
|
-
|
|
1807
|
+
const local = locals.get(name.text);
|
|
1808
|
+
if (local !== undefined) {
|
|
1809
|
+
if (indices.length > 0)
|
|
1810
|
+
throw new SmtParseError("invalid indexed identifier, symbol is a local declaration", at);
|
|
1811
|
+
return getLocalTerm(local);
|
|
1812
|
+
}
|
|
1813
|
+
const value = /^bv([0-9]+)$/.exec(name.text);
|
|
1814
|
+
if (value !== null) {
|
|
1815
|
+
const width = indices[0];
|
|
1816
|
+
const digits =
|
|
1817
|
+
indices.length !== 1
|
|
1818
|
+
? "-1"
|
|
1819
|
+
: width.kind === "bitvector"
|
|
1820
|
+
? `0${width.text.slice(1)}`
|
|
1821
|
+
: width.kind === "numeral"
|
|
1822
|
+
? width.text
|
|
1823
|
+
: "-1";
|
|
1824
|
+
if (!isUnsigned(digits))
|
|
1825
|
+
throw new SmtParseError("invalid bit-vector constant, index expected", at);
|
|
1826
|
+
if (BigInt(digits) === 0n)
|
|
1827
|
+
throw new SmtParseError("bit-vector size must be greater than zero", at);
|
|
1828
|
+
return manager.mkBvNumeral(BigInt(value[1]), Number(BigInt(digits)));
|
|
1829
|
+
}
|
|
1830
|
+
const isNumbered = indices.every((index) => index.kind === "numeral");
|
|
1831
|
+
if (isNumbered && isSeqOpName(name.text))
|
|
1536
1832
|
return mkSeqTerm(
|
|
1537
1833
|
name.text,
|
|
1538
1834
|
[],
|
|
1539
1835
|
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1540
|
-
|
|
1836
|
+
at,
|
|
1541
1837
|
);
|
|
1542
|
-
if (
|
|
1543
|
-
isSymbol(name) &&
|
|
1544
|
-
isFpaOpName(name.text) &&
|
|
1545
|
-
indices.every((index) => index.kind === "numeral")
|
|
1546
|
-
) {
|
|
1838
|
+
if (isNumbered && isFpaOpName(name.text)) {
|
|
1547
1839
|
const signature = getFpaSignature(
|
|
1548
1840
|
manager,
|
|
1549
1841
|
FPA_OP_NAMES.get(name.text) ?? -1,
|
|
1550
1842
|
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1551
1843
|
[],
|
|
1552
1844
|
);
|
|
1553
|
-
if (typeof signature === "string")
|
|
1554
|
-
throw new SmtParseError(signature, { line: list.end.line, column: list.end.column + 1 });
|
|
1845
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1555
1846
|
return mkFpaAppOf(manager, signature, []);
|
|
1556
1847
|
}
|
|
1557
|
-
|
|
1558
|
-
|
|
1559
|
-
|
|
1560
|
-
|
|
1561
|
-
|
|
1562
|
-
|
|
1563
|
-
|
|
1564
|
-
|
|
1848
|
+
if (isKnownOperator(name.text) || !indices.every(isSimpleIndex))
|
|
1849
|
+
throw new SmtUnsupportedError("indexed identifiers");
|
|
1850
|
+
return parseApp(name, [], at, [], range);
|
|
1851
|
+
};
|
|
1852
|
+
|
|
1853
|
+
// parse_qualified_name.
|
|
1854
|
+
const parseQualifiedName = (list: SmtList) => {
|
|
1855
|
+
const at = list.follower ?? list.end;
|
|
1856
|
+
if (isSymbol(list.items[0], "_")) return parseIndexedTerm(list, at);
|
|
1857
|
+
const sort = parseQualifierSort(list);
|
|
1858
|
+
const target = list.items[1];
|
|
1859
|
+
const local = isSymbol(target) ? locals.get(target.text) : undefined;
|
|
1860
|
+
if (isSymbol(target) && local === undefined)
|
|
1861
|
+
return hasArrays && target.text === "const"
|
|
1862
|
+
? mkArrayTerm(OP_CONST_ARRAY, [], [sort], at)
|
|
1863
|
+
: parseApp(target, [], at, [], sort);
|
|
1864
|
+
const term =
|
|
1865
|
+
local === undefined
|
|
1866
|
+
? parseIndexedTerm(
|
|
1867
|
+
expectList(target, "invalid indexed identifier, '_' expected", list),
|
|
1868
|
+
at,
|
|
1869
|
+
sort,
|
|
1870
|
+
)
|
|
1871
|
+
: getLocalTerm(local);
|
|
1872
|
+
if (manager.sorts[term] !== sort)
|
|
1873
|
+
throw new SmtParseError(
|
|
1874
|
+
`sort mismatch in qualified identifier, expected: ${manager.getSortName(sort)}, got: ${manager.getSortName(manager.sorts[term])}`,
|
|
1875
|
+
at,
|
|
1876
|
+
);
|
|
1877
|
+
return term;
|
|
1565
1878
|
};
|
|
1566
1879
|
|
|
1567
1880
|
const mkArrayTerm = (op: number, inputArgs: number[], parameters: number[], at: SExpr) => {
|
|
@@ -1624,10 +1937,7 @@ export const createSmtlibReader = (
|
|
|
1624
1937
|
sort === argSorts[index] || (isArithSort(sort) && isArithSort(argSorts[index])),
|
|
1625
1938
|
),
|
|
1626
1939
|
);
|
|
1627
|
-
const found =
|
|
1628
|
-
candidates.find((decl) =>
|
|
1629
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === argSorts[index]),
|
|
1630
|
-
) ?? candidates.at(-1);
|
|
1940
|
+
const found = candidates.find((decl) => hasSignature(decl, argSorts, -1)) ?? candidates.at(-1);
|
|
1631
1941
|
if (found !== undefined) return mkApp(found, args, at);
|
|
1632
1942
|
if (args.length === 0 || range !== undefined) return undefined;
|
|
1633
1943
|
if (decls.length > 1) throwAmbiguousConstant(name, at);
|
|
@@ -1678,10 +1988,23 @@ export const createSmtlibReader = (
|
|
|
1678
1988
|
|
|
1679
1989
|
const mkIsApp = (constructorName: SmtToken, args: number[], at: SExpr) => {
|
|
1680
1990
|
const declared = findFuncDecl(constructorName);
|
|
1681
|
-
|
|
1991
|
+
// datatype::decl::plugin::mk_is.
|
|
1992
|
+
if (declared !== undefined) {
|
|
1993
|
+
if (args.length !== 1) throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
|
|
1994
|
+
if (!manager.isDatatypeSort(manager.sorts[args[0]]))
|
|
1995
|
+
throw new SmtParseError(
|
|
1996
|
+
"invalid parameter to datatype function u().is_datatype(domain[0])",
|
|
1997
|
+
at,
|
|
1998
|
+
);
|
|
1999
|
+
if (manager.sorts[args[0]] !== manager.funcDecls[declared].range)
|
|
2000
|
+
throw new SmtParseError("invalid sort argument passed to recognizer", at);
|
|
2001
|
+
if (manager.funcDecls[declared].op !== OP_DT_CONSTRUCTOR)
|
|
2002
|
+
throw new SmtParseError("expecting constructor argument to recognizer", at);
|
|
2003
|
+
return manager.mkApp(getConstructorIs(manager, declared), args, SORT_BOOL);
|
|
2004
|
+
}
|
|
1682
2005
|
const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
|
|
1683
2006
|
if (argSort === -1 || !manager.isDatatypeSort(argSort))
|
|
1684
|
-
throw new
|
|
2007
|
+
throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
|
|
1685
2008
|
const constructor = getDatatypeConstructors(manager, argSort).find(
|
|
1686
2009
|
(decl) => manager.funcDecls[decl].name === constructorName.text,
|
|
1687
2010
|
);
|
|
@@ -1700,9 +2023,23 @@ export const createSmtlibReader = (
|
|
|
1700
2023
|
`invalid function declaration reference, unknown function ${accessorName.text}`,
|
|
1701
2024
|
accessorName,
|
|
1702
2025
|
);
|
|
1703
|
-
|
|
1704
|
-
|
|
1705
|
-
|
|
2026
|
+
// datatype::decl::plugin::mk_update_field.
|
|
2027
|
+
if (args.length !== 2)
|
|
2028
|
+
throw new SmtParseError("invalid number of arguments for datatype field update", at);
|
|
2029
|
+
const funcDecl = manager.funcDecls[accessor];
|
|
2030
|
+
if (funcDecl.op !== OP_DT_ACCESSOR)
|
|
2031
|
+
throw new SmtParseError(
|
|
2032
|
+
"datatype field update requires a datatype accessor as the second argument",
|
|
2033
|
+
at,
|
|
2034
|
+
);
|
|
2035
|
+
if (funcDecl.domain[0] !== manager.sorts[args[0]])
|
|
2036
|
+
throw new SmtParseError("first argument to field update should be a data-type", at);
|
|
2037
|
+
if (funcDecl.range !== manager.sorts[args[1]])
|
|
2038
|
+
throw new SmtParseError(
|
|
2039
|
+
`second argument to field update should be ${manager.getSortName(funcDecl.range)} instead of ${manager.getSortName(manager.sorts[args[1]])}`,
|
|
2040
|
+
at,
|
|
2041
|
+
);
|
|
2042
|
+
return manager.mkApp(mkUpdateField(manager, accessor), args, funcDecl.domain[0]);
|
|
1706
2043
|
};
|
|
1707
2044
|
|
|
1708
2045
|
const getUnknownConstantMessage = (name: string, args: number[], range: number | undefined) => {
|
|
@@ -1735,14 +2072,7 @@ export const createSmtlibReader = (
|
|
|
1735
2072
|
throw new SmtUnsupportedError("the declaration reference");
|
|
1736
2073
|
const domain = domainList.items.map((item) => parseSort(item, "Invalid function name"));
|
|
1737
2074
|
const range = parseSort(rangeSort, "Invalid function name");
|
|
1738
|
-
const declared = funcs
|
|
1739
|
-
.get(name.text)
|
|
1740
|
-
?.find(
|
|
1741
|
-
(decl) =>
|
|
1742
|
-
manager.funcDecls[decl].range === range &&
|
|
1743
|
-
manager.funcDecls[decl].domain.length === domain.length &&
|
|
1744
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
1745
|
-
);
|
|
2075
|
+
const declared = funcs.get(name.text)?.find((decl) => hasSignature(decl, domain, range));
|
|
1746
2076
|
if (declared !== undefined) return { decl: declared, domain, range };
|
|
1747
2077
|
const builtin = CHAINABLE_OPS.get(name.text) ?? BUILTIN_OPS.get(name.text);
|
|
1748
2078
|
if (builtin === undefined)
|
|
@@ -1781,10 +2111,11 @@ export const createSmtlibReader = (
|
|
|
1781
2111
|
) => {
|
|
1782
2112
|
const name = head.text;
|
|
1783
2113
|
// A bound variable applied to arguments selects from the array it stands for, one at a time.
|
|
1784
|
-
|
|
2114
|
+
const local = locals.get(name);
|
|
2115
|
+
if (args.length > 0 && local !== undefined)
|
|
1785
2116
|
return args.reduce(
|
|
1786
2117
|
(array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], at),
|
|
1787
|
-
|
|
2118
|
+
getLocalTerm(local),
|
|
1788
2119
|
);
|
|
1789
2120
|
if (indices.length > 0)
|
|
1790
2121
|
return isFpaOpName(name)
|
|
@@ -1793,19 +2124,31 @@ export const createSmtlibReader = (
|
|
|
1793
2124
|
? mkSeqTerm(name, args, indices, at)
|
|
1794
2125
|
: mkBvApp(name, args, indices, at);
|
|
1795
2126
|
const macro = macros.get(name);
|
|
1796
|
-
// macros_find: a macro
|
|
1797
|
-
|
|
1798
|
-
|
|
1799
|
-
|
|
1800
|
-
|
|
1801
|
-
|
|
2127
|
+
// macros_find: a macro takes its own sorts, and Int for Real or Real for Int. Any other
|
|
2128
|
+
// application leaves the name to a declaration.
|
|
2129
|
+
if (
|
|
2130
|
+
macro !== undefined &&
|
|
2131
|
+
macro.domain.length === args.length &&
|
|
2132
|
+
args.every(
|
|
2133
|
+
(arg, index) =>
|
|
2134
|
+
manager.sorts[arg] === macro.domain[index] ||
|
|
2135
|
+
(isArithSort(manager.sorts[arg]) && isArithSort(macro.domain[index])),
|
|
1802
2136
|
)
|
|
1803
|
-
|
|
1804
|
-
return expandMacro(
|
|
1805
|
-
|
|
2137
|
+
)
|
|
2138
|
+
return expandMacro(
|
|
2139
|
+
macro,
|
|
2140
|
+
args.map((arg, index) => coerce(arg, macro.domain[index])),
|
|
2141
|
+
);
|
|
1806
2142
|
const decls = funcs.get(name);
|
|
1807
2143
|
const declared = decls === undefined ? undefined : mkDeclaredApp(name, decls, args, range, at);
|
|
1808
2144
|
if (declared !== undefined) return declared;
|
|
2145
|
+
// cmd_context::mk_app: a constant that starts with #f is a finite-field literal.
|
|
2146
|
+
if (args.length === 0 && name.startsWith("#f")) {
|
|
2147
|
+
if (!FF_LITERAL.test(name))
|
|
2148
|
+
throw new SmtParseError("invalid finite-field literal, expected #f<integer>m<prime>", at);
|
|
2149
|
+
if (!restricted.hasFf) throw new SmtParseError("logic does not support finite fields", at);
|
|
2150
|
+
throw new SmtUnsupportedError("finite-field literals");
|
|
2151
|
+
}
|
|
1809
2152
|
if (isSeqOpName(name)) return mkSeqTerm(name, args, indices, at, range);
|
|
1810
2153
|
if (range !== undefined)
|
|
1811
2154
|
throw new SmtParseError(getUnknownConstantMessage(name, args, range), at);
|
|
@@ -1820,56 +2163,30 @@ export const createSmtlibReader = (
|
|
|
1820
2163
|
const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
|
|
1821
2164
|
if (isTranscendental && transcendentalOp === undefined)
|
|
1822
2165
|
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1823
|
-
const
|
|
1824
|
-
|
|
1825
|
-
|
|
2166
|
+
const named =
|
|
2167
|
+
builtin === "~"
|
|
2168
|
+
? OP_UMINUS
|
|
2169
|
+
: (CHAINABLE_OPS.get(builtin) ?? BUILTIN_OPS.get(builtin) ?? transcendentalOp);
|
|
1826
2170
|
if (
|
|
1827
2171
|
args.length === 0 &&
|
|
1828
|
-
|
|
1829
|
-
manager.funcDecls[
|
|
2172
|
+
named !== undefined &&
|
|
2173
|
+
manager.funcDecls[named].family === FAMILY_ARITH
|
|
1830
2174
|
)
|
|
1831
2175
|
throw new SmtParseError("no arguments supplied to arithmetical operator", head);
|
|
1832
|
-
|
|
1833
|
-
|
|
1834
|
-
|
|
1835
|
-
|
|
1836
|
-
|
|
1837
|
-
|
|
1838
|
-
|
|
1839
|
-
if (
|
|
1840
|
-
|
|
1841
|
-
if (op === undefined) {
|
|
1842
|
-
if (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name))
|
|
1843
|
-
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1844
|
-
const instance = mkDatatypeInstanceApp(name, args, at);
|
|
1845
|
-
if (instance !== undefined) return instance;
|
|
1846
|
-
throw new SmtParseError(
|
|
1847
|
-
getUnknownConstantMessage(name, args, undefined),
|
|
1848
|
-
args.length === 0 ? head : at,
|
|
1849
|
-
);
|
|
1850
|
-
}
|
|
1851
|
-
// xor is associative, so ast_manager::mk_app takes fewer than two arguments, which
|
|
1852
|
-
// bool_rewriter reduces to false or the argument.
|
|
1853
|
-
if (op === OP_XOR && args.length < 2) {
|
|
1854
|
-
if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
|
|
1855
|
-
throw new SmtParseError(`ill-sorted application of ${name}`, at);
|
|
1856
|
-
return args[0] ?? manager.falseExpr;
|
|
1857
|
-
}
|
|
1858
|
-
if (args.length <= 2 || !NESTED_OPS.has(op)) return mkApp(op, args, at);
|
|
1859
|
-
const domainSort = getDomainSort(op, args);
|
|
1860
|
-
return op === OP_XOR || op === OP_IMPLIES
|
|
1861
|
-
? args
|
|
1862
|
-
.slice(0, -1)
|
|
1863
|
-
.reduceRight(
|
|
1864
|
-
(right, left) => mkApp(op, [left, right], at, domainSort),
|
|
1865
|
-
args[args.length - 1],
|
|
1866
|
-
)
|
|
1867
|
-
: args.slice(1).reduce((left, right) => mkApp(op, [left, right], at, domainSort), args[0]);
|
|
2176
|
+
// arith_decl_plugin::fix_kind.
|
|
2177
|
+
const op = named === OP_SUB && args.length === 1 ? OP_UMINUS : named;
|
|
2178
|
+
const domainSort = op === undefined ? -1 : getDomainSort(op, args, at);
|
|
2179
|
+
if (op !== undefined && domainSort !== -1) return mkApp(op, args, at, domainSort);
|
|
2180
|
+
if (op === undefined && (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name)))
|
|
2181
|
+
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
2182
|
+
const instance = mkDatatypeInstanceApp(name, args, at);
|
|
2183
|
+
if (instance !== undefined) return instance;
|
|
2184
|
+
throw new SmtParseError(getUnknownConstantMessage(name, args, undefined), at);
|
|
1868
2185
|
};
|
|
1869
2186
|
|
|
1870
|
-
const parseLeaf = (sexpr:
|
|
2187
|
+
const parseLeaf = (sexpr: SmtToken): number => {
|
|
1871
2188
|
if (sexpr.kind === "numeral")
|
|
1872
|
-
return isNumeralAsReal
|
|
2189
|
+
return restricted.isNumeralAsReal
|
|
1873
2190
|
? manager.mkRealNumeral(Rational.of(BigInt(sexpr.text), 1n))
|
|
1874
2191
|
: manager.mkNumeral(BigInt(sexpr.text));
|
|
1875
2192
|
if (sexpr.kind === "decimal") {
|
|
@@ -1888,222 +2205,452 @@ export const createSmtlibReader = (
|
|
|
1888
2205
|
}
|
|
1889
2206
|
if (sexpr.kind === "string") return manager.mkString(parseZstring(sexpr.text, manager.maxChar));
|
|
1890
2207
|
if (sexpr.kind === "symbol") {
|
|
2208
|
+
const local = locals.get(sexpr.text);
|
|
2209
|
+
if (local !== undefined) return getLocalTerm(local);
|
|
1891
2210
|
if (sexpr.text === "true") return manager.trueExpr;
|
|
1892
2211
|
if (sexpr.text === "false") return manager.falseExpr;
|
|
1893
|
-
const binding = lookup(sexpr.text);
|
|
1894
|
-
if (binding?.kind === "var")
|
|
1895
|
-
return manager.mkVar(binders.depth - 1 - binding.depth, binding.sort);
|
|
1896
|
-
// Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
|
|
1897
|
-
// holds the terms it makes, but this parser holds no references, so it rebuilds the binding
|
|
1898
|
-
// with replaceFreeVars.
|
|
1899
|
-
if (binding !== undefined)
|
|
1900
|
-
return binders.depth === binding.depth
|
|
1901
|
-
? binding.expr
|
|
1902
|
-
: replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
|
|
1903
|
-
manager.mkVar(index + shift + binders.depth - binding.depth, manager.sorts[variable]),
|
|
1904
|
-
);
|
|
1905
2212
|
return parseApp(sexpr, [], sexpr);
|
|
1906
2213
|
}
|
|
1907
|
-
|
|
1908
|
-
|
|
1909
|
-
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
head.text === "forall"
|
|
1913
|
-
? QUANTIFIER_FORALL
|
|
1914
|
-
: head.text === "exists"
|
|
1915
|
-
? QUANTIFIER_EXISTS
|
|
1916
|
-
: QUANTIFIER_LAMBDA,
|
|
1917
|
-
);
|
|
1918
|
-
if (isSymbol(head, "let")) return parseLet(sexpr);
|
|
1919
|
-
// Each attribute applies to the expression the attributes before it made.
|
|
1920
|
-
return sexpr.items.slice(2).reduce(
|
|
1921
|
-
(annotated, keyword, index, attributes) => {
|
|
1922
|
-
if (keyword.kind !== "keyword") return annotated;
|
|
1923
|
-
const value = attributes[index + 1];
|
|
1924
|
-
if (keyword.text === ":lblpos" || keyword.text === ":lblneg")
|
|
1925
|
-
return mkLabel(annotated, keyword.text === ":lblpos", value, sexpr);
|
|
1926
|
-
if (keyword.text !== ":named") return annotated;
|
|
1927
|
-
const name = expectSymbol(value, "invalid attribute value, symbol expected", sexpr).text;
|
|
1928
|
-
manager.incRef(annotated);
|
|
1929
|
-
lastNamed.name = name;
|
|
1930
|
-
lastNamed.expr = annotated;
|
|
1931
|
-
manager.mkMacro(name, annotated);
|
|
1932
|
-
declare(macros, name, { domain: [], range: manager.sorts[annotated], body: annotated });
|
|
1933
|
-
return annotated;
|
|
1934
|
-
},
|
|
1935
|
-
parseTerm(sexpr.items[1] ?? sexpr.end),
|
|
2214
|
+
throw new SmtParseError(
|
|
2215
|
+
sexpr.kind === "keyword"
|
|
2216
|
+
? "invalid expression, unexpected keyword"
|
|
2217
|
+
: "invalid expression, unexpected ')'",
|
|
2218
|
+
sexpr,
|
|
1936
2219
|
);
|
|
1937
2220
|
};
|
|
1938
2221
|
|
|
1939
|
-
|
|
1940
|
-
|
|
1941
|
-
|
|
1942
|
-
|
|
1943
|
-
|
|
1944
|
-
|
|
1945
|
-
|
|
1946
|
-
|
|
1947
|
-
|
|
1948
|
-
|
|
1949
|
-
|
|
2222
|
+
// name_expr and cmd_context::insert of a named term. Z3 reports an error at the token after the
|
|
2223
|
+
// name.
|
|
2224
|
+
const nameExpr = (expr: number, name: string, at: SExpr) => {
|
|
2225
|
+
if (manager.freeVarBounds[expr] > 0)
|
|
2226
|
+
throw new SmtParseError("invalid named expression, expression contains free variables", at);
|
|
2227
|
+
if (macros.get(name)?.domain.length === 0)
|
|
2228
|
+
throw new SmtParseError("named expression already defined", at);
|
|
2229
|
+
if ((funcs.get(name) ?? []).some((decl) => hasSignature(decl, [], manager.sorts[expr])))
|
|
2230
|
+
throw new SmtParseError(
|
|
2231
|
+
`invalid named expression, declaration already defined with this name ${name}`,
|
|
2232
|
+
at,
|
|
2233
|
+
);
|
|
2234
|
+
manager.incRef(expr);
|
|
2235
|
+
lastNamed.name = name;
|
|
2236
|
+
lastNamed.expr = expr;
|
|
2237
|
+
manager.mkMacro(name, expr);
|
|
2238
|
+
declare(macros, name, { domain: [], range: manager.sorts[expr], body: expr });
|
|
2239
|
+
};
|
|
2240
|
+
|
|
2241
|
+
// push_app_frame's parse_qualified_identifier_core, on a head that is (_ <symbol> <index>*) or
|
|
2242
|
+
// (as <identifier> <sort>).
|
|
2243
|
+
const parseQualifiedHead = (list: SmtList, head: SmtList): QualifiedHead => {
|
|
2244
|
+
if (isSymbol(head.items[0], "as")) {
|
|
2245
|
+
const range = parseQualifierSort(head);
|
|
2246
|
+
const target = head.items[1];
|
|
2247
|
+
if (!isSymbol(target)) throw new SmtUnsupportedError("indexed and qualified identifiers");
|
|
2248
|
+
return {
|
|
2249
|
+
head: target,
|
|
2250
|
+
indices: [],
|
|
2251
|
+
build:
|
|
2252
|
+
hasArrays && target.text === "const"
|
|
2253
|
+
? (args) => mkArrayTerm(OP_CONST_ARRAY, args, [range], list.end)
|
|
2254
|
+
: (args) => parseApp(target, args, list.end, [], range),
|
|
2255
|
+
};
|
|
2256
|
+
}
|
|
2257
|
+
const name = getIndexedName(head);
|
|
2258
|
+
const indices = head.items.slice(2);
|
|
2259
|
+
const indexed = indices[0];
|
|
2260
|
+
if (hasArrays && hasArrayExtensions && name.text === "map" && indices.length === 1) {
|
|
2261
|
+
const mapped = parseFuncDeclRef(indexed);
|
|
2262
|
+
return { head: name, indices: [], build: (args) => mkMapTerm(mapped, args, list.end) };
|
|
2263
|
+
}
|
|
2264
|
+
if ((name.text === "is" || name.text === "update-field") && indices.length === 1) {
|
|
2265
|
+
if (!isSymbol(indexed)) throw new SmtUnsupportedError("indexed and qualified identifiers");
|
|
2266
|
+
return {
|
|
2267
|
+
head: name,
|
|
2268
|
+
indices: [],
|
|
2269
|
+
build: (args) =>
|
|
2270
|
+
name.text === "is"
|
|
2271
|
+
? mkIsApp(indexed, args, list.end)
|
|
2272
|
+
: mkUpdateFieldApp(indexed, args, list.end),
|
|
2273
|
+
};
|
|
2274
|
+
}
|
|
2275
|
+
const isNumbered = indices.every((index) => index.kind === "numeral");
|
|
2276
|
+
if (isNumbered && isPbOpName(name.text)) {
|
|
2277
|
+
const parameters = indices.map((index) =>
|
|
2278
|
+
Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
|
|
2279
|
+
);
|
|
2280
|
+
return {
|
|
2281
|
+
head: name,
|
|
2282
|
+
indices: [],
|
|
2283
|
+
build: (args) => mkPbTerm(name.text, args, parameters, list.end),
|
|
2284
|
+
};
|
|
2285
|
+
}
|
|
2286
|
+
if (isNumbered && (isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)))
|
|
2287
|
+
return {
|
|
2288
|
+
head: name,
|
|
2289
|
+
indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
2290
|
+
};
|
|
2291
|
+
// cmd_context::mk_app finds a name that no theory knows among the declarations, whatever its
|
|
2292
|
+
// indices are.
|
|
2293
|
+
if (isKnownOperator(name.text) || !indices.every(isSimpleIndex))
|
|
2294
|
+
throw new SmtUnsupportedError("indexed and qualified identifiers");
|
|
2295
|
+
return { head: name, indices: [] };
|
|
2296
|
+
};
|
|
2297
|
+
|
|
2298
|
+
// parse_expr. Z3 leaves the term on its stack until the command ends. A tail term is one whose
|
|
2299
|
+
// value is the value of the whole: it stays off the stack, in parsed, so that the caller of
|
|
2300
|
+
// parseTerm can have a term that nothing else holds without a reference of the parser's.
|
|
2301
|
+
const runTerm = (sexpr: SExpr, isRootTail: boolean) => {
|
|
2302
|
+
const root = sexpr.kind === "list" ? sexpr.root : undefined;
|
|
2303
|
+
if (root === undefined || root === parsed.root) protect(floating);
|
|
2304
|
+
else {
|
|
2305
|
+
releasePending();
|
|
2306
|
+
shrink(floating, 0);
|
|
2307
|
+
parsed.root = root;
|
|
2308
|
+
}
|
|
2309
|
+
protect(unrooted);
|
|
2310
|
+
const frames: TermFrame[] = [];
|
|
2311
|
+
// The value of a frame replaces what the frame left on the stack. Z3 holds it in an expr_ref
|
|
2312
|
+
// meanwhile.
|
|
2313
|
+
const deliver = (expr: number, isTail: boolean, start: number) => {
|
|
2314
|
+
const isOwned = !isTail || manager.getRefCount(expr) > 0;
|
|
2315
|
+
if (isOwned) manager.incRef(expr);
|
|
2316
|
+
shrinkRefs(exprStack, start);
|
|
2317
|
+
if (!isTail) {
|
|
2318
|
+
exprStack.push(expr);
|
|
2319
|
+
return;
|
|
2320
|
+
}
|
|
2321
|
+
parsed.expr = expr;
|
|
2322
|
+
parsed.isOwned = isOwned;
|
|
2323
|
+
};
|
|
2324
|
+
// push_pattern_frame.
|
|
2325
|
+
const enterPattern = (value: SExpr, frame: AttributeFrame) => {
|
|
2326
|
+
if (value.kind !== "list") {
|
|
2327
|
+
if (!options.isIgnoringBadPatterns)
|
|
2328
|
+
throw new SmtParseError("invalid pattern, '(' expected", value);
|
|
2329
|
+
// Z3 skips a bad pattern as an s-expression, which cannot start with ')'.
|
|
2330
|
+
if (value.kind === ")")
|
|
2331
|
+
throw new SmtParseError("invalid s-expression, unexpected ')'", value);
|
|
2332
|
+
frame.next++;
|
|
2333
|
+
exprStack.push(-1);
|
|
2334
|
+
return;
|
|
2335
|
+
}
|
|
2336
|
+
frame.next++;
|
|
2337
|
+
const first = value.items[0];
|
|
2338
|
+
if (first === undefined) {
|
|
2339
|
+
exprStack.push(-1);
|
|
2340
|
+
return;
|
|
2341
|
+
}
|
|
2342
|
+
if (first.kind === "list") {
|
|
2343
|
+
frames.push({ kind: "pattern", list: value, start: exprStack.length, next: 0 });
|
|
2344
|
+
return;
|
|
2345
|
+
}
|
|
2346
|
+
const decl = first.text === "true" || first.text === "false" ? -1 : getFirstFunc(first.text);
|
|
2347
|
+
if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0)) {
|
|
2348
|
+
if (!options.isIgnoringBadPatterns)
|
|
2349
|
+
throw new SmtParseError("invalid constant pattern", first);
|
|
2350
|
+
exprStack.push(-1);
|
|
2351
|
+
return;
|
|
2352
|
+
}
|
|
2353
|
+
if (first.kind !== "symbol")
|
|
2354
|
+
throw new SmtParseError("invalid pattern, '(' or identifier expected", first);
|
|
2355
|
+
frames.push({
|
|
2356
|
+
kind: "application",
|
|
2357
|
+
list: value,
|
|
2358
|
+
head: first,
|
|
2359
|
+
indices: [],
|
|
2360
|
+
isTail: false,
|
|
2361
|
+
start: exprStack.length,
|
|
2362
|
+
next: 1,
|
|
2363
|
+
});
|
|
2364
|
+
};
|
|
2365
|
+
const enter = (current: SExpr, isTail: boolean) => {
|
|
1950
2366
|
if (current.kind !== "list") {
|
|
1951
|
-
|
|
2367
|
+
deliver(parseLeaf(current), isTail, exprStack.length);
|
|
1952
2368
|
return;
|
|
1953
2369
|
}
|
|
1954
2370
|
const head = current.items[0];
|
|
1955
|
-
if (head === undefined)
|
|
1956
|
-
throw new SmtParseError("invalid expression,
|
|
2371
|
+
if (head === undefined || (head.kind !== "symbol" && head.kind !== "list"))
|
|
2372
|
+
throw new SmtParseError("invalid expression, '(' or symbol expected", head ?? current.end);
|
|
1957
2373
|
if (head.kind === "list") {
|
|
1958
|
-
|
|
1959
|
-
|
|
1960
|
-
if (
|
|
1961
|
-
hasArrays &&
|
|
1962
|
-
isSymbol(head.items[0], "as") &&
|
|
1963
|
-
isSymbol(name, "const") &&
|
|
1964
|
-
head.items.length === 3
|
|
1965
|
-
) {
|
|
1966
|
-
const sort = parseSort(head.items[2], "");
|
|
1967
|
-
frames.push({
|
|
1968
|
-
head: name,
|
|
1969
|
-
indices: [],
|
|
1970
|
-
build: (args) => mkArrayTerm(OP_CONST_ARRAY, args, [sort], current.end),
|
|
1971
|
-
list: current,
|
|
1972
|
-
start: results.length,
|
|
1973
|
-
next: 1,
|
|
1974
|
-
});
|
|
1975
|
-
return;
|
|
1976
|
-
}
|
|
1977
|
-
if (
|
|
1978
|
-
hasArrays &&
|
|
1979
|
-
hasArrayExtensions &&
|
|
1980
|
-
isSymbol(head.items[0], "_") &&
|
|
1981
|
-
isSymbol(name, "map") &&
|
|
1982
|
-
head.items.length === 3
|
|
1983
|
-
) {
|
|
1984
|
-
const mapped = parseFuncDeclRef(head.items[2]);
|
|
1985
|
-
frames.push({
|
|
1986
|
-
head: name,
|
|
1987
|
-
indices: [],
|
|
1988
|
-
build: (args) => mkMapTerm(mapped, args, current.end),
|
|
1989
|
-
list: current,
|
|
1990
|
-
start: results.length,
|
|
1991
|
-
next: 1,
|
|
1992
|
-
});
|
|
1993
|
-
return;
|
|
1994
|
-
}
|
|
1995
|
-
const indexed = head.items[2];
|
|
1996
|
-
if (
|
|
1997
|
-
isSymbol(head.items[0], "_") &&
|
|
1998
|
-
(isSymbol(name, "is") || isSymbol(name, "update-field")) &&
|
|
1999
|
-
isSymbol(indexed) &&
|
|
2000
|
-
head.items.length === 3
|
|
2001
|
-
) {
|
|
2002
|
-
frames.push({
|
|
2003
|
-
head: name,
|
|
2004
|
-
indices: [],
|
|
2005
|
-
build: (args) =>
|
|
2006
|
-
name.text === "is"
|
|
2007
|
-
? mkIsApp(indexed, args, current.end)
|
|
2008
|
-
: mkUpdateFieldApp(indexed, args, current.end),
|
|
2009
|
-
list: current,
|
|
2010
|
-
start: results.length,
|
|
2011
|
-
next: 1,
|
|
2012
|
-
});
|
|
2013
|
-
return;
|
|
2014
|
-
}
|
|
2015
|
-
if (isSymbol(head.items[0], "as") && isSymbol(name) && head.items.length === 3) {
|
|
2016
|
-
const range = parseSort(head.items[2], "Invalid qualified identifier");
|
|
2017
|
-
frames.push({
|
|
2018
|
-
head: name,
|
|
2019
|
-
indices: [],
|
|
2020
|
-
build: (args) => parseApp(name, args, current.end, [], range),
|
|
2021
|
-
list: current,
|
|
2022
|
-
start: results.length,
|
|
2023
|
-
next: 1,
|
|
2024
|
-
});
|
|
2025
|
-
return;
|
|
2026
|
-
}
|
|
2027
|
-
if (
|
|
2028
|
-
isSymbol(head.items[0], "_") &&
|
|
2029
|
-
isSymbol(name) &&
|
|
2030
|
-
isPbOpName(name.text) &&
|
|
2031
|
-
indices.every((index) => index.kind === "numeral")
|
|
2032
|
-
) {
|
|
2033
|
-
const parameters = indices.map((index) =>
|
|
2034
|
-
Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
|
|
2035
|
-
);
|
|
2036
|
-
frames.push({
|
|
2037
|
-
head: name,
|
|
2038
|
-
indices: [],
|
|
2039
|
-
build: (args) => mkPbTerm(name.text, args, parameters, current.end),
|
|
2040
|
-
list: current,
|
|
2041
|
-
start: results.length,
|
|
2042
|
-
next: 1,
|
|
2043
|
-
});
|
|
2044
|
-
return;
|
|
2045
|
-
}
|
|
2046
|
-
if (
|
|
2047
|
-
!isSymbol(head.items[0], "_") ||
|
|
2048
|
-
!isSymbol(name) ||
|
|
2049
|
-
!(isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)) ||
|
|
2050
|
-
!indices.every((index) => index.kind === "numeral")
|
|
2051
|
-
)
|
|
2374
|
+
// push_app_frame: Z3 reads a head that is neither indexed nor qualified as a term.
|
|
2375
|
+
if (isSymbol(head.items[0], "lambda"))
|
|
2052
2376
|
throw new SmtUnsupportedError("indexed and qualified identifiers");
|
|
2377
|
+
frames.push(
|
|
2378
|
+
isSymbol(head.items[0], "_") || isSymbol(head.items[0], "as")
|
|
2379
|
+
? {
|
|
2380
|
+
kind: "application",
|
|
2381
|
+
list: current,
|
|
2382
|
+
...parseQualifiedHead(current, head),
|
|
2383
|
+
isTail,
|
|
2384
|
+
start: exprStack.length,
|
|
2385
|
+
next: 1,
|
|
2386
|
+
}
|
|
2387
|
+
: { kind: "selection", list: current, isTail, start: exprStack.length, next: 0 },
|
|
2388
|
+
);
|
|
2389
|
+
return;
|
|
2390
|
+
}
|
|
2391
|
+
if (head.text === "_" || head.text === "as") {
|
|
2392
|
+
deliver(parseQualifiedName(current), isTail, exprStack.length);
|
|
2393
|
+
return;
|
|
2394
|
+
}
|
|
2395
|
+
if (head.text === "root-obj") {
|
|
2396
|
+
deliver(parseRootObj(current), isTail, exprStack.length);
|
|
2397
|
+
return;
|
|
2398
|
+
}
|
|
2399
|
+
if (head.text === "match") throw new SmtUnsupportedError("the expression match");
|
|
2400
|
+
if (head.text === "let") {
|
|
2401
|
+
const bindings = current.items[1];
|
|
2402
|
+
if (bindings?.kind !== "list")
|
|
2403
|
+
throw new SmtParseError(
|
|
2404
|
+
`invalid let declaration, '(' expected got ${getLastId(bindings) ?? "let"}`,
|
|
2405
|
+
bindings ?? current.end,
|
|
2406
|
+
);
|
|
2053
2407
|
frames.push({
|
|
2054
|
-
|
|
2055
|
-
indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
2408
|
+
kind: "let",
|
|
2056
2409
|
list: current,
|
|
2057
|
-
|
|
2058
|
-
|
|
2410
|
+
bindings,
|
|
2411
|
+
names: [],
|
|
2412
|
+
isInDecls: true,
|
|
2413
|
+
isTail,
|
|
2414
|
+
start: exprStack.length,
|
|
2415
|
+
next: 0,
|
|
2059
2416
|
});
|
|
2060
2417
|
return;
|
|
2061
2418
|
}
|
|
2062
|
-
if (head.
|
|
2063
|
-
|
|
2064
|
-
|
|
2065
|
-
|
|
2066
|
-
|
|
2067
|
-
|
|
2068
|
-
|
|
2069
|
-
|
|
2070
|
-
|
|
2071
|
-
|
|
2072
|
-
|
|
2073
|
-
[],
|
|
2074
|
-
qualified,
|
|
2075
|
-
[],
|
|
2076
|
-
parseSort(current.items[2], "Invalid qualified identifier"),
|
|
2077
|
-
),
|
|
2078
|
-
);
|
|
2419
|
+
if (head.text === "!") {
|
|
2420
|
+
const parent = frames[frames.length - 1];
|
|
2421
|
+
frames.push({
|
|
2422
|
+
kind: "attribute",
|
|
2423
|
+
list: current,
|
|
2424
|
+
quantifier: parent?.kind === "quantifier" ? parent : undefined,
|
|
2425
|
+
lastKeyword: "",
|
|
2426
|
+
isTail,
|
|
2427
|
+
start: exprStack.length,
|
|
2428
|
+
next: 1,
|
|
2429
|
+
});
|
|
2079
2430
|
return;
|
|
2080
2431
|
}
|
|
2081
|
-
|
|
2082
|
-
|
|
2432
|
+
const quantifierKind = QUANTIFIER_KINDS.get(head.text);
|
|
2433
|
+
if (quantifierKind === undefined) {
|
|
2434
|
+
frames.push({
|
|
2435
|
+
kind: "application",
|
|
2436
|
+
list: current,
|
|
2437
|
+
head,
|
|
2438
|
+
indices: [],
|
|
2439
|
+
isTail,
|
|
2440
|
+
start: exprStack.length,
|
|
2441
|
+
next: 1,
|
|
2442
|
+
});
|
|
2083
2443
|
return;
|
|
2084
2444
|
}
|
|
2085
|
-
|
|
2086
|
-
|
|
2087
|
-
|
|
2088
|
-
|
|
2089
|
-
|
|
2445
|
+
// push_quant_frame.
|
|
2446
|
+
const start = exprStack.length;
|
|
2447
|
+
const bound = bindSortedVars(current.items[1], current.end, head.text);
|
|
2448
|
+
if (bound.varSorts.length === 0)
|
|
2449
|
+
throw new SmtParseError(
|
|
2450
|
+
"invalid quantifier, list of sorted variables is empty",
|
|
2451
|
+
current.items[2] ?? current.end,
|
|
2452
|
+
);
|
|
2453
|
+
frames.push({
|
|
2454
|
+
kind: "quantifier",
|
|
2455
|
+
list: current,
|
|
2456
|
+
quantifierKind,
|
|
2457
|
+
names: bound.names,
|
|
2458
|
+
varSorts: bound.varSorts,
|
|
2459
|
+
weight: 1,
|
|
2460
|
+
qid: "",
|
|
2461
|
+
skid: undefined,
|
|
2462
|
+
isTail,
|
|
2463
|
+
start,
|
|
2464
|
+
patternStart: patternStack.length,
|
|
2465
|
+
noPatternStart: noPatternStack.length,
|
|
2466
|
+
next: 2,
|
|
2467
|
+
});
|
|
2090
2468
|
};
|
|
2091
|
-
enter(sexpr);
|
|
2469
|
+
enter(sexpr, isRootTail);
|
|
2092
2470
|
while (frames.length > 0) {
|
|
2093
2471
|
const frame = frames[frames.length - 1];
|
|
2094
|
-
if (frame.
|
|
2095
|
-
|
|
2472
|
+
if (frame.kind === "let") {
|
|
2473
|
+
if (frame.isInDecls) {
|
|
2474
|
+
const declaration = frame.bindings.items[frame.next];
|
|
2475
|
+
if (declaration !== undefined) {
|
|
2476
|
+
// push_let_decl_frame.
|
|
2477
|
+
if (declaration.kind !== "list")
|
|
2478
|
+
throw new SmtParseError(
|
|
2479
|
+
`invalid let declaration, '(' expected got ${getLastId(declaration) ?? getLastIdBefore(frame.bindings.items, frame.next) ?? "let"}`,
|
|
2480
|
+
declaration,
|
|
2481
|
+
);
|
|
2482
|
+
const name = declaration.items[0];
|
|
2483
|
+
if (!isSymbol(name)) throw new SmtParseError(LET_MESSAGE, name ?? declaration.end);
|
|
2484
|
+
frame.names.push(name.text);
|
|
2485
|
+
frame.next++;
|
|
2486
|
+
frames.push({ kind: "let-decl", list: declaration, next: 1 });
|
|
2487
|
+
continue;
|
|
2488
|
+
}
|
|
2489
|
+
// pop_let_frame at the end of the declarations.
|
|
2490
|
+
if (frame.names.length !== exprStack.length - frame.start)
|
|
2491
|
+
throw new SmtParseError("malformed let expression", frame.bindings.end);
|
|
2492
|
+
beginScope();
|
|
2493
|
+
for (const [index, name] of frame.names.entries())
|
|
2494
|
+
insertLocal(name, exprStack[frame.start + index]);
|
|
2495
|
+
frame.isInDecls = false;
|
|
2496
|
+
frame.next = 2;
|
|
2497
|
+
continue;
|
|
2498
|
+
}
|
|
2499
|
+
const body = frame.list.items[frame.next];
|
|
2500
|
+
if (body !== undefined) {
|
|
2501
|
+
frame.next++;
|
|
2502
|
+
enter(body, frame.isTail && frame.next === frame.list.items.length);
|
|
2503
|
+
continue;
|
|
2504
|
+
}
|
|
2505
|
+
frames.pop();
|
|
2506
|
+
// Z3 takes the last expression on its stack, so a let without a body is its last binding.
|
|
2507
|
+
if (frame.isTail && frame.list.items.length > 2) shrinkRefs(exprStack, frame.start);
|
|
2508
|
+
else if (exprStack.length === frame.start)
|
|
2509
|
+
throw new SmtParseError("invalid let expression", frame.list.end);
|
|
2510
|
+
else deliver(exprStack[exprStack.length - 1], frame.isTail, frame.start);
|
|
2511
|
+
endScope();
|
|
2512
|
+
continue;
|
|
2513
|
+
}
|
|
2514
|
+
const items = frame.list.items;
|
|
2515
|
+
if (frame.kind === "attribute") {
|
|
2516
|
+
// consume_attributes.
|
|
2517
|
+
if (exprStack.length === frame.start) {
|
|
2518
|
+
if (frame.next >= items.length)
|
|
2519
|
+
throw new SmtParseError("invalid expression", frame.list.end);
|
|
2520
|
+
enter(items[frame.next++], false);
|
|
2521
|
+
continue;
|
|
2522
|
+
}
|
|
2523
|
+
// process_last_symbol.
|
|
2524
|
+
const last = exprStack[exprStack.length - 1];
|
|
2525
|
+
if (frame.lastKeyword === ":pattern") {
|
|
2526
|
+
const at = items[frame.next] ?? frame.list.end;
|
|
2527
|
+
if (last === -1 && !options.isIgnoringBadPatterns)
|
|
2528
|
+
throw new SmtParseError("invalid empty pattern", at);
|
|
2529
|
+
if (last !== -1)
|
|
2530
|
+
pushRef(
|
|
2531
|
+
patternStack,
|
|
2532
|
+
manager.kinds[last] === KIND_APP && manager.decls[last] === OP_PATTERN
|
|
2533
|
+
? last
|
|
2534
|
+
: mkPattern([last], at),
|
|
2535
|
+
);
|
|
2536
|
+
shrinkRefs(exprStack, exprStack.length - 1);
|
|
2537
|
+
} else if (frame.lastKeyword === ":no-pattern") {
|
|
2538
|
+
pushRef(noPatternStack, last);
|
|
2539
|
+
shrinkRefs(exprStack, exprStack.length - 1);
|
|
2540
|
+
}
|
|
2541
|
+
frame.lastKeyword = "";
|
|
2542
|
+
if (frame.next >= items.length) {
|
|
2543
|
+
frames.pop();
|
|
2544
|
+
if (frame.isTail) deliver(exprStack[exprStack.length - 1], true, frame.start);
|
|
2545
|
+
continue;
|
|
2546
|
+
}
|
|
2547
|
+
while (frame.next < items.length && frame.lastKeyword === "") {
|
|
2548
|
+
const keyword = items[frame.next];
|
|
2549
|
+
if (keyword.kind !== "keyword")
|
|
2550
|
+
throw new SmtParseError("invalid attributed expression, keyword expected", keyword);
|
|
2551
|
+
const value = items[frame.next + 1] ?? frame.list.end;
|
|
2552
|
+
const annotated = exprStack[exprStack.length - 1];
|
|
2553
|
+
const quantifier = frame.quantifier;
|
|
2554
|
+
if (keyword.text === ":named") {
|
|
2555
|
+
if (!isSymbol(value))
|
|
2556
|
+
throw new SmtParseError("invalid attribute value, symbol expected", value);
|
|
2557
|
+
nameExpr(annotated, value.text, items[frame.next + 2] ?? frame.list.end);
|
|
2558
|
+
frame.next += 2;
|
|
2559
|
+
} else if (keyword.text === ":lblpos" || keyword.text === ":lblneg") {
|
|
2560
|
+
if (!isSymbol(value))
|
|
2561
|
+
throw new SmtParseError("invalid attribute value, symbol expected", value);
|
|
2562
|
+
if (manager.sorts[annotated] !== SORT_BOOL)
|
|
2563
|
+
throw new SmtParseError(
|
|
2564
|
+
"invalid labeled expression, expression must have Bool sort",
|
|
2565
|
+
value,
|
|
2566
|
+
);
|
|
2567
|
+
deliver(
|
|
2568
|
+
manager.mkLabel(keyword.text === ":lblpos", [value.text], annotated),
|
|
2569
|
+
false,
|
|
2570
|
+
exprStack.length - 1,
|
|
2571
|
+
);
|
|
2572
|
+
frame.next += 2;
|
|
2573
|
+
} else if (!QUANTIFIER_ATTRIBUTES.has(keyword.text)) {
|
|
2574
|
+
// Z3 warns of an unknown attribute and skips its value as an s-expression.
|
|
2575
|
+
if (value.kind === ")")
|
|
2576
|
+
throw new SmtParseError("invalid s-expression, unexpected ')'", value);
|
|
2577
|
+
frame.next += 2;
|
|
2578
|
+
} else if (quantifier === undefined)
|
|
2579
|
+
throw new SmtParseError("invalid attribute, not in the scope of a quantifier", keyword);
|
|
2580
|
+
else if (keyword.text === ":weight") {
|
|
2581
|
+
// check_int, and curr_unsigned.
|
|
2582
|
+
if (value.kind !== "numeral")
|
|
2583
|
+
throw new SmtParseError("invalid weight attribute, integer expected", value);
|
|
2584
|
+
if (!isUnsigned(value.text))
|
|
2585
|
+
throw new SmtParseError(
|
|
2586
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
2587
|
+
value,
|
|
2588
|
+
);
|
|
2589
|
+
quantifier.weight = Number(value.text);
|
|
2590
|
+
frame.next += 2;
|
|
2591
|
+
} else if (keyword.text === ":skolemid" || keyword.text === ":qid") {
|
|
2592
|
+
if (!isSymbol(value))
|
|
2593
|
+
throw new SmtParseError("invalid attribute value, symbol expected", value);
|
|
2594
|
+
if (keyword.text === ":qid") quantifier.qid = value.text;
|
|
2595
|
+
else quantifier.skid = value.text;
|
|
2596
|
+
frame.next += 2;
|
|
2597
|
+
} else {
|
|
2598
|
+
frame.lastKeyword = keyword.text;
|
|
2599
|
+
frame.next++;
|
|
2600
|
+
if (keyword.text === ":pattern") enterPattern(value, frame);
|
|
2601
|
+
else if (value.kind === ")")
|
|
2602
|
+
throw new SmtParseError("invalid expression, unexpected input", value);
|
|
2603
|
+
else enter(items[frame.next++], false);
|
|
2604
|
+
}
|
|
2605
|
+
}
|
|
2606
|
+
continue;
|
|
2607
|
+
}
|
|
2608
|
+
if (frame.next < items.length) {
|
|
2609
|
+
enter(items[frame.next++], false);
|
|
2096
2610
|
continue;
|
|
2097
2611
|
}
|
|
2098
2612
|
frames.pop();
|
|
2099
|
-
if (frame.
|
|
2613
|
+
if (frame.kind === "let-decl") continue;
|
|
2614
|
+
if (frame.kind === "pattern") {
|
|
2615
|
+
deliver(mkPattern(exprStack.slice(frame.start), frame.list.end), false, frame.start);
|
|
2616
|
+
continue;
|
|
2617
|
+
}
|
|
2618
|
+
if (frame.kind === "quantifier") {
|
|
2619
|
+
// pop_quant_frame.
|
|
2620
|
+
deliver(mkParsedQuantifier(frame), frame.isTail, frame.start);
|
|
2621
|
+
shrinkRefs(patternStack, frame.patternStart);
|
|
2622
|
+
shrinkRefs(noPatternStack, frame.noPatternStart);
|
|
2623
|
+
unbindSortedVars(frame.varSorts.length);
|
|
2624
|
+
continue;
|
|
2625
|
+
}
|
|
2626
|
+
// pop_app_frame.
|
|
2627
|
+
const args = exprStack.slice(frame.start);
|
|
2628
|
+
if (args.length < (frame.kind === "selection" ? 2 : 1))
|
|
2100
2629
|
throw new SmtParseError("invalid function application, arguments missing", frame.list.end);
|
|
2101
|
-
|
|
2102
|
-
|
|
2103
|
-
|
|
2630
|
+
deliver(
|
|
2631
|
+
frame.kind === "selection"
|
|
2632
|
+
? args
|
|
2633
|
+
.slice(1)
|
|
2634
|
+
.reduce(
|
|
2635
|
+
(array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], frame.list.end),
|
|
2636
|
+
args[0],
|
|
2637
|
+
)
|
|
2638
|
+
: (frame.build?.(args) ?? parseApp(frame.head, args, frame.list.end, frame.indices)),
|
|
2639
|
+
frame.isTail,
|
|
2640
|
+
frame.start,
|
|
2104
2641
|
);
|
|
2105
2642
|
}
|
|
2106
|
-
|
|
2643
|
+
};
|
|
2644
|
+
|
|
2645
|
+
const parseTerm = (sexpr: SExpr) => {
|
|
2646
|
+
runTerm(sexpr, true);
|
|
2647
|
+
const expr = parsed.expr;
|
|
2648
|
+
parsed.expr = -1;
|
|
2649
|
+
if (!parsed.isOwned)
|
|
2650
|
+
(sexpr.kind === "list" && sexpr.root !== undefined ? floating : unrooted).push(expr);
|
|
2651
|
+
else if (manager.getRefCount(expr) > 1) manager.decRef(expr);
|
|
2652
|
+
else pending.push(expr);
|
|
2653
|
+
return expr;
|
|
2107
2654
|
};
|
|
2108
2655
|
|
|
2109
2656
|
const parseDomain = (sexpr: SExpr | undefined, at: SExpr) => {
|
|
@@ -2381,14 +2928,15 @@ export const createSmtlibReader = (
|
|
|
2381
2928
|
);
|
|
2382
2929
|
};
|
|
2383
2930
|
|
|
2384
|
-
// parse_rec_fun_decl: the variables are bound only while the range is parsed
|
|
2931
|
+
// parse_rec_fun_decl: the variables are bound only while the range is parsed, and Z3 holds them
|
|
2932
|
+
// until the command ends, as the stack does here.
|
|
2385
2933
|
const declareRecFun = (items: SExpr[], at: SExpr) => {
|
|
2386
2934
|
const symbol = expectSymbol(
|
|
2387
2935
|
items[0],
|
|
2388
2936
|
"invalid function/constant definition, symbol expected",
|
|
2389
2937
|
at,
|
|
2390
2938
|
);
|
|
2391
|
-
const bound = bindSortedVars(items[1], at);
|
|
2939
|
+
const bound = bindSortedVars(items[1], at, symbol.text);
|
|
2392
2940
|
const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
|
|
2393
2941
|
unbindSortedVars(bound.varSorts.length);
|
|
2394
2942
|
return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
|
|
@@ -2396,16 +2944,19 @@ export const createSmtlibReader = (
|
|
|
2396
2944
|
|
|
2397
2945
|
// parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
|
|
2398
2946
|
const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
|
|
2399
|
-
const
|
|
2400
|
-
const
|
|
2947
|
+
const start = exprStack.length;
|
|
2948
|
+
const bound = bindSortedVars(variables, body, "");
|
|
2949
|
+
runTerm(body, false);
|
|
2950
|
+
const parsedBody = exprStack[exprStack.length - 1];
|
|
2401
2951
|
unbindSortedVars(bound.varSorts.length);
|
|
2402
2952
|
const range = manager.funcDecls[decl].range;
|
|
2403
|
-
if (manager.sorts[
|
|
2953
|
+
if (manager.sorts[parsedBody] !== range)
|
|
2404
2954
|
throw new SmtParseError(
|
|
2405
|
-
`invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[
|
|
2955
|
+
`invalid function definition, sort mismatch. Expcected ${manager.getSortName(range)} but function body has sort ${manager.getSortName(manager.sorts[parsedBody])}`,
|
|
2406
2956
|
next,
|
|
2407
2957
|
);
|
|
2408
|
-
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false,
|
|
2958
|
+
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsedBody);
|
|
2959
|
+
shrinkRefs(exprStack, start);
|
|
2409
2960
|
};
|
|
2410
2961
|
|
|
2411
2962
|
// parse_define and insert_macro: Z3 declares a macro as a recursive function with one case, which
|
|
@@ -2422,7 +2973,9 @@ export const createSmtlibReader = (
|
|
|
2422
2973
|
subst.release();
|
|
2423
2974
|
}
|
|
2424
2975
|
for (const [index, sort] of domain.entries()) manager.incRef(manager.mkVar(index, sort));
|
|
2425
|
-
const reversedVars = domain.map((
|
|
2976
|
+
const reversedVars = domain.map((_value, index) =>
|
|
2977
|
+
manager.mkVar(index, domain[count - index - 1]),
|
|
2978
|
+
);
|
|
2426
2979
|
for (const reversedVar of reversedVars) manager.incRef(reversedVar);
|
|
2427
2980
|
const decl = manager.mkRecFuncDecl(name, domain, manager.sorts[body]);
|
|
2428
2981
|
for (const reversedVar of reversedVars) manager.decRef(reversedVar);
|
|
@@ -2431,11 +2984,13 @@ export const createSmtlibReader = (
|
|
|
2431
2984
|
};
|
|
2432
2985
|
|
|
2433
2986
|
const declareCommand = (list: SmtList) => {
|
|
2987
|
+
releasePending();
|
|
2434
2988
|
const name = list.items[0].kind === "list" ? "" : list.items[0].text;
|
|
2435
2989
|
if (name === "define-fun-rec") {
|
|
2436
2990
|
const decl = declareRecFun(list.items.slice(1), list.end);
|
|
2437
2991
|
insertFunc(decl, list.items[4] ?? list.end);
|
|
2438
2992
|
defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
|
|
2993
|
+
shrinkRefs(exprStack, 0);
|
|
2439
2994
|
return;
|
|
2440
2995
|
}
|
|
2441
2996
|
if (name === "define-funs-rec") {
|
|
@@ -2466,6 +3021,7 @@ export const createSmtlibReader = (
|
|
|
2466
3021
|
const extra = bodies.items[signatures.length];
|
|
2467
3022
|
if (extra !== undefined)
|
|
2468
3023
|
throw new SmtParseError("invalid recursive function definition, ')' expected", extra);
|
|
3024
|
+
shrinkRefs(exprStack, 0);
|
|
2469
3025
|
return;
|
|
2470
3026
|
}
|
|
2471
3027
|
if (name === "declare-datatypes") {
|
|
@@ -2512,24 +3068,27 @@ export const createSmtlibReader = (
|
|
|
2512
3068
|
}
|
|
2513
3069
|
if (name === "define-fun" || name === "define-const") {
|
|
2514
3070
|
const isConst = name === "define-const";
|
|
2515
|
-
const bound = isConst
|
|
3071
|
+
const bound = isConst
|
|
3072
|
+
? { names: [], varSorts: [] }
|
|
3073
|
+
: bindSortedVars(list.items[2], list.end, symbol.text);
|
|
2516
3074
|
const range = parseSort(
|
|
2517
3075
|
list.items[isConst ? 2 : 3] ?? list.end,
|
|
2518
3076
|
isConst ? "Invalid constant definition" : "Invalid function definition",
|
|
2519
3077
|
);
|
|
2520
|
-
|
|
3078
|
+
runTerm(list.items[isConst ? 3 : 4] ?? list.end, false);
|
|
3079
|
+
const body = exprStack[exprStack.length - 1];
|
|
2521
3080
|
if (!isConst) unbindSortedVars(bound.varSorts.length);
|
|
2522
|
-
|
|
2523
|
-
if (manager.sorts[coerced] !== range)
|
|
3081
|
+
if (manager.sorts[body] !== range)
|
|
2524
3082
|
throw new SmtParseError(
|
|
2525
3083
|
isConst
|
|
2526
3084
|
? "invalid constant definition, sort mismatch"
|
|
2527
3085
|
: "invalid function/constant definition, sort mismatch",
|
|
2528
3086
|
list.end,
|
|
2529
3087
|
);
|
|
2530
|
-
manager.incRef(
|
|
2531
|
-
declare(macros, symbol.text, { domain: bound.varSorts, range, body
|
|
2532
|
-
defineMacroFunc(symbol.text, bound.varSorts,
|
|
3088
|
+
manager.incRef(body);
|
|
3089
|
+
declare(macros, symbol.text, { domain: bound.varSorts, range, body });
|
|
3090
|
+
defineMacroFunc(symbol.text, bound.varSorts, body);
|
|
3091
|
+
shrinkRefs(exprStack, 0);
|
|
2533
3092
|
return;
|
|
2534
3093
|
}
|
|
2535
3094
|
const domain = name === "declare-fun" ? parseDomain(list.items[2], list) : [];
|
|
@@ -2548,14 +3107,7 @@ export const createSmtlibReader = (
|
|
|
2548
3107
|
if (macros.has(symbol.text))
|
|
2549
3108
|
throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
|
|
2550
3109
|
const existing = funcs.get(symbol.text) ?? [];
|
|
2551
|
-
if (
|
|
2552
|
-
existing.some(
|
|
2553
|
-
(decl) =>
|
|
2554
|
-
manager.funcDecls[decl].range === range &&
|
|
2555
|
-
manager.funcDecls[decl].domain.length === domain.length &&
|
|
2556
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
2557
|
-
)
|
|
2558
|
-
)
|
|
3110
|
+
if (existing.some((other) => hasSignature(other, domain, range)))
|
|
2559
3111
|
throw new SmtParseError(
|
|
2560
3112
|
`invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
|
|
2561
3113
|
list.end,
|
|
@@ -2563,28 +3115,66 @@ export const createSmtlibReader = (
|
|
|
2563
3115
|
declare(funcs, symbol.text, [...existing, decl]);
|
|
2564
3116
|
};
|
|
2565
3117
|
|
|
3118
|
+
// The caller takes the reference of the stack.
|
|
2566
3119
|
const parseFormula = (sexpr: SExpr) => {
|
|
2567
|
-
|
|
3120
|
+
runTerm(sexpr, false);
|
|
3121
|
+
const assertion = exprStack[exprStack.length - 1];
|
|
2568
3122
|
if (manager.sorts[assertion] !== SORT_BOOL)
|
|
2569
3123
|
throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
|
|
2570
|
-
|
|
3124
|
+
exprStack.pop();
|
|
2571
3125
|
return assertion;
|
|
2572
3126
|
};
|
|
2573
3127
|
|
|
2574
3128
|
// An assertion is named when the last name of its term is its own.
|
|
2575
3129
|
const parseAssertion = (sexpr: SExpr) => {
|
|
3130
|
+
releasePending();
|
|
2576
3131
|
lastNamed.expr = -1;
|
|
2577
3132
|
const formula = parseFormula(sexpr);
|
|
2578
3133
|
return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
|
|
2579
3134
|
};
|
|
2580
3135
|
|
|
2581
|
-
const push = () =>
|
|
3136
|
+
const push = () => {
|
|
3137
|
+
releasePending();
|
|
3138
|
+
scopeStarts.push(undo.length);
|
|
3139
|
+
};
|
|
2582
3140
|
|
|
2583
3141
|
const pop = () => {
|
|
3142
|
+
releasePending();
|
|
2584
3143
|
const start = scopeStarts.pop() ?? 0;
|
|
2585
3144
|
for (const restore of undo.splice(start).reverse()) restore();
|
|
2586
3145
|
};
|
|
2587
3146
|
|
|
3147
|
+
// parser::reset, after an error: Z3 frees its stacks, and with them the terms that only the
|
|
3148
|
+
// command that failed held.
|
|
3149
|
+
const reset = () => {
|
|
3150
|
+
protect(floating);
|
|
3151
|
+
protect(unrooted);
|
|
3152
|
+
releasePending();
|
|
3153
|
+
shrinkRefs(exprStack, 0);
|
|
3154
|
+
if (parsed.expr !== -1) {
|
|
3155
|
+
if (!parsed.isOwned) manager.incRef(parsed.expr);
|
|
3156
|
+
manager.decRef(parsed.expr);
|
|
3157
|
+
parsed.expr = -1;
|
|
3158
|
+
}
|
|
3159
|
+
shrinkRefs(patternStack, 0);
|
|
3160
|
+
shrinkRefs(noPatternStack, 0);
|
|
3161
|
+
locals.clear();
|
|
3162
|
+
shrink(shadowedNames, 0);
|
|
3163
|
+
shrink(shadowedLocals, 0);
|
|
3164
|
+
shrink(localScopes, 0);
|
|
3165
|
+
binders.depth = 0;
|
|
3166
|
+
};
|
|
3167
|
+
|
|
3168
|
+
// cmd_context::set_logic on a manager that is in use: restrict_builtin_sorts takes the sorts the
|
|
3169
|
+
// logic lacks, and the declarations and the operators stay.
|
|
3170
|
+
const restrictSorts = (name: string) => {
|
|
3171
|
+
releasePending();
|
|
3172
|
+
if (logicHasRealsOnly(name)) restricted.isNumeralAsReal = true;
|
|
3173
|
+
if (!ARRAY_EXTENSION_LOGICS.has(name)) restricted.hasSetSort = false;
|
|
3174
|
+
if (INT_FREE_LOGICS.has(name)) sortDecls.delete("Int");
|
|
3175
|
+
restricted.hasFf = FF_LOGICS.has(name);
|
|
3176
|
+
};
|
|
3177
|
+
|
|
2588
3178
|
const isUsed = (name: string) => funcs.has(name) || BUILTIN_NAMES.has(name);
|
|
2589
3179
|
|
|
2590
3180
|
const isClashing = (decl: number) => {
|
|
@@ -2592,12 +3182,7 @@ export const createSmtlibReader = (
|
|
|
2592
3182
|
const decls = funcs.get(String(manager.funcDecls[decl].name)) ?? [];
|
|
2593
3183
|
return (
|
|
2594
3184
|
decls.includes(decl) &&
|
|
2595
|
-
decls.some(
|
|
2596
|
-
(other) =>
|
|
2597
|
-
other !== decl &&
|
|
2598
|
-
manager.funcDecls[other].domain.length === domain.length &&
|
|
2599
|
-
manager.funcDecls[other].domain.every((sort, index) => sort === domain[index]),
|
|
2600
|
-
)
|
|
3185
|
+
decls.some((other) => other !== decl && hasSignature(other, domain, -1))
|
|
2601
3186
|
);
|
|
2602
3187
|
};
|
|
2603
3188
|
|
|
@@ -2625,6 +3210,8 @@ export const createSmtlibReader = (
|
|
|
2625
3210
|
getLogicError: logicChecker.checkExpr,
|
|
2626
3211
|
push,
|
|
2627
3212
|
pop,
|
|
3213
|
+
reset,
|
|
3214
|
+
restrictSorts,
|
|
2628
3215
|
isUsed,
|
|
2629
3216
|
isClashing,
|
|
2630
3217
|
getDeclaredFuncs,
|
|
@@ -2654,7 +3241,7 @@ export const parseSmtlib = (
|
|
|
2654
3241
|
report: (error: SmtParseError) => void,
|
|
2655
3242
|
): SmtProblem => {
|
|
2656
3243
|
const commands = createCommandReader(text);
|
|
2657
|
-
const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0 };
|
|
3244
|
+
const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0, isInUse: false };
|
|
2658
3245
|
const assertions: number[] = [];
|
|
2659
3246
|
const runCommand = (list: SmtList) => {
|
|
2660
3247
|
const name = expectSymbol(list.items[0], "invalid command, symbol expected", list).text;
|
|
@@ -2668,19 +3255,26 @@ export const parseSmtlib = (
|
|
|
2668
3255
|
)
|
|
2669
3256
|
state.rlimit = Number(value.text);
|
|
2670
3257
|
if (name === "set-logic") {
|
|
3258
|
+
if (option === undefined)
|
|
3259
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2671
3260
|
if (!isSymbol(option))
|
|
2672
|
-
throw new SmtParseError("invalid
|
|
2673
|
-
if (
|
|
3261
|
+
throw new SmtParseError("invalid command argument, symbol expected", option);
|
|
3262
|
+
if (value !== undefined)
|
|
3263
|
+
throw new SmtParseError("invalid command, too many arguments", value);
|
|
3264
|
+
if (state.logic !== "") throw new SmtParseError("the logic has already been set", option);
|
|
2674
3265
|
if (assertions.length > 0)
|
|
2675
|
-
throw new SmtParseError("logic must be set before initialization",
|
|
3266
|
+
throw new SmtParseError("logic must be set before initialization", option);
|
|
2676
3267
|
if (!isSupportedLogic(option.text)) return;
|
|
2677
3268
|
state.logic = option.text;
|
|
2678
|
-
state.reader
|
|
3269
|
+
if (state.isInUse) state.reader.restrictSorts(option.text);
|
|
3270
|
+
else state.reader = createSmtlibReader(manager, option.text);
|
|
2679
3271
|
} else if (DECLARATIONS.has(name)) {
|
|
3272
|
+
state.isInUse = true;
|
|
2680
3273
|
if (name.startsWith("define-"))
|
|
2681
3274
|
throw new SmtUnsupportedError(`the command ${name} is not supported`);
|
|
2682
3275
|
state.reader.declareCommand(list);
|
|
2683
3276
|
} else if (name === "assert") {
|
|
3277
|
+
state.isInUse = true;
|
|
2684
3278
|
const assertion = state.reader.parseFormula(list.items[1] ?? list.end);
|
|
2685
3279
|
const logicError = state.reader.getLogicError(assertion);
|
|
2686
3280
|
if (logicError !== undefined) {
|
|
@@ -2702,6 +3296,7 @@ export const parseSmtlib = (
|
|
|
2702
3296
|
} catch (error) {
|
|
2703
3297
|
if (!(error instanceof SmtParseError)) throw error;
|
|
2704
3298
|
report(error);
|
|
3299
|
+
state.reader.reset();
|
|
2705
3300
|
commands.skip(report);
|
|
2706
3301
|
}
|
|
2707
3302
|
}
|