tla-ts 0.0.10-dev.094b9b512 → 0.0.10-dev.09e53c2a6
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 +3 -0
- package/dist/index.d.ts +3 -0
- 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 +142 -54
- package/dist/run.cjs +45 -43
- package/dist/run.js +47 -45
- package/dist/transfer.cjs +39 -36
- package/dist/transfer.js +23 -20
- 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/check.ts +203 -33
- package/src/cli/tlapm.ts +268 -71
- package/src/cli/tlc-output.ts +3 -3
- package/src/cli/tlc-usage.ts +0 -1
- package/src/cli/tlc.ts +15 -1
- package/src/dependencies.ts +23 -2
- package/src/environment.ts +10 -5
- package/src/errors.ts +1 -1
- package/src/exit-codes.ts +1 -0
- package/src/liveness-checker.ts +530 -201
- 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 +8 -7
- 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 +1 -4
- package/src/obligations/substitution.ts +0 -2
- package/src/obligations/temporal.ts +0 -2
- package/src/obligations/tuples.ts +0 -2
- package/src/parallel.ts +2 -2
- package/src/parser.ts +151 -42
- 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 -55
- package/src/prover/isabelle/isar/context.ts +25 -26
- package/src/prover/isabelle/isar/induct.ts +2 -12
- package/src/prover/isabelle/isar/method.ts +6 -10
- package/src/prover/isabelle/isar/proof.ts +40 -39
- package/src/prover/isabelle/isar/rule-cases.ts +6 -16
- 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 +0 -2
- package/src/prover/isabelle/provers/classical.ts +1 -3
- package/src/prover/isabelle/provers/hypsubst.ts +0 -2
- 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 +55 -6
- 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/context.ts +10 -14
- package/src/prover/smt/data.ts +51 -45
- package/src/prover/smt/encode.ts +1 -2
- package/src/prover/smt/rewrite.ts +1 -0
- 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 +1 -8
- 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 +4 -7
- 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 +1 -4
- package/src/prover/smt/solver/asserted-formulas.ts +1 -2
- package/src/prover/smt/solver/ast-lt.ts +1 -2
- package/src/prover/smt/solver/ast-util.ts +4 -5
- package/src/prover/smt/solver/ast.ts +113 -157
- package/src/prover/smt/solver/auf-solver.ts +0 -1
- package/src/prover/smt/solver/bit-blast-tactic.ts +2 -11
- 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 +14 -18
- 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 +0 -2
- 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 +8 -8
- package/src/prover/smt/solver/context.ts +21 -12
- package/src/prover/smt/solver/ctx-simplify.ts +0 -1
- package/src/prover/smt/solver/ctx-solver-simplify.ts +0 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +7 -10
- 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 +0 -1
- 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 +3 -16
- package/src/prover/smt/solver/enode.ts +16 -10
- 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 -7
- package/src/prover/smt/solver/euf/arith-solver.ts +0 -6
- 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 +0 -2
- 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 +66 -44
- package/src/prover/smt/solver/euf/euf-solver.ts +37 -35
- package/src/prover/smt/solver/euf/fpa-solver.ts +37 -53
- package/src/prover/smt/solver/euf/mam.ts +6 -50
- package/src/prover/smt/solver/euf/q-ematch.ts +26 -96
- 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 +3 -3
- package/src/prover/smt/solver/euf/th-solver.ts +1 -9
- 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 +0 -1
- package/src/prover/smt/solver/factor.ts +1 -12
- package/src/prover/smt/solver/fd-solver.ts +1 -5
- package/src/prover/smt/solver/fingerprints.ts +0 -1
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/flat-literals.ts +0 -1
- package/src/prover/smt/solver/fm-tactic.ts +25 -14
- package/src/prover/smt/solver/fpa-decl-plugin.ts +0 -1
- package/src/prover/smt/solver/fpa-rewriter.ts +13 -14
- package/src/prover/smt/solver/fpa2bv-converter.ts +10 -7
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +0 -1
- package/src/prover/smt/solver/fpa2bv-tactic.ts +1 -3
- package/src/prover/smt/solver/goal.ts +0 -1
- package/src/prover/smt/solver/goal2nlsat.ts +0 -2
- 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 +1 -2
- 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 +0 -1
- package/src/prover/smt/solver/lp/core-solver.ts +0 -3
- package/src/prover/smt/solver/lp/cross-nested.ts +0 -1
- 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 +0 -1
- package/src/prover/smt/solver/lp/nex.ts +0 -1
- 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 +25 -6
- 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 +0 -2
- 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 +97 -62
- package/src/prover/smt/solver/lp/numeric-pair.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-interval.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +0 -1
- package/src/prover/smt/solver/lp/pdd-solver.ts +0 -2
- package/src/prover/smt/solver/lp/pdd.ts +2 -2
- 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 +0 -1
- package/src/prover/smt/solver/macro-finder.ts +1 -4
- package/src/prover/smt/solver/mam-compiler.ts +13 -14
- 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 +6 -15
- package/src/prover/smt/solver/maximize-ac-sharing.ts +0 -2
- 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 +10 -3
- 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 +1 -19
- package/src/prover/smt/solver/model-based-opt.ts +0 -1
- package/src/prover/smt/solver/model-checker.ts +2 -3
- 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 +0 -1
- 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 +0 -1
- package/src/prover/smt/solver/mus.ts +0 -1
- package/src/prover/smt/solver/muz/dl-context.ts +57 -15
- 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 -6
- package/src/prover/smt/solver/muz/dl-mk-rule-inliner.ts +39 -11
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +76 -14
- package/src/prover/smt/solver/muz/dl-mk-subsumption-checker.ts +9 -4
- package/src/prover/smt/solver/muz/dl-rule-set.ts +0 -30
- package/src/prover/smt/solver/muz/dl-rule-transformer.ts +0 -4
- package/src/prover/smt/solver/muz/dl-rule.ts +91 -55
- 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 +14 -5
- package/src/prover/smt/solver/muz/rule-properties.ts +195 -37
- package/src/prover/smt/solver/muz/spacer-context.ts +109 -98
- package/src/prover/smt/solver/muz/spacer-dl-interface.ts +15 -4
- package/src/prover/smt/solver/muz/spacer-generalizers.ts +0 -3
- package/src/prover/smt/solver/muz/spacer-manager.ts +0 -6
- package/src/prover/smt/solver/muz/spacer-pdr.ts +3 -4
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +4 -15
- package/src/prover/smt/solver/muz/spacer-util.ts +2 -29
- 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 +1 -4
- package/src/prover/smt/solver/nlsat/atoms.ts +0 -2
- package/src/prover/smt/solver/nlsat/evaluator.ts +0 -1
- package/src/prover/smt/solver/nlsat/explain.ts +5 -1
- package/src/prover/smt/solver/nlsat/interval-set.ts +0 -1
- package/src/prover/smt/solver/nlsat/levelwise.ts +2 -3
- package/src/prover/smt/solver/nlsat/mpbq.ts +0 -1
- package/src/prover/smt/solver/nlsat/polynomial.ts +0 -2
- package/src/prover/smt/solver/nlsat/solver.ts +47 -44
- package/src/prover/smt/solver/nlsat/transcendental-eval.ts +2 -3
- package/src/prover/smt/solver/nlsat/transcendentals.ts +0 -2
- package/src/prover/smt/solver/nlsat/types.ts +0 -2
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +0 -3
- package/src/prover/smt/solver/nlsat/upolynomial.ts +0 -2
- 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 +10 -10
- package/src/prover/smt/solver/opt-nlsat.ts +68 -59
- 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 +16 -8
- package/src/prover/smt/solver/opt-value.ts +0 -1
- package/src/prover/smt/solver/optsmt.ts +12 -11
- 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 -26
- 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 +3 -5
- package/src/prover/smt/solver/propagate-values.ts +4 -1
- package/src/prover/smt/solver/proto-model.ts +5 -6
- 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 +2 -3
- 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 +45 -55
- 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 +71 -97
- package/src/prover/smt/solver/quant-hoist.ts +2 -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 +0 -1
- 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 +33 -20
- 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 +2 -20
- package/src/prover/smt/solver/sat/cleaner.ts +0 -2
- package/src/prover/smt/solver/sat/config.ts +5 -8
- 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 -14
- package/src/prover/smt/solver/sat/model-converter.ts +1 -21
- package/src/prover/smt/solver/sat/pb-constraint.ts +0 -3
- package/src/prover/smt/solver/sat/pb-solver.ts +49 -25
- package/src/prover/smt/solver/sat/probing.ts +22 -21
- package/src/prover/smt/solver/sat/sat-tactic.ts +0 -1
- package/src/prover/smt/solver/sat/sat2goal.ts +9 -15
- package/src/prover/smt/solver/sat/scc.ts +1 -2
- package/src/prover/smt/solver/sat/simplifier.ts +15 -59
- package/src/prover/smt/solver/sat/solver.ts +22 -23
- 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 +1 -4
- package/src/prover/smt/solver/seq-decl-plugin.ts +9 -13
- package/src/prover/smt/solver/seq-derive.ts +8 -10
- package/src/prover/smt/solver/seq-eq-approx.ts +0 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +7 -8
- package/src/prover/smt/solver/seq-factory.ts +2 -4
- package/src/prover/smt/solver/seq-monadic.ts +0 -2
- package/src/prover/smt/solver/seq-range-predicate.ts +18 -8
- package/src/prover/smt/solver/seq-re-rewriter.ts +3 -129
- package/src/prover/smt/solver/seq-re-util.ts +7 -26
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -2
- package/src/prover/smt/solver/seq-regex-live.ts +4 -6
- package/src/prover/smt/solver/seq-rewriter.ts +1 -6
- package/src/prover/smt/solver/seq-skolem.ts +0 -1
- package/src/prover/smt/solver/seq-subset.ts +0 -1
- package/src/prover/smt/solver/seq-view-witness.ts +0 -2
- package/src/prover/smt/solver/smt-consequences.ts +0 -2
- package/src/prover/smt/solver/smt-kernel.ts +0 -2
- 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 +1204 -582
- package/src/prover/smt/solver/smtlib-script.ts +868 -730
- package/src/prover/smt/solver/solve-eqs.ts +0 -2
- package/src/prover/smt/solver/solver.ts +1 -2
- package/src/prover/smt/solver/static-features.ts +0 -5
- package/src/prover/smt/solver/sticky-generations.ts +0 -1
- package/src/prover/smt/solver/tactic.ts +66 -16
- 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 +13 -52
- 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 -1
- 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 -1
- package/src/prover/smt/solver/theory-lra-state.ts +0 -1
- package/src/prover/smt/solver/theory-lra.ts +0 -6
- package/src/prover/smt/solver/theory-pb.ts +10 -8
- 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 +5 -7
- package/src/prover/smt/solver/theory-seq-state.ts +6 -15
- 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 +6 -6
- 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 +0 -2
- package/src/prover/zenon/expr.ts +0 -2
- package/src/prover/zenon/index-table.ts +0 -2
- package/src/prover/zenon/isar-case.ts +0 -2
- package/src/prover/zenon/isar.ts +0 -2
- 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 +0 -2
- package/src/prover/zenon/proof.ts +0 -2
- package/src/prover/zenon/propositional-rules.ts +0 -2
- package/src/prover/zenon/rules.ts +0 -2
- 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 +1 -2
- package/src/runtime.ts +4 -0
- package/src/sany/levels.ts +0 -2
- package/src/sany/linter.ts +0 -2
- package/src/search.ts +160 -36
- package/src/simulate.ts +3 -0
- package/src/standard-definitions.ts +4 -0
- package/src/state-graph.ts +0 -2
- 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/summary.ts +29 -14
- package/src/tlc/tlcext-operators.ts +44 -12
- package/src/typed-tier.ts +6535 -0
- 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;
|
|
@@ -214,15 +216,103 @@ interface SmtProblem {
|
|
|
214
216
|
rlimit: number;
|
|
215
217
|
}
|
|
216
218
|
|
|
217
|
-
interface
|
|
219
|
+
interface QualifiedHead {
|
|
218
220
|
head: SmtToken;
|
|
219
221
|
indices: number[];
|
|
220
222
|
build?: (args: number[]) => number;
|
|
223
|
+
}
|
|
224
|
+
|
|
225
|
+
interface ApplicationFrame extends QualifiedHead {
|
|
226
|
+
kind: "application";
|
|
227
|
+
list: SmtList;
|
|
228
|
+
isTail: boolean;
|
|
229
|
+
start: number;
|
|
230
|
+
next: number;
|
|
231
|
+
}
|
|
232
|
+
|
|
233
|
+
// An application whose head is a term, which selects from the array it stands for.
|
|
234
|
+
interface SelectionFrame {
|
|
235
|
+
kind: "selection";
|
|
221
236
|
list: SmtList;
|
|
237
|
+
isTail: boolean;
|
|
222
238
|
start: number;
|
|
223
239
|
next: number;
|
|
224
240
|
}
|
|
225
241
|
|
|
242
|
+
interface LetFrame {
|
|
243
|
+
kind: "let";
|
|
244
|
+
list: SmtList;
|
|
245
|
+
bindings: SmtList;
|
|
246
|
+
names: string[];
|
|
247
|
+
isInDecls: boolean;
|
|
248
|
+
isTail: boolean;
|
|
249
|
+
start: number;
|
|
250
|
+
next: number;
|
|
251
|
+
}
|
|
252
|
+
|
|
253
|
+
interface LetDeclFrame {
|
|
254
|
+
kind: "let-decl";
|
|
255
|
+
list: SmtList;
|
|
256
|
+
next: number;
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
interface QuantifierFrame {
|
|
260
|
+
kind: "quantifier";
|
|
261
|
+
list: SmtList;
|
|
262
|
+
quantifierKind: number;
|
|
263
|
+
names: string[];
|
|
264
|
+
varSorts: number[];
|
|
265
|
+
weight: number;
|
|
266
|
+
qid: string;
|
|
267
|
+
skid: string | undefined;
|
|
268
|
+
isTail: boolean;
|
|
269
|
+
start: number;
|
|
270
|
+
patternStart: number;
|
|
271
|
+
noPatternStart: number;
|
|
272
|
+
next: number;
|
|
273
|
+
}
|
|
274
|
+
|
|
275
|
+
interface AttributeFrame {
|
|
276
|
+
kind: "attribute";
|
|
277
|
+
list: SmtList;
|
|
278
|
+
quantifier: QuantifierFrame | undefined;
|
|
279
|
+
lastKeyword: string;
|
|
280
|
+
isTail: boolean;
|
|
281
|
+
start: number;
|
|
282
|
+
next: number;
|
|
283
|
+
}
|
|
284
|
+
|
|
285
|
+
interface PatternFrame {
|
|
286
|
+
kind: "pattern";
|
|
287
|
+
list: SmtList;
|
|
288
|
+
start: number;
|
|
289
|
+
next: number;
|
|
290
|
+
}
|
|
291
|
+
|
|
292
|
+
// smt2parser.cpp's expr_frame.
|
|
293
|
+
type TermFrame =
|
|
294
|
+
| ApplicationFrame
|
|
295
|
+
| SelectionFrame
|
|
296
|
+
| LetFrame
|
|
297
|
+
| LetDeclFrame
|
|
298
|
+
| QuantifierFrame
|
|
299
|
+
| AttributeFrame
|
|
300
|
+
| PatternFrame;
|
|
301
|
+
|
|
302
|
+
const QUANTIFIER_KINDS = new Map([
|
|
303
|
+
["forall", QUANTIFIER_FORALL],
|
|
304
|
+
["exists", QUANTIFIER_EXISTS],
|
|
305
|
+
["lambda", QUANTIFIER_LAMBDA],
|
|
306
|
+
]);
|
|
307
|
+
|
|
308
|
+
const LET_MESSAGE = "invalid let declaration, symbol expected";
|
|
309
|
+
|
|
310
|
+
// The attributes that consume_attributes takes only in the body of a quantifier.
|
|
311
|
+
const QUANTIFIER_ATTRIBUTES = new Set([":weight", ":skolemid", ":qid", ":pattern", ":no-pattern"]);
|
|
312
|
+
|
|
313
|
+
const IS_PARAMETER_MESSAGE =
|
|
314
|
+
"invalid parameter to datatype function arity == 1 && num_parameters == 1 && parameters[0].is_ast() && is_func_decl(parameters[0].get_ast())";
|
|
315
|
+
|
|
226
316
|
const BUILTIN_OPS = new Map<string, number>([
|
|
227
317
|
["and", OP_AND],
|
|
228
318
|
["-", OP_SUB],
|
|
@@ -389,17 +479,19 @@ const THEORY_OPERATORS = new Set([
|
|
|
389
479
|
"transitive-closure",
|
|
390
480
|
]);
|
|
391
481
|
|
|
392
|
-
//
|
|
393
|
-
// left.
|
|
394
|
-
const
|
|
482
|
+
// func_decl_info of the builtin declarations: associative to both sides, flat, and associative to
|
|
483
|
+
// the left only. => alone is associative to the right only.
|
|
484
|
+
const ASSOCIATIVE_OPS = new Set([OP_AND, OP_OR, OP_XOR, OP_ADD, OP_MUL]);
|
|
485
|
+
const FLAT_OPS = new Set([OP_AND, OP_OR, OP_ADD, OP_MUL]);
|
|
486
|
+
const LEFT_ASSOCIATIVE_OPS = new Set([OP_SUB, OP_DIV, OP_IDIV]);
|
|
395
487
|
|
|
488
|
+
// arith_decl_plugin's use_coercion.
|
|
396
489
|
const COERCING_OPS = new Set([
|
|
397
490
|
OP_ADD,
|
|
398
491
|
OP_SUB,
|
|
399
492
|
OP_UMINUS,
|
|
400
493
|
OP_MUL,
|
|
401
494
|
OP_POWER,
|
|
402
|
-
OP_POWER0,
|
|
403
495
|
OP_LE,
|
|
404
496
|
OP_GE,
|
|
405
497
|
OP_LT,
|
|
@@ -424,30 +516,12 @@ const REAL_FUNCTION_OPS = new Set([
|
|
|
424
516
|
OP_LOG,
|
|
425
517
|
]);
|
|
426
518
|
|
|
427
|
-
|
|
428
|
-
|
|
429
|
-
[
|
|
430
|
-
[OP_ITE, [3, 3]],
|
|
431
|
-
[OP_EQ, [2, Infinity]],
|
|
432
|
-
[OP_DISTINCT, [1, Infinity]],
|
|
519
|
+
// The arity of each builtin declaration but distinct, which takes the arguments it is given.
|
|
520
|
+
const ARITIES = new Map<number, number>([
|
|
521
|
+
[OP_ITE, 3],
|
|
433
522
|
...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
|
|
434
523
|
.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]]),
|
|
524
|
+
.map((op): [number, number] => [op, 1]),
|
|
451
525
|
]);
|
|
452
526
|
|
|
453
527
|
const RANGES = new Map<number, number>([
|
|
@@ -483,6 +557,7 @@ const CHAINABLE_OPS = new Map<string, number>([
|
|
|
483
557
|
["<", OP_LT],
|
|
484
558
|
[">", OP_GT],
|
|
485
559
|
]);
|
|
560
|
+
const CHAINABLE_DECLS = new Set(CHAINABLE_OPS.values());
|
|
486
561
|
|
|
487
562
|
const BV_EXTENSION_NAMES = new Set([
|
|
488
563
|
"bvumul_noovfl",
|
|
@@ -544,6 +619,9 @@ interface MappedDecl {
|
|
|
544
619
|
}
|
|
545
620
|
const ARRAY_EXTENSION_LOGICS = new Set(["HORN", "ALL"]);
|
|
546
621
|
|
|
622
|
+
// arith_decl_plugin::get_sort_names gives these logics no Int.
|
|
623
|
+
const INT_FREE_LOGICS = new Set(["NRA", "QF_NRA", "QF_NTA", "QF_UFNRA"]);
|
|
624
|
+
|
|
547
625
|
const BUILTIN_NAMES = new Set([
|
|
548
626
|
"true",
|
|
549
627
|
"false",
|
|
@@ -558,6 +636,14 @@ const BUILTIN_NAMES = new Set([
|
|
|
558
636
|
...CHAR_OP_NAMES.keys(),
|
|
559
637
|
]);
|
|
560
638
|
|
|
639
|
+
const FOLLOWED_HEADS = new Set(["root-obj", "_", "as"]);
|
|
640
|
+
|
|
641
|
+
const FF_LITERAL = /^#f-?[0-9]+m[0-9]+$/;
|
|
642
|
+
const FF_LOGICS = new Set(["QF_FF", "QF_FFA", "ALL", "HO_ALL"]);
|
|
643
|
+
|
|
644
|
+
// rational::is_unsigned of a numeral token.
|
|
645
|
+
const isUnsigned = (numeral: string) => BigInt(numeral) >= 0n && BigInt(numeral) <= 0xffffffffn;
|
|
646
|
+
|
|
561
647
|
const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
|
|
562
648
|
|
|
563
649
|
const createScanner = (text: string) => {
|
|
@@ -607,6 +693,11 @@ const createScanner = (text: string) => {
|
|
|
607
693
|
{ line: state.line, column: getColumn() },
|
|
608
694
|
);
|
|
609
695
|
const current = text[state.index];
|
|
696
|
+
if (character === "|" && current === "\\")
|
|
697
|
+
throw new SmtParseError("invalid character '\\' in quoted symbol", {
|
|
698
|
+
line: state.line,
|
|
699
|
+
column: getColumn(),
|
|
700
|
+
});
|
|
610
701
|
advance();
|
|
611
702
|
// Z3's scanner starts the line before it reads past a newline in a quoted symbol or a
|
|
612
703
|
// string, so the columns of the rest of the line count one more.
|
|
@@ -630,7 +721,36 @@ const createScanner = (text: string) => {
|
|
|
630
721
|
}
|
|
631
722
|
if (character === "#") {
|
|
632
723
|
advance();
|
|
633
|
-
|
|
724
|
+
const radix = text[state.index];
|
|
725
|
+
if (radix === "|") {
|
|
726
|
+
advance();
|
|
727
|
+
while (state.index < text.length) {
|
|
728
|
+
const current = text[state.index];
|
|
729
|
+
advance();
|
|
730
|
+
if (current !== "|" || text[state.index] !== "#") continue;
|
|
731
|
+
advance();
|
|
732
|
+
break;
|
|
733
|
+
}
|
|
734
|
+
continue;
|
|
735
|
+
}
|
|
736
|
+
if (radix === "f") {
|
|
737
|
+
advance();
|
|
738
|
+
readWhile(/[0-9m-]/);
|
|
739
|
+
return getToken("symbol");
|
|
740
|
+
}
|
|
741
|
+
if (radix !== "x" && radix !== "b")
|
|
742
|
+
throw new SmtParseError("invalid bit-vector literal, expecting 'x' or 'b'", {
|
|
743
|
+
line: state.line,
|
|
744
|
+
column: getColumn(),
|
|
745
|
+
});
|
|
746
|
+
advance();
|
|
747
|
+
const digitsStart = state.index;
|
|
748
|
+
readWhile(radix === "x" ? /[0-9a-fA-F]/ : /[01]/);
|
|
749
|
+
if (state.index === digitsStart)
|
|
750
|
+
throw new SmtParseError("invalid empty bit-vector literal", {
|
|
751
|
+
line: state.line,
|
|
752
|
+
column: getColumn(),
|
|
753
|
+
});
|
|
634
754
|
return getToken("bitvector");
|
|
635
755
|
}
|
|
636
756
|
if (character === ":" || SYMBOL_CHARACTER.test(character)) {
|
|
@@ -666,13 +786,13 @@ export const createCommandReader = (text: string) => {
|
|
|
666
786
|
offset: open.offset,
|
|
667
787
|
end: open,
|
|
668
788
|
};
|
|
669
|
-
let
|
|
789
|
+
let followed: SmtList | undefined;
|
|
670
790
|
for (let current = root; ;) {
|
|
671
791
|
const token = take();
|
|
672
792
|
if (token === undefined)
|
|
673
793
|
throw new SmtParseError("unexpected end of file", scanner.getPosition());
|
|
674
|
-
if (
|
|
675
|
-
|
|
794
|
+
if (followed !== undefined) followed.follower = token;
|
|
795
|
+
followed = undefined;
|
|
676
796
|
if (token.kind === "(") {
|
|
677
797
|
const list: SmtList = {
|
|
678
798
|
kind: "list",
|
|
@@ -681,6 +801,7 @@ export const createCommandReader = (text: string) => {
|
|
|
681
801
|
column: token.column,
|
|
682
802
|
offset: token.offset,
|
|
683
803
|
end: token,
|
|
804
|
+
root,
|
|
684
805
|
};
|
|
685
806
|
current.items.push(list);
|
|
686
807
|
stack.push(current);
|
|
@@ -693,7 +814,8 @@ export const createCommandReader = (text: string) => {
|
|
|
693
814
|
continue;
|
|
694
815
|
}
|
|
695
816
|
current.end = token;
|
|
696
|
-
if (isSymbol(current.items[0]
|
|
817
|
+
if (isSymbol(current.items[0]) && FOLLOWED_HEADS.has(current.items[0].text))
|
|
818
|
+
followed = current;
|
|
697
819
|
state.depth--;
|
|
698
820
|
const parent = stack.pop();
|
|
699
821
|
if (parent === undefined) return root;
|
|
@@ -730,6 +852,28 @@ export const createCommandReader = (text: string) => {
|
|
|
730
852
|
export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
|
|
731
853
|
sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
|
|
732
854
|
|
|
855
|
+
// The identifier Z3's scanner read last, which check_next prints after "got".
|
|
856
|
+
const getLastId = (sexpr: SExpr | undefined): string | undefined => {
|
|
857
|
+
if (sexpr === undefined) return undefined;
|
|
858
|
+
if (sexpr.kind !== "list")
|
|
859
|
+
return sexpr.kind === "symbol" || sexpr.kind === "keyword" ? sexpr.text : undefined;
|
|
860
|
+
return getLastIdBefore(sexpr.items, sexpr.items.length);
|
|
861
|
+
};
|
|
862
|
+
|
|
863
|
+
const getLastIdBefore = (items: SExpr[], end: number): string | undefined => {
|
|
864
|
+
for (let index = end - 1; index >= 0; index--) {
|
|
865
|
+
const id = getLastId(items[index]);
|
|
866
|
+
if (id !== undefined) return id;
|
|
867
|
+
}
|
|
868
|
+
return undefined;
|
|
869
|
+
};
|
|
870
|
+
|
|
871
|
+
const isSimpleIndex = (index: SExpr) =>
|
|
872
|
+
index.kind === "numeral" ||
|
|
873
|
+
index.kind === "bitvector" ||
|
|
874
|
+
index.kind === "decimal" ||
|
|
875
|
+
index.kind === "keyword";
|
|
876
|
+
|
|
733
877
|
const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtList => {
|
|
734
878
|
if (sexpr?.kind !== "list") throw new SmtParseError(message, sexpr ?? at);
|
|
735
879
|
return sexpr;
|
|
@@ -747,16 +891,13 @@ export const createSmtlibReader = (
|
|
|
747
891
|
) => {
|
|
748
892
|
const hasArith = logic === undefined || logicHasArith(logic);
|
|
749
893
|
const hasBv = logic === undefined || logicHasBv(logic);
|
|
750
|
-
const isNumeralAsReal = logic !== undefined && logicHasRealsOnly(logic);
|
|
751
894
|
const logicChecker = createLogicChecker(manager, logic);
|
|
752
895
|
const sortDecls = new Map<string, SortDecl>([
|
|
753
896
|
["Bool", { kind: "sort", sort: SORT_BOOL }],
|
|
754
|
-
...(hasArith
|
|
755
|
-
? [
|
|
756
|
-
["Int", { kind: "sort", sort: SORT_INT }] as const,
|
|
757
|
-
["Real", { kind: "sort", sort: SORT_REAL }] as const,
|
|
758
|
-
]
|
|
897
|
+
...(hasArith && !(logic !== undefined && INT_FREE_LOGICS.has(logic))
|
|
898
|
+
? [["Int", { kind: "sort", sort: SORT_INT }] as const]
|
|
759
899
|
: []),
|
|
900
|
+
...(hasArith ? [["Real", { kind: "sort", sort: SORT_REAL }] as const] : []),
|
|
760
901
|
...(logic === undefined ? [["List", { kind: "list" }] as const] : []),
|
|
761
902
|
]);
|
|
762
903
|
const funcs = new Map<string, readonly number[]>();
|
|
@@ -765,8 +906,25 @@ export const createSmtlibReader = (
|
|
|
765
906
|
const notifiedSorts = new Set<number>();
|
|
766
907
|
const undo: (() => void)[] = [];
|
|
767
908
|
const scopeStarts: number[] = [];
|
|
768
|
-
|
|
909
|
+
// smt2parser's m_env, a scoped symbol table: one map, and the trail of what each scope shadowed.
|
|
910
|
+
const locals = new Map<string, Local>();
|
|
911
|
+
const shadowedNames: string[] = [];
|
|
912
|
+
const shadowedLocals: (Local | undefined)[] = [];
|
|
913
|
+
const localScopes: number[] = [];
|
|
769
914
|
const binders = { depth: 0 };
|
|
915
|
+
// smt2parser's expr_stack, pattern_stack and nopattern_stack, which hold a reference to each term.
|
|
916
|
+
// -1 on the first stands for a pattern that Z3 ignores.
|
|
917
|
+
const exprStack: number[] = [];
|
|
918
|
+
const patternStack: number[] = [];
|
|
919
|
+
const noPatternStack: number[] = [];
|
|
920
|
+
// The term that parseTerm returns leaves the stack before its caller takes a reference. One that
|
|
921
|
+
// only the stack held keeps a reference in pending until a term of another command is parsed, and
|
|
922
|
+
// one that nothing held, in floating or, where its command is not known, in unrooted, gets one
|
|
923
|
+
// there when another term is parsed while its caller may still read it.
|
|
924
|
+
const parsed: ParsedTerm = { expr: -1, isOwned: false, root: undefined };
|
|
925
|
+
const floating: number[] = [];
|
|
926
|
+
const unrooted: number[] = [];
|
|
927
|
+
const pending: number[] = [];
|
|
770
928
|
|
|
771
929
|
const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
|
|
772
930
|
const previous = names.get(name);
|
|
@@ -781,9 +939,20 @@ export const createSmtlibReader = (
|
|
|
781
939
|
const hasFpa = logic === undefined || logicHasFpa(logic);
|
|
782
940
|
const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
|
|
783
941
|
const hasSeq = logic === undefined || logicHasSeq(logic);
|
|
942
|
+
const restricted = {
|
|
943
|
+
isNumeralAsReal: logic !== undefined && logicHasRealsOnly(logic),
|
|
944
|
+
hasSetSort: hasArrayExtensions,
|
|
945
|
+
hasFf: logic === undefined || FF_LOGICS.has(logic),
|
|
946
|
+
};
|
|
784
947
|
|
|
785
948
|
const getFirstFunc = (name: string) => funcs.get(name)?.[0];
|
|
786
949
|
|
|
950
|
+
// func_decls::signatures_collide: the domain, and the range unless it is -1.
|
|
951
|
+
const hasSignature = (decl: number, domain: readonly number[], range: number) =>
|
|
952
|
+
(range === -1 || manager.funcDecls[decl].range === range) &&
|
|
953
|
+
manager.funcDecls[decl].domain.length === domain.length &&
|
|
954
|
+
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]);
|
|
955
|
+
|
|
787
956
|
const checkDecl = (decl: number, at: SExpr) => {
|
|
788
957
|
const error = logicChecker.checkDecl(decl);
|
|
789
958
|
if (error !== undefined) throw new SmtParseError(error, at);
|
|
@@ -909,7 +1078,8 @@ export const createSmtlibReader = (
|
|
|
909
1078
|
): number => {
|
|
910
1079
|
const head = sexpr.items[0];
|
|
911
1080
|
if (!isSymbol(head)) throw new SmtParseError("invalid sort, symbol or '_' expected", head);
|
|
912
|
-
const isArray =
|
|
1081
|
+
const isArray =
|
|
1082
|
+
ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && restricted.hasSetSort);
|
|
913
1083
|
if (isArray && hasArrays) {
|
|
914
1084
|
const parameters = sexpr.items.slice(1).map((item) => parseSort(item, context, bindings));
|
|
915
1085
|
if (head.text === "Set" ? parameters.length !== 1 : parameters.length < 2)
|
|
@@ -941,7 +1111,7 @@ export const createSmtlibReader = (
|
|
|
941
1111
|
return parseSort(head, context, bindings);
|
|
942
1112
|
}
|
|
943
1113
|
if (decl === undefined) {
|
|
944
|
-
if (THEORY_SORTS.has(head.text) && !
|
|
1114
|
+
if (THEORY_SORTS.has(head.text) && !isLackingSort(head.text))
|
|
945
1115
|
throw new SmtUnsupportedError(`the sort ${head.text}`);
|
|
946
1116
|
throw new SmtParseError(`unknown sort '${head.text}'`, head);
|
|
947
1117
|
}
|
|
@@ -968,8 +1138,20 @@ export const createSmtlibReader = (
|
|
|
968
1138
|
for (const item of (sexpr as SmtList).items.slice(1)) checkPsort(item, bindings);
|
|
969
1139
|
};
|
|
970
1140
|
|
|
1141
|
+
// Z3 does not know the sorts of a theory that the logic lacks.
|
|
1142
|
+
const isLackingSort = (name: string) =>
|
|
1143
|
+
name === "Set"
|
|
1144
|
+
? !hasArrays || !restricted.hasSetSort
|
|
1145
|
+
: ARRAY_SORT_NAMES.has(name)
|
|
1146
|
+
? !hasArrays
|
|
1147
|
+
: name === "BitVec"
|
|
1148
|
+
? !hasBv
|
|
1149
|
+
: SEQ_SORT_NAMES.has(name) || name === "Unicode"
|
|
1150
|
+
? !hasSeq
|
|
1151
|
+
: FPA_SORT_NAMES.has(name) && !hasFpa;
|
|
1152
|
+
|
|
971
1153
|
const isBuiltinParametricSort = (name: string) =>
|
|
972
|
-
(hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" &&
|
|
1154
|
+
(hasArrays && (ARRAY_SORT_NAMES.has(name) || (name === "Set" && restricted.hasSetSort))) ||
|
|
973
1155
|
(hasSeq && (name === "Seq" || name === "RegEx")) ||
|
|
974
1156
|
(hasFpa && FPA_SORT_NAMES.has(name));
|
|
975
1157
|
|
|
@@ -993,19 +1175,31 @@ export const createSmtlibReader = (
|
|
|
993
1175
|
context: string,
|
|
994
1176
|
bindings: ReadonlyMap<string, number> = NO_BINDINGS,
|
|
995
1177
|
): number => {
|
|
1178
|
+
if (sexpr.kind === ")")
|
|
1179
|
+
throw new SmtParseError(`${context} invalid sort, unexpected ')'`, sexpr);
|
|
996
1180
|
if (sexpr.kind === "list") {
|
|
997
1181
|
if (!isSymbol(sexpr.items[0], "_")) return parseParametricSort(sexpr, context, bindings);
|
|
998
|
-
|
|
999
|
-
|
|
1000
|
-
|
|
1001
|
-
|
|
1002
|
-
|
|
1003
|
-
|
|
1004
|
-
|
|
1005
|
-
|
|
1006
|
-
|
|
1007
|
-
)
|
|
1008
|
-
|
|
1182
|
+
// parse_indexed_sort.
|
|
1183
|
+
const name = sexpr.items[1];
|
|
1184
|
+
if (!isSymbol(name))
|
|
1185
|
+
throw new SmtParseError("invalid indexed sort, symbol expected", name ?? sexpr.end);
|
|
1186
|
+
if (hasFpa && name.text === "FloatingPoint") return mkFloatSort(sexpr.items.slice(2), sexpr);
|
|
1187
|
+
const indices = sexpr.items.slice(2);
|
|
1188
|
+
if (isLackingSort(name.text) || !(THEORY_SORTS.has(name.text) || sortDecls.has(name.text)))
|
|
1189
|
+
throw new SmtParseError(`unknown sort '${name.text}'`, indices[0] ?? sexpr.end);
|
|
1190
|
+
if (name.text !== "BitVec") throw new SmtUnsupportedError("indexed sorts");
|
|
1191
|
+
for (const index of indices) {
|
|
1192
|
+
if (index.kind !== "numeral")
|
|
1193
|
+
throw new SmtParseError("invalid indexed sort, integer or ')' expected", index);
|
|
1194
|
+
if (!isUnsigned(index.text))
|
|
1195
|
+
throw new SmtParseError(
|
|
1196
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
1197
|
+
index,
|
|
1198
|
+
);
|
|
1199
|
+
}
|
|
1200
|
+
const width = indices[0];
|
|
1201
|
+
if (indices.length !== 1 || width.kind !== "numeral")
|
|
1202
|
+
throw new SmtParseError("expecting one integer parameter to bit-vector sort", sexpr.end);
|
|
1009
1203
|
if (BigInt(width.text) === 0n)
|
|
1010
1204
|
throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
|
|
1011
1205
|
return manager.mkBvSort(Number(width.text));
|
|
@@ -1034,106 +1228,222 @@ export const createSmtlibReader = (
|
|
|
1034
1228
|
const bits = FPA_SORT_NAMES.get(sexpr.text);
|
|
1035
1229
|
return bits === undefined ? mkFloatSort([], sexpr) : manager.mkFpSort(bits[0], bits[1]);
|
|
1036
1230
|
}
|
|
1037
|
-
if (THEORY_SORTS.has(sexpr.text)
|
|
1231
|
+
if (THEORY_SORTS.has(sexpr.text) && !isLackingSort(sexpr.text))
|
|
1232
|
+
throw new SmtUnsupportedError(`the sort ${sexpr.text}`);
|
|
1038
1233
|
throw new SmtParseError(
|
|
1039
1234
|
`${context === "" ? "" : `${context}: `}unknown sort '${sexpr.text}'`,
|
|
1040
1235
|
sexpr,
|
|
1041
1236
|
);
|
|
1042
1237
|
};
|
|
1043
1238
|
|
|
1044
|
-
const
|
|
1045
|
-
|
|
1046
|
-
|
|
1047
|
-
|
|
1239
|
+
const beginScope = () => localScopes.push(shadowedNames.length);
|
|
1240
|
+
|
|
1241
|
+
const insertLocal = (name: string, expr: number) => {
|
|
1242
|
+
shadowedNames.push(name);
|
|
1243
|
+
shadowedLocals.push(locals.get(name));
|
|
1244
|
+
locals.set(name, { expr, level: binders.depth });
|
|
1245
|
+
};
|
|
1246
|
+
|
|
1247
|
+
const endScope = () => {
|
|
1248
|
+
const start = localScopes.pop() ?? 0;
|
|
1249
|
+
for (let index = shadowedNames.length - 1; index >= start; index--) {
|
|
1250
|
+
const shadowed = shadowedLocals[index];
|
|
1251
|
+
if (shadowed === undefined) locals.delete(shadowedNames[index]);
|
|
1252
|
+
else locals.set(shadowedNames[index], shadowed);
|
|
1048
1253
|
}
|
|
1049
|
-
|
|
1254
|
+
shrink(shadowedNames, start);
|
|
1255
|
+
shrink(shadowedLocals, start);
|
|
1050
1256
|
};
|
|
1051
1257
|
|
|
1052
|
-
const
|
|
1053
|
-
|
|
1054
|
-
|
|
1055
|
-
return argSorts.includes(SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
1258
|
+
const pushRef = (stack: number[], expr: number) => {
|
|
1259
|
+
if (expr !== -1) manager.incRef(expr);
|
|
1260
|
+
stack.push(expr);
|
|
1056
1261
|
};
|
|
1057
1262
|
|
|
1058
|
-
|
|
1059
|
-
|
|
1060
|
-
|
|
1061
|
-
|
|
1062
|
-
|
|
1063
|
-
|
|
1263
|
+
// ref_vector::shrink, which releases from the new end on.
|
|
1264
|
+
const shrinkRefs = (stack: number[], size: number) => {
|
|
1265
|
+
for (let index = size; index < stack.length; index++)
|
|
1266
|
+
if (stack[index] !== -1) manager.decRef(stack[index]);
|
|
1267
|
+
shrink(stack, size);
|
|
1268
|
+
};
|
|
1269
|
+
|
|
1270
|
+
const releasePending = () => {
|
|
1271
|
+
for (const expr of pending) manager.decRef(expr);
|
|
1272
|
+
shrink(pending, 0);
|
|
1273
|
+
};
|
|
1274
|
+
|
|
1275
|
+
const protect = (exprs: number[]) => {
|
|
1276
|
+
for (const expr of exprs)
|
|
1277
|
+
if (manager.ids[expr] !== -1 && manager.getRefCount(expr) === 0) pushRef(pending, expr);
|
|
1278
|
+
shrink(exprs, 0);
|
|
1279
|
+
};
|
|
1280
|
+
|
|
1281
|
+
// push_local: var_shifter moves the free variables of a term that was bound under fewer binders.
|
|
1282
|
+
// Its cache holds the terms it makes, which replaceFreeVars rebuilds.
|
|
1283
|
+
const getLocalTerm = (local: Local) => {
|
|
1284
|
+
if (local.level === binders.depth) return local.expr;
|
|
1285
|
+
if (manager.kinds[local.expr] === KIND_VAR)
|
|
1286
|
+
return manager.mkVar(
|
|
1287
|
+
manager.values[local.expr] + binders.depth - local.level,
|
|
1288
|
+
manager.sorts[local.expr],
|
|
1289
|
+
);
|
|
1290
|
+
return replaceFreeVars(manager, local.expr, (variable, index, shift) =>
|
|
1291
|
+
manager.mkVar(index + shift + binders.depth - local.level, manager.sorts[variable]),
|
|
1292
|
+
);
|
|
1293
|
+
};
|
|
1294
|
+
|
|
1295
|
+
// basic_decl_plugin::join.
|
|
1296
|
+
const getJoin = (left: number, right: number, at: SExpr) => {
|
|
1297
|
+
if (left === right) return left;
|
|
1298
|
+
if (isArithSort(left) && isArithSort(right)) return left === SORT_REAL ? left : right;
|
|
1299
|
+
if (left === SORT_BOOL && isArithSort(right)) return right;
|
|
1300
|
+
if (right === SORT_BOOL && isArithSort(left)) return left;
|
|
1301
|
+
throw new SmtParseError(
|
|
1302
|
+
`Sorts ${manager.getSortName(left)} and ${manager.getSortName(right)} are incompatible`,
|
|
1303
|
+
at,
|
|
1304
|
+
);
|
|
1305
|
+
};
|
|
1306
|
+
|
|
1307
|
+
const getJoinOfArgs = (args: number[], at: SExpr) =>
|
|
1308
|
+
args.reduce((join, arg) => getJoin(join, manager.sorts[arg], at), manager.sorts[args[0]]);
|
|
1309
|
+
|
|
1310
|
+
// basic_decl_plugin::mk_func_decl and arith_decl_plugin::mk_func_decl: the sort of the arguments
|
|
1311
|
+
// that the declaration takes, the condition of ite aside, or -1 where the plugin makes none.
|
|
1312
|
+
const getDomainSort = (op: number, args: number[], at: SExpr) => {
|
|
1313
|
+
if (op === OP_ITE)
|
|
1314
|
+
return args.length === 3 ? getJoin(manager.sorts[args[1]], manager.sorts[args[2]], at) : -1;
|
|
1315
|
+
if (op === OP_EQ) return args.length >= 2 ? getJoinOfArgs(args, at) : -1;
|
|
1316
|
+
if (op === OP_DISTINCT) return args.length === 0 ? SORT_BOOL : getJoinOfArgs(args, at);
|
|
1317
|
+
if (manager.funcDecls[op].family === FAMILY_BASIC) return SORT_BOOL;
|
|
1318
|
+
if (COERCING_OPS.has(op))
|
|
1319
|
+
return args.some((arg) => manager.sorts[arg] === SORT_REAL) ? SORT_REAL : SORT_INT;
|
|
1064
1320
|
if (op === OP_DIV || op === OP_IS_INT || REAL_FUNCTION_OPS.has(op)) return SORT_REAL;
|
|
1065
|
-
return
|
|
1321
|
+
if (op === OP_IDIV || op === OP_MOD || op === OP_REM) return SORT_INT;
|
|
1322
|
+
return manager.sorts[args[0]] === SORT_REAL ? SORT_REAL : SORT_INT;
|
|
1066
1323
|
};
|
|
1067
1324
|
|
|
1325
|
+
// ast_manager::coerce_to.
|
|
1068
1326
|
const coerce = (arg: number, sort: number) => {
|
|
1069
1327
|
const argSort = manager.sorts[arg];
|
|
1070
|
-
if (argSort === sort || !isArithSort(
|
|
1071
|
-
|
|
1072
|
-
|
|
1073
|
-
|
|
1074
|
-
|
|
1075
|
-
|
|
1076
|
-
|
|
1077
|
-
|
|
1078
|
-
|
|
1079
|
-
|
|
1080
|
-
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1328
|
+
if (argSort === sort || !isArithSort(sort)) return arg;
|
|
1329
|
+
if (isArithSort(argSort))
|
|
1330
|
+
return sort === SORT_REAL
|
|
1331
|
+
? manager.mkApp(OP_TO_REAL, [arg], SORT_REAL)
|
|
1332
|
+
: manager.mkApp(OP_TO_INT, [arg], SORT_INT);
|
|
1333
|
+
if (argSort !== SORT_BOOL) return arg;
|
|
1334
|
+
const one = manager.mkNumeralOfSort(Rational.of(1n), sort);
|
|
1335
|
+
return manager.mkApp(OP_ITE, [arg, one, manager.mkNumeralOfSort(Rational.of(0n), sort)], sort);
|
|
1336
|
+
};
|
|
1337
|
+
|
|
1338
|
+
// A declaration of the script has its own domain, and a builtin one takes domainSort.
|
|
1339
|
+
const getArity = (decl: number, numArgs: number, domainSort: number) =>
|
|
1340
|
+
domainSort === -1
|
|
1341
|
+
? manager.funcDecls[decl].domain.length
|
|
1342
|
+
: decl === OP_DISTINCT
|
|
1343
|
+
? numArgs
|
|
1344
|
+
: (ARITIES.get(decl) ?? 2);
|
|
1345
|
+
|
|
1346
|
+
const getExpectedSort = (decl: number, index: number, domainSort: number) =>
|
|
1347
|
+
domainSort === -1
|
|
1348
|
+
? manager.funcDecls[decl].domain[index]
|
|
1349
|
+
: decl === OP_ITE && index === 0
|
|
1350
|
+
? SORT_BOOL
|
|
1351
|
+
: domainSort;
|
|
1352
|
+
|
|
1353
|
+
const formatDecl = (decl: number, numArgs: number, domainSort: number) => {
|
|
1354
|
+
const domain = Array.from({ length: getArity(decl, numArgs, domainSort) }, (_unused, index) =>
|
|
1355
|
+
manager.getSortName(getExpectedSort(decl, index, domainSort)),
|
|
1089
1356
|
);
|
|
1090
|
-
const
|
|
1091
|
-
|
|
1092
|
-
|
|
1093
|
-
|
|
1094
|
-
|
|
1095
|
-
|
|
1096
|
-
|
|
1097
|
-
|
|
1098
|
-
|
|
1099
|
-
|
|
1357
|
+
const range =
|
|
1358
|
+
domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort);
|
|
1359
|
+
return `(declare-fun ${String(manager.funcDecls[decl].name)} (${domain.join(" ")}) ${manager.getSortName(range)})`;
|
|
1360
|
+
};
|
|
1361
|
+
|
|
1362
|
+
// ast_manager::mk_app_core: coercion_needed, coerce_to and check_args.
|
|
1363
|
+
const mkAppCore = (decl: number, args: number[], at: SExpr, domainSort: number) => {
|
|
1364
|
+
const isAssociative = domainSort !== -1 && ASSOCIATIVE_OPS.has(decl);
|
|
1365
|
+
const isCoercing =
|
|
1366
|
+
(isAssociative || getArity(decl, args.length, domainSort) === args.length) &&
|
|
1367
|
+
args.some((arg, index) => {
|
|
1368
|
+
const expected = getExpectedSort(decl, index, domainSort);
|
|
1369
|
+
return isArithSort(expected) && expected !== manager.sorts[arg];
|
|
1370
|
+
});
|
|
1371
|
+
const coerced = isCoercing
|
|
1372
|
+
? args.map((arg, index) => coerce(arg, getExpectedSort(decl, index, domainSort)))
|
|
1373
|
+
: args;
|
|
1374
|
+
for (let index = 0; index < coerced.length; index++) {
|
|
1375
|
+
const sort = manager.sorts[coerced[index]];
|
|
1376
|
+
if (sort !== getExpectedSort(decl, index, domainSort))
|
|
1377
|
+
throw new SmtParseError(
|
|
1378
|
+
`Sort mismatch at argument #${index + 1} for function ${formatDecl(decl, args.length, domainSort)} supplied sort is ${manager.getSortName(sort)}`,
|
|
1379
|
+
at,
|
|
1380
|
+
);
|
|
1381
|
+
}
|
|
1382
|
+
// Z3 keeps xor, / and div of fewer than two arguments until its rewriters make false or the
|
|
1383
|
+
// argument of them, which those of this port do not.
|
|
1384
|
+
if (
|
|
1385
|
+
coerced.length < 2 &&
|
|
1386
|
+
domainSort !== -1 &&
|
|
1387
|
+
(decl === OP_XOR || LEFT_ASSOCIATIVE_OPS.has(decl))
|
|
1388
|
+
)
|
|
1389
|
+
return coerced[0] ?? manager.falseExpr;
|
|
1100
1390
|
return manager.mkApp(
|
|
1101
1391
|
decl,
|
|
1102
|
-
|
|
1103
|
-
|
|
1392
|
+
coerced,
|
|
1393
|
+
domainSort === -1 ? manager.funcDecls[decl].range : (RANGES.get(decl) ?? domainSort),
|
|
1104
1394
|
);
|
|
1105
1395
|
};
|
|
1106
1396
|
|
|
1107
|
-
|
|
1108
|
-
|
|
1397
|
+
// ast_manager::mk_app.
|
|
1398
|
+
const mkApp = (decl: number, args: number[], at: SExpr, domainSort = -1): number => {
|
|
1399
|
+
const isBuiltin = domainSort !== -1;
|
|
1400
|
+
const isAssociative = isBuiltin && ASSOCIATIVE_OPS.has(decl);
|
|
1401
|
+
const isLeftAssociative = isAssociative || (isBuiltin && LEFT_ASSOCIATIVE_OPS.has(decl));
|
|
1402
|
+
const isRightAssociative = isAssociative || (isBuiltin && decl === OP_IMPLIES);
|
|
1403
|
+
const isChainable = isBuiltin && CHAINABLE_DECLS.has(decl);
|
|
1404
|
+
if (
|
|
1405
|
+
getArity(decl, args.length, domainSort) !== args.length &&
|
|
1406
|
+
((!isLeftAssociative && !isRightAssociative && !isChainable) ||
|
|
1407
|
+
(args.length < 2 && manager.funcDecls[decl].family === FAMILY_BASIC && !isAssociative))
|
|
1408
|
+
) {
|
|
1409
|
+
const environment = { options: DEFAULT_PRINT_OPTIONS, isUsed, isClashing };
|
|
1410
|
+
// Z3 prints an error without the newlines that end it.
|
|
1411
|
+
throw new SmtParseError(
|
|
1412
|
+
`Wrong number of arguments (${args.length}) passed to function ${formatDecl(decl, args.length, domainSort)} ${args
|
|
1413
|
+
.map((arg) => `\narg: ${printExpr(manager, environment, arg)}\n`)
|
|
1414
|
+
.join("")}`.replace(/\n+$/, ""),
|
|
1415
|
+
at,
|
|
1416
|
+
);
|
|
1417
|
+
}
|
|
1418
|
+
if (args.length === 1 && isChainable) return manager.trueExpr;
|
|
1419
|
+
if (args.length <= 2 || (isBuiltin && FLAT_OPS.has(decl)))
|
|
1420
|
+
return mkAppCore(decl, args, at, domainSort);
|
|
1421
|
+
if (isRightAssociative)
|
|
1422
|
+
return args
|
|
1423
|
+
.slice(0, -2)
|
|
1424
|
+
.reduceRight(
|
|
1425
|
+
(right, left) => mkAppCore(decl, [left, right], at, domainSort),
|
|
1426
|
+
mkAppCore(decl, args.slice(-2), at, domainSort),
|
|
1427
|
+
);
|
|
1428
|
+
if (isLeftAssociative)
|
|
1429
|
+
return args
|
|
1430
|
+
.slice(2)
|
|
1431
|
+
.reduce(
|
|
1432
|
+
(left, right) => mkAppCore(decl, [left, right], at, domainSort),
|
|
1433
|
+
mkAppCore(decl, args.slice(0, 2), at, domainSort),
|
|
1434
|
+
);
|
|
1435
|
+
if (!isChainable) return mkAppCore(decl, args, at, domainSort);
|
|
1109
1436
|
const pairs: number[] = [];
|
|
1110
|
-
for (let index =
|
|
1111
|
-
pairs.push(
|
|
1112
|
-
return
|
|
1113
|
-
};
|
|
1114
|
-
|
|
1115
|
-
const rejectPattern = (message: string, at: SExpr) => {
|
|
1116
|
-
if (!options.isIgnoringBadPatterns) throw new SmtParseError(message, at);
|
|
1117
|
-
return undefined;
|
|
1437
|
+
for (let index = 1; index < args.length; index++)
|
|
1438
|
+
pairs.push(mkAppCore(decl, [args[index - 1], args[index]], at, domainSort));
|
|
1439
|
+
return mkApp(OP_AND, pairs, at, SORT_BOOL);
|
|
1118
1440
|
};
|
|
1119
1441
|
|
|
1120
|
-
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1124
|
-
|
|
1125
|
-
throw new SmtParseError("invalid pattern, '(' expected", sexpr);
|
|
1126
|
-
}
|
|
1127
|
-
if (sexpr.kind !== "list") return rejectPattern("invalid pattern, '(' expected", sexpr);
|
|
1128
|
-
if (sexpr.items.length === 0) return rejectPattern("invalid empty pattern", at);
|
|
1129
|
-
const head = sexpr.items[0];
|
|
1130
|
-
if (head.kind === "list") return manager.mkPattern(sexpr.items.map(parseTerm));
|
|
1131
|
-
const decl = head.text === "true" || head.text === "false" ? -1 : getFirstFunc(head.text);
|
|
1132
|
-
if (decl === -1 || (decl !== undefined && manager.funcDecls[decl].domain.length === 0))
|
|
1133
|
-
return rejectPattern("invalid constant pattern", head);
|
|
1134
|
-
if (head.kind !== "symbol")
|
|
1135
|
-
throw new SmtParseError("invalid pattern, '(' or identifier expected", head);
|
|
1136
|
-
return manager.mkPattern([parseTerm(sexpr)]);
|
|
1442
|
+
// ast_manager::mk_pattern.
|
|
1443
|
+
const mkPattern = (terms: number[], at: SExpr) => {
|
|
1444
|
+
if (terms.some((term) => manager.kinds[term] !== KIND_APP))
|
|
1445
|
+
throw new SmtParseError("patterns cannot be variables or quantifiers", at);
|
|
1446
|
+
return manager.mkPattern(terms);
|
|
1137
1447
|
};
|
|
1138
1448
|
|
|
1139
1449
|
const isValidPattern = (pattern: number, numDecls: number) => {
|
|
@@ -1158,151 +1468,90 @@ export const createSmtlibReader = (
|
|
|
1158
1468
|
return manager.everyArg(pattern, isValid) && found.size === numDecls;
|
|
1159
1469
|
};
|
|
1160
1470
|
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
|
|
1164
|
-
|
|
1165
|
-
|
|
1166
|
-
|
|
1167
|
-
|
|
1168
|
-
|
|
1169
|
-
|
|
1170
|
-
const varSorts =
|
|
1171
|
-
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1471
|
+
// parse_sorted_vars: the variables are created the first declared with the largest index, and
|
|
1472
|
+
// the stack holds them. previousId is the identifier before the list.
|
|
1473
|
+
const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr, previousId: string) => {
|
|
1474
|
+
if (sexpr?.kind !== "list")
|
|
1475
|
+
throw new SmtParseError(
|
|
1476
|
+
`invalid list of sorted variables, '(' expected got ${getLastId(sexpr) ?? previousId}`,
|
|
1477
|
+
sexpr ?? at,
|
|
1478
|
+
);
|
|
1479
|
+
const names: string[] = [];
|
|
1480
|
+
const varSorts: number[] = [];
|
|
1481
|
+
for (const [index, declaration] of sexpr.items.entries()) {
|
|
1482
|
+
if (declaration.kind !== "list")
|
|
1483
|
+
throw new SmtParseError(
|
|
1484
|
+
`invalid sorted variable, '(' expected got ${getLastId(declaration) ?? getLastIdBefore(sexpr.items, index) ?? previousId}`,
|
|
1485
|
+
declaration,
|
|
1486
|
+
);
|
|
1487
|
+
const name = declaration.items[0];
|
|
1488
|
+
if (!isSymbol(name))
|
|
1489
|
+
throw new SmtParseError(
|
|
1490
|
+
"invalid sorted variable, symbol expected",
|
|
1491
|
+
name ?? declaration.end,
|
|
1492
|
+
);
|
|
1493
|
+
names.push(name.text);
|
|
1494
|
+
varSorts.push(parseSort(declaration.items[1] ?? declaration.end, "invalid sorted variables"));
|
|
1495
|
+
const extra = declaration.items[2];
|
|
1496
|
+
if (extra !== undefined)
|
|
1497
|
+
throw new SmtParseError(
|
|
1498
|
+
`invalid sorted variable, ')' expected got ${getLastId(extra) ?? getLastId(declaration.items[1]) ?? name.text}`,
|
|
1499
|
+
extra,
|
|
1500
|
+
);
|
|
1501
|
+
}
|
|
1502
|
+
beginScope();
|
|
1177
1503
|
binders.depth += varSorts.length;
|
|
1504
|
+
for (const [index, sort] of varSorts.entries()) {
|
|
1505
|
+
const boundVar = manager.mkVar(varSorts.length - 1 - index, sort);
|
|
1506
|
+
pushRef(exprStack, boundVar);
|
|
1507
|
+
insertLocal(names[index], boundVar);
|
|
1508
|
+
}
|
|
1178
1509
|
return { names, varSorts };
|
|
1179
1510
|
};
|
|
1180
1511
|
|
|
1181
1512
|
const unbindSortedVars = (count: number) => {
|
|
1182
|
-
|
|
1513
|
+
endScope();
|
|
1183
1514
|
binders.depth -= count;
|
|
1184
1515
|
};
|
|
1185
1516
|
|
|
1186
|
-
|
|
1187
|
-
|
|
1517
|
+
// pop_quant_frame, up to the quantifier.
|
|
1518
|
+
const mkParsedQuantifier = (frame: QuantifierFrame) => {
|
|
1519
|
+
const list = frame.list;
|
|
1520
|
+
const numDecls = frame.varSorts.length;
|
|
1521
|
+
if (exprStack.length - frame.start !== numDecls + 1)
|
|
1188
1522
|
throw new SmtParseError(
|
|
1189
1523
|
"invalid quantified expression, syntax error: (forall|exists ((<symbol> <sort>)*) <expr>) expected",
|
|
1190
1524
|
list.end,
|
|
1191
1525
|
);
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
|
|
1196
|
-
|
|
1197
|
-
manager.mkVar(varSorts.length - 1 - index, sort),
|
|
1198
|
-
);
|
|
1199
|
-
for (const boundVar of boundVars) manager.incRef(boundVar);
|
|
1200
|
-
const bodySExpr = list.items[2];
|
|
1201
|
-
const isAnnotated = bodySExpr.kind === "list" && isSymbol(bodySExpr.items[0], "!");
|
|
1202
|
-
const annotations = bodySExpr.kind === "list" && isAnnotated ? bodySExpr.items : [];
|
|
1203
|
-
const parsedBody = parseTerm(isAnnotated ? annotations[1] : bodySExpr);
|
|
1204
|
-
if (kind !== QUANTIFIER_LAMBDA && manager.sorts[parsedBody] !== SORT_BOOL)
|
|
1205
|
-
throw new SmtParseError("expected a formula", bodySExpr);
|
|
1206
|
-
const attributes = Array.from(
|
|
1207
|
-
{ length: Math.ceil((annotations.length - 2) / 2) },
|
|
1208
|
-
(_unused, index) => ({
|
|
1209
|
-
keyword: annotations[2 + 2 * index],
|
|
1210
|
-
value: annotations[3 + 2 * index],
|
|
1211
|
-
}),
|
|
1212
|
-
);
|
|
1213
|
-
const body = attributes.reduce(
|
|
1214
|
-
(labeled, attribute) =>
|
|
1215
|
-
attribute.keyword.kind === "keyword" &&
|
|
1216
|
-
(attribute.keyword.text === ":lblpos" || attribute.keyword.text === ":lblneg")
|
|
1217
|
-
? mkLabel(labeled, attribute.keyword.text === ":lblpos", attribute.value, bodySExpr)
|
|
1218
|
-
: labeled,
|
|
1219
|
-
parsedBody,
|
|
1220
|
-
);
|
|
1221
|
-
const patterns: number[] = [];
|
|
1222
|
-
const noPatterns: number[] = [];
|
|
1223
|
-
for (const attribute of attributes) {
|
|
1224
|
-
if (attribute.keyword.kind !== "keyword") continue;
|
|
1225
|
-
if (attribute.keyword.text === ":no-pattern") {
|
|
1226
|
-
const noPattern = parseTerm(attribute.value ?? list.end);
|
|
1227
|
-
manager.incRef(noPattern);
|
|
1228
|
-
noPatterns.push(noPattern);
|
|
1229
|
-
continue;
|
|
1230
|
-
}
|
|
1231
|
-
if (attribute.keyword.text !== ":pattern") continue;
|
|
1232
|
-
const pattern = parsePattern(
|
|
1233
|
-
attribute.value ?? (bodySExpr.kind === "list" ? bodySExpr.end : list.end),
|
|
1234
|
-
list.end,
|
|
1235
|
-
);
|
|
1236
|
-
if (pattern === undefined) continue;
|
|
1237
|
-
manager.incRef(pattern);
|
|
1238
|
-
patterns.push(pattern);
|
|
1239
|
-
}
|
|
1240
|
-
const getAttribute = (name: string) => {
|
|
1241
|
-
const value = attributes
|
|
1242
|
-
.filter(
|
|
1243
|
-
(attribute) =>
|
|
1244
|
-
attribute.keyword.kind === "keyword" &&
|
|
1245
|
-
attribute.keyword.text === name &&
|
|
1246
|
-
attribute.value?.kind !== "list",
|
|
1247
|
-
)
|
|
1248
|
-
.at(-1)?.value;
|
|
1249
|
-
return value?.kind === "list" ? undefined : value?.text;
|
|
1250
|
-
};
|
|
1251
|
-
const weight = Number(getAttribute(":weight") ?? 1);
|
|
1252
|
-
const qid = getAttribute(":qid") ?? "";
|
|
1253
|
-
const skid = getAttribute(":skolemid");
|
|
1254
|
-
unbindSortedVars(varSorts.length);
|
|
1255
|
-
// pop_quant_frame: the invalid patterns leave the parser's stack before the quantifier is made,
|
|
1256
|
-
// and the valid ones after.
|
|
1257
|
-
let numKept = 0;
|
|
1258
|
-
for (const pattern of patterns) {
|
|
1259
|
-
if (!isValidPattern(pattern, varSorts.length)) {
|
|
1260
|
-
rejectPattern("invalid pattern", list.end);
|
|
1526
|
+
let numKept = frame.patternStart;
|
|
1527
|
+
for (let index = frame.patternStart; index < patternStack.length; index++) {
|
|
1528
|
+
const pattern = patternStack[index];
|
|
1529
|
+
if (!isValidPattern(pattern, numDecls)) {
|
|
1530
|
+
if (!options.isIgnoringBadPatterns) throw new SmtParseError("invalid pattern", list.end);
|
|
1261
1531
|
continue;
|
|
1262
1532
|
}
|
|
1263
1533
|
manager.incRef(pattern);
|
|
1264
|
-
manager.decRef(
|
|
1265
|
-
|
|
1534
|
+
manager.decRef(patternStack[numKept]);
|
|
1535
|
+
patternStack[numKept] = pattern;
|
|
1266
1536
|
numKept++;
|
|
1267
1537
|
}
|
|
1268
|
-
|
|
1269
|
-
|
|
1538
|
+
shrinkRefs(patternStack, numKept);
|
|
1539
|
+
const body = exprStack[exprStack.length - 1];
|
|
1540
|
+
if (frame.quantifierKind !== QUANTIFIER_LAMBDA && manager.sorts[body] !== SORT_BOOL)
|
|
1541
|
+
throw new SmtParseError("quantifier body must be a Boolean expression", list.end);
|
|
1542
|
+
if (patternStack.length > frame.patternStart && noPatternStack.length > frame.noPatternStart)
|
|
1270
1543
|
throw new SmtParseError("simultaneous patterns and no-patterns not supported", list.end);
|
|
1271
|
-
|
|
1272
|
-
kind,
|
|
1273
|
-
sorts: varSorts,
|
|
1274
|
-
names:
|
|
1544
|
+
return manager.mkQuantifier({
|
|
1545
|
+
kind: frame.quantifierKind,
|
|
1546
|
+
sorts: frame.varSorts,
|
|
1547
|
+
names: frame.names,
|
|
1275
1548
|
body,
|
|
1276
|
-
patterns,
|
|
1277
|
-
noPatterns,
|
|
1278
|
-
weight,
|
|
1279
|
-
qid,
|
|
1280
|
-
...(skid === undefined ? {} : { skid }),
|
|
1549
|
+
patterns: patternStack.slice(frame.patternStart),
|
|
1550
|
+
noPatterns: noPatternStack.slice(frame.noPatternStart),
|
|
1551
|
+
weight: frame.weight,
|
|
1552
|
+
qid: frame.qid,
|
|
1553
|
+
...(frame.skid === undefined ? {} : { skid: frame.skid }),
|
|
1281
1554
|
});
|
|
1282
|
-
for (const pattern of patterns) manager.decRef(pattern);
|
|
1283
|
-
for (const noPattern of noPatterns) manager.decRef(noPattern);
|
|
1284
|
-
for (const boundVar of boundVars) manager.decRef(boundVar);
|
|
1285
|
-
return quantifier;
|
|
1286
|
-
};
|
|
1287
|
-
|
|
1288
|
-
const parseLet = (list: SmtList) => {
|
|
1289
|
-
const message = "invalid let declaration, symbol expected";
|
|
1290
|
-
const scope = new Map<string, Binding>();
|
|
1291
|
-
const exprs: number[] = [];
|
|
1292
|
-
for (const binding of expectList(list.items[1], message, list).items) {
|
|
1293
|
-
const pair = expectList(binding, message, binding);
|
|
1294
|
-
const name = expectSymbol(pair.items[0], message, pair);
|
|
1295
|
-
const expr = parseTerm(pair.items[1] ?? pair.end);
|
|
1296
|
-
exprs.push(expr);
|
|
1297
|
-
scope.set(name.text, { kind: "let", depth: binders.depth, expr });
|
|
1298
|
-
}
|
|
1299
|
-
scopes.push(scope);
|
|
1300
|
-
// Z3 takes the last expression on its stack, so a let without a body is its last binding.
|
|
1301
|
-
for (const body of list.items.slice(2)) exprs.push(parseTerm(body));
|
|
1302
|
-
scopes.pop();
|
|
1303
|
-
const result = exprs.at(-1);
|
|
1304
|
-
if (result === undefined) throw new SmtParseError("invalid let expression", list.end);
|
|
1305
|
-
return result;
|
|
1306
1555
|
};
|
|
1307
1556
|
|
|
1308
1557
|
const expandMacro = (macro: Macro, args: number[]) =>
|
|
@@ -1376,7 +1625,7 @@ export const createSmtlibReader = (
|
|
|
1376
1625
|
const pair = [args[index], args[index + 1]];
|
|
1377
1626
|
pairs.push(mkFpaAppOf(manager, getSignature(pair), pair));
|
|
1378
1627
|
}
|
|
1379
|
-
return mkApp(OP_AND, pairs, at);
|
|
1628
|
+
return mkApp(OP_AND, pairs, at, SORT_BOOL);
|
|
1380
1629
|
};
|
|
1381
1630
|
|
|
1382
1631
|
const isSeqOpName = (name: string) =>
|
|
@@ -1496,43 +1745,136 @@ export const createSmtlibReader = (
|
|
|
1496
1745
|
return manager.mkAlgebraicNumeral(root);
|
|
1497
1746
|
};
|
|
1498
1747
|
|
|
1499
|
-
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) => {
|
|
1500
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);
|
|
1501
1806
|
const indices = list.items.slice(2);
|
|
1502
|
-
|
|
1503
|
-
|
|
1504
|
-
|
|
1505
|
-
|
|
1506
|
-
|
|
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))
|
|
1507
1832
|
return mkSeqTerm(
|
|
1508
1833
|
name.text,
|
|
1509
1834
|
[],
|
|
1510
1835
|
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1511
|
-
|
|
1836
|
+
at,
|
|
1512
1837
|
);
|
|
1513
|
-
if (
|
|
1514
|
-
isSymbol(name) &&
|
|
1515
|
-
isFpaOpName(name.text) &&
|
|
1516
|
-
indices.every((index) => index.kind === "numeral")
|
|
1517
|
-
) {
|
|
1838
|
+
if (isNumbered && isFpaOpName(name.text)) {
|
|
1518
1839
|
const signature = getFpaSignature(
|
|
1519
1840
|
manager,
|
|
1520
1841
|
FPA_OP_NAMES.get(name.text) ?? -1,
|
|
1521
1842
|
indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
1522
1843
|
[],
|
|
1523
1844
|
);
|
|
1524
|
-
if (typeof signature === "string")
|
|
1525
|
-
throw new SmtParseError(signature, { line: list.end.line, column: list.end.column + 1 });
|
|
1845
|
+
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1526
1846
|
return mkFpaAppOf(manager, signature, []);
|
|
1527
1847
|
}
|
|
1528
|
-
|
|
1529
|
-
|
|
1530
|
-
|
|
1531
|
-
|
|
1532
|
-
|
|
1533
|
-
|
|
1534
|
-
|
|
1535
|
-
|
|
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;
|
|
1536
1878
|
};
|
|
1537
1879
|
|
|
1538
1880
|
const mkArrayTerm = (op: number, inputArgs: number[], parameters: number[], at: SExpr) => {
|
|
@@ -1595,10 +1937,7 @@ export const createSmtlibReader = (
|
|
|
1595
1937
|
sort === argSorts[index] || (isArithSort(sort) && isArithSort(argSorts[index])),
|
|
1596
1938
|
),
|
|
1597
1939
|
);
|
|
1598
|
-
const found =
|
|
1599
|
-
candidates.find((decl) =>
|
|
1600
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === argSorts[index]),
|
|
1601
|
-
) ?? candidates.at(-1);
|
|
1940
|
+
const found = candidates.find((decl) => hasSignature(decl, argSorts, -1)) ?? candidates.at(-1);
|
|
1602
1941
|
if (found !== undefined) return mkApp(found, args, at);
|
|
1603
1942
|
if (args.length === 0 || range !== undefined) return undefined;
|
|
1604
1943
|
if (decls.length > 1) throwAmbiguousConstant(name, at);
|
|
@@ -1649,10 +1988,23 @@ export const createSmtlibReader = (
|
|
|
1649
1988
|
|
|
1650
1989
|
const mkIsApp = (constructorName: SmtToken, args: number[], at: SExpr) => {
|
|
1651
1990
|
const declared = findFuncDecl(constructorName);
|
|
1652
|
-
|
|
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
|
+
}
|
|
1653
2005
|
const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
|
|
1654
2006
|
if (argSort === -1 || !manager.isDatatypeSort(argSort))
|
|
1655
|
-
throw new
|
|
2007
|
+
throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
|
|
1656
2008
|
const constructor = getDatatypeConstructors(manager, argSort).find(
|
|
1657
2009
|
(decl) => manager.funcDecls[decl].name === constructorName.text,
|
|
1658
2010
|
);
|
|
@@ -1671,9 +2023,23 @@ export const createSmtlibReader = (
|
|
|
1671
2023
|
`invalid function declaration reference, unknown function ${accessorName.text}`,
|
|
1672
2024
|
accessorName,
|
|
1673
2025
|
);
|
|
1674
|
-
|
|
1675
|
-
|
|
1676
|
-
|
|
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]);
|
|
1677
2043
|
};
|
|
1678
2044
|
|
|
1679
2045
|
const getUnknownConstantMessage = (name: string, args: number[], range: number | undefined) => {
|
|
@@ -1706,14 +2072,7 @@ export const createSmtlibReader = (
|
|
|
1706
2072
|
throw new SmtUnsupportedError("the declaration reference");
|
|
1707
2073
|
const domain = domainList.items.map((item) => parseSort(item, "Invalid function name"));
|
|
1708
2074
|
const range = parseSort(rangeSort, "Invalid function name");
|
|
1709
|
-
const declared = funcs
|
|
1710
|
-
.get(name.text)
|
|
1711
|
-
?.find(
|
|
1712
|
-
(decl) =>
|
|
1713
|
-
manager.funcDecls[decl].range === range &&
|
|
1714
|
-
manager.funcDecls[decl].domain.length === domain.length &&
|
|
1715
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
1716
|
-
);
|
|
2075
|
+
const declared = funcs.get(name.text)?.find((decl) => hasSignature(decl, domain, range));
|
|
1717
2076
|
if (declared !== undefined) return { decl: declared, domain, range };
|
|
1718
2077
|
const builtin = CHAINABLE_OPS.get(name.text) ?? BUILTIN_OPS.get(name.text);
|
|
1719
2078
|
if (builtin === undefined)
|
|
@@ -1752,10 +2111,11 @@ export const createSmtlibReader = (
|
|
|
1752
2111
|
) => {
|
|
1753
2112
|
const name = head.text;
|
|
1754
2113
|
// A bound variable applied to arguments selects from the array it stands for, one at a time.
|
|
1755
|
-
|
|
2114
|
+
const local = locals.get(name);
|
|
2115
|
+
if (args.length > 0 && local !== undefined)
|
|
1756
2116
|
return args.reduce(
|
|
1757
2117
|
(array, arg) => mkArrayTerm(OP_SELECT, [array, arg], [], at),
|
|
1758
|
-
|
|
2118
|
+
getLocalTerm(local),
|
|
1759
2119
|
);
|
|
1760
2120
|
if (indices.length > 0)
|
|
1761
2121
|
return isFpaOpName(name)
|
|
@@ -1764,19 +2124,31 @@ export const createSmtlibReader = (
|
|
|
1764
2124
|
? mkSeqTerm(name, args, indices, at)
|
|
1765
2125
|
: mkBvApp(name, args, indices, at);
|
|
1766
2126
|
const macro = macros.get(name);
|
|
1767
|
-
// macros_find: a macro
|
|
1768
|
-
|
|
1769
|
-
|
|
1770
|
-
|
|
1771
|
-
|
|
1772
|
-
|
|
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])),
|
|
1773
2136
|
)
|
|
1774
|
-
|
|
1775
|
-
return expandMacro(
|
|
1776
|
-
|
|
2137
|
+
)
|
|
2138
|
+
return expandMacro(
|
|
2139
|
+
macro,
|
|
2140
|
+
args.map((arg, index) => coerce(arg, macro.domain[index])),
|
|
2141
|
+
);
|
|
1777
2142
|
const decls = funcs.get(name);
|
|
1778
2143
|
const declared = decls === undefined ? undefined : mkDeclaredApp(name, decls, args, range, at);
|
|
1779
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
|
+
}
|
|
1780
2152
|
if (isSeqOpName(name)) return mkSeqTerm(name, args, indices, at, range);
|
|
1781
2153
|
if (range !== undefined)
|
|
1782
2154
|
throw new SmtParseError(getUnknownConstantMessage(name, args, range), at);
|
|
@@ -1791,56 +2163,30 @@ export const createSmtlibReader = (
|
|
|
1791
2163
|
const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
|
|
1792
2164
|
if (isTranscendental && transcendentalOp === undefined)
|
|
1793
2165
|
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1794
|
-
const
|
|
1795
|
-
|
|
1796
|
-
|
|
2166
|
+
const named =
|
|
2167
|
+
builtin === "~"
|
|
2168
|
+
? OP_UMINUS
|
|
2169
|
+
: (CHAINABLE_OPS.get(builtin) ?? BUILTIN_OPS.get(builtin) ?? transcendentalOp);
|
|
1797
2170
|
if (
|
|
1798
2171
|
args.length === 0 &&
|
|
1799
|
-
|
|
1800
|
-
manager.funcDecls[
|
|
2172
|
+
named !== undefined &&
|
|
2173
|
+
manager.funcDecls[named].family === FAMILY_ARITH
|
|
1801
2174
|
)
|
|
1802
2175
|
throw new SmtParseError("no arguments supplied to arithmetical operator", head);
|
|
1803
|
-
|
|
1804
|
-
|
|
1805
|
-
|
|
1806
|
-
|
|
1807
|
-
|
|
1808
|
-
|
|
1809
|
-
|
|
1810
|
-
if (
|
|
1811
|
-
|
|
1812
|
-
if (op === undefined) {
|
|
1813
|
-
if (THEORY_OPERATOR.test(name) || THEORY_OPERATORS.has(name))
|
|
1814
|
-
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
1815
|
-
const instance = mkDatatypeInstanceApp(name, args, at);
|
|
1816
|
-
if (instance !== undefined) return instance;
|
|
1817
|
-
throw new SmtParseError(
|
|
1818
|
-
getUnknownConstantMessage(name, args, undefined),
|
|
1819
|
-
args.length === 0 ? head : at,
|
|
1820
|
-
);
|
|
1821
|
-
}
|
|
1822
|
-
// xor is associative, so ast_manager::mk_app takes fewer than two arguments, which
|
|
1823
|
-
// bool_rewriter reduces to false or the argument.
|
|
1824
|
-
if (op === OP_XOR && args.length < 2) {
|
|
1825
|
-
if (args.some((arg) => manager.sorts[arg] !== SORT_BOOL))
|
|
1826
|
-
throw new SmtParseError(`ill-sorted application of ${name}`, at);
|
|
1827
|
-
return args[0] ?? manager.falseExpr;
|
|
1828
|
-
}
|
|
1829
|
-
if (args.length <= 2 || !NESTED_OPS.has(op)) return mkApp(op, args, at);
|
|
1830
|
-
const domainSort = getDomainSort(op, args);
|
|
1831
|
-
return op === OP_XOR || op === OP_IMPLIES
|
|
1832
|
-
? args
|
|
1833
|
-
.slice(0, -1)
|
|
1834
|
-
.reduceRight(
|
|
1835
|
-
(right, left) => mkApp(op, [left, right], at, domainSort),
|
|
1836
|
-
args[args.length - 1],
|
|
1837
|
-
)
|
|
1838
|
-
: args.slice(1).reduce((left, right) => mkApp(op, [left, right], at, domainSort), args[0]);
|
|
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);
|
|
1839
2185
|
};
|
|
1840
2186
|
|
|
1841
|
-
const parseLeaf = (sexpr:
|
|
2187
|
+
const parseLeaf = (sexpr: SmtToken): number => {
|
|
1842
2188
|
if (sexpr.kind === "numeral")
|
|
1843
|
-
return isNumeralAsReal
|
|
2189
|
+
return restricted.isNumeralAsReal
|
|
1844
2190
|
? manager.mkRealNumeral(Rational.of(BigInt(sexpr.text), 1n))
|
|
1845
2191
|
: manager.mkNumeral(BigInt(sexpr.text));
|
|
1846
2192
|
if (sexpr.kind === "decimal") {
|
|
@@ -1859,222 +2205,452 @@ export const createSmtlibReader = (
|
|
|
1859
2205
|
}
|
|
1860
2206
|
if (sexpr.kind === "string") return manager.mkString(parseZstring(sexpr.text, manager.maxChar));
|
|
1861
2207
|
if (sexpr.kind === "symbol") {
|
|
2208
|
+
const local = locals.get(sexpr.text);
|
|
2209
|
+
if (local !== undefined) return getLocalTerm(local);
|
|
1862
2210
|
if (sexpr.text === "true") return manager.trueExpr;
|
|
1863
2211
|
if (sexpr.text === "false") return manager.falseExpr;
|
|
1864
|
-
const binding = lookup(sexpr.text);
|
|
1865
|
-
if (binding?.kind === "var")
|
|
1866
|
-
return manager.mkVar(binders.depth - 1 - binding.depth, binding.sort);
|
|
1867
|
-
// Z3's var_shifter moves the free variables of a let binding up by the binders since. Its cache
|
|
1868
|
-
// holds the terms it makes, but this parser holds no references, so it rebuilds the binding
|
|
1869
|
-
// with replaceFreeVars.
|
|
1870
|
-
if (binding !== undefined)
|
|
1871
|
-
return binders.depth === binding.depth
|
|
1872
|
-
? binding.expr
|
|
1873
|
-
: replaceFreeVars(manager, binding.expr, (variable, index, shift) =>
|
|
1874
|
-
manager.mkVar(index + shift + binders.depth - binding.depth, manager.sorts[variable]),
|
|
1875
|
-
);
|
|
1876
2212
|
return parseApp(sexpr, [], sexpr);
|
|
1877
2213
|
}
|
|
1878
|
-
|
|
1879
|
-
|
|
1880
|
-
|
|
1881
|
-
|
|
1882
|
-
|
|
1883
|
-
head.text === "forall"
|
|
1884
|
-
? QUANTIFIER_FORALL
|
|
1885
|
-
: head.text === "exists"
|
|
1886
|
-
? QUANTIFIER_EXISTS
|
|
1887
|
-
: QUANTIFIER_LAMBDA,
|
|
1888
|
-
);
|
|
1889
|
-
if (isSymbol(head, "let")) return parseLet(sexpr);
|
|
1890
|
-
// Each attribute applies to the expression the attributes before it made.
|
|
1891
|
-
return sexpr.items.slice(2).reduce(
|
|
1892
|
-
(annotated, keyword, index, attributes) => {
|
|
1893
|
-
if (keyword.kind !== "keyword") return annotated;
|
|
1894
|
-
const value = attributes[index + 1];
|
|
1895
|
-
if (keyword.text === ":lblpos" || keyword.text === ":lblneg")
|
|
1896
|
-
return mkLabel(annotated, keyword.text === ":lblpos", value, sexpr);
|
|
1897
|
-
if (keyword.text !== ":named") return annotated;
|
|
1898
|
-
const name = expectSymbol(value, "invalid attribute value, symbol expected", sexpr).text;
|
|
1899
|
-
manager.incRef(annotated);
|
|
1900
|
-
lastNamed.name = name;
|
|
1901
|
-
lastNamed.expr = annotated;
|
|
1902
|
-
manager.mkMacro(name, annotated);
|
|
1903
|
-
declare(macros, name, { domain: [], range: manager.sorts[annotated], body: annotated });
|
|
1904
|
-
return annotated;
|
|
1905
|
-
},
|
|
1906
|
-
parseTerm(sexpr.items[1] ?? sexpr.end),
|
|
2214
|
+
throw new SmtParseError(
|
|
2215
|
+
sexpr.kind === "keyword"
|
|
2216
|
+
? "invalid expression, unexpected keyword"
|
|
2217
|
+
: "invalid expression, unexpected ')'",
|
|
2218
|
+
sexpr,
|
|
1907
2219
|
);
|
|
1908
2220
|
};
|
|
1909
2221
|
|
|
1910
|
-
|
|
1911
|
-
|
|
1912
|
-
|
|
1913
|
-
|
|
1914
|
-
|
|
1915
|
-
|
|
1916
|
-
|
|
1917
|
-
|
|
1918
|
-
|
|
1919
|
-
|
|
1920
|
-
|
|
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) => {
|
|
1921
2366
|
if (current.kind !== "list") {
|
|
1922
|
-
|
|
2367
|
+
deliver(parseLeaf(current), isTail, exprStack.length);
|
|
1923
2368
|
return;
|
|
1924
2369
|
}
|
|
1925
2370
|
const head = current.items[0];
|
|
1926
|
-
if (head === undefined)
|
|
1927
|
-
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);
|
|
1928
2373
|
if (head.kind === "list") {
|
|
1929
|
-
|
|
1930
|
-
|
|
1931
|
-
if (
|
|
1932
|
-
hasArrays &&
|
|
1933
|
-
isSymbol(head.items[0], "as") &&
|
|
1934
|
-
isSymbol(name, "const") &&
|
|
1935
|
-
head.items.length === 3
|
|
1936
|
-
) {
|
|
1937
|
-
const sort = parseSort(head.items[2], "");
|
|
1938
|
-
frames.push({
|
|
1939
|
-
head: name,
|
|
1940
|
-
indices: [],
|
|
1941
|
-
build: (args) => mkArrayTerm(OP_CONST_ARRAY, args, [sort], current.end),
|
|
1942
|
-
list: current,
|
|
1943
|
-
start: results.length,
|
|
1944
|
-
next: 1,
|
|
1945
|
-
});
|
|
1946
|
-
return;
|
|
1947
|
-
}
|
|
1948
|
-
if (
|
|
1949
|
-
hasArrays &&
|
|
1950
|
-
hasArrayExtensions &&
|
|
1951
|
-
isSymbol(head.items[0], "_") &&
|
|
1952
|
-
isSymbol(name, "map") &&
|
|
1953
|
-
head.items.length === 3
|
|
1954
|
-
) {
|
|
1955
|
-
const mapped = parseFuncDeclRef(head.items[2]);
|
|
1956
|
-
frames.push({
|
|
1957
|
-
head: name,
|
|
1958
|
-
indices: [],
|
|
1959
|
-
build: (args) => mkMapTerm(mapped, args, current.end),
|
|
1960
|
-
list: current,
|
|
1961
|
-
start: results.length,
|
|
1962
|
-
next: 1,
|
|
1963
|
-
});
|
|
1964
|
-
return;
|
|
1965
|
-
}
|
|
1966
|
-
const indexed = head.items[2];
|
|
1967
|
-
if (
|
|
1968
|
-
isSymbol(head.items[0], "_") &&
|
|
1969
|
-
(isSymbol(name, "is") || isSymbol(name, "update-field")) &&
|
|
1970
|
-
isSymbol(indexed) &&
|
|
1971
|
-
head.items.length === 3
|
|
1972
|
-
) {
|
|
1973
|
-
frames.push({
|
|
1974
|
-
head: name,
|
|
1975
|
-
indices: [],
|
|
1976
|
-
build: (args) =>
|
|
1977
|
-
name.text === "is"
|
|
1978
|
-
? mkIsApp(indexed, args, current.end)
|
|
1979
|
-
: mkUpdateFieldApp(indexed, args, current.end),
|
|
1980
|
-
list: current,
|
|
1981
|
-
start: results.length,
|
|
1982
|
-
next: 1,
|
|
1983
|
-
});
|
|
1984
|
-
return;
|
|
1985
|
-
}
|
|
1986
|
-
if (isSymbol(head.items[0], "as") && isSymbol(name) && head.items.length === 3) {
|
|
1987
|
-
const range = parseSort(head.items[2], "Invalid qualified identifier");
|
|
1988
|
-
frames.push({
|
|
1989
|
-
head: name,
|
|
1990
|
-
indices: [],
|
|
1991
|
-
build: (args) => parseApp(name, args, current.end, [], range),
|
|
1992
|
-
list: current,
|
|
1993
|
-
start: results.length,
|
|
1994
|
-
next: 1,
|
|
1995
|
-
});
|
|
1996
|
-
return;
|
|
1997
|
-
}
|
|
1998
|
-
if (
|
|
1999
|
-
isSymbol(head.items[0], "_") &&
|
|
2000
|
-
isSymbol(name) &&
|
|
2001
|
-
isPbOpName(name.text) &&
|
|
2002
|
-
indices.every((index) => index.kind === "numeral")
|
|
2003
|
-
) {
|
|
2004
|
-
const parameters = indices.map((index) =>
|
|
2005
|
-
Rational.of(BigInt(index.kind === "list" ? 0 : index.text)),
|
|
2006
|
-
);
|
|
2007
|
-
frames.push({
|
|
2008
|
-
head: name,
|
|
2009
|
-
indices: [],
|
|
2010
|
-
build: (args) => mkPbTerm(name.text, args, parameters, current.end),
|
|
2011
|
-
list: current,
|
|
2012
|
-
start: results.length,
|
|
2013
|
-
next: 1,
|
|
2014
|
-
});
|
|
2015
|
-
return;
|
|
2016
|
-
}
|
|
2017
|
-
if (
|
|
2018
|
-
!isSymbol(head.items[0], "_") ||
|
|
2019
|
-
!isSymbol(name) ||
|
|
2020
|
-
!(isBvOpName(name.text) || isFpaOpName(name.text) || isSeqOpName(name.text)) ||
|
|
2021
|
-
!indices.every((index) => index.kind === "numeral")
|
|
2022
|
-
)
|
|
2374
|
+
// push_app_frame: Z3 reads a head that is neither indexed nor qualified as a term.
|
|
2375
|
+
if (isSymbol(head.items[0], "lambda"))
|
|
2023
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
|
+
);
|
|
2024
2407
|
frames.push({
|
|
2025
|
-
|
|
2026
|
-
indices: indices.map((index) => (index.kind === "list" ? 0 : Number(index.text))),
|
|
2408
|
+
kind: "let",
|
|
2027
2409
|
list: current,
|
|
2028
|
-
|
|
2029
|
-
|
|
2410
|
+
bindings,
|
|
2411
|
+
names: [],
|
|
2412
|
+
isInDecls: true,
|
|
2413
|
+
isTail,
|
|
2414
|
+
start: exprStack.length,
|
|
2415
|
+
next: 0,
|
|
2030
2416
|
});
|
|
2031
2417
|
return;
|
|
2032
2418
|
}
|
|
2033
|
-
if (head.
|
|
2034
|
-
|
|
2035
|
-
|
|
2036
|
-
|
|
2037
|
-
|
|
2038
|
-
|
|
2039
|
-
|
|
2040
|
-
|
|
2041
|
-
|
|
2042
|
-
|
|
2043
|
-
|
|
2044
|
-
[],
|
|
2045
|
-
qualified,
|
|
2046
|
-
[],
|
|
2047
|
-
parseSort(current.items[2], "Invalid qualified identifier"),
|
|
2048
|
-
),
|
|
2049
|
-
);
|
|
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
|
+
});
|
|
2050
2430
|
return;
|
|
2051
2431
|
}
|
|
2052
|
-
|
|
2053
|
-
|
|
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
|
+
});
|
|
2054
2443
|
return;
|
|
2055
2444
|
}
|
|
2056
|
-
|
|
2057
|
-
|
|
2058
|
-
|
|
2059
|
-
|
|
2060
|
-
|
|
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
|
+
});
|
|
2061
2468
|
};
|
|
2062
|
-
enter(sexpr);
|
|
2469
|
+
enter(sexpr, isRootTail);
|
|
2063
2470
|
while (frames.length > 0) {
|
|
2064
2471
|
const frame = frames[frames.length - 1];
|
|
2065
|
-
if (frame.
|
|
2066
|
-
|
|
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);
|
|
2067
2610
|
continue;
|
|
2068
2611
|
}
|
|
2069
2612
|
frames.pop();
|
|
2070
|
-
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))
|
|
2071
2629
|
throw new SmtParseError("invalid function application, arguments missing", frame.list.end);
|
|
2072
|
-
|
|
2073
|
-
|
|
2074
|
-
|
|
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,
|
|
2075
2641
|
);
|
|
2076
2642
|
}
|
|
2077
|
-
|
|
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;
|
|
2078
2654
|
};
|
|
2079
2655
|
|
|
2080
2656
|
const parseDomain = (sexpr: SExpr | undefined, at: SExpr) => {
|
|
@@ -2352,14 +2928,15 @@ export const createSmtlibReader = (
|
|
|
2352
2928
|
);
|
|
2353
2929
|
};
|
|
2354
2930
|
|
|
2355
|
-
// 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.
|
|
2356
2933
|
const declareRecFun = (items: SExpr[], at: SExpr) => {
|
|
2357
2934
|
const symbol = expectSymbol(
|
|
2358
2935
|
items[0],
|
|
2359
2936
|
"invalid function/constant definition, symbol expected",
|
|
2360
2937
|
at,
|
|
2361
2938
|
);
|
|
2362
|
-
const bound = bindSortedVars(items[1], at);
|
|
2939
|
+
const bound = bindSortedVars(items[1], at, symbol.text);
|
|
2363
2940
|
const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
|
|
2364
2941
|
unbindSortedVars(bound.varSorts.length);
|
|
2365
2942
|
return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
|
|
@@ -2367,16 +2944,19 @@ export const createSmtlibReader = (
|
|
|
2367
2944
|
|
|
2368
2945
|
// parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
|
|
2369
2946
|
const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
|
|
2370
|
-
const
|
|
2371
|
-
const
|
|
2947
|
+
const start = exprStack.length;
|
|
2948
|
+
const bound = bindSortedVars(variables, body, "");
|
|
2949
|
+
runTerm(body, false);
|
|
2950
|
+
const parsedBody = exprStack[exprStack.length - 1];
|
|
2372
2951
|
unbindSortedVars(bound.varSorts.length);
|
|
2373
2952
|
const range = manager.funcDecls[decl].range;
|
|
2374
|
-
if (manager.sorts[
|
|
2953
|
+
if (manager.sorts[parsedBody] !== range)
|
|
2375
2954
|
throw new SmtParseError(
|
|
2376
|
-
`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])}`,
|
|
2377
2956
|
next,
|
|
2378
2957
|
);
|
|
2379
|
-
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false,
|
|
2958
|
+
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, false, parsedBody);
|
|
2959
|
+
shrinkRefs(exprStack, start);
|
|
2380
2960
|
};
|
|
2381
2961
|
|
|
2382
2962
|
// parse_define and insert_macro: Z3 declares a macro as a recursive function with one case, which
|
|
@@ -2402,11 +2982,13 @@ export const createSmtlibReader = (
|
|
|
2402
2982
|
};
|
|
2403
2983
|
|
|
2404
2984
|
const declareCommand = (list: SmtList) => {
|
|
2985
|
+
releasePending();
|
|
2405
2986
|
const name = list.items[0].kind === "list" ? "" : list.items[0].text;
|
|
2406
2987
|
if (name === "define-fun-rec") {
|
|
2407
2988
|
const decl = declareRecFun(list.items.slice(1), list.end);
|
|
2408
2989
|
insertFunc(decl, list.items[4] ?? list.end);
|
|
2409
2990
|
defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
|
|
2991
|
+
shrinkRefs(exprStack, 0);
|
|
2410
2992
|
return;
|
|
2411
2993
|
}
|
|
2412
2994
|
if (name === "define-funs-rec") {
|
|
@@ -2437,6 +3019,7 @@ export const createSmtlibReader = (
|
|
|
2437
3019
|
const extra = bodies.items[signatures.length];
|
|
2438
3020
|
if (extra !== undefined)
|
|
2439
3021
|
throw new SmtParseError("invalid recursive function definition, ')' expected", extra);
|
|
3022
|
+
shrinkRefs(exprStack, 0);
|
|
2440
3023
|
return;
|
|
2441
3024
|
}
|
|
2442
3025
|
if (name === "declare-datatypes") {
|
|
@@ -2483,24 +3066,27 @@ export const createSmtlibReader = (
|
|
|
2483
3066
|
}
|
|
2484
3067
|
if (name === "define-fun" || name === "define-const") {
|
|
2485
3068
|
const isConst = name === "define-const";
|
|
2486
|
-
const bound = isConst
|
|
3069
|
+
const bound = isConst
|
|
3070
|
+
? { names: [], varSorts: [] }
|
|
3071
|
+
: bindSortedVars(list.items[2], list.end, symbol.text);
|
|
2487
3072
|
const range = parseSort(
|
|
2488
3073
|
list.items[isConst ? 2 : 3] ?? list.end,
|
|
2489
3074
|
isConst ? "Invalid constant definition" : "Invalid function definition",
|
|
2490
3075
|
);
|
|
2491
|
-
|
|
3076
|
+
runTerm(list.items[isConst ? 3 : 4] ?? list.end, false);
|
|
3077
|
+
const body = exprStack[exprStack.length - 1];
|
|
2492
3078
|
if (!isConst) unbindSortedVars(bound.varSorts.length);
|
|
2493
|
-
|
|
2494
|
-
if (manager.sorts[coerced] !== range)
|
|
3079
|
+
if (manager.sorts[body] !== range)
|
|
2495
3080
|
throw new SmtParseError(
|
|
2496
3081
|
isConst
|
|
2497
3082
|
? "invalid constant definition, sort mismatch"
|
|
2498
3083
|
: "invalid function/constant definition, sort mismatch",
|
|
2499
3084
|
list.end,
|
|
2500
3085
|
);
|
|
2501
|
-
manager.incRef(
|
|
2502
|
-
declare(macros, symbol.text, { domain: bound.varSorts, range, body
|
|
2503
|
-
defineMacroFunc(symbol.text, bound.varSorts,
|
|
3086
|
+
manager.incRef(body);
|
|
3087
|
+
declare(macros, symbol.text, { domain: bound.varSorts, range, body });
|
|
3088
|
+
defineMacroFunc(symbol.text, bound.varSorts, body);
|
|
3089
|
+
shrinkRefs(exprStack, 0);
|
|
2504
3090
|
return;
|
|
2505
3091
|
}
|
|
2506
3092
|
const domain = name === "declare-fun" ? parseDomain(list.items[2], list) : [];
|
|
@@ -2519,14 +3105,7 @@ export const createSmtlibReader = (
|
|
|
2519
3105
|
if (macros.has(symbol.text))
|
|
2520
3106
|
throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
|
|
2521
3107
|
const existing = funcs.get(symbol.text) ?? [];
|
|
2522
|
-
if (
|
|
2523
|
-
existing.some(
|
|
2524
|
-
(decl) =>
|
|
2525
|
-
manager.funcDecls[decl].range === range &&
|
|
2526
|
-
manager.funcDecls[decl].domain.length === domain.length &&
|
|
2527
|
-
manager.funcDecls[decl].domain.every((sort, index) => sort === domain[index]),
|
|
2528
|
-
)
|
|
2529
|
-
)
|
|
3108
|
+
if (existing.some((other) => hasSignature(other, domain, range)))
|
|
2530
3109
|
throw new SmtParseError(
|
|
2531
3110
|
`invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
|
|
2532
3111
|
list.end,
|
|
@@ -2534,28 +3113,66 @@ export const createSmtlibReader = (
|
|
|
2534
3113
|
declare(funcs, symbol.text, [...existing, decl]);
|
|
2535
3114
|
};
|
|
2536
3115
|
|
|
3116
|
+
// The caller takes the reference of the stack.
|
|
2537
3117
|
const parseFormula = (sexpr: SExpr) => {
|
|
2538
|
-
|
|
3118
|
+
runTerm(sexpr, false);
|
|
3119
|
+
const assertion = exprStack[exprStack.length - 1];
|
|
2539
3120
|
if (manager.sorts[assertion] !== SORT_BOOL)
|
|
2540
3121
|
throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
|
|
2541
|
-
|
|
3122
|
+
exprStack.pop();
|
|
2542
3123
|
return assertion;
|
|
2543
3124
|
};
|
|
2544
3125
|
|
|
2545
3126
|
// An assertion is named when the last name of its term is its own.
|
|
2546
3127
|
const parseAssertion = (sexpr: SExpr) => {
|
|
3128
|
+
releasePending();
|
|
2547
3129
|
lastNamed.expr = -1;
|
|
2548
3130
|
const formula = parseFormula(sexpr);
|
|
2549
3131
|
return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
|
|
2550
3132
|
};
|
|
2551
3133
|
|
|
2552
|
-
const push = () =>
|
|
3134
|
+
const push = () => {
|
|
3135
|
+
releasePending();
|
|
3136
|
+
scopeStarts.push(undo.length);
|
|
3137
|
+
};
|
|
2553
3138
|
|
|
2554
3139
|
const pop = () => {
|
|
3140
|
+
releasePending();
|
|
2555
3141
|
const start = scopeStarts.pop() ?? 0;
|
|
2556
3142
|
for (const restore of undo.splice(start).reverse()) restore();
|
|
2557
3143
|
};
|
|
2558
3144
|
|
|
3145
|
+
// parser::reset, after an error: Z3 frees its stacks, and with them the terms that only the
|
|
3146
|
+
// command that failed held.
|
|
3147
|
+
const reset = () => {
|
|
3148
|
+
protect(floating);
|
|
3149
|
+
protect(unrooted);
|
|
3150
|
+
releasePending();
|
|
3151
|
+
shrinkRefs(exprStack, 0);
|
|
3152
|
+
if (parsed.expr !== -1) {
|
|
3153
|
+
if (!parsed.isOwned) manager.incRef(parsed.expr);
|
|
3154
|
+
manager.decRef(parsed.expr);
|
|
3155
|
+
parsed.expr = -1;
|
|
3156
|
+
}
|
|
3157
|
+
shrinkRefs(patternStack, 0);
|
|
3158
|
+
shrinkRefs(noPatternStack, 0);
|
|
3159
|
+
locals.clear();
|
|
3160
|
+
shrink(shadowedNames, 0);
|
|
3161
|
+
shrink(shadowedLocals, 0);
|
|
3162
|
+
shrink(localScopes, 0);
|
|
3163
|
+
binders.depth = 0;
|
|
3164
|
+
};
|
|
3165
|
+
|
|
3166
|
+
// cmd_context::set_logic on a manager that is in use: restrict_builtin_sorts takes the sorts the
|
|
3167
|
+
// logic lacks, and the declarations and the operators stay.
|
|
3168
|
+
const restrictSorts = (name: string) => {
|
|
3169
|
+
releasePending();
|
|
3170
|
+
if (logicHasRealsOnly(name)) restricted.isNumeralAsReal = true;
|
|
3171
|
+
if (!ARRAY_EXTENSION_LOGICS.has(name)) restricted.hasSetSort = false;
|
|
3172
|
+
if (INT_FREE_LOGICS.has(name)) sortDecls.delete("Int");
|
|
3173
|
+
restricted.hasFf = FF_LOGICS.has(name);
|
|
3174
|
+
};
|
|
3175
|
+
|
|
2559
3176
|
const isUsed = (name: string) => funcs.has(name) || BUILTIN_NAMES.has(name);
|
|
2560
3177
|
|
|
2561
3178
|
const isClashing = (decl: number) => {
|
|
@@ -2563,12 +3180,7 @@ export const createSmtlibReader = (
|
|
|
2563
3180
|
const decls = funcs.get(String(manager.funcDecls[decl].name)) ?? [];
|
|
2564
3181
|
return (
|
|
2565
3182
|
decls.includes(decl) &&
|
|
2566
|
-
decls.some(
|
|
2567
|
-
(other) =>
|
|
2568
|
-
other !== decl &&
|
|
2569
|
-
manager.funcDecls[other].domain.length === domain.length &&
|
|
2570
|
-
manager.funcDecls[other].domain.every((sort, index) => sort === domain[index]),
|
|
2571
|
-
)
|
|
3183
|
+
decls.some((other) => other !== decl && hasSignature(other, domain, -1))
|
|
2572
3184
|
);
|
|
2573
3185
|
};
|
|
2574
3186
|
|
|
@@ -2596,6 +3208,8 @@ export const createSmtlibReader = (
|
|
|
2596
3208
|
getLogicError: logicChecker.checkExpr,
|
|
2597
3209
|
push,
|
|
2598
3210
|
pop,
|
|
3211
|
+
reset,
|
|
3212
|
+
restrictSorts,
|
|
2599
3213
|
isUsed,
|
|
2600
3214
|
isClashing,
|
|
2601
3215
|
getDeclaredFuncs,
|
|
@@ -2625,7 +3239,7 @@ export const parseSmtlib = (
|
|
|
2625
3239
|
report: (error: SmtParseError) => void,
|
|
2626
3240
|
): SmtProblem => {
|
|
2627
3241
|
const commands = createCommandReader(text);
|
|
2628
|
-
const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0 };
|
|
3242
|
+
const state = { reader: createSmtlibReader(manager), logic: "", rlimit: 0, isInUse: false };
|
|
2629
3243
|
const assertions: number[] = [];
|
|
2630
3244
|
const runCommand = (list: SmtList) => {
|
|
2631
3245
|
const name = expectSymbol(list.items[0], "invalid command, symbol expected", list).text;
|
|
@@ -2639,19 +3253,26 @@ export const parseSmtlib = (
|
|
|
2639
3253
|
)
|
|
2640
3254
|
state.rlimit = Number(value.text);
|
|
2641
3255
|
if (name === "set-logic") {
|
|
3256
|
+
if (option === undefined)
|
|
3257
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2642
3258
|
if (!isSymbol(option))
|
|
2643
|
-
throw new SmtParseError("invalid
|
|
2644
|
-
if (
|
|
3259
|
+
throw new SmtParseError("invalid command argument, symbol expected", option);
|
|
3260
|
+
if (value !== undefined)
|
|
3261
|
+
throw new SmtParseError("invalid command, too many arguments", value);
|
|
3262
|
+
if (state.logic !== "") throw new SmtParseError("the logic has already been set", option);
|
|
2645
3263
|
if (assertions.length > 0)
|
|
2646
|
-
throw new SmtParseError("logic must be set before initialization",
|
|
3264
|
+
throw new SmtParseError("logic must be set before initialization", option);
|
|
2647
3265
|
if (!isSupportedLogic(option.text)) return;
|
|
2648
3266
|
state.logic = option.text;
|
|
2649
|
-
state.reader
|
|
3267
|
+
if (state.isInUse) state.reader.restrictSorts(option.text);
|
|
3268
|
+
else state.reader = createSmtlibReader(manager, option.text);
|
|
2650
3269
|
} else if (DECLARATIONS.has(name)) {
|
|
3270
|
+
state.isInUse = true;
|
|
2651
3271
|
if (name.startsWith("define-"))
|
|
2652
3272
|
throw new SmtUnsupportedError(`the command ${name} is not supported`);
|
|
2653
3273
|
state.reader.declareCommand(list);
|
|
2654
3274
|
} else if (name === "assert") {
|
|
3275
|
+
state.isInUse = true;
|
|
2655
3276
|
const assertion = state.reader.parseFormula(list.items[1] ?? list.end);
|
|
2656
3277
|
const logicError = state.reader.getLogicError(assertion);
|
|
2657
3278
|
if (logicError !== undefined) {
|
|
@@ -2673,6 +3294,7 @@ export const parseSmtlib = (
|
|
|
2673
3294
|
} catch (error) {
|
|
2674
3295
|
if (!(error instanceof SmtParseError)) throw error;
|
|
2675
3296
|
report(error);
|
|
3297
|
+
state.reader.reset();
|
|
2676
3298
|
commands.skip(report);
|
|
2677
3299
|
}
|
|
2678
3300
|
}
|