tla-ts 0.0.10-dev.c92e6a4ea → 0.0.10-dev.d166e0ae9
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/compile.cjs +3 -3
- package/dist/compile.js +1 -1
- package/dist/deciders.cjs +36 -36
- package/dist/deciders.js +54 -54
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +13 -3
- package/dist/index.d.ts +13 -3
- package/dist/index.js +1 -1
- package/dist/parallel-worker.cjs +1 -1
- package/dist/parallel-worker.js +1 -1
- package/dist/prove-worker.cjs +1 -1
- package/dist/prove-worker.js +1 -1
- package/dist/prove.cjs +68 -68
- package/dist/prove.js +78 -78
- package/dist/run.cjs +42 -42
- package/dist/run.js +44 -44
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +45 -43
- package/dist/transfer.js +45 -43
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +11 -1
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +9 -6
- package/src/check-trace.ts +116 -64
- package/src/check.ts +356 -173
- package/src/cli/tlc-output.ts +1 -0
- package/src/cli/tlc.ts +4 -3
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +34 -13
- package/src/coverage.ts +3 -0
- package/src/dependencies.ts +61 -13
- package/src/dfid.ts +22 -10
- package/src/environment.ts +71 -35
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +149 -54
- package/src/exit-codes.ts +29 -15
- package/src/instances.ts +16 -6
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +186 -97
- package/src/liveness-checker.ts +131 -83
- package/src/liveness.ts +52 -11
- package/src/obligations/index.ts +1 -1
- package/src/obligations/normalize.ts +1 -4
- package/src/obligations/printer.ts +5 -5
- package/src/obligations/source.ts +2 -0
- package/src/parser.ts +115 -145
- package/src/prover/isabelle/isar/attrib.ts +4 -4
- package/src/prover/isabelle/isar/rule-cases.ts +8 -6
- package/src/prover/isabelle/provers/clasimp.ts +1 -1
- package/src/prover/isabelle/provers/hypsubst.ts +2 -2
- package/src/prover/isabelle/pure/rewriter.ts +3 -3
- package/src/prover/isabelle/pure/term.ts +3 -3
- package/src/prover/prep/md5.ts +26 -29
- package/src/prover/smt/rewrite.ts +2 -7
- package/src/prover/smt/simplify.ts +1 -1
- package/src/prover/smt/solver/arith-rewriter.ts +11 -3
- package/src/prover/smt/solver/array-rewriter.ts +12 -2
- package/src/prover/smt/solver/asserted-formulas.ts +169 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +63 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +26 -0
- package/src/prover/smt/solver/blast-term-ite.ts +47 -0
- package/src/prover/smt/solver/bound-simplifier.ts +11 -13
- package/src/prover/smt/solver/bv-decl-plugin.ts +13 -10
- package/src/prover/smt/solver/bv-rewriter.ts +1 -1
- package/src/prover/smt/solver/card2bv.ts +35 -18
- package/src/prover/smt/solver/cofactor-elim-term-ite.ts +39 -24
- package/src/prover/smt/solver/context.ts +67 -13
- package/src/prover/smt/solver/ctx-simplify.ts +1 -2
- package/src/prover/smt/solver/datatype-decl-plugin.ts +15 -7
- package/src/prover/smt/solver/dependent-expr-state.ts +26 -15
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +36 -20
- package/src/prover/smt/solver/elim-bounds.ts +89 -0
- package/src/prover/smt/solver/elim-term-ite-tactic.ts +48 -0
- package/src/prover/smt/solver/elim-uncnstr.ts +5 -8
- package/src/prover/smt/solver/euf/arith-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/array-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/bv-internalize.ts +1 -1
- package/src/prover/smt/solver/euf/egraph.ts +4 -11
- package/src/prover/smt/solver/euf/euf-solver.ts +1 -2
- package/src/prover/smt/solver/euf/mam.ts +1 -5
- package/src/prover/smt/solver/euf/q-ematch.ts +1 -2
- package/src/prover/smt/solver/euf/th-solver.ts +0 -7
- package/src/prover/smt/solver/expr2polynomial.ts +204 -79
- package/src/prover/smt/solver/factor.ts +36 -14
- package/src/prover/smt/solver/fd-solver.ts +148 -39
- package/src/prover/smt/solver/fix-dl-var.ts +1 -2
- package/src/prover/smt/solver/fpa-rewriter.ts +1 -2
- package/src/prover/smt/solver/fpa2bv-converter.ts +3 -1
- package/src/prover/smt/solver/fpa2bv-rewriter.ts +1 -0
- package/src/prover/smt/solver/goal.ts +6 -3
- package/src/prover/smt/solver/goal2nlsat.ts +57 -30
- package/src/prover/smt/solver/hashtable.ts +4 -0
- package/src/prover/smt/solver/internalizer.ts +1 -1
- package/src/prover/smt/solver/logic-tactics.ts +9 -2
- package/src/prover/smt/solver/lp/lp-settings.ts +5 -1
- package/src/prover/smt/solver/lp/nla-core.ts +1 -1
- package/src/prover/smt/solver/lp/nla-grobner.ts +2 -2
- package/src/prover/smt/solver/lp/nra-solver.ts +45 -39
- package/src/prover/smt/solver/lp/pdd.ts +2 -3
- package/src/prover/smt/solver/lp/union-find.ts +1 -1
- package/src/prover/smt/solver/mam-compiler.ts +1 -1
- package/src/prover/smt/solver/maxcore.ts +2 -1
- package/src/prover/smt/solver/maxsmt-base.ts +1 -0
- package/src/prover/smt/solver/model-based-opt.ts +1 -1
- package/src/prover/smt/solver/model-checker.ts +1 -1
- package/src/prover/smt/solver/model-evaluator.ts +2 -0
- package/src/prover/smt/solver/model-generator.ts +85 -43
- package/src/prover/smt/solver/mpf.ts +2 -4
- package/src/prover/smt/solver/mus.ts +2 -3
- package/src/prover/smt/solver/muz/dl-context.ts +22 -44
- package/src/prover/smt/solver/muz/dl-mk-coi-filter.ts +1 -1
- package/src/prover/smt/solver/muz/dl-mk-slice.ts +3 -3
- package/src/prover/smt/solver/muz/dl-rule.ts +8 -9
- package/src/prover/smt/solver/muz/hnf.ts +2 -2
- package/src/prover/smt/solver/muz/horn-subsume-model-converter.ts +1 -1
- package/src/prover/smt/solver/muz/horn-tactic.ts +15 -2
- package/src/prover/smt/solver/muz/rule-properties.ts +22 -0
- package/src/prover/smt/solver/muz/spacer-context.ts +2 -4
- package/src/prover/smt/solver/muz/spacer-pdr.ts +1 -0
- package/src/prover/smt/solver/muz/spacer-prop-solver.ts +1 -1
- package/src/prover/smt/solver/nlqsat.ts +1 -1
- package/src/prover/smt/solver/nlsat/algebraic.ts +196 -92
- package/src/prover/smt/solver/nlsat/atoms.ts +52 -33
- package/src/prover/smt/solver/nlsat/explain.ts +375 -217
- package/src/prover/smt/solver/nlsat/levelwise.ts +460 -240
- package/src/prover/smt/solver/nlsat/polynomial.ts +2366 -681
- package/src/prover/smt/solver/nlsat/solver.ts +74 -64
- package/src/prover/smt/solver/nlsat/transcendentals.ts +41 -17
- package/src/prover/smt/solver/nlsat/upolynomial-factorization.ts +8 -4
- package/src/prover/smt/solver/nlsat/upolynomial.ts +41 -18
- package/src/prover/smt/solver/nlsat-tactic.ts +1 -1
- package/src/prover/smt/solver/nnf.ts +6 -2
- package/src/prover/smt/solver/opt-context.ts +21 -7
- package/src/prover/smt/solver/opt-nlsat.ts +29 -18
- package/src/prover/smt/solver/opt-pareto.ts +19 -0
- package/src/prover/smt/solver/opt-preprocess.ts +1 -1
- package/src/prover/smt/solver/opt-solver.ts +10 -6
- package/src/prover/smt/solver/optsmt.ts +1 -1
- package/src/prover/smt/solver/parallel-tactic.ts +1 -1
- package/src/prover/smt/solver/pb-rewriter.ts +1 -4
- package/src/prover/smt/solver/poly-rewriter.ts +75 -18
- package/src/prover/smt/solver/probes.ts +88 -23
- package/src/prover/smt/solver/proto-model.ts +8 -8
- package/src/prover/smt/solver/push-app-ite.ts +37 -0
- package/src/prover/smt/solver/qe-arith-plugin.ts +2 -4
- package/src/prover/smt/solver/qe-lite.ts +2 -2
- package/src/prover/smt/solver/qe.ts +3 -2
- package/src/prover/smt/solver/qsat.ts +23 -8
- package/src/prover/smt/solver/quantifier-manager.ts +14 -9
- package/src/prover/smt/solver/recfun-decl-plugin.ts +2 -1
- package/src/prover/smt/solver/rewriter-tpl.ts +7 -6
- package/src/prover/smt/solver/rewriter.ts +31 -25
- package/src/prover/smt/solver/rlimit.ts +4 -0
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +0 -1
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +81 -28
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-solver.ts +1 -1
- package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +10 -7
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +25 -47
- package/src/prover/smt/solver/seq-axioms.ts +20 -35
- package/src/prover/smt/solver/seq-decl-plugin.ts +1 -1
- package/src/prover/smt/solver/seq-derive.ts +2 -2
- package/src/prover/smt/solver/seq-eq-solver.ts +2 -2
- package/src/prover/smt/solver/seq-monadic.ts +7 -5
- package/src/prover/smt/solver/seq-re-rewriter.ts +2 -1
- package/src/prover/smt/solver/seq-re-util.ts +1 -1
- package/src/prover/smt/solver/seq-regex-bisim.ts +1 -1
- package/src/prover/smt/solver/seq-regex-live.ts +2 -2
- package/src/prover/smt/solver/seq-rewriter.ts +31 -29
- package/src/prover/smt/solver/seq-skolem.ts +0 -23
- package/src/prover/smt/solver/seq-view-witness.ts +4 -4
- package/src/prover/smt/solver/smt-consequences.ts +1 -1
- package/src/prover/smt/solver/smt-kernel.ts +48 -7
- package/src/prover/smt/solver/smt-setup.ts +96 -10
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +674 -195
- package/src/prover/smt/solver/solve-eqs.ts +36 -37
- package/src/prover/smt/solver/solver.ts +18 -3
- package/src/prover/smt/solver/tactic.ts +332 -189
- package/src/prover/smt/solver/theory-bv.ts +13 -3
- package/src/prover/smt/solver/theory-fpa.ts +1 -1
- package/src/prover/smt/solver/theory-lra-final-check.ts +1 -0
- package/src/prover/smt/solver/theory-lra-internalize.ts +2 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra.ts +1 -1
- package/src/prover/smt/solver/theory-pb.ts +24 -7
- package/src/prover/smt/solver/theory-seq-solve.ts +1 -1
- package/src/prover/smt/solver/theory-seq-state.ts +2 -21
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/index-table.ts +5 -2
- package/src/prover/zenon/isar-case.ts +1 -1
- package/src/prover/zenon/isar.ts +2 -2
- package/src/prover/zenon/phrase.ts +1 -1
- package/src/resolve.ts +1071 -251
- package/src/runtime.ts +5 -1
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +2 -13
- package/src/sany/generator-definitions.ts +3 -1
- package/src/sany/generator-expressions.ts +38 -30
- package/src/sany/generator-proofs.ts +6 -3
- package/src/sany/generator.ts +2 -1
- package/src/sany/lexer.ts +3 -3
- package/src/sany/modules.ts +4 -2
- package/src/sany/nodes.ts +1 -1
- package/src/sany/selectors.ts +11 -6
- package/src/sany/xml.ts +2 -3
- package/src/search.ts +197 -117
- package/src/simulate.ts +165 -102
- package/src/spec-description.ts +8 -6
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +518 -123
- package/src/successors.ts +10 -3
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +27 -14
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +26 -10
- package/src/tlc/trace-spec.ts +9 -22
- package/src/typed-tier.ts +44 -27
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +135 -78
|
@@ -3,6 +3,7 @@ import {
|
|
|
3
3
|
isStackOverflow,
|
|
4
4
|
SmtCanceledError,
|
|
5
5
|
SmtParseError,
|
|
6
|
+
SmtDefaultError,
|
|
6
7
|
SmtTacticError,
|
|
7
8
|
SmtUnsupportedError,
|
|
8
9
|
} from "../../../errors";
|
|
@@ -38,19 +39,23 @@ import {
|
|
|
38
39
|
createCommandReader,
|
|
39
40
|
createSmtlibReader,
|
|
40
41
|
DECLARATIONS,
|
|
42
|
+
expectClosed,
|
|
41
43
|
isSymbol,
|
|
44
|
+
isUnsigned,
|
|
42
45
|
type SExpr,
|
|
43
46
|
type SmtList,
|
|
44
47
|
type SmtlibReader,
|
|
48
|
+
type SmtToken,
|
|
45
49
|
} from "./smtlib-parser";
|
|
46
50
|
import { O_MAXIMIZE, O_MAXSMT, O_MINIMIZE, OptContext, type OptObjective } from "./opt-context";
|
|
47
51
|
import { getLogicStrategy } from "./logic-tactics";
|
|
48
52
|
import { isMbqiByFeatures, isMbqiByLogic } from "./smt-setup";
|
|
49
|
-
import { isSupportedLogic } from "./smt-logics";
|
|
53
|
+
import { isSupportedLogic, logicHasSeq } from "./smt-logics";
|
|
50
54
|
import { getVerdict, solveAssertions, solveAssuming } from "./solver";
|
|
51
55
|
import { getConsequences } from "./smt-consequences";
|
|
52
|
-
import { getFdConsequences } from "./fd-solver";
|
|
56
|
+
import { checkFdSolver, getFdConsequences } from "./fd-solver";
|
|
53
57
|
import { SmtKernel } from "./smt-kernel";
|
|
58
|
+
import { RefVector } from "./ref-vector";
|
|
54
59
|
import { IncSatSolver } from "./sat/inc-sat-solver";
|
|
55
60
|
import { mkThSolver } from "./euf/th-solvers";
|
|
56
61
|
import { isAstLess } from "./ast-lt";
|
|
@@ -61,6 +66,7 @@ import { L_FALSE, L_TRUE, L_UNDEF } from "./lbool";
|
|
|
61
66
|
import type { DatalogContext } from "./muz/dl-context";
|
|
62
67
|
import { createDatalogContext } from "./muz/horn-tactic";
|
|
63
68
|
import { printModel } from "./model-printer";
|
|
69
|
+
import { ModelEvaluator } from "./model-evaluator";
|
|
64
70
|
import { FuncInterp, getManagerSomeValue, ProtoModel } from "./proto-model";
|
|
65
71
|
import {
|
|
66
72
|
applyTactic,
|
|
@@ -69,9 +75,60 @@ import {
|
|
|
69
75
|
compileTactic,
|
|
70
76
|
getRewriterOptions,
|
|
71
77
|
getSatParams,
|
|
78
|
+
getSmtTacticFailure,
|
|
72
79
|
type TacticParam,
|
|
73
80
|
} from "./tactic";
|
|
74
81
|
|
|
82
|
+
const UNPORTED_COMMANDS = new Set([
|
|
83
|
+
"assert-not",
|
|
84
|
+
"assume",
|
|
85
|
+
"dbg-bool-rewriter",
|
|
86
|
+
"dbg-elim-and",
|
|
87
|
+
"dbg-get-qbody",
|
|
88
|
+
"dbg-params",
|
|
89
|
+
"dbg-pp-var",
|
|
90
|
+
"dbg-set",
|
|
91
|
+
"dbg-set-next-id",
|
|
92
|
+
"dbg-sexpr",
|
|
93
|
+
"dbg-shift-vars",
|
|
94
|
+
"dbg-size",
|
|
95
|
+
"dbg-subst",
|
|
96
|
+
"dbg-th-rewriter",
|
|
97
|
+
"dbg-translator",
|
|
98
|
+
"declare-map",
|
|
99
|
+
"declare-tactic",
|
|
100
|
+
"declare-type-var",
|
|
101
|
+
"del",
|
|
102
|
+
"display-dimacs",
|
|
103
|
+
"euf-project",
|
|
104
|
+
"eufi",
|
|
105
|
+
"ff-boolean-certify",
|
|
106
|
+
"ff-certify",
|
|
107
|
+
"ff-check-native-proof",
|
|
108
|
+
"ff-integrated-certify",
|
|
109
|
+
"get-interpolant",
|
|
110
|
+
"get-proof",
|
|
111
|
+
"get-proof-graph",
|
|
112
|
+
"get-user-tactics",
|
|
113
|
+
"help",
|
|
114
|
+
"help-simplifier",
|
|
115
|
+
"help-tactic",
|
|
116
|
+
"include",
|
|
117
|
+
"infer",
|
|
118
|
+
"labels",
|
|
119
|
+
"mbi",
|
|
120
|
+
"mbp",
|
|
121
|
+
"mbp-qel",
|
|
122
|
+
"model-add",
|
|
123
|
+
"model-del",
|
|
124
|
+
"prefer",
|
|
125
|
+
"qe-lite",
|
|
126
|
+
"qel",
|
|
127
|
+
"reset-preferences",
|
|
128
|
+
"set-initial-value",
|
|
129
|
+
"set-simplifier",
|
|
130
|
+
]);
|
|
131
|
+
|
|
75
132
|
const SILENT_COMMANDS = new Set([
|
|
76
133
|
...DECLARATIONS,
|
|
77
134
|
"assert",
|
|
@@ -81,8 +138,6 @@ const SILENT_COMMANDS = new Set([
|
|
|
81
138
|
"reset-assertions",
|
|
82
139
|
"set-option",
|
|
83
140
|
"set-info",
|
|
84
|
-
"minimize",
|
|
85
|
-
"maximize",
|
|
86
141
|
"assert-soft",
|
|
87
142
|
"declare-rel",
|
|
88
143
|
"declare-var",
|
|
@@ -121,6 +176,7 @@ const SIMPLIFY_PARAMETERS = new Set([
|
|
|
121
176
|
"som",
|
|
122
177
|
"sort_sums",
|
|
123
178
|
"arith_lhs",
|
|
179
|
+
"arith_ineq_lhs",
|
|
124
180
|
"gcd_rounding",
|
|
125
181
|
"hi_div0",
|
|
126
182
|
"mul2concat",
|
|
@@ -175,7 +231,9 @@ const getSoftParameters = (items: SExpr[]) => {
|
|
|
175
231
|
const parameters = { weight: Rational.one, id: null as string | null };
|
|
176
232
|
for (let index = 0; index < items.length; index += 2) {
|
|
177
233
|
const keyword = items[index];
|
|
178
|
-
|
|
234
|
+
if (keyword.kind !== "keyword")
|
|
235
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
236
|
+
const name = getParameterName(keyword.text);
|
|
179
237
|
const value = items[index + 1];
|
|
180
238
|
if (name === "weight" && (value?.kind === "numeral" || value?.kind === "decimal")) {
|
|
181
239
|
const [whole, fraction = ""] = value.text.split(".");
|
|
@@ -193,7 +251,9 @@ const getSimplifyParams = (items: SExpr[]) => {
|
|
|
193
251
|
const params = new Map<string, TacticParam>();
|
|
194
252
|
for (let index = 0; index < items.length; index += 2) {
|
|
195
253
|
const keyword = items[index];
|
|
196
|
-
|
|
254
|
+
if (keyword.kind !== "keyword")
|
|
255
|
+
throw new SmtParseError("invalid command argument, keyword expected", keyword);
|
|
256
|
+
const name = getParameterName(keyword.text);
|
|
197
257
|
const value = items[index + 1];
|
|
198
258
|
if (SIMPLIFY_UINT_PARAMETERS.has(name) && value?.kind === "numeral") {
|
|
199
259
|
params.set(name, Number(value.text));
|
|
@@ -206,6 +266,17 @@ const getSimplifyParams = (items: SExpr[]) => {
|
|
|
206
266
|
return params;
|
|
207
267
|
};
|
|
208
268
|
|
|
269
|
+
const GET_INFO_KEYWORDS = [
|
|
270
|
+
":reason-unknown",
|
|
271
|
+
":status",
|
|
272
|
+
":version",
|
|
273
|
+
":authors",
|
|
274
|
+
":error-behavior",
|
|
275
|
+
":parameters",
|
|
276
|
+
":rlimit",
|
|
277
|
+
":assertion-stack-levels",
|
|
278
|
+
];
|
|
279
|
+
|
|
209
280
|
const APPLY_PARAMETERS = new Map([
|
|
210
281
|
["print", true],
|
|
211
282
|
["print_model_converter", true],
|
|
@@ -245,12 +316,29 @@ const getCommandParams = (items: SExpr[], isBooleans: ReadonlyMap<string, boolea
|
|
|
245
316
|
"invalid command argument, unsigned integer expected",
|
|
246
317
|
value ?? keyword,
|
|
247
318
|
);
|
|
319
|
+
if (!isUnsigned(value.text))
|
|
320
|
+
throw new SmtParseError(
|
|
321
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
322
|
+
value,
|
|
323
|
+
);
|
|
248
324
|
params.set(name, Number(value.text));
|
|
249
325
|
}
|
|
250
326
|
}
|
|
251
327
|
return params;
|
|
252
328
|
};
|
|
253
329
|
|
|
330
|
+
const getFirstArgument = (list: SmtList) => {
|
|
331
|
+
const argument = list.items[1];
|
|
332
|
+
if (argument === undefined)
|
|
333
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
334
|
+
return argument;
|
|
335
|
+
};
|
|
336
|
+
|
|
337
|
+
const checkArgumentCount = (list: SmtList, count: number) => {
|
|
338
|
+
const extra = list.items[count + 1];
|
|
339
|
+
if (extra !== undefined) throw new SmtParseError("invalid command, too many arguments", extra);
|
|
340
|
+
};
|
|
341
|
+
|
|
254
342
|
// Z3's parse_opt_unsigned names the push command for pop as well.
|
|
255
343
|
const getScopeCount = (list: SmtList) => {
|
|
256
344
|
const argument = list.items[1];
|
|
@@ -266,18 +354,26 @@ interface Scope {
|
|
|
266
354
|
assertions: number;
|
|
267
355
|
objectives: number;
|
|
268
356
|
softTrail: number;
|
|
357
|
+
rlimit: number;
|
|
269
358
|
}
|
|
270
359
|
|
|
271
360
|
interface CheckResult {
|
|
272
361
|
status: number;
|
|
273
362
|
context: Context | undefined;
|
|
274
363
|
isOptimizing: boolean;
|
|
364
|
+
isFromTactic: boolean;
|
|
275
365
|
model: ProtoModel | undefined;
|
|
276
366
|
core: number[] | undefined;
|
|
277
367
|
// check_sat_result::reason_unknown, where the port tracks it.
|
|
278
368
|
reasonUnknown?: string;
|
|
279
369
|
}
|
|
280
370
|
|
|
371
|
+
interface SolverAnswer {
|
|
372
|
+
result: number;
|
|
373
|
+
context: Context | undefined;
|
|
374
|
+
reasonUnknown: string | undefined;
|
|
375
|
+
}
|
|
376
|
+
|
|
281
377
|
interface ScriptState {
|
|
282
378
|
manager: AstManager;
|
|
283
379
|
logic: string | undefined;
|
|
@@ -299,9 +395,7 @@ interface ScriptState {
|
|
|
299
395
|
// combined_solver's incremental smt kernel, which keeps one context across the checks, or
|
|
300
396
|
// undefined while Z3 has made no such kernel.
|
|
301
397
|
kernel: SmtKernel | undefined;
|
|
302
|
-
|
|
303
|
-
// an unported theory and the smt kernel answers in its place.
|
|
304
|
-
eufSolver: IncSatSolver | undefined;
|
|
398
|
+
satSolver: IncSatSolver | undefined;
|
|
305
399
|
}
|
|
306
400
|
|
|
307
401
|
// Z3 fixes the proof mode at the first command that needs terms.
|
|
@@ -311,6 +405,7 @@ const MANAGERLESS_COMMANDS = new Set([
|
|
|
311
405
|
"set-logic",
|
|
312
406
|
"get-option",
|
|
313
407
|
"get-info",
|
|
408
|
+
"get-assertions",
|
|
314
409
|
"echo",
|
|
315
410
|
]);
|
|
316
411
|
|
|
@@ -330,6 +425,7 @@ export const runSmtlibScript = (
|
|
|
330
425
|
isPrintingSuccess: false,
|
|
331
426
|
isProducingModels: true,
|
|
332
427
|
isProducingUnsatCores: false,
|
|
428
|
+
isProducingUnsatAssumptions: false,
|
|
333
429
|
isProducingProofs: false,
|
|
334
430
|
isExitingOnError: false,
|
|
335
431
|
isInteractive: false,
|
|
@@ -343,11 +439,11 @@ export const runSmtlibScript = (
|
|
|
343
439
|
rlimit: 0,
|
|
344
440
|
printOptions: { ...DEFAULT_PRINT_OPTIONS },
|
|
345
441
|
parserOptions: { isIgnoringBadPatterns: true },
|
|
442
|
+
// Z3 keeps set-info's :status across reset.
|
|
443
|
+
status: L_UNDEF,
|
|
346
444
|
};
|
|
347
445
|
const createState = (): ScriptState => {
|
|
348
|
-
const manager = new AstManager(
|
|
349
|
-
new ResourceLimit(Date.now() + options.timeLimitMs, options.signal),
|
|
350
|
-
);
|
|
446
|
+
const manager = new AstManager(new ResourceLimit(Infinity, options.signal));
|
|
351
447
|
manager.isHiDiv0 = settings.isHiDiv0;
|
|
352
448
|
manager.maxChar = settings.encoding.maxChar;
|
|
353
449
|
manager.charBits = settings.encoding.charBits;
|
|
@@ -368,7 +464,7 @@ export const runSmtlibScript = (
|
|
|
368
464
|
hasChecked: false,
|
|
369
465
|
datalog: undefined,
|
|
370
466
|
kernel: undefined,
|
|
371
|
-
|
|
467
|
+
satSolver: undefined,
|
|
372
468
|
};
|
|
373
469
|
};
|
|
374
470
|
let state = createState();
|
|
@@ -409,7 +505,7 @@ export const runSmtlibScript = (
|
|
|
409
505
|
paretoMaxLemmas: Number(parameters.get("opt.pareto_nlsat_max_lemmas") ?? 128),
|
|
410
506
|
};
|
|
411
507
|
};
|
|
412
|
-
const optimize = (extra: number[]) => {
|
|
508
|
+
const optimize = (extra: number[], end: SmtToken) => {
|
|
413
509
|
const manager = state.manager;
|
|
414
510
|
const objectives = state.objectives;
|
|
415
511
|
const hard = [...getNamedAssertions(), ...state.names.filter((name) => name !== -1), ...extra];
|
|
@@ -452,7 +548,11 @@ export const runSmtlibScript = (
|
|
|
452
548
|
!hasAssumptions &&
|
|
453
549
|
settings.parameters.get("opt.incremental") !== "true",
|
|
454
550
|
});
|
|
455
|
-
setCheck(status, {
|
|
551
|
+
setCheck(status, {
|
|
552
|
+
isOptimizing: true,
|
|
553
|
+
model: optimizer.model ?? undefined,
|
|
554
|
+
reasonUnknown: optimizer.getReasonUnknown(),
|
|
555
|
+
});
|
|
456
556
|
print(getVerdict(status));
|
|
457
557
|
return true;
|
|
458
558
|
} catch (error) {
|
|
@@ -461,9 +561,16 @@ export const runSmtlibScript = (
|
|
|
461
561
|
resetOptimizer();
|
|
462
562
|
return false;
|
|
463
563
|
}
|
|
564
|
+
if (error instanceof SmtDefaultError) {
|
|
565
|
+
setCheck(L_UNDEF, { isFromTactic: true, reasonUnknown: optimizer.getReasonUnknown() });
|
|
566
|
+
throw new SmtParseError(error.message, end);
|
|
567
|
+
}
|
|
464
568
|
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
569
|
+
const reasonUnknown = optimizer.getReasonUnknown();
|
|
465
570
|
optimizer.release();
|
|
466
|
-
setCheck(L_UNDEF, { isOptimizing: true });
|
|
571
|
+
setCheck(L_UNDEF, { isOptimizing: true, reasonUnknown });
|
|
572
|
+
if (error instanceof SmtCanceledError)
|
|
573
|
+
throw new SmtParseError(manager.limit.getCancelMessage(), end);
|
|
467
574
|
print("unknown");
|
|
468
575
|
return true;
|
|
469
576
|
} finally {
|
|
@@ -477,33 +584,63 @@ export const runSmtlibScript = (
|
|
|
477
584
|
};
|
|
478
585
|
// The port keeps answering with the smt kernel where it lacks a piece of the logic's strategy.
|
|
479
586
|
const solveWithStrategy = () => {
|
|
480
|
-
const goal = getGoal();
|
|
481
|
-
const strategy =
|
|
482
|
-
settings.parameters.get("tactic.default_tactic") ??
|
|
483
|
-
getLogicStrategy(state.logic, goal.isProofsEnabled);
|
|
484
587
|
try {
|
|
588
|
+
if (isUsingFdSolver())
|
|
589
|
+
return {
|
|
590
|
+
...checkFdSolver(state.manager, getSatParams(settings.parameters), state.assertions),
|
|
591
|
+
context: undefined,
|
|
592
|
+
};
|
|
593
|
+
const goal = getGoal();
|
|
594
|
+
const strategy =
|
|
595
|
+
settings.parameters.get("tactic.default_tactic") ??
|
|
596
|
+
getLogicStrategy(state.logic, goal.isProofsEnabled);
|
|
485
597
|
const checked = checkSatUsing(compileInternalTactic(getTacticEnvironment(), strategy), goal);
|
|
486
|
-
return {
|
|
598
|
+
return {
|
|
599
|
+
result: checked.status,
|
|
600
|
+
context: undefined,
|
|
601
|
+
model: checked.model,
|
|
602
|
+
reasonUnknown: checked.reasonUnknown,
|
|
603
|
+
};
|
|
487
604
|
} catch (error) {
|
|
488
605
|
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
489
606
|
const hasQuantifiers = state.assertions.some(
|
|
490
607
|
(assertion) => state.manager.hasQuantifierFlags[assertion],
|
|
491
608
|
);
|
|
609
|
+
const solved = solveAssertions(state.manager, state.assertions, {
|
|
610
|
+
isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
|
|
611
|
+
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
612
|
+
isFindingMacros: settings.isFindingMacros,
|
|
613
|
+
setup: getSetup(),
|
|
614
|
+
});
|
|
492
615
|
return {
|
|
493
|
-
...
|
|
494
|
-
isMbqi: settings.isMbqi || isMbqiByFeatures(getSetup(), hasQuantifiers),
|
|
495
|
-
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
496
|
-
isFindingMacros: settings.isFindingMacros,
|
|
497
|
-
setup: getSetup(),
|
|
498
|
-
}),
|
|
616
|
+
...solved,
|
|
499
617
|
model: undefined,
|
|
618
|
+
reasonUnknown:
|
|
619
|
+
solved.result === L_UNDEF && solved.context !== undefined
|
|
620
|
+
? getSmtTacticFailure(solved.context)
|
|
621
|
+
: "",
|
|
500
622
|
};
|
|
501
623
|
}
|
|
502
624
|
};
|
|
503
|
-
|
|
504
|
-
|
|
625
|
+
// Deviation from Z3: the heap guard and a stack overflow, which Z3 lacks, read as an exhausted rlimit.
|
|
626
|
+
const getCancelMessage = (deadline: number) =>
|
|
627
|
+
Date.now() > deadline || options.signal?.aborted === true
|
|
628
|
+
? "canceled"
|
|
629
|
+
: "max. resource limit exceeded";
|
|
630
|
+
// As in Z3, a timeout leaves "timeout" in the kernel, which reports it while its last search hasn't failed.
|
|
631
|
+
const getReasonUnknown = (solved: SolverAnswer, deadline: number) => {
|
|
632
|
+
const isTimedOut = solved.result === L_UNDEF && Date.now() > deadline;
|
|
633
|
+
const context = state.kernel?.context;
|
|
634
|
+
if (isTimedOut && context !== undefined) context.reasonUnknown = "timeout";
|
|
635
|
+
if (context !== undefined && solved.context === context) return context.getLastFailureMessage();
|
|
636
|
+
return isTimedOut ? "timeout" : (solved.reasonUnknown ?? getCancelMessage(deadline));
|
|
637
|
+
};
|
|
638
|
+
// As in Z3, a kernel loses the mbqi its logic turned on once it reads the parameters again.
|
|
639
|
+
const getKernelParams = (isSetUp = false) => ({
|
|
640
|
+
isMbqi: settings.isMbqi || (!isSetUp && isMbqiByLogic(getSetup())),
|
|
505
641
|
mbqiMaxIterations: settings.mbqiMaxIterations,
|
|
506
642
|
isFindingMacros: settings.isFindingMacros,
|
|
643
|
+
isCoreMinimizing: settings.parameters.get("smt.core.minimize") === "true",
|
|
507
644
|
setup: getSetup(),
|
|
508
645
|
});
|
|
509
646
|
// mk_special_solver_for_logic gives these logics the finite-domain solver, incremental or not.
|
|
@@ -511,45 +648,62 @@ export const runSmtlibScript = (
|
|
|
511
648
|
(state.logic === "QF_FD" || state.logic === "SAT") &&
|
|
512
649
|
!settings.isProducingProofs &&
|
|
513
650
|
!settings.parameters.has("tactic.default_tactic");
|
|
514
|
-
const checkSat = (extra: number[]) => {
|
|
515
|
-
|
|
651
|
+
const checkSat = (extra: number[], end: SmtToken) => {
|
|
652
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
653
|
+
state.manager.limit.restart(deadline);
|
|
516
654
|
// opt::context::optimize answers as the search of the hard constraints does: once they are
|
|
517
655
|
// satisfiable, optsmt and maxsmt only improve the model. The unported parts of optimization
|
|
518
656
|
// only get that answer.
|
|
519
|
-
if (state.objectives.length > 0 && optimize(extra)) return;
|
|
657
|
+
if (state.objectives.length > 0 && optimize(extra, end)) return;
|
|
520
658
|
state.manager.limit.push(settings.rlimit);
|
|
521
659
|
const isOptimizing = state.objectives.length > 0;
|
|
660
|
+
const manager = state.manager;
|
|
661
|
+
const names = state.names.filter((name) => name !== -1);
|
|
662
|
+
const isNamed = names.length > 0;
|
|
663
|
+
const isAssuming = isNamed || extra.length > 0;
|
|
664
|
+
if (isAssuming) state.isIncremental = true;
|
|
665
|
+
if (!isOptimizing) state.hasChecked = true;
|
|
666
|
+
const isKernelChecking =
|
|
667
|
+
isAssuming || (state.isIncremental && !isOptimizing && !isUsingFdSolver());
|
|
522
668
|
try {
|
|
523
|
-
const
|
|
524
|
-
const names = state.names.filter((name) => name !== -1);
|
|
525
|
-
const isNamed = names.length > 0;
|
|
526
|
-
const isAssuming = isNamed || extra.length > 0;
|
|
527
|
-
if (isAssuming) state.isIncremental = true;
|
|
528
|
-
if (!isOptimizing) state.hasChecked = true;
|
|
529
|
-
const assumptions = isNamed ? [...names, ...extra] : extra;
|
|
530
|
-
const kernel =
|
|
531
|
-
isAssuming || (state.isIncremental && !isOptimizing && !isUsingFdSolver())
|
|
532
|
-
? checkKernel(assumptions)
|
|
533
|
-
: undefined;
|
|
669
|
+
const kernel = isKernelChecking ? checkKernel(names, extra) : undefined;
|
|
534
670
|
// Z3 retries a quantifier-free problem with its tactic when the incremental kernel gives up.
|
|
535
|
-
const
|
|
671
|
+
const isFromTactic =
|
|
536
672
|
kernel === undefined ||
|
|
537
673
|
(!isAssuming &&
|
|
538
674
|
kernel.result === L_UNDEF &&
|
|
539
675
|
!state.assertions.some((assertion) => manager.hasQuantifierFlags[assertion]) &&
|
|
540
|
-
manager.limit.inc())
|
|
541
|
-
|
|
542
|
-
: kernel;
|
|
676
|
+
manager.limit.inc());
|
|
677
|
+
const solved = isFromTactic ? { ...solveWithStrategy(), core: undefined } : kernel;
|
|
543
678
|
setCheck(solved.result, {
|
|
544
679
|
context: solved.context,
|
|
545
680
|
isOptimizing,
|
|
681
|
+
isFromTactic,
|
|
546
682
|
model: solved.model,
|
|
547
683
|
core: solved.core ?? solved.context?.unsatCore ?? [],
|
|
684
|
+
reasonUnknown: getReasonUnknown(solved, deadline),
|
|
548
685
|
});
|
|
686
|
+
if (isFromTactic && isUsingFdSolver()) solved.model?.decRef();
|
|
549
687
|
print(getVerdict(solved.result));
|
|
550
688
|
} catch (error) {
|
|
551
|
-
if (
|
|
552
|
-
|
|
689
|
+
if (
|
|
690
|
+
!(
|
|
691
|
+
error instanceof SmtCanceledError ||
|
|
692
|
+
error instanceof SmtDefaultError ||
|
|
693
|
+
isStackOverflow(error)
|
|
694
|
+
)
|
|
695
|
+
)
|
|
696
|
+
throw error;
|
|
697
|
+
const context = isKernelChecking ? state.kernel?.context : undefined;
|
|
698
|
+
const reasonUnknown = isKernelChecking ? state.satSolver?.reasonUnknown : undefined;
|
|
699
|
+
setCheck(L_UNDEF, {
|
|
700
|
+
isOptimizing,
|
|
701
|
+
isFromTactic: !isKernelChecking,
|
|
702
|
+
reasonUnknown:
|
|
703
|
+
error instanceof SmtDefaultError
|
|
704
|
+
? error.message
|
|
705
|
+
: getReasonUnknown({ result: L_UNDEF, context, reasonUnknown }, deadline),
|
|
706
|
+
});
|
|
553
707
|
print("unknown");
|
|
554
708
|
} finally {
|
|
555
709
|
state.manager.limit.release();
|
|
@@ -563,8 +717,12 @@ export const runSmtlibScript = (
|
|
|
563
717
|
if (check.model !== undefined) return check.model;
|
|
564
718
|
if (check.isOptimizing) throw new SmtUnsupportedError("the models of optimization");
|
|
565
719
|
if (check.context === undefined && check.status !== L_TRUE)
|
|
566
|
-
throw
|
|
567
|
-
|
|
720
|
+
throw check.isFromTactic
|
|
721
|
+
? new SmtParseError("model is not available", list.end)
|
|
722
|
+
: new SmtUnsupportedError("the model of a canceled search");
|
|
723
|
+
const context = check.context;
|
|
724
|
+
const model = context === undefined ? new ProtoModel(state.manager) : context.getModel();
|
|
725
|
+
if (model === undefined) throw new SmtParseError("model is not available", list.end);
|
|
568
726
|
model.incRef();
|
|
569
727
|
check.model = model;
|
|
570
728
|
return model;
|
|
@@ -573,6 +731,12 @@ export const runSmtlibScript = (
|
|
|
573
731
|
state.check?.model?.decRef();
|
|
574
732
|
state.check = undefined;
|
|
575
733
|
};
|
|
734
|
+
// cmd_context::validate_check_sat_result runs after the answer is printed.
|
|
735
|
+
const validateCheck = (end: SmtToken) => {
|
|
736
|
+
const status = state.check?.status ?? L_UNDEF;
|
|
737
|
+
if (status !== L_UNDEF && settings.status !== L_UNDEF && status !== settings.status)
|
|
738
|
+
throw new SmtParseError(`check annotation that says ${getVerdict(settings.status)}`, end);
|
|
739
|
+
};
|
|
576
740
|
// The check holds a reference to its model until clearCheck.
|
|
577
741
|
const setCheck = (status: number, result: Partial<Omit<CheckResult, "status">> = {}) => {
|
|
578
742
|
result.model?.incRef();
|
|
@@ -580,14 +744,12 @@ export const runSmtlibScript = (
|
|
|
580
744
|
status,
|
|
581
745
|
context: undefined,
|
|
582
746
|
isOptimizing: false,
|
|
747
|
+
isFromTactic: false,
|
|
583
748
|
model: undefined,
|
|
584
749
|
core: undefined,
|
|
585
750
|
...result,
|
|
586
751
|
};
|
|
587
752
|
};
|
|
588
|
-
// cmd_context::mk_solver: mk_solver_for_logic makes the incremental solver the smt kernel unless
|
|
589
|
-
// the logic, the default tactic or the sat parameters pick a sat solver. Under sat.euf that
|
|
590
|
-
// solver is inc_sat_solver in euf mode; the other sat solvers only store their assertions.
|
|
591
753
|
const resetKernel = () => {
|
|
592
754
|
const logic = state.logic;
|
|
593
755
|
const parameters = settings.parameters;
|
|
@@ -601,48 +763,61 @@ export const runSmtlibScript = (
|
|
|
601
763
|
parameters.get("tactic.default_tactic") === "sat" ||
|
|
602
764
|
parameters.get("sat.smt") === "true" ||
|
|
603
765
|
isEuf;
|
|
604
|
-
state.
|
|
766
|
+
state.satSolver?.release();
|
|
605
767
|
state.kernel = isSatSolver ? undefined : new SmtKernel(state.manager, getKernelParams());
|
|
606
|
-
state.
|
|
607
|
-
|
|
608
|
-
? new IncSatSolver(state.manager, getSatParams(parameters), true, mkThSolver)
|
|
768
|
+
state.satSolver =
|
|
769
|
+
isSatSolver && !isFdSolver && parameters.get("sat.smt") !== "true"
|
|
770
|
+
? new IncSatSolver(state.manager, getSatParams(parameters), true, isEuf ? mkThSolver : null)
|
|
609
771
|
: undefined;
|
|
610
772
|
for (let index = 0; index < state.scopes.length; index++) {
|
|
611
773
|
state.kernel?.push();
|
|
612
|
-
|
|
774
|
+
useSatSolver((solver) => solver.push());
|
|
613
775
|
}
|
|
614
776
|
};
|
|
615
|
-
|
|
616
|
-
|
|
617
|
-
|
|
777
|
+
const initManager = () => {
|
|
778
|
+
if (state.isProofsEnabled !== undefined) return;
|
|
779
|
+
state.isProofsEnabled = settings.parameters.get("proof") === "true";
|
|
780
|
+
if (state.logic === undefined || logicHasSeq(state.logic)) state.manager.initSeqPlugin();
|
|
781
|
+
if (state.logic === undefined) state.reader.registerList();
|
|
782
|
+
resetKernel();
|
|
783
|
+
};
|
|
784
|
+
// The parts of inc_sat_solver that are not ported leave its answers to the smt kernel.
|
|
785
|
+
const useSatSolver = <Result>(action: (solver: IncSatSolver) => Result) => {
|
|
786
|
+
const solver = state.satSolver;
|
|
618
787
|
if (solver === undefined) return undefined;
|
|
619
788
|
try {
|
|
620
789
|
return action(solver);
|
|
621
790
|
} catch (error) {
|
|
622
791
|
if (!(error instanceof SmtUnsupportedError)) throw error;
|
|
623
792
|
solver.release();
|
|
624
|
-
state.
|
|
793
|
+
state.satSolver = undefined;
|
|
625
794
|
return undefined;
|
|
626
795
|
}
|
|
627
796
|
};
|
|
628
797
|
// solver_na2as asserts a named assertion as an implication from its name.
|
|
629
798
|
const assertInKernel = (formula: number, name: number) => {
|
|
630
799
|
const manager = state.manager;
|
|
800
|
+
useSatSolver((solver) =>
|
|
801
|
+
name === -1 ? solver.assertExpr(formula) : solver.assertNamed(formula, name),
|
|
802
|
+
);
|
|
803
|
+
const kernel = state.kernel;
|
|
804
|
+
if (kernel === undefined) return;
|
|
631
805
|
const asserted = name === -1 ? formula : manager.mkApp(OP_IMPLIES, [name, formula], SORT_BOOL);
|
|
632
806
|
manager.incRef(asserted);
|
|
633
|
-
|
|
634
|
-
useEufSolver((solver) => solver.assertExpr(asserted));
|
|
807
|
+
kernel.assertExpr(asserted);
|
|
635
808
|
manager.decRef(asserted);
|
|
636
809
|
};
|
|
637
|
-
const checkKernel = (
|
|
810
|
+
const checkKernel = (names: number[], extra: number[]) => {
|
|
638
811
|
const kernel = state.kernel;
|
|
639
|
-
const
|
|
640
|
-
|
|
812
|
+
const assumptions = [...names, ...extra];
|
|
813
|
+
const found = useSatSolver((solver) => {
|
|
814
|
+
const result = solver.check(extra);
|
|
641
815
|
return {
|
|
642
816
|
result,
|
|
643
817
|
context: undefined,
|
|
644
818
|
model: result === L_TRUE ? (solver.getModel() ?? undefined) : undefined,
|
|
645
819
|
core: result === L_FALSE ? [...solver.getUnsatCore()] : undefined,
|
|
820
|
+
reasonUnknown: solver.reasonUnknown,
|
|
646
821
|
};
|
|
647
822
|
});
|
|
648
823
|
if (found !== undefined) return found;
|
|
@@ -652,11 +827,21 @@ export const runSmtlibScript = (
|
|
|
652
827
|
context: kernel.context,
|
|
653
828
|
model: undefined,
|
|
654
829
|
core: undefined,
|
|
830
|
+
reasonUnknown: undefined,
|
|
655
831
|
};
|
|
832
|
+
const solved = solveAssuming(
|
|
833
|
+
state.manager,
|
|
834
|
+
getNamedAssertions(),
|
|
835
|
+
assumptions,
|
|
836
|
+
getKernelParams(),
|
|
837
|
+
);
|
|
656
838
|
return {
|
|
657
|
-
...
|
|
839
|
+
...solved,
|
|
658
840
|
model: undefined,
|
|
659
841
|
core: undefined,
|
|
842
|
+
// inc_sat_solver, which these logics use, keeps "no reason given" after an answer.
|
|
843
|
+
reasonUnknown:
|
|
844
|
+
solved.result === L_UNDEF ? solved.context.getLastFailureMessage() : "no reason given",
|
|
660
845
|
};
|
|
661
846
|
};
|
|
662
847
|
const printDiagnostic = (line: string) => print(line, !settings.isDiagnosticOnStdout);
|
|
@@ -690,11 +875,10 @@ export const runSmtlibScript = (
|
|
|
690
875
|
);
|
|
691
876
|
return state.datalog;
|
|
692
877
|
};
|
|
693
|
-
const getTactic = (sexpr: SExpr, end: SmtList["end"]) =>
|
|
694
|
-
compileTactic(getTacticEnvironment(), sexpr, end);
|
|
695
878
|
const getGoal = (isTrackingDependencies = false) => {
|
|
696
879
|
const goal = new Goal(state.manager);
|
|
697
880
|
goal.isProofsEnabled = settings.isProducingProofs || state.isProofsEnabled === true;
|
|
881
|
+
goal.isModelsEnabled = settings.isProducingModels;
|
|
698
882
|
goal.isCoresEnabled = settings.isProducingUnsatCores;
|
|
699
883
|
for (const [index, assertion] of state.assertions.entries())
|
|
700
884
|
goal.assert(
|
|
@@ -705,22 +889,43 @@ export const runSmtlibScript = (
|
|
|
705
889
|
);
|
|
706
890
|
return goal;
|
|
707
891
|
};
|
|
892
|
+
const getCommandGoal = (isTrackingDependencies: boolean, end: SmtToken) => {
|
|
893
|
+
if (
|
|
894
|
+
settings.isProducingUnsatCores &&
|
|
895
|
+
(settings.isProducingProofs || state.isProofsEnabled === true)
|
|
896
|
+
)
|
|
897
|
+
throw new SmtParseError(
|
|
898
|
+
"Frontend does not support simultaneous generation of proofs and unsat cores",
|
|
899
|
+
end,
|
|
900
|
+
);
|
|
901
|
+
return getGoal(isTrackingDependencies);
|
|
902
|
+
};
|
|
708
903
|
const hasNames = () => state.names.some((name) => name !== -1);
|
|
709
904
|
// parse_check_sat shrinks the expression stack once the check has run.
|
|
710
|
-
const checkSatAssuming = (items: SmtList["items"]) => {
|
|
905
|
+
const checkSatAssuming = (items: SmtList["items"], itemsEnd: SmtToken, end: SmtToken) => {
|
|
711
906
|
const literals: number[] = [];
|
|
712
907
|
try {
|
|
713
|
-
for (const item of items
|
|
714
|
-
|
|
908
|
+
for (const [index, item] of items.entries())
|
|
909
|
+
literals.push(
|
|
910
|
+
state.reader.parseFormula(
|
|
911
|
+
item,
|
|
912
|
+
items[index + 1] ?? itemsEnd,
|
|
913
|
+
"invalid check-sat command, argument must be a Boolean literal",
|
|
914
|
+
),
|
|
915
|
+
);
|
|
916
|
+
checkSat(literals, end);
|
|
715
917
|
} finally {
|
|
716
918
|
for (const literal of literals) state.manager.decRef(literal);
|
|
717
919
|
}
|
|
718
920
|
};
|
|
719
921
|
const addObjective = (list: SmtList, isMax: boolean) => {
|
|
720
|
-
const term = state.reader.parseTerm(list
|
|
922
|
+
const term = state.reader.parseTerm(getFirstArgument(list));
|
|
721
923
|
const sort = state.manager.sorts[term];
|
|
722
924
|
if (sort !== SORT_INT && sort !== SORT_REAL && !state.manager.isBvSort(sort))
|
|
723
|
-
throw new SmtParseError(
|
|
925
|
+
throw new SmtParseError(
|
|
926
|
+
"Objective must be bit-vector, integer or real",
|
|
927
|
+
list.items[2] ?? list.end,
|
|
928
|
+
);
|
|
724
929
|
resetOptimizer();
|
|
725
930
|
state.manager.incRef(term);
|
|
726
931
|
state.objectives.push({
|
|
@@ -730,6 +935,8 @@ export const runSmtlibScript = (
|
|
|
730
935
|
weights: [],
|
|
731
936
|
id: null,
|
|
732
937
|
});
|
|
938
|
+
if (settings.isPrintingSuccess) print("success");
|
|
939
|
+
checkArgumentCount(list, 1);
|
|
733
940
|
};
|
|
734
941
|
const releaseObjectives = (size: number, softSize: number) => {
|
|
735
942
|
for (const index of state.softTrail.splice(softSize).reverse()) {
|
|
@@ -798,20 +1005,25 @@ export const runSmtlibScript = (
|
|
|
798
1005
|
if (name.kind === "list")
|
|
799
1006
|
throw new SmtUnsupportedError("an indexed function declaration reference");
|
|
800
1007
|
throw new SmtParseError(
|
|
801
|
-
|
|
1008
|
+
`invalid function declaration reference, symbol or '(' expected got ${name.lastId}`,
|
|
802
1009
|
name,
|
|
803
1010
|
);
|
|
804
1011
|
}
|
|
805
1012
|
const domain = reference.items[1] ?? reference.end;
|
|
806
1013
|
if (domain.kind !== "list")
|
|
807
1014
|
throw new SmtParseError(
|
|
808
|
-
`Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.
|
|
1015
|
+
`Invalid function name. Expecting sort list starting with '(' to disambiguate function name got ${domain.lastId}`,
|
|
809
1016
|
domain,
|
|
810
1017
|
);
|
|
811
|
-
const sorts = domain.items.map((sort) =>
|
|
1018
|
+
const sorts = domain.items.map((sort) =>
|
|
1019
|
+
state.reader.parseSort(
|
|
1020
|
+
sort,
|
|
1021
|
+
"Invalid function name. Expecting sort list starting with '(' to disambiguate function name",
|
|
1022
|
+
),
|
|
1023
|
+
);
|
|
812
1024
|
if (reference.items[2] === undefined)
|
|
813
1025
|
throw new SmtParseError("Invalid function name invalid sort, unexpected ')'", reference.end);
|
|
814
|
-
const range = state.reader.parseSort(reference.items[2]);
|
|
1026
|
+
const range = state.reader.parseSort(reference.items[2], "Invalid function name");
|
|
815
1027
|
const follower = reference.items[3] ?? reference.end;
|
|
816
1028
|
const found = state.reader.getFuncs(name.text).find((decl) => {
|
|
817
1029
|
const funcDecl = state.manager.funcDecls[decl];
|
|
@@ -830,16 +1042,87 @@ export const runSmtlibScript = (
|
|
|
830
1042
|
throw new SmtUnsupportedError("a function declaration reference with trailing terms");
|
|
831
1043
|
return found;
|
|
832
1044
|
};
|
|
1045
|
+
// get_info_cmd prints in set_next_arg, before the parser checks the rest of the command.
|
|
1046
|
+
const printInfo = (list: SmtList, keyword: string) => {
|
|
1047
|
+
if (keyword === ":reason-unknown") {
|
|
1048
|
+
const check = state.check;
|
|
1049
|
+
const reasonUnknown =
|
|
1050
|
+
check === undefined
|
|
1051
|
+
? "state of the most recent check-sat command is not known"
|
|
1052
|
+
: check.reasonUnknown;
|
|
1053
|
+
if (reasonUnknown === undefined)
|
|
1054
|
+
throw new SmtUnsupportedError("the information :reason-unknown");
|
|
1055
|
+
print(`(:reason-unknown "${reasonUnknown.replaceAll('"', '\\"')}")`);
|
|
1056
|
+
return;
|
|
1057
|
+
}
|
|
1058
|
+
if (keyword === ":rlimit") {
|
|
1059
|
+
initManager();
|
|
1060
|
+
print(`(:rlimit ${state.manager.limit.count})`);
|
|
1061
|
+
return;
|
|
1062
|
+
}
|
|
1063
|
+
if (keyword === ":error-behavior") {
|
|
1064
|
+
print(
|
|
1065
|
+
`(:error-behavior ${settings.isExitingOnError ? "immediate-exit" : "continued-execution"})`,
|
|
1066
|
+
);
|
|
1067
|
+
return;
|
|
1068
|
+
}
|
|
1069
|
+
if (keyword === ":name") {
|
|
1070
|
+
print('(:name "Z3")');
|
|
1071
|
+
return;
|
|
1072
|
+
}
|
|
1073
|
+
if (keyword === ":authors") {
|
|
1074
|
+
print(
|
|
1075
|
+
'(:authors "Leonardo de Moura, Nikolaj Bjorner, Lev Nachmanson and Christoph Wintersteiger")',
|
|
1076
|
+
);
|
|
1077
|
+
return;
|
|
1078
|
+
}
|
|
1079
|
+
if (keyword === ":version") {
|
|
1080
|
+
print('(:version "5.3.2")');
|
|
1081
|
+
return;
|
|
1082
|
+
}
|
|
1083
|
+
if (keyword === ":status") {
|
|
1084
|
+
print(`(:status ${getVerdict(settings.status)})`);
|
|
1085
|
+
return;
|
|
1086
|
+
}
|
|
1087
|
+
if (keyword === ":assertion-stack-levels") {
|
|
1088
|
+
print(`(:assertion-stack-levels ${state.scopes.length})`);
|
|
1089
|
+
return;
|
|
1090
|
+
}
|
|
1091
|
+
if (keyword === ":all-statistics" || keyword === ":parameters")
|
|
1092
|
+
throw new SmtUnsupportedError(`the information ${keyword}`);
|
|
1093
|
+
if (keyword !== ":?") {
|
|
1094
|
+
print("unsupported");
|
|
1095
|
+
printDiagnostic(`; ${keyword} line: ${list.line} position: ${list.column}`);
|
|
1096
|
+
}
|
|
1097
|
+
print("; Suppported get-info parameters:");
|
|
1098
|
+
for (const supported of GET_INFO_KEYWORDS) print(`; (get-info ${supported})`);
|
|
1099
|
+
};
|
|
1100
|
+
const printCore = () => {
|
|
1101
|
+
const check = state.check;
|
|
1102
|
+
if (check?.core === undefined)
|
|
1103
|
+
throw new SmtUnsupportedError("the unsat core of a tactic that drops dependencies");
|
|
1104
|
+
const kernel = state.kernel;
|
|
1105
|
+
if (kernel === undefined || check.context !== kernel.context) {
|
|
1106
|
+
print(`(${check.core.map(format).join(" ")})`);
|
|
1107
|
+
return;
|
|
1108
|
+
}
|
|
1109
|
+
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1110
|
+
const core = new RefVector(state.manager);
|
|
1111
|
+
kernel.getUnsatCore(core);
|
|
1112
|
+
print(`(${core.items.map(format).join(" ")})`);
|
|
1113
|
+
core.reset();
|
|
1114
|
+
};
|
|
833
1115
|
const runCommand = new Map<string, (list: SmtList) => void>([
|
|
834
1116
|
[
|
|
835
1117
|
"assert",
|
|
836
1118
|
(list) => {
|
|
837
1119
|
const term = list.items[1] ?? list.end;
|
|
838
|
-
const
|
|
1120
|
+
const follower = list.items[2] ?? list.end;
|
|
1121
|
+
const assertion = state.reader.parseAssertion(term, follower);
|
|
839
1122
|
const logicError = state.reader.getLogicError(assertion.formula);
|
|
840
1123
|
if (logicError !== undefined) {
|
|
841
1124
|
state.manager.decRef(assertion.formula);
|
|
842
|
-
throw new SmtParseError(logicError,
|
|
1125
|
+
throw new SmtParseError(logicError, follower);
|
|
843
1126
|
}
|
|
844
1127
|
state.assertions.push(assertion.formula);
|
|
845
1128
|
state.assertionTexts.push(
|
|
@@ -860,9 +1143,17 @@ export const runSmtlibScript = (
|
|
|
860
1143
|
}
|
|
861
1144
|
assertInKernel(assertion.formula, state.names[state.names.length - 1]);
|
|
862
1145
|
clearCheck();
|
|
1146
|
+
if (follower !== list.end)
|
|
1147
|
+
throw new SmtParseError("invalid assert command, ')' expected", follower);
|
|
1148
|
+
},
|
|
1149
|
+
],
|
|
1150
|
+
[
|
|
1151
|
+
"check-sat",
|
|
1152
|
+
(list) => {
|
|
1153
|
+
checkSatAssuming(list.items.slice(1), list.end, list.end);
|
|
1154
|
+
validateCheck(list.end);
|
|
863
1155
|
},
|
|
864
1156
|
],
|
|
865
|
-
["check-sat", (list) => checkSatAssuming(list.items.slice(1))],
|
|
866
1157
|
[
|
|
867
1158
|
"declare-rel",
|
|
868
1159
|
(list) => {
|
|
@@ -872,7 +1163,9 @@ export const runSmtlibScript = (
|
|
|
872
1163
|
throw new SmtParseError("at least 2 arguments expected", list.end);
|
|
873
1164
|
const decl = state.manager.mkFuncDecl(
|
|
874
1165
|
name.text,
|
|
875
|
-
domain.items.map((sort) =>
|
|
1166
|
+
domain.items.map((sort) =>
|
|
1167
|
+
state.reader.parseSort(sort, "expecting sort list starting with '('"),
|
|
1168
|
+
),
|
|
876
1169
|
SORT_BOOL,
|
|
877
1170
|
);
|
|
878
1171
|
state.reader.insertFunc(decl, list.end);
|
|
@@ -890,7 +1183,7 @@ export const runSmtlibScript = (
|
|
|
890
1183
|
list.end,
|
|
891
1184
|
);
|
|
892
1185
|
const manager = state.manager;
|
|
893
|
-
const range = state.reader.parseSort(sort);
|
|
1186
|
+
const range = state.reader.parseSort(sort, "invalid command argument, sort expected");
|
|
894
1187
|
const decl = manager.mkFuncDecl(name.text, [], range);
|
|
895
1188
|
state.reader.insertFunc(decl, list.end);
|
|
896
1189
|
getDatalog().registerVariable(manager.mkApp(decl, [], range));
|
|
@@ -902,7 +1195,10 @@ export const runSmtlibScript = (
|
|
|
902
1195
|
const rule = list.items[1];
|
|
903
1196
|
if (rule === undefined) throw new SmtParseError("invalid rule, expected formula", list.end);
|
|
904
1197
|
const name = list.items[2];
|
|
905
|
-
getDatalog().addRule(
|
|
1198
|
+
getDatalog().addRule(
|
|
1199
|
+
state.reader.parseFormula(rule, rule),
|
|
1200
|
+
isSymbol(name) ? name.text : undefined,
|
|
1201
|
+
);
|
|
906
1202
|
},
|
|
907
1203
|
],
|
|
908
1204
|
[
|
|
@@ -924,15 +1220,17 @@ export const runSmtlibScript = (
|
|
|
924
1220
|
for (const assertion of state.assertions) datalog.assertExpr(assertion);
|
|
925
1221
|
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
926
1222
|
state.manager.limit.push(settings.rlimit);
|
|
1223
|
+
let status = L_UNDEF;
|
|
927
1224
|
try {
|
|
928
|
-
|
|
1225
|
+
status = datalog.relQuery(relation);
|
|
929
1226
|
} catch (error) {
|
|
930
1227
|
if (!(error instanceof SmtTacticError)) throw error;
|
|
931
1228
|
print(`(error "query failed: ${error.message}")`);
|
|
932
|
-
print("unknown");
|
|
933
1229
|
} finally {
|
|
934
1230
|
state.manager.limit.pop();
|
|
935
1231
|
}
|
|
1232
|
+
print(status === L_UNDEF && datalog.isBounded ? "bounded" : getVerdict(status));
|
|
1233
|
+
datalog.isBounded = false;
|
|
936
1234
|
},
|
|
937
1235
|
],
|
|
938
1236
|
[
|
|
@@ -941,37 +1239,48 @@ export const runSmtlibScript = (
|
|
|
941
1239
|
const params = getCommandParams(list.items, CHECK_SAT_USING_PARAMETERS);
|
|
942
1240
|
if (list.items[1] === undefined)
|
|
943
1241
|
throw new SmtParseError("check-sat-using needs a tactic argument", list.end);
|
|
944
|
-
|
|
1242
|
+
expectClosed(list.items[1]);
|
|
1243
|
+
const builder = compileTactic(getTacticEnvironment(), list.items[1]);
|
|
945
1244
|
const tactic = builder.build(params);
|
|
1245
|
+
const goal = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
946
1246
|
clearCheck();
|
|
947
|
-
|
|
1247
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1248
|
+
state.manager.limit.restart(deadline);
|
|
948
1249
|
state.manager.limit.push(settings.rlimit);
|
|
949
1250
|
try {
|
|
950
|
-
const checked = checkSatUsing(tactic,
|
|
1251
|
+
const checked = checkSatUsing(tactic, goal);
|
|
1252
|
+
const reasonUnknown = checked.reasonUnknown ?? getCancelMessage(deadline);
|
|
951
1253
|
setCheck(checked.status, {
|
|
1254
|
+
isFromTactic: true,
|
|
952
1255
|
model: checked.model,
|
|
953
1256
|
core:
|
|
954
1257
|
builder.isTrackingDependencies || !hasNames()
|
|
955
1258
|
? getDependencyValues(checked.core)
|
|
956
1259
|
: undefined,
|
|
957
|
-
reasonUnknown
|
|
1260
|
+
reasonUnknown,
|
|
958
1261
|
});
|
|
959
|
-
print(
|
|
1262
|
+
print(
|
|
1263
|
+
checked.isConversionCanceled
|
|
1264
|
+
? `(error "tactic failed: ${reasonUnknown}")`
|
|
1265
|
+
: getVerdict(checked.status),
|
|
1266
|
+
);
|
|
960
1267
|
} finally {
|
|
961
1268
|
state.manager.limit.pop();
|
|
962
1269
|
}
|
|
1270
|
+
validateCheck(list.end);
|
|
963
1271
|
},
|
|
964
1272
|
],
|
|
965
1273
|
[
|
|
966
1274
|
"check-sat-assuming",
|
|
967
1275
|
(list) => {
|
|
968
|
-
const literals = list.items[1];
|
|
969
|
-
if (literals
|
|
1276
|
+
const literals = list.items[1] ?? list.end;
|
|
1277
|
+
if (literals.kind !== "list")
|
|
970
1278
|
throw new SmtParseError(
|
|
971
|
-
|
|
972
|
-
literals
|
|
1279
|
+
`invalid check-sat-assuming command, '(', expected got ${literals.lastId}`,
|
|
1280
|
+
literals,
|
|
973
1281
|
);
|
|
974
|
-
checkSatAssuming(literals.items);
|
|
1282
|
+
checkSatAssuming(literals.items, literals.end, list.end);
|
|
1283
|
+
validateCheck(list.end);
|
|
975
1284
|
},
|
|
976
1285
|
],
|
|
977
1286
|
[
|
|
@@ -982,13 +1291,17 @@ export const runSmtlibScript = (
|
|
|
982
1291
|
if (terms === undefined)
|
|
983
1292
|
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
984
1293
|
if (terms.kind !== "list")
|
|
985
|
-
throw new SmtParseError(
|
|
1294
|
+
throw new SmtParseError(
|
|
1295
|
+
`invalid list of terms, '(' expected got ${terms.lastId}`,
|
|
1296
|
+
terms,
|
|
1297
|
+
);
|
|
986
1298
|
return terms.items.map((item) => state.reader.parseTerm(item));
|
|
987
1299
|
});
|
|
988
1300
|
if (list.items.length > 3)
|
|
989
1301
|
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
990
1302
|
clearCheck();
|
|
991
|
-
|
|
1303
|
+
const deadline = Date.now() + options.timeLimitMs;
|
|
1304
|
+
manager.limit.restart(deadline);
|
|
992
1305
|
manager.limit.push(settings.rlimit);
|
|
993
1306
|
const names = state.names.filter((name) => name !== -1);
|
|
994
1307
|
try {
|
|
@@ -1002,7 +1315,11 @@ export const runSmtlibScript = (
|
|
|
1002
1315
|
assumptions,
|
|
1003
1316
|
vars,
|
|
1004
1317
|
);
|
|
1005
|
-
setCheck(found.result, {
|
|
1318
|
+
setCheck(found.result, {
|
|
1319
|
+
model: found.model,
|
|
1320
|
+
core: found.core,
|
|
1321
|
+
reasonUnknown: found.reasonUnknown,
|
|
1322
|
+
});
|
|
1006
1323
|
print(getVerdict(found.result));
|
|
1007
1324
|
print("");
|
|
1008
1325
|
for (const consequence of found.consequences.items) display(consequence);
|
|
@@ -1013,11 +1330,22 @@ export const runSmtlibScript = (
|
|
|
1013
1330
|
if (state.kernel === undefined)
|
|
1014
1331
|
for (const assertion of getNamedAssertions()) kernel.assertExpr(assertion);
|
|
1015
1332
|
const found = getConsequences(kernel, [...names, ...assumptions], vars);
|
|
1016
|
-
setCheck(found.result, {
|
|
1333
|
+
setCheck(found.result, {
|
|
1334
|
+
context: kernel.context,
|
|
1335
|
+
core: kernel.context.unsatCore,
|
|
1336
|
+
reasonUnknown: kernel.context.getLastFailureMessage(),
|
|
1337
|
+
});
|
|
1017
1338
|
print(getVerdict(found.result));
|
|
1018
1339
|
print("");
|
|
1019
1340
|
for (const consequence of found.consequences.items) display(consequence);
|
|
1020
1341
|
found.consequences.reset();
|
|
1342
|
+
} catch (error) {
|
|
1343
|
+
if (!(error instanceof SmtCanceledError || isStackOverflow(error))) throw error;
|
|
1344
|
+
const reasonUnknown = getCancelMessage(deadline);
|
|
1345
|
+
if (state.kernel !== undefined) state.kernel.context.reasonUnknown = reasonUnknown;
|
|
1346
|
+
setCheck(L_UNDEF, { reasonUnknown });
|
|
1347
|
+
print("unknown");
|
|
1348
|
+
print("");
|
|
1021
1349
|
} finally {
|
|
1022
1350
|
manager.limit.pop();
|
|
1023
1351
|
}
|
|
@@ -1061,39 +1389,58 @@ export const runSmtlibScript = (
|
|
|
1061
1389
|
assertions: state.assertions.length,
|
|
1062
1390
|
objectives: state.objectives.length,
|
|
1063
1391
|
softTrail: state.softTrail.length,
|
|
1392
|
+
rlimit: settings.rlimit,
|
|
1064
1393
|
});
|
|
1065
1394
|
state.reader.push();
|
|
1066
1395
|
state.isIncremental = true;
|
|
1067
|
-
state.
|
|
1068
|
-
|
|
1396
|
+
const limit = state.manager.limit;
|
|
1397
|
+
limit.push(settings.rlimit);
|
|
1398
|
+
try {
|
|
1399
|
+
state.kernel?.push();
|
|
1400
|
+
useSatSolver((solver) => solver.push());
|
|
1401
|
+
} catch (error) {
|
|
1402
|
+
if (!(error instanceof SmtCanceledError)) throw error;
|
|
1403
|
+
throw new SmtParseError(limit.getCancelMessage(), list.end);
|
|
1404
|
+
} finally {
|
|
1405
|
+
limit.pop();
|
|
1406
|
+
}
|
|
1069
1407
|
}
|
|
1408
|
+
if (list.items[2] !== undefined)
|
|
1409
|
+
throw new SmtParseError("invalid push command, ')' expected", list.items[2]);
|
|
1070
1410
|
},
|
|
1071
1411
|
],
|
|
1072
1412
|
[
|
|
1073
1413
|
"pop",
|
|
1074
1414
|
(list) => {
|
|
1075
1415
|
const count = getScopeCount(list);
|
|
1416
|
+
const follower = list.items[2] ?? list.end;
|
|
1417
|
+
clearCheck();
|
|
1076
1418
|
if (count > state.scopes.length)
|
|
1077
1419
|
throw new SmtParseError(
|
|
1078
1420
|
"invalid pop command, argument is greater than the current stack depth",
|
|
1079
|
-
|
|
1421
|
+
follower,
|
|
1080
1422
|
);
|
|
1081
|
-
|
|
1082
|
-
|
|
1083
|
-
|
|
1084
|
-
|
|
1085
|
-
|
|
1086
|
-
|
|
1087
|
-
|
|
1088
|
-
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1423
|
+
if (count > 0) {
|
|
1424
|
+
state.isIncremental = true;
|
|
1425
|
+
const scope = state.scopes[state.scopes.length - count];
|
|
1426
|
+
state.kernel?.pop(count);
|
|
1427
|
+
useSatSolver((solver) => solver.pop(count));
|
|
1428
|
+
state.reader.pop(count);
|
|
1429
|
+
restoreAssertions(scope.assertions);
|
|
1430
|
+
settings.rlimit = scope.rlimit;
|
|
1431
|
+
resetOptimizer();
|
|
1432
|
+
releaseObjectives(scope.objectives, scope.softTrail);
|
|
1433
|
+
state.scopes.length -= count;
|
|
1434
|
+
}
|
|
1435
|
+
if (follower !== list.end)
|
|
1436
|
+
throw new SmtParseError("invalid pop command, ')' expected", follower);
|
|
1092
1437
|
},
|
|
1093
1438
|
],
|
|
1094
1439
|
[
|
|
1095
1440
|
"reset",
|
|
1096
|
-
() => {
|
|
1441
|
+
(list) => {
|
|
1442
|
+
if (list.items[1] !== undefined)
|
|
1443
|
+
throw new SmtParseError("invalid reset command, ')' expected", list.items[1]);
|
|
1097
1444
|
clearCheck();
|
|
1098
1445
|
resetOptimizer();
|
|
1099
1446
|
state = createState();
|
|
@@ -1101,12 +1448,17 @@ export const runSmtlibScript = (
|
|
|
1101
1448
|
],
|
|
1102
1449
|
[
|
|
1103
1450
|
"reset-assertions",
|
|
1104
|
-
() => {
|
|
1105
|
-
|
|
1451
|
+
(list) => {
|
|
1452
|
+
checkArgumentCount(list, 0);
|
|
1106
1453
|
restoreAssertions(0);
|
|
1107
1454
|
resetOptimizer();
|
|
1108
1455
|
releaseObjectives(0, 0);
|
|
1109
|
-
state.scopes = state.scopes.map(() => ({
|
|
1456
|
+
state.scopes = state.scopes.map((scope) => ({
|
|
1457
|
+
...scope,
|
|
1458
|
+
assertions: 0,
|
|
1459
|
+
objectives: 0,
|
|
1460
|
+
softTrail: 0,
|
|
1461
|
+
}));
|
|
1110
1462
|
if (state.isProofsEnabled !== undefined) resetKernel();
|
|
1111
1463
|
state.isIncremental = state.scopes.length > 0;
|
|
1112
1464
|
state.hasChecked = false;
|
|
@@ -1124,7 +1476,17 @@ export const runSmtlibScript = (
|
|
|
1124
1476
|
manager,
|
|
1125
1477
|
getRewriterOptions(manager, getSimplifyParams(list.items.slice(2))),
|
|
1126
1478
|
);
|
|
1127
|
-
|
|
1479
|
+
// simplify_cmd prints a failure of the rewriter and then the term as it was.
|
|
1480
|
+
const simplified = (() => {
|
|
1481
|
+
try {
|
|
1482
|
+
return rewriter.rewrite(term);
|
|
1483
|
+
} catch (error) {
|
|
1484
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
1485
|
+
print(`(error "simplifier failed: ${error.message}")`);
|
|
1486
|
+
manager.incRef(term);
|
|
1487
|
+
return term;
|
|
1488
|
+
}
|
|
1489
|
+
})();
|
|
1128
1490
|
rewriter.cleanup();
|
|
1129
1491
|
display(simplified);
|
|
1130
1492
|
rewriter.release();
|
|
@@ -1143,8 +1505,7 @@ export const runSmtlibScript = (
|
|
|
1143
1505
|
manager.incRef(term);
|
|
1144
1506
|
const visited = new Set<number>();
|
|
1145
1507
|
const todo = [term];
|
|
1146
|
-
|
|
1147
|
-
const expr = todo.pop() as number;
|
|
1508
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1148
1509
|
if (visited.has(expr)) continue;
|
|
1149
1510
|
visited.add(expr);
|
|
1150
1511
|
const family = manager.kinds[expr] === KIND_APP ? manager.getFamily(expr) : -1;
|
|
@@ -1168,13 +1529,19 @@ export const runSmtlibScript = (
|
|
|
1168
1529
|
const params = getCommandParams(list.items, APPLY_PARAMETERS);
|
|
1169
1530
|
if (list.items[1] === undefined)
|
|
1170
1531
|
throw new SmtParseError("apply needs a tactic argument", list.end);
|
|
1171
|
-
|
|
1532
|
+
expectClosed(list.items[1]);
|
|
1533
|
+
// apply_tactic_cmd, unlike check-sat-using, gives the tactic no logic.
|
|
1534
|
+
const builder = compileTactic(
|
|
1535
|
+
{ ...getTacticEnvironment(), setup: { ...getSetup(), logic: undefined } },
|
|
1536
|
+
list.items[1],
|
|
1537
|
+
);
|
|
1172
1538
|
const tactic = builder.build(params);
|
|
1539
|
+
const input = getCommandGoal(builder.isTrackingDependencies, list.end);
|
|
1173
1540
|
const isPrintingDependencies = params.get("print_dependencies") === true;
|
|
1174
1541
|
if (isPrintingDependencies && !builder.isTrackingDependencies && hasNames())
|
|
1175
1542
|
throw new SmtUnsupportedError("the dependencies of a tactic that drops dependencies");
|
|
1176
1543
|
state.manager.limit.restart(Date.now() + options.timeLimitMs);
|
|
1177
|
-
|
|
1544
|
+
state.manager.limit.push(settings.rlimit);
|
|
1178
1545
|
const goals = (() => {
|
|
1179
1546
|
try {
|
|
1180
1547
|
return applyTactic(tactic, input);
|
|
@@ -1182,6 +1549,8 @@ export const runSmtlibScript = (
|
|
|
1182
1549
|
if (!(error instanceof SmtTacticError)) throw error;
|
|
1183
1550
|
print(`(error "tactic failed: ${error.message}")`);
|
|
1184
1551
|
return undefined;
|
|
1552
|
+
} finally {
|
|
1553
|
+
state.manager.limit.pop();
|
|
1185
1554
|
}
|
|
1186
1555
|
})();
|
|
1187
1556
|
// apply_tactic_cmd releases the result goals and then the input goal.
|
|
@@ -1239,8 +1608,7 @@ export const runSmtlibScript = (
|
|
|
1239
1608
|
const decls = new Set<number>();
|
|
1240
1609
|
for (const assertion of assertions) {
|
|
1241
1610
|
const todo = [assertion];
|
|
1242
|
-
|
|
1243
|
-
const expr = todo.pop() as number;
|
|
1611
|
+
for (let expr = todo.pop(); expr !== undefined; expr = todo.pop()) {
|
|
1244
1612
|
if (visited.has(expr)) continue;
|
|
1245
1613
|
visited.add(expr);
|
|
1246
1614
|
if (manager.kinds[expr] === KIND_QUANTIFIER) {
|
|
@@ -1281,6 +1649,7 @@ export const runSmtlibScript = (
|
|
|
1281
1649
|
[
|
|
1282
1650
|
"get-assertions",
|
|
1283
1651
|
(list) => {
|
|
1652
|
+
checkArgumentCount(list, 0);
|
|
1284
1653
|
if (!settings.isInteractive)
|
|
1285
1654
|
throw new SmtParseError(
|
|
1286
1655
|
"command is only available in interactive mode, use command (set-option :interactive-mode true)",
|
|
@@ -1292,17 +1661,29 @@ export const runSmtlibScript = (
|
|
|
1292
1661
|
[
|
|
1293
1662
|
"get-unsat-core",
|
|
1294
1663
|
(list) => {
|
|
1664
|
+
checkArgumentCount(list, 0);
|
|
1295
1665
|
if (!settings.isProducingUnsatCores)
|
|
1296
1666
|
throw new SmtParseError(
|
|
1297
1667
|
"unsat core construction is not enabled, use command (set-option :produce-unsat-cores true)",
|
|
1298
1668
|
list.end,
|
|
1299
1669
|
);
|
|
1300
|
-
|
|
1301
|
-
if (check === undefined || check.status !== L_FALSE)
|
|
1670
|
+
if (state.check?.status !== L_FALSE)
|
|
1302
1671
|
throw new SmtParseError("unsat core is not available", list.end);
|
|
1303
|
-
|
|
1304
|
-
|
|
1305
|
-
|
|
1672
|
+
printCore();
|
|
1673
|
+
},
|
|
1674
|
+
],
|
|
1675
|
+
[
|
|
1676
|
+
"get-unsat-assumptions",
|
|
1677
|
+
(list) => {
|
|
1678
|
+
checkArgumentCount(list, 0);
|
|
1679
|
+
if (!settings.isProducingUnsatAssumptions)
|
|
1680
|
+
throw new SmtParseError(
|
|
1681
|
+
"unsat assumptions construction is not enabled, use command (set-option :produce-unsat-assumptions true)",
|
|
1682
|
+
list.end,
|
|
1683
|
+
);
|
|
1684
|
+
if (state.check?.status !== L_FALSE)
|
|
1685
|
+
throw new SmtParseError("unsat assumptions is not available", list.end);
|
|
1686
|
+
printCore();
|
|
1306
1687
|
},
|
|
1307
1688
|
],
|
|
1308
1689
|
[
|
|
@@ -1310,13 +1691,19 @@ export const runSmtlibScript = (
|
|
|
1310
1691
|
(list) => {
|
|
1311
1692
|
const target = list.items[1];
|
|
1312
1693
|
const term = target === undefined ? -1 : state.reader.parseTerm(target);
|
|
1313
|
-
|
|
1694
|
+
const parameter = list.items[2];
|
|
1695
|
+
if (parameter !== undefined && parameter.kind !== "keyword")
|
|
1696
|
+
throw new SmtParseError("invalid command argument, keyword expected", parameter);
|
|
1697
|
+
if (parameter !== undefined) throw new SmtUnsupportedError("the parameters of eval");
|
|
1314
1698
|
const model = getModel(list);
|
|
1315
1699
|
if (term === -1) throw new SmtParseError("no arguments passed to eval", list.end);
|
|
1316
1700
|
const manager = state.manager;
|
|
1317
1701
|
manager.incRef(term);
|
|
1318
|
-
const
|
|
1702
|
+
const evaluator = new ModelEvaluator(manager, model);
|
|
1703
|
+
const value = evaluator.rewrite(term);
|
|
1319
1704
|
display(value);
|
|
1705
|
+
// eval_cmd frees its model_evaluator before the value, and the parser frees the term last.
|
|
1706
|
+
evaluator.release();
|
|
1320
1707
|
manager.decRef(value);
|
|
1321
1708
|
manager.decRef(term);
|
|
1322
1709
|
},
|
|
@@ -1324,30 +1711,57 @@ export const runSmtlibScript = (
|
|
|
1324
1711
|
[
|
|
1325
1712
|
"get-value",
|
|
1326
1713
|
(list) => {
|
|
1327
|
-
const terms = list.items[1];
|
|
1328
|
-
if (terms
|
|
1329
|
-
throw new SmtParseError(
|
|
1714
|
+
const terms = list.items[1] ?? list.end;
|
|
1715
|
+
if (terms.kind !== "list")
|
|
1716
|
+
throw new SmtParseError(
|
|
1717
|
+
`invalid get-value command, '(' expected got ${terms.lastId}`,
|
|
1718
|
+
terms,
|
|
1719
|
+
);
|
|
1330
1720
|
const manager = state.manager;
|
|
1331
1721
|
const exprs = terms.items.map((item) => state.reader.parseTerm(item));
|
|
1332
1722
|
if (exprs.length === 0)
|
|
1333
1723
|
throw new SmtParseError("invalid get-value command, empty list of terms", terms.end);
|
|
1334
|
-
|
|
1724
|
+
const extra = list.items[2];
|
|
1725
|
+
if (
|
|
1726
|
+
extra?.kind === "keyword" &&
|
|
1727
|
+
(extra.text === ":model-index" || extra.text === ":model_index")
|
|
1728
|
+
)
|
|
1729
|
+
throw new SmtUnsupportedError("the model index of get-value");
|
|
1730
|
+
if (extra !== undefined)
|
|
1731
|
+
throw new SmtParseError("invalid get-value command, ')' expected", extra);
|
|
1335
1732
|
const model = getModel(list);
|
|
1733
|
+
pendingText += "(";
|
|
1336
1734
|
model.compact();
|
|
1337
1735
|
// Z3 prints each term as the script spells it, from the end of the term before.
|
|
1338
1736
|
const offsets = [
|
|
1339
1737
|
terms.offset + 1,
|
|
1340
1738
|
...terms.items.map((item) => (item.kind === "list" ? item.end : item).endOffset),
|
|
1341
1739
|
];
|
|
1342
|
-
|
|
1740
|
+
exprs.forEach((expr, index) => {
|
|
1343
1741
|
manager.incRef(expr);
|
|
1344
1742
|
const value = model.eval(expr, true);
|
|
1345
|
-
|
|
1743
|
+
pendingText += `${index > 0 ? "\n " : ""}(${text.slice(offsets[index], offsets[index + 1]).trim()} ${format(value)})`;
|
|
1346
1744
|
manager.decRef(value);
|
|
1347
1745
|
manager.decRef(expr);
|
|
1348
|
-
return line;
|
|
1349
1746
|
});
|
|
1350
|
-
print(
|
|
1747
|
+
print(")");
|
|
1748
|
+
},
|
|
1749
|
+
],
|
|
1750
|
+
[
|
|
1751
|
+
"get-assignment",
|
|
1752
|
+
(list) => {
|
|
1753
|
+
checkArgumentCount(list, 0);
|
|
1754
|
+
const manager = state.manager;
|
|
1755
|
+
const model = getModel(list);
|
|
1756
|
+
const assignments = state.reader.getConstantMacros().flatMap((macro) => {
|
|
1757
|
+
if (manager.sorts[macro.body] !== SORT_BOOL) return [];
|
|
1758
|
+
const value = model.eval(macro.body, true);
|
|
1759
|
+
const assignment = `(${getQuotedName(macro.name)} ${manager.isTrue(value)})`;
|
|
1760
|
+
const isDecided = manager.isTrue(value) || manager.isFalse(value);
|
|
1761
|
+
manager.decRef(value);
|
|
1762
|
+
return isDecided ? [assignment] : [];
|
|
1763
|
+
});
|
|
1764
|
+
print(`(${assignments.join(" ")})`);
|
|
1351
1765
|
},
|
|
1352
1766
|
],
|
|
1353
1767
|
[
|
|
@@ -1362,14 +1776,27 @@ export const runSmtlibScript = (
|
|
|
1362
1776
|
[
|
|
1363
1777
|
"get-model",
|
|
1364
1778
|
(list) => {
|
|
1365
|
-
|
|
1779
|
+
for (const index of list.items.slice(1)) {
|
|
1780
|
+
if (index.kind !== "numeral")
|
|
1781
|
+
throw new SmtParseError("invalid command argument, unsigned integer expected", index);
|
|
1782
|
+
if (!isUnsigned(index.text))
|
|
1783
|
+
throw new SmtParseError(
|
|
1784
|
+
"invalid indexed identifier, index is too big to fit in an unsigned machine integer",
|
|
1785
|
+
index,
|
|
1786
|
+
);
|
|
1787
|
+
}
|
|
1366
1788
|
const manager = state.manager;
|
|
1367
1789
|
const model = getModel(list);
|
|
1790
|
+
const last = list.items[list.items.length - 1];
|
|
1791
|
+
// get_model_cmd takes any number of indices and keeps the last.
|
|
1792
|
+
if (last.kind === "numeral" && BigInt(last.text) > 0n)
|
|
1793
|
+
throw new SmtUnsupportedError("the index of get-model");
|
|
1368
1794
|
model.compact();
|
|
1369
1795
|
for (const decl of state.reader.getDeclaredFuncs()) {
|
|
1370
1796
|
const funcDecl = manager.funcDecls[decl];
|
|
1371
1797
|
if (
|
|
1372
1798
|
funcDecl.family !== FAMILY_USER ||
|
|
1799
|
+
manager.macros.has(decl) ||
|
|
1373
1800
|
model.constInterps.has(decl) ||
|
|
1374
1801
|
model.funcInterps.has(decl)
|
|
1375
1802
|
)
|
|
@@ -1387,7 +1814,13 @@ export const runSmtlibScript = (
|
|
|
1387
1814
|
print(`(\n${printModel(manager, getPrintEnvironment(), model, 2)})`);
|
|
1388
1815
|
},
|
|
1389
1816
|
],
|
|
1390
|
-
[
|
|
1817
|
+
[
|
|
1818
|
+
"display",
|
|
1819
|
+
(list) => {
|
|
1820
|
+
display(state.reader.parseTerm(getFirstArgument(list)));
|
|
1821
|
+
checkArgumentCount(list, 1);
|
|
1822
|
+
},
|
|
1823
|
+
],
|
|
1391
1824
|
[
|
|
1392
1825
|
"dbg-lt",
|
|
1393
1826
|
(list) => {
|
|
@@ -1400,7 +1833,13 @@ export const runSmtlibScript = (
|
|
|
1400
1833
|
"dbg-some-value",
|
|
1401
1834
|
(list) => {
|
|
1402
1835
|
display(
|
|
1403
|
-
getManagerSomeValue(
|
|
1836
|
+
getManagerSomeValue(
|
|
1837
|
+
state.manager,
|
|
1838
|
+
state.reader.parseSort(
|
|
1839
|
+
list.items[1] ?? list.end,
|
|
1840
|
+
"invalid command argument, sort expected",
|
|
1841
|
+
),
|
|
1842
|
+
),
|
|
1404
1843
|
);
|
|
1405
1844
|
},
|
|
1406
1845
|
],
|
|
@@ -1436,10 +1875,11 @@ export const runSmtlibScript = (
|
|
|
1436
1875
|
[
|
|
1437
1876
|
"echo",
|
|
1438
1877
|
(list) => {
|
|
1439
|
-
const message = list
|
|
1440
|
-
if (message
|
|
1441
|
-
throw new SmtParseError("invalid
|
|
1878
|
+
const message = getFirstArgument(list);
|
|
1879
|
+
if (message.kind !== "string")
|
|
1880
|
+
throw new SmtParseError("invalid command argument, string expected", message);
|
|
1442
1881
|
print(message.text);
|
|
1882
|
+
checkArgumentCount(list, 1);
|
|
1443
1883
|
},
|
|
1444
1884
|
],
|
|
1445
1885
|
[
|
|
@@ -1450,10 +1890,28 @@ export const runSmtlibScript = (
|
|
|
1450
1890
|
const optionName = `:${getParameterName(keyword)}`;
|
|
1451
1891
|
const value = list.items[2];
|
|
1452
1892
|
const isTrue = isSymbol(value, "true");
|
|
1893
|
+
if (
|
|
1894
|
+
(keyword === ":produce-proofs" ||
|
|
1895
|
+
keyword === ":produce-unsat-cores" ||
|
|
1896
|
+
keyword === ":produce-unsat-assumptions") &&
|
|
1897
|
+
state.assertions.length > 0
|
|
1898
|
+
)
|
|
1899
|
+
throw new SmtParseError(
|
|
1900
|
+
`error setting '${keyword}', option value cannot be modified after assertions have been added`,
|
|
1901
|
+
value ?? list.end,
|
|
1902
|
+
);
|
|
1453
1903
|
if (keyword === ":produce-models") settings.isProducingModels = isTrue;
|
|
1454
1904
|
if (keyword === ":produce-unsat-cores") settings.isProducingUnsatCores = isTrue;
|
|
1905
|
+
if (keyword === ":produce-unsat-assumptions") settings.isProducingUnsatAssumptions = isTrue;
|
|
1455
1906
|
if (keyword === ":produce-proofs") settings.isProducingProofs = isTrue;
|
|
1456
|
-
if (keyword === ":interactive-mode"
|
|
1907
|
+
if (keyword === ":interactive-mode" || keyword === ":produce-assertions") {
|
|
1908
|
+
if (state.isProofsEnabled !== undefined)
|
|
1909
|
+
throw new SmtParseError(
|
|
1910
|
+
"error setting ':produce-assertions', option value cannot be modified after initialization",
|
|
1911
|
+
value ?? list.end,
|
|
1912
|
+
);
|
|
1913
|
+
settings.isInteractive = isTrue;
|
|
1914
|
+
}
|
|
1457
1915
|
if (keyword === ":diagnostic-output-channel")
|
|
1458
1916
|
settings.isDiagnosticOnStdout = value?.kind === "string" && value.text === "stdout";
|
|
1459
1917
|
if (keyword === ":int-real-coercions" && !isTrue)
|
|
@@ -1466,13 +1924,12 @@ export const runSmtlibScript = (
|
|
|
1466
1924
|
);
|
|
1467
1925
|
settings.isExitingOnError = isSymbol(value, "immediate-exit");
|
|
1468
1926
|
}
|
|
1469
|
-
|
|
1927
|
+
const isParameter =
|
|
1470
1928
|
keyword !== "" &&
|
|
1471
1929
|
!BUILTIN_OPTIONS.has(keyword) &&
|
|
1472
1930
|
value !== undefined &&
|
|
1473
|
-
value.kind !== "list"
|
|
1474
|
-
)
|
|
1475
|
-
settings.parameters.set(getParameterName(keyword), value.text);
|
|
1931
|
+
value.kind !== "list";
|
|
1932
|
+
if (isParameter) settings.parameters.set(getParameterName(keyword), value.text);
|
|
1476
1933
|
if (optionName === ":print_success") settings.isPrintingSuccess = isTrue;
|
|
1477
1934
|
if (
|
|
1478
1935
|
!BUILTIN_OPTIONS.has(keyword) &&
|
|
@@ -1485,6 +1942,9 @@ export const runSmtlibScript = (
|
|
|
1485
1942
|
settings.mbqiMaxIterations = Number(value.text);
|
|
1486
1943
|
if (optionName === ":rlimit" && value?.kind === "numeral")
|
|
1487
1944
|
settings.rlimit = Number(value.text);
|
|
1945
|
+
const kernel = state.kernel;
|
|
1946
|
+
if (isParameter && kernel !== undefined)
|
|
1947
|
+
kernel.updateParams(getKernelParams(kernel.isSetUp));
|
|
1488
1948
|
if (optionName === ":rewriter.hi_div0") {
|
|
1489
1949
|
settings.isHiDiv0 = isTrue;
|
|
1490
1950
|
state.manager.isHiDiv0 = isTrue;
|
|
@@ -1519,6 +1979,9 @@ export const runSmtlibScript = (
|
|
|
1519
1979
|
[":print-success", settings.isPrintingSuccess],
|
|
1520
1980
|
[":produce-models", settings.isProducingModels],
|
|
1521
1981
|
[":produce-unsat-cores", settings.isProducingUnsatCores],
|
|
1982
|
+
[":produce-unsat-assumptions", settings.isProducingUnsatAssumptions],
|
|
1983
|
+
[":interactive-mode", settings.isInteractive],
|
|
1984
|
+
[":produce-assertions", settings.isInteractive],
|
|
1522
1985
|
[":int-real-coercions", true],
|
|
1523
1986
|
[":error-behavior", settings.isExitingOnError ? "immediate-exit" : "continued-execution"],
|
|
1524
1987
|
]);
|
|
@@ -1536,44 +1999,20 @@ export const runSmtlibScript = (
|
|
|
1536
1999
|
"get-info",
|
|
1537
2000
|
(list) => {
|
|
1538
2001
|
const info = list.items[1];
|
|
1539
|
-
if (info
|
|
1540
|
-
throw new SmtParseError("invalid command argument
|
|
1541
|
-
|
|
1542
|
-
|
|
1543
|
-
|
|
1544
|
-
|
|
1545
|
-
check?.status === L_UNDEF &&
|
|
1546
|
-
optimizer !== undefined &&
|
|
1547
|
-
optimizer.reasonUnknown !== ""
|
|
1548
|
-
) {
|
|
1549
|
-
print(`(:reason-unknown "${optimizer.reasonUnknown}")`);
|
|
1550
|
-
return;
|
|
1551
|
-
}
|
|
1552
|
-
const reasonUnknown =
|
|
1553
|
-
check === undefined
|
|
1554
|
-
? "state of the most recent check-sat command is not known"
|
|
1555
|
-
: check.reasonUnknown;
|
|
1556
|
-
if (info.text === ":reason-unknown" && reasonUnknown !== undefined) {
|
|
1557
|
-
print(`(:reason-unknown "${reasonUnknown.replaceAll('"', '\\"')}")`);
|
|
1558
|
-
return;
|
|
1559
|
-
}
|
|
1560
|
-
if (info.text === ":rlimit") {
|
|
1561
|
-
print(`(:rlimit ${state.manager.limit.count})`);
|
|
1562
|
-
return;
|
|
1563
|
-
}
|
|
1564
|
-
if (info.text !== ":error-behavior")
|
|
1565
|
-
throw new SmtUnsupportedError(`the information ${info.text}`);
|
|
1566
|
-
print(
|
|
1567
|
-
`(:error-behavior ${settings.isExitingOnError ? "immediate-exit" : "continued-execution"})`,
|
|
1568
|
-
);
|
|
2002
|
+
if (info === undefined)
|
|
2003
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2004
|
+
if (info.kind !== "keyword")
|
|
2005
|
+
throw new SmtParseError("invalid command argument, keyword expected", info);
|
|
2006
|
+
printInfo(list, info.text);
|
|
2007
|
+
checkArgumentCount(list, 1);
|
|
1569
2008
|
},
|
|
1570
2009
|
],
|
|
1571
2010
|
[
|
|
1572
2011
|
"set-logic",
|
|
1573
2012
|
(list) => {
|
|
1574
|
-
const logic = list
|
|
2013
|
+
const logic = getFirstArgument(list);
|
|
1575
2014
|
if (!isSymbol(logic))
|
|
1576
|
-
throw new SmtParseError("invalid
|
|
2015
|
+
throw new SmtParseError("invalid command argument, symbol expected", logic);
|
|
1577
2016
|
if (state.logic !== undefined)
|
|
1578
2017
|
throw new SmtParseError("the logic has already been set", logic);
|
|
1579
2018
|
if (state.assertions.length > 0)
|
|
@@ -1583,6 +2022,7 @@ export const runSmtlibScript = (
|
|
|
1583
2022
|
printDiagnostic(
|
|
1584
2023
|
`; ignoring unsupported logic ${logic.text} line: ${list.line} position: ${list.column}`,
|
|
1585
2024
|
);
|
|
2025
|
+
checkArgumentCount(list, 1);
|
|
1586
2026
|
return;
|
|
1587
2027
|
}
|
|
1588
2028
|
state.logic = logic.text;
|
|
@@ -1590,14 +2030,37 @@ export const runSmtlibScript = (
|
|
|
1590
2030
|
state.reader = createSmtlibReader(state.manager, logic.text, settings.parserOptions);
|
|
1591
2031
|
else {
|
|
1592
2032
|
state.reader.restrictSorts(logic.text);
|
|
1593
|
-
// Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop
|
|
1594
|
-
// and keeps what they asserted.
|
|
2033
|
+
// Deviation from Z3: its new solver starts without the open scopes, so it ignores their pop and keeps what they asserted.
|
|
1595
2034
|
resetKernel();
|
|
1596
2035
|
}
|
|
1597
2036
|
if (settings.isPrintingSuccess) print("success");
|
|
2037
|
+
checkArgumentCount(list, 1);
|
|
2038
|
+
},
|
|
2039
|
+
],
|
|
2040
|
+
[
|
|
2041
|
+
"set-info",
|
|
2042
|
+
(list) => {
|
|
2043
|
+
const info = list.items[1];
|
|
2044
|
+
if (info === undefined)
|
|
2045
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2046
|
+
if (info.kind !== "keyword")
|
|
2047
|
+
throw new SmtParseError("invalid command argument, keyword expected", info);
|
|
2048
|
+
const value = list.items[2];
|
|
2049
|
+
if (value === undefined)
|
|
2050
|
+
throw new SmtParseError("invalid command, argument(s) missing", list.end);
|
|
2051
|
+
if (value.kind === "list" || value.kind === "keyword" || value.kind === "eof")
|
|
2052
|
+
throw new SmtParseError("invalid option value", value);
|
|
2053
|
+
if (info.text === ":status" && value.kind === "symbol") {
|
|
2054
|
+
const status = [L_TRUE, L_FALSE, L_UNDEF].find(
|
|
2055
|
+
(innerStatus) => getVerdict(innerStatus) === value.text,
|
|
2056
|
+
);
|
|
2057
|
+
if (status === undefined) throw new SmtParseError("invalid ':status' attribute", value);
|
|
2058
|
+
settings.status = status;
|
|
2059
|
+
}
|
|
2060
|
+
if (list.items[3] !== undefined)
|
|
2061
|
+
throw new SmtParseError("invalid command, too many arguments", list.items[3]);
|
|
1598
2062
|
},
|
|
1599
2063
|
],
|
|
1600
|
-
["set-info", () => {}],
|
|
1601
2064
|
]);
|
|
1602
2065
|
const run = (list: SmtList) => {
|
|
1603
2066
|
const head = list.items[0];
|
|
@@ -1606,18 +2069,34 @@ export const runSmtlibScript = (
|
|
|
1606
2069
|
const command = DECLARATIONS.has(head.text)
|
|
1607
2070
|
? (declaration: SmtList) => state.reader.declareCommand(declaration)
|
|
1608
2071
|
: runCommand.get(head.text);
|
|
1609
|
-
if (command === undefined
|
|
1610
|
-
|
|
1611
|
-
|
|
1612
|
-
|
|
2072
|
+
if (command === undefined && UNPORTED_COMMANDS.has(head.text))
|
|
2073
|
+
throw new SmtUnsupportedError(`the command ${head.text}`);
|
|
2074
|
+
if (command === undefined) {
|
|
2075
|
+
expectClosed(list);
|
|
2076
|
+
print("unsupported");
|
|
2077
|
+
printDiagnostic(`; ${head.text} line: ${list.end.line} position: ${list.end.column}`);
|
|
2078
|
+
return;
|
|
2079
|
+
}
|
|
2080
|
+
// Z3's scoped_timer ends with the command that set it, so a command starts without one.
|
|
2081
|
+
state.manager.limit.restart(Infinity);
|
|
2082
|
+
if (!MANAGERLESS_COMMANDS.has(head.text)) initManager();
|
|
2083
|
+
try {
|
|
2084
|
+
command(list);
|
|
2085
|
+
} catch (error) {
|
|
2086
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
2087
|
+
throw new SmtParseError(error.message, list.end);
|
|
1613
2088
|
}
|
|
1614
|
-
command(list);
|
|
1615
2089
|
if (settings.isPrintingSuccess && SILENT_COMMANDS.has(head.text)) print("success");
|
|
1616
2090
|
};
|
|
1617
2091
|
for (;;) {
|
|
1618
2092
|
try {
|
|
1619
|
-
const list = commands.
|
|
1620
|
-
if (list === undefined
|
|
2093
|
+
const list = commands.readCommand();
|
|
2094
|
+
if (list === undefined) break;
|
|
2095
|
+
if (isSymbol(list.items[0], "exit")) {
|
|
2096
|
+
checkArgumentCount(list, 0);
|
|
2097
|
+
if (settings.isPrintingSuccess) print("success");
|
|
2098
|
+
break;
|
|
2099
|
+
}
|
|
1621
2100
|
run(list);
|
|
1622
2101
|
} catch (error) {
|
|
1623
2102
|
if (!(error instanceof SmtParseError)) throw error;
|