tla-ts 0.0.10-dev.3a85c3a9e → 0.0.10-dev.45c0eaef5
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 +53 -53
- package/dist/index.cjs +1 -1
- package/dist/index.d.cts +18 -4
- package/dist/index.d.ts +18 -4
- 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 +56 -56
- package/dist/prove.js +79 -79
- package/dist/run.cjs +40 -44
- package/dist/run.js +42 -46
- package/dist/tlapm.cjs +1 -1
- package/dist/tlapm.js +2 -2
- package/dist/transfer.cjs +97 -92
- package/dist/transfer.js +97 -92
- package/dist/worker.cjs +7 -7
- package/dist/worker.js +7 -7
- package/package.json +1 -1
- package/src/ast.ts +31 -3
- package/src/bags.ts +50 -29
- package/src/builtins.ts +4 -3
- package/src/check-failure.ts +13 -11
- package/src/check-trace.ts +146 -107
- package/src/check.ts +535 -281
- package/src/cli/runtime-invariants.ts +20 -56
- package/src/cli/tlc-arguments.ts +2 -2
- package/src/cli/tlc-output.ts +21 -7
- package/src/cli/tlc.ts +31 -11
- package/src/cli/xml-exporter.ts +1 -1
- package/src/codegen.ts +23 -10
- package/src/coverage.ts +255 -18
- package/src/dependencies.ts +68 -15
- package/src/dfid.ts +101 -36
- package/src/environment.ts +131 -41
- package/src/errors.ts +7 -0
- package/src/evaluate.ts +424 -135
- package/src/exit-codes.ts +28 -13
- package/src/instances.ts +135 -11
- package/src/java-hash.ts +14 -0
- package/src/java-overrides.ts +2 -2
- package/src/levels.ts +675 -236
- package/src/lexer.ts +12 -2
- package/src/liveness-checker.ts +204 -62
- package/src/liveness.ts +55 -10
- 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/parallel-worker.ts +8 -2
- package/src/parallel.ts +5 -0
- package/src/parser.ts +180 -149
- 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 +171 -58
- package/src/prover/smt/solver/ast-lt.ts +1 -1
- package/src/prover/smt/solver/ast.ts +66 -14
- package/src/prover/smt/solver/auf-solver.ts +23 -12
- package/src/prover/smt/solver/bit-blast-tactic.ts +27 -1
- 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 +84 -15
- 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 +28 -16
- package/src/prover/smt/solver/diff-neq.ts +1 -2
- package/src/prover/smt/solver/dt2bv-tactic.ts +57 -21
- 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 -10
- 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 +608 -139
- 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 +15 -5
- package/src/prover/smt/solver/lp/containers.ts +7 -1
- package/src/prover/smt/solver/lp/core-solver.ts +12 -8
- package/src/prover/smt/solver/lp/cross-nested.ts +1 -3
- package/src/prover/smt/solver/lp/lar-solver.ts +1 -1
- package/src/prover/smt/solver/lp/lp-settings.ts +6 -2
- package/src/prover/smt/solver/lp/nex-creator.ts +3 -2
- package/src/prover/smt/solver/lp/nex.ts +2 -1
- package/src/prover/smt/solver/lp/nla-basics.ts +46 -1
- package/src/prover/smt/solver/lp/nla-core.ts +26 -6
- package/src/prover/smt/solver/lp/nla-grobner.ts +158 -81
- package/src/prover/smt/solver/lp/nra-solver.ts +138 -95
- package/src/prover/smt/solver/lp/pdd-interval.ts +6 -2
- package/src/prover/smt/solver/lp/pdd-simplifier.ts +60 -20
- package/src/prover/smt/solver/lp/pdd-solver.ts +72 -39
- package/src/prover/smt/solver/lp/pdd.ts +725 -290
- 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 -71
- 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 +20 -3
- package/src/prover/smt/solver/sat/config.ts +1 -1
- package/src/prover/smt/solver/sat/goal2sat.ts +65 -12
- package/src/prover/smt/solver/sat/inc-sat-solver.ts +129 -43
- package/src/prover/smt/solver/sat/model-converter.ts +1 -1
- package/src/prover/smt/solver/sat/pb-constraint.ts +7 -0
- package/src/prover/smt/solver/sat/pb-solver.ts +26 -7
- package/src/prover/smt/solver/sat/sat-tactic.ts +17 -7
- package/src/prover/smt/solver/sat/sat2goal.ts +72 -48
- package/src/prover/smt/solver/sat/simplifier.ts +1 -1
- package/src/prover/smt/solver/sat/solver.ts +27 -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 +4 -7
- 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 +106 -13
- package/src/prover/smt/solver/smtlib-parser.ts +589 -224
- package/src/prover/smt/solver/smtlib-script.ts +713 -210
- 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 +350 -195
- 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 +10 -0
- package/src/prover/smt/solver/theory-lra-propagate.ts +11 -3
- package/src/prover/smt/solver/theory-lra-state.ts +1 -1
- 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/theory-without-terms.ts +24 -0
- package/src/prover/smt/solver/tseitin-cnf.ts +1 -0
- package/src/prover/tlapm/cache.ts +8 -8
- package/src/prover/zenon/equality-rules.ts +24 -0
- package/src/prover/zenon/expr.ts +21 -0
- package/src/prover/zenon/index-table.ts +7 -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/prover/zenon/rules.ts +2 -1
- package/src/resolve.ts +1274 -258
- package/src/runtime.ts +25 -2
- package/src/sany/builtins.ts +10 -10
- package/src/sany/generation.ts +5 -15
- package/src/sany/generator-def-entries.ts +123 -36
- package/src/sany/generator-definitions.ts +5 -3
- package/src/sany/generator-expressions.ts +60 -37
- package/src/sany/generator-proofs.ts +18 -12
- package/src/sany/generator.ts +12 -6
- package/src/sany/lexer.ts +15 -7
- 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 +348 -153
- package/src/simulate.ts +250 -185
- package/src/spec-description.ts +15 -7
- package/src/standard-definitions.ts +5 -0
- package/src/standard-modules.ts +56 -22
- package/src/subexpressions.ts +564 -138
- package/src/successors.ts +50 -20
- package/src/symmetry.ts +2 -1
- package/src/tlc/jar-data.ts +10 -0
- package/src/tlc/messages.ts +3 -3
- package/src/tlc/order.ts +14 -3
- package/src/tlc/random.ts +2 -1
- package/src/tlc/replay.ts +147 -46
- package/src/tlc/tlc-operators.ts +10 -8
- package/src/tlc/tlcext-operators.ts +87 -26
- package/src/tlc/trace-spec.ts +11 -25
- package/src/trace-liveness.ts +529 -0
- package/src/typed-tier.ts +52 -31
- package/src/typescript/types.ts +2 -2
- package/src/values.ts +150 -79
|
@@ -1,4 +1,9 @@
|
|
|
1
|
-
import {
|
|
1
|
+
import {
|
|
2
|
+
SmtDefaultError,
|
|
3
|
+
SmtParseError,
|
|
4
|
+
type SmtPosition,
|
|
5
|
+
SmtUnsupportedError,
|
|
6
|
+
} from "../../../errors";
|
|
2
7
|
import {
|
|
3
8
|
type AstManager,
|
|
4
9
|
getSymbolHash,
|
|
@@ -27,10 +32,12 @@ import {
|
|
|
27
32
|
OP_GT,
|
|
28
33
|
OP_IDIV,
|
|
29
34
|
OP_IMPLIES,
|
|
35
|
+
OP_INT2BV,
|
|
30
36
|
OP_IS_INT,
|
|
31
37
|
OP_ITE,
|
|
32
38
|
OP_LE,
|
|
33
39
|
OP_LT,
|
|
40
|
+
OP_MKBV,
|
|
34
41
|
OP_MOD,
|
|
35
42
|
OP_REM,
|
|
36
43
|
OP_MUL,
|
|
@@ -72,7 +79,7 @@ import {
|
|
|
72
79
|
QUANTIFIER_LAMBDA,
|
|
73
80
|
} from "./ast";
|
|
74
81
|
import { getArraySignature, getMapSignature, mkAsArray } from "./array-decl-plugin";
|
|
75
|
-
import { BV_OP_NAMES, getBvSignature } from "./bv-decl-plugin";
|
|
82
|
+
import { BV_OP_NAMES, getBvSignature, getMismatchedArgument } from "./bv-decl-plugin";
|
|
76
83
|
import {
|
|
77
84
|
type ConstructorDef,
|
|
78
85
|
type DatatypeDef,
|
|
@@ -88,6 +95,7 @@ import {
|
|
|
88
95
|
mkDatatypes,
|
|
89
96
|
mkUpdateField,
|
|
90
97
|
removeDatatype,
|
|
98
|
+
resetDatatypePlugin,
|
|
91
99
|
substituteSort,
|
|
92
100
|
} from "./datatype-decl-plugin";
|
|
93
101
|
import {
|
|
@@ -120,6 +128,7 @@ import {
|
|
|
120
128
|
} from "./smt-logics";
|
|
121
129
|
import { setRecFunDefinition } from "./recfun-decl-plugin";
|
|
122
130
|
import { DEFAULT_PRINT_OPTIONS, printExpr } from "./smt2-printer";
|
|
131
|
+
import { InvVarShifter } from "./rewriter-tpl";
|
|
123
132
|
import { replaceFreeVars, VarSubst } from "./var-subst";
|
|
124
133
|
import { UpolynomialManager } from "./nlsat/upolynomial";
|
|
125
134
|
|
|
@@ -131,12 +140,13 @@ const DEFAULT_PARSER_OPTIONS: ParserOptions = { isIgnoringBadPatterns: true };
|
|
|
131
140
|
|
|
132
141
|
// Z3 counts the columns of the first line from 1 and of the others from 0.
|
|
133
142
|
export interface SmtToken {
|
|
134
|
-
kind: "(" | ")" | "symbol" | "keyword" | "string" | "numeral" | "decimal" | "bitvector";
|
|
143
|
+
kind: "(" | ")" | "symbol" | "keyword" | "string" | "numeral" | "decimal" | "bitvector" | "eof";
|
|
135
144
|
text: string;
|
|
136
145
|
line: number;
|
|
137
146
|
column: number;
|
|
138
147
|
offset: number;
|
|
139
148
|
endOffset: number;
|
|
149
|
+
lastId: string;
|
|
140
150
|
}
|
|
141
151
|
|
|
142
152
|
export interface SmtList {
|
|
@@ -145,6 +155,7 @@ export interface SmtList {
|
|
|
145
155
|
line: number;
|
|
146
156
|
column: number;
|
|
147
157
|
offset: number;
|
|
158
|
+
lastId: string;
|
|
148
159
|
// Z3 reports an error in making an application at its closing parenthesis.
|
|
149
160
|
end: SmtToken;
|
|
150
161
|
// The token after a root-obj or an indexed or qualified identifier, where Z3 reports an error in
|
|
@@ -208,8 +219,6 @@ type SortDecl = ConstantSortDecl | UserSortDecl | DatatypeSortDecl | DefinedSort
|
|
|
208
219
|
|
|
209
220
|
const NO_BINDINGS: ReadonlyMap<string, number> = new Map();
|
|
210
221
|
|
|
211
|
-
const UPOLYNOMIALS = new UpolynomialManager();
|
|
212
|
-
|
|
213
222
|
interface SmtProblem {
|
|
214
223
|
assertions: number[];
|
|
215
224
|
hasCheckSat: boolean;
|
|
@@ -289,6 +298,17 @@ interface PatternFrame {
|
|
|
289
298
|
next: number;
|
|
290
299
|
}
|
|
291
300
|
|
|
301
|
+
interface MatchFrame {
|
|
302
|
+
kind: "match";
|
|
303
|
+
list: SmtList;
|
|
304
|
+
cases: SExpr[];
|
|
305
|
+
isCaseForm: boolean;
|
|
306
|
+
depth: number;
|
|
307
|
+
isTail: boolean;
|
|
308
|
+
start: number;
|
|
309
|
+
next: number;
|
|
310
|
+
}
|
|
311
|
+
|
|
292
312
|
// smt2parser.cpp's expr_frame.
|
|
293
313
|
type TermFrame =
|
|
294
314
|
| ApplicationFrame
|
|
@@ -297,7 +317,8 @@ type TermFrame =
|
|
|
297
317
|
| LetDeclFrame
|
|
298
318
|
| QuantifierFrame
|
|
299
319
|
| AttributeFrame
|
|
300
|
-
| PatternFrame
|
|
320
|
+
| PatternFrame
|
|
321
|
+
| MatchFrame;
|
|
301
322
|
|
|
302
323
|
const QUANTIFIER_KINDS = new Map([
|
|
303
324
|
["forall", QUANTIFIER_FORALL],
|
|
@@ -518,6 +539,8 @@ const REAL_FUNCTION_OPS = new Set([
|
|
|
518
539
|
|
|
519
540
|
// The arity of each builtin declaration but distinct, which takes the arguments it is given.
|
|
520
541
|
const ARITIES = new Map<number, number>([
|
|
542
|
+
[OP_TRUE, 0],
|
|
543
|
+
[OP_FALSE, 0],
|
|
521
544
|
[OP_ITE, 3],
|
|
522
545
|
...[OP_NOT, OP_UMINUS, OP_ABS, OP_TO_REAL, OP_TO_INT, OP_IS_INT, ...REAL_FUNCTION_OPS]
|
|
523
546
|
.filter((op) => op !== OP_ATAN2)
|
|
@@ -588,6 +611,14 @@ const ARRAY_OPS = new Map([
|
|
|
588
611
|
]);
|
|
589
612
|
const ARRAY_EXTENSION_OPS = new Map([["default", OP_ARRAY_DEFAULT]]);
|
|
590
613
|
|
|
614
|
+
const isPortedTheoryOperator = (name: string) =>
|
|
615
|
+
BV_OP_NAMES.has(name) ||
|
|
616
|
+
FPA_OP_NAMES.has(name) ||
|
|
617
|
+
SEQ_OP_NAMES.has(name) ||
|
|
618
|
+
CHAR_OP_NAMES.has(name) ||
|
|
619
|
+
ARRAY_OPS.has(name) ||
|
|
620
|
+
ARRAY_EXTENSION_OPS.has(name);
|
|
621
|
+
|
|
591
622
|
const UNARY_BOOL_REFS = new Map([["not", OP_NOT]]);
|
|
592
623
|
const BINARY_BOOL_REFS = new Map([
|
|
593
624
|
["and", OP_AND],
|
|
@@ -642,12 +673,14 @@ const FF_LITERAL = /^#f-?[0-9]+m[0-9]+$/;
|
|
|
642
673
|
const FF_LOGICS = new Set(["QF_FF", "QF_FFA", "ALL", "HO_ALL"]);
|
|
643
674
|
|
|
644
675
|
// rational::is_unsigned of a numeral token.
|
|
645
|
-
const isUnsigned = (numeral: string) =>
|
|
676
|
+
export const isUnsigned = (numeral: string) =>
|
|
677
|
+
BigInt(numeral) >= 0n && BigInt(numeral) <= 0xffffffffn;
|
|
646
678
|
|
|
647
679
|
const SYMBOL_CHARACTER = /[A-Za-z0-9~!@$%^&*_\-+=<>.?/,]/;
|
|
648
680
|
|
|
649
681
|
const createScanner = (text: string) => {
|
|
650
|
-
|
|
682
|
+
// Z3 prints the null symbol its scanner starts with as null.
|
|
683
|
+
const state = { index: 0, line: 1, lineStart: -1, lastId: "null" };
|
|
651
684
|
const getColumn = () => state.index - state.lineStart - (state.line === 1 ? 0 : 1);
|
|
652
685
|
const advance = () => {
|
|
653
686
|
if (text[state.index] === "\n") {
|
|
@@ -673,13 +706,17 @@ const createScanner = (text: string) => {
|
|
|
673
706
|
}
|
|
674
707
|
const start = state.index;
|
|
675
708
|
const position = { line: state.line, column: getColumn() };
|
|
676
|
-
const getToken = (kind: SmtToken["kind"], tokenText = text.slice(start, state.index)) =>
|
|
677
|
-
kind
|
|
678
|
-
|
|
679
|
-
|
|
680
|
-
|
|
681
|
-
|
|
682
|
-
|
|
709
|
+
const getToken = (kind: SmtToken["kind"], tokenText = text.slice(start, state.index)) => {
|
|
710
|
+
if (kind === "symbol" || kind === "keyword") state.lastId = tokenText;
|
|
711
|
+
return {
|
|
712
|
+
kind,
|
|
713
|
+
text: tokenText,
|
|
714
|
+
...position,
|
|
715
|
+
offset: start,
|
|
716
|
+
endOffset: state.index,
|
|
717
|
+
lastId: state.lastId,
|
|
718
|
+
};
|
|
719
|
+
};
|
|
683
720
|
if (character === "(" || character === ")") {
|
|
684
721
|
advance();
|
|
685
722
|
return getToken(character);
|
|
@@ -703,6 +740,9 @@ const createScanner = (text: string) => {
|
|
|
703
740
|
// string, so the columns of the rest of the line count one more.
|
|
704
741
|
if (current === "\n") state.lineStart--;
|
|
705
742
|
if (current !== character) continue;
|
|
743
|
+
// Z3's scanner rereads the last character at the end of the file, as if the quote were doubled.
|
|
744
|
+
if (character === '"' && state.index === text.length)
|
|
745
|
+
throw new SmtParseError("unexpected end of file", position);
|
|
706
746
|
if (character !== '"' || text[state.index] !== '"') break;
|
|
707
747
|
advance();
|
|
708
748
|
}
|
|
@@ -733,25 +773,23 @@ const createScanner = (text: string) => {
|
|
|
733
773
|
}
|
|
734
774
|
continue;
|
|
735
775
|
}
|
|
736
|
-
if (radix
|
|
737
|
-
advance();
|
|
738
|
-
readWhile(/[0-9m-]/);
|
|
739
|
-
return getToken("symbol");
|
|
740
|
-
}
|
|
741
|
-
if (radix !== "x" && radix !== "b")
|
|
776
|
+
if (radix !== "f" && radix !== "x" && radix !== "b")
|
|
742
777
|
throw new SmtParseError("invalid bit-vector literal, expecting 'x' or 'b'", {
|
|
743
778
|
line: state.line,
|
|
744
779
|
column: getColumn(),
|
|
745
780
|
});
|
|
746
781
|
advance();
|
|
747
782
|
const digitsStart = state.index;
|
|
748
|
-
readWhile(radix === "x" ? /[0-9a-fA-F]/ : /[01]/);
|
|
749
|
-
if (state.index === digitsStart)
|
|
783
|
+
readWhile(radix === "f" ? /[0-9m-]/ : radix === "x" ? /[0-9a-fA-F]/ : /[01]/);
|
|
784
|
+
if (state.index === digitsStart && radix !== "f")
|
|
750
785
|
throw new SmtParseError("invalid empty bit-vector literal", {
|
|
751
786
|
line: state.line,
|
|
752
787
|
column: getColumn(),
|
|
753
788
|
});
|
|
754
|
-
|
|
789
|
+
// Z3's scanner rereads the last digit at the end of the file.
|
|
790
|
+
if (state.index === text.length && state.index !== digitsStart)
|
|
791
|
+
throw new SmtParseError("unexpected end of file", position);
|
|
792
|
+
return getToken(radix === "f" ? "symbol" : "bitvector");
|
|
755
793
|
}
|
|
756
794
|
if (character === ":" || SYMBOL_CHARACTER.test(character)) {
|
|
757
795
|
advance();
|
|
@@ -762,7 +800,11 @@ const createScanner = (text: string) => {
|
|
|
762
800
|
throw new SmtParseError("unexpected character", position);
|
|
763
801
|
}
|
|
764
802
|
};
|
|
765
|
-
return {
|
|
803
|
+
return {
|
|
804
|
+
next,
|
|
805
|
+
getPosition: () => ({ line: state.line, column: getColumn() }),
|
|
806
|
+
getLastId: () => state.lastId,
|
|
807
|
+
};
|
|
766
808
|
};
|
|
767
809
|
|
|
768
810
|
export const createCommandReader = (text: string) => {
|
|
@@ -784,13 +826,29 @@ export const createCommandReader = (text: string) => {
|
|
|
784
826
|
line: open.line,
|
|
785
827
|
column: open.column,
|
|
786
828
|
offset: open.offset,
|
|
829
|
+
lastId: open.lastId,
|
|
787
830
|
end: open,
|
|
788
831
|
};
|
|
789
832
|
let followed: SmtList | undefined;
|
|
790
833
|
for (let current = root; ;) {
|
|
791
834
|
const token = take();
|
|
792
|
-
if (token === undefined)
|
|
793
|
-
|
|
835
|
+
if (token === undefined) {
|
|
836
|
+
// Z3 parses a command as it reads it, and sees the end of the file where it wants a token.
|
|
837
|
+
const eof: SmtToken = {
|
|
838
|
+
kind: "eof",
|
|
839
|
+
text: "",
|
|
840
|
+
...scanner.getPosition(),
|
|
841
|
+
offset: text.length,
|
|
842
|
+
endOffset: text.length,
|
|
843
|
+
lastId: scanner.getLastId(),
|
|
844
|
+
};
|
|
845
|
+
if (followed !== undefined) followed.follower = eof;
|
|
846
|
+
current.items.push(eof);
|
|
847
|
+
const end = { ...eof };
|
|
848
|
+
current.end = end;
|
|
849
|
+
for (const list of stack) list.end = end;
|
|
850
|
+
return root;
|
|
851
|
+
}
|
|
794
852
|
if (followed !== undefined) followed.follower = token;
|
|
795
853
|
followed = undefined;
|
|
796
854
|
if (token.kind === "(") {
|
|
@@ -800,6 +858,7 @@ export const createCommandReader = (text: string) => {
|
|
|
800
858
|
line: token.line,
|
|
801
859
|
column: token.column,
|
|
802
860
|
offset: token.offset,
|
|
861
|
+
lastId: token.lastId,
|
|
803
862
|
end: token,
|
|
804
863
|
root,
|
|
805
864
|
};
|
|
@@ -822,12 +881,28 @@ export const createCommandReader = (text: string) => {
|
|
|
822
881
|
current = parent;
|
|
823
882
|
}
|
|
824
883
|
};
|
|
825
|
-
const
|
|
884
|
+
const readOpen = () => {
|
|
826
885
|
const token = take();
|
|
827
886
|
if (token === undefined) return undefined;
|
|
828
887
|
if (token.kind !== "(") throw new SmtParseError("invalid command, '(' expected", token);
|
|
829
888
|
state.depth = 1;
|
|
830
|
-
return
|
|
889
|
+
return token;
|
|
890
|
+
};
|
|
891
|
+
const read = () => {
|
|
892
|
+
const open = readOpen();
|
|
893
|
+
return open === undefined ? undefined : readList(open);
|
|
894
|
+
};
|
|
895
|
+
// parse_cmd checks the head of a command before it reads the rest.
|
|
896
|
+
const readCommand = () => {
|
|
897
|
+
const open = readOpen();
|
|
898
|
+
if (open === undefined) return undefined;
|
|
899
|
+
state.lookahead = take();
|
|
900
|
+
if (!isSymbol(state.lookahead))
|
|
901
|
+
throw new SmtParseError(
|
|
902
|
+
"invalid command, symbol expected",
|
|
903
|
+
state.lookahead ?? scanner.getPosition(),
|
|
904
|
+
);
|
|
905
|
+
return readList(open);
|
|
831
906
|
};
|
|
832
907
|
const skip = (report: (error: SmtParseError) => void) => {
|
|
833
908
|
for (;;) {
|
|
@@ -846,27 +921,17 @@ export const createCommandReader = (text: string) => {
|
|
|
846
921
|
}
|
|
847
922
|
}
|
|
848
923
|
};
|
|
849
|
-
return { read, skip };
|
|
924
|
+
return { read, readCommand, skip };
|
|
850
925
|
};
|
|
851
926
|
|
|
852
|
-
export const
|
|
853
|
-
|
|
854
|
-
|
|
855
|
-
|
|
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);
|
|
927
|
+
export const expectClosed = (sexpr: SExpr) => {
|
|
928
|
+
const end = sexpr.kind === "list" ? sexpr.end : sexpr;
|
|
929
|
+
if (end.kind === "eof")
|
|
930
|
+
throw new SmtParseError("invalid s-expression, unexpected end of file", end);
|
|
861
931
|
};
|
|
862
932
|
|
|
863
|
-
const
|
|
864
|
-
|
|
865
|
-
const id = getLastId(items[index]);
|
|
866
|
-
if (id !== undefined) return id;
|
|
867
|
-
}
|
|
868
|
-
return undefined;
|
|
869
|
-
};
|
|
933
|
+
export const isSymbol = (sexpr: SExpr | undefined, text?: string): sexpr is SmtToken =>
|
|
934
|
+
sexpr !== undefined && sexpr.kind === "symbol" && (text === undefined || sexpr.text === text);
|
|
870
935
|
|
|
871
936
|
const isSimpleIndex = (index: SExpr) =>
|
|
872
937
|
index.kind === "numeral" ||
|
|
@@ -879,11 +944,20 @@ const expectList = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtLi
|
|
|
879
944
|
return sexpr;
|
|
880
945
|
};
|
|
881
946
|
|
|
947
|
+
const expectListNext = (sexpr: SExpr, message: string) => {
|
|
948
|
+
if (sexpr.kind !== "list") throw new SmtParseError(`${message} got ${sexpr.lastId}`, sexpr);
|
|
949
|
+
return sexpr;
|
|
950
|
+
};
|
|
951
|
+
|
|
882
952
|
const expectSymbol = (sexpr: SExpr | undefined, message: string, at: SExpr): SmtToken => {
|
|
883
953
|
if (!isSymbol(sexpr)) throw new SmtParseError(message, sexpr ?? at);
|
|
884
954
|
return sexpr;
|
|
885
955
|
};
|
|
886
956
|
|
|
957
|
+
const expectEnd = (extra: SExpr | undefined, message: string) => {
|
|
958
|
+
if (extra !== undefined) throw new SmtParseError(message, extra);
|
|
959
|
+
};
|
|
960
|
+
|
|
887
961
|
export const createSmtlibReader = (
|
|
888
962
|
manager: AstManager,
|
|
889
963
|
logic?: string,
|
|
@@ -902,6 +976,10 @@ export const createSmtlibReader = (
|
|
|
902
976
|
]);
|
|
903
977
|
const funcs = new Map<string, readonly number[]>();
|
|
904
978
|
const macros = new Map<string, Macro>();
|
|
979
|
+
// A pop empties the macros of a name but keeps the name in the dictionary.
|
|
980
|
+
const macroNames: string[] = [];
|
|
981
|
+
const dictionaryNames = new Set<string>();
|
|
982
|
+
const macroDictionary = new ObjMap<string>((index) => getSymbolHash(macroNames[index]));
|
|
905
983
|
const lastNamed = { name: "", expr: -1 };
|
|
906
984
|
const notifiedSorts = new Set<number>();
|
|
907
985
|
const undo: (() => void)[] = [];
|
|
@@ -926,6 +1004,9 @@ export const createSmtlibReader = (
|
|
|
926
1004
|
const unrooted: number[] = [];
|
|
927
1005
|
const pending: number[] = [];
|
|
928
1006
|
|
|
1007
|
+
const scopedFuncs: number[] = [];
|
|
1008
|
+
const scopedFuncStarts: number[] = [];
|
|
1009
|
+
|
|
929
1010
|
const declare = <Value>(names: Map<string, Value>, name: string, value: Value) => {
|
|
930
1011
|
const previous = names.get(name);
|
|
931
1012
|
undo.push(() => {
|
|
@@ -935,6 +1016,14 @@ export const createSmtlibReader = (
|
|
|
935
1016
|
names.set(name, value);
|
|
936
1017
|
};
|
|
937
1018
|
|
|
1019
|
+
const insertMacro = (name: string, macro: Macro) => {
|
|
1020
|
+
if (!dictionaryNames.has(name)) {
|
|
1021
|
+
dictionaryNames.add(name);
|
|
1022
|
+
macroDictionary.set(macroNames.push(name) - 1, name);
|
|
1023
|
+
}
|
|
1024
|
+
declare(macros, name, macro);
|
|
1025
|
+
};
|
|
1026
|
+
|
|
938
1027
|
const hasArrays = logic === undefined || logicHasArray(logic);
|
|
939
1028
|
const hasFpa = logic === undefined || logicHasFpa(logic);
|
|
940
1029
|
const hasArrayExtensions = logic === undefined || ARRAY_EXTENSION_LOGICS.has(logic);
|
|
@@ -974,6 +1063,7 @@ export const createSmtlibReader = (
|
|
|
974
1063
|
at,
|
|
975
1064
|
);
|
|
976
1065
|
declare(funcs, name, [...existing, decl]);
|
|
1066
|
+
scopedFuncs.push(decl);
|
|
977
1067
|
};
|
|
978
1068
|
|
|
979
1069
|
const insertDatatypeDecls = (sort: number, at: SExpr) => {
|
|
@@ -1030,38 +1120,40 @@ export const createSmtlibReader = (
|
|
|
1030
1120
|
? decl.parameters.length
|
|
1031
1121
|
: decl.arity;
|
|
1032
1122
|
|
|
1123
|
+
const registerList = () => {
|
|
1124
|
+
const element = manager.mkTypeParameter(0);
|
|
1125
|
+
mkDatatypes(manager, [
|
|
1126
|
+
mkDatatypeDef(
|
|
1127
|
+
manager,
|
|
1128
|
+
"List",
|
|
1129
|
+
[element],
|
|
1130
|
+
[
|
|
1131
|
+
{ name: "nil", recognizer: "is-nil", accessors: [] },
|
|
1132
|
+
{
|
|
1133
|
+
name: "insert",
|
|
1134
|
+
recognizer: "is-insert",
|
|
1135
|
+
accessors: [
|
|
1136
|
+
{ name: "head", range: element },
|
|
1137
|
+
{ name: "tail", range: -1 },
|
|
1138
|
+
],
|
|
1139
|
+
},
|
|
1140
|
+
],
|
|
1141
|
+
),
|
|
1142
|
+
]);
|
|
1143
|
+
const list: DatatypeSortDecl = {
|
|
1144
|
+
kind: "datatype",
|
|
1145
|
+
name: "List",
|
|
1146
|
+
arity: 1,
|
|
1147
|
+
siblings: [],
|
|
1148
|
+
instances: new Map(),
|
|
1149
|
+
};
|
|
1150
|
+
sortDecls.set("List", list);
|
|
1151
|
+
return list;
|
|
1152
|
+
};
|
|
1153
|
+
|
|
1033
1154
|
const instantiateSort = (decl: SortDecl, parameters: number[], at: SExpr): number => {
|
|
1034
1155
|
if (decl.kind === "sort") return decl.sort;
|
|
1035
|
-
if (decl.kind === "list")
|
|
1036
|
-
const element = manager.mkTypeParameter(0);
|
|
1037
|
-
mkDatatypes(manager, [
|
|
1038
|
-
mkDatatypeDef(
|
|
1039
|
-
manager,
|
|
1040
|
-
"List",
|
|
1041
|
-
[element],
|
|
1042
|
-
[
|
|
1043
|
-
{ name: "nil", recognizer: "is-nil", accessors: [] },
|
|
1044
|
-
{
|
|
1045
|
-
name: "insert",
|
|
1046
|
-
recognizer: "is-insert",
|
|
1047
|
-
accessors: [
|
|
1048
|
-
{ name: "head", range: element },
|
|
1049
|
-
{ name: "tail", range: -1 },
|
|
1050
|
-
],
|
|
1051
|
-
},
|
|
1052
|
-
],
|
|
1053
|
-
),
|
|
1054
|
-
]);
|
|
1055
|
-
const list: DatatypeSortDecl = {
|
|
1056
|
-
kind: "datatype",
|
|
1057
|
-
name: "List",
|
|
1058
|
-
arity: 1,
|
|
1059
|
-
siblings: [],
|
|
1060
|
-
instances: new Map(),
|
|
1061
|
-
};
|
|
1062
|
-
sortDecls.set("List", list);
|
|
1063
|
-
return instantiateSort(list, parameters, at);
|
|
1064
|
-
}
|
|
1156
|
+
if (decl.kind === "list") return instantiateSort(registerList(), parameters, at);
|
|
1065
1157
|
if (decl.kind === "user") return manager.mkUninterpretedSort(decl.name, parameters);
|
|
1066
1158
|
if (decl.kind === "datatype") return instantiateDatatype(decl, parameters, at);
|
|
1067
1159
|
return parseSort(
|
|
@@ -1077,7 +1169,11 @@ export const createSmtlibReader = (
|
|
|
1077
1169
|
bindings: ReadonlyMap<string, number>,
|
|
1078
1170
|
): number => {
|
|
1079
1171
|
const head = sexpr.items[0];
|
|
1080
|
-
if (!isSymbol(head))
|
|
1172
|
+
if (!isSymbol(head))
|
|
1173
|
+
throw new SmtParseError(
|
|
1174
|
+
`${context === "" ? "" : `${context} `}invalid sort, symbol or '_' expected`,
|
|
1175
|
+
head ?? sexpr.end,
|
|
1176
|
+
);
|
|
1081
1177
|
const isArray =
|
|
1082
1178
|
ARRAY_SORT_NAMES.has(head.text) || (head.text === "Set" && restricted.hasSetSort);
|
|
1083
1179
|
if (isArray && hasArrays) {
|
|
@@ -1204,6 +1300,11 @@ export const createSmtlibReader = (
|
|
|
1204
1300
|
throw new SmtParseError("bit-vector size must be greater than zero", sexpr.end);
|
|
1205
1301
|
return manager.mkBvSort(Number(width.text));
|
|
1206
1302
|
}
|
|
1303
|
+
if (sexpr.kind !== "symbol")
|
|
1304
|
+
throw new SmtParseError(
|
|
1305
|
+
`invalid sort, symbol, '_' or '(' expected got ${sexpr.lastId}`,
|
|
1306
|
+
sexpr,
|
|
1307
|
+
);
|
|
1207
1308
|
const decl = sortDecls.get(sexpr.text);
|
|
1208
1309
|
if (decl !== undefined) {
|
|
1209
1310
|
if (getSortDeclArity(decl) !== 0)
|
|
@@ -1278,19 +1379,18 @@ export const createSmtlibReader = (
|
|
|
1278
1379
|
shrink(exprs, 0);
|
|
1279
1380
|
};
|
|
1280
1381
|
|
|
1281
|
-
//
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
};
|
|
1382
|
+
// The parser's var_shifter, whose cache holds the terms it makes, which replaceFreeVars rebuilds.
|
|
1383
|
+
const shiftFreeVars = (expr: number, amount: number) =>
|
|
1384
|
+
manager.kinds[expr] === KIND_VAR
|
|
1385
|
+
? manager.mkVar(manager.values[expr] + amount, manager.sorts[expr])
|
|
1386
|
+
: replaceFreeVars(manager, expr, (variable, index, shift) =>
|
|
1387
|
+
manager.mkVar(index + shift + amount, manager.sorts[variable]),
|
|
1388
|
+
);
|
|
1389
|
+
|
|
1390
|
+
const getLocalTerm = (local: Local) =>
|
|
1391
|
+
local.level === binders.depth
|
|
1392
|
+
? local.expr
|
|
1393
|
+
: shiftFreeVars(local.expr, binders.depth - local.level);
|
|
1294
1394
|
|
|
1295
1395
|
// basic_decl_plugin::join.
|
|
1296
1396
|
const getJoin = (left: number, right: number, at: SExpr) => {
|
|
@@ -1469,19 +1569,19 @@ export const createSmtlibReader = (
|
|
|
1469
1569
|
};
|
|
1470
1570
|
|
|
1471
1571
|
// parse_sorted_vars: the variables are created the first declared with the largest index, and
|
|
1472
|
-
// the stack holds them.
|
|
1473
|
-
const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr
|
|
1572
|
+
// the stack holds them.
|
|
1573
|
+
const bindSortedVars = (sexpr: SExpr | undefined, at: SExpr) => {
|
|
1474
1574
|
if (sexpr?.kind !== "list")
|
|
1475
1575
|
throw new SmtParseError(
|
|
1476
|
-
`invalid list of sorted variables, '(' expected got ${
|
|
1576
|
+
`invalid list of sorted variables, '(' expected got ${(sexpr ?? at).lastId}`,
|
|
1477
1577
|
sexpr ?? at,
|
|
1478
1578
|
);
|
|
1479
1579
|
const names: string[] = [];
|
|
1480
1580
|
const varSorts: number[] = [];
|
|
1481
|
-
for (const
|
|
1581
|
+
for (const declaration of sexpr.items) {
|
|
1482
1582
|
if (declaration.kind !== "list")
|
|
1483
1583
|
throw new SmtParseError(
|
|
1484
|
-
`invalid sorted variable, '(' expected got ${
|
|
1584
|
+
`invalid sorted variable, '(' expected got ${declaration.lastId}`,
|
|
1485
1585
|
declaration,
|
|
1486
1586
|
);
|
|
1487
1587
|
const name = declaration.items[0];
|
|
@@ -1494,10 +1594,7 @@ export const createSmtlibReader = (
|
|
|
1494
1594
|
varSorts.push(parseSort(declaration.items[1] ?? declaration.end, "invalid sorted variables"));
|
|
1495
1595
|
const extra = declaration.items[2];
|
|
1496
1596
|
if (extra !== undefined)
|
|
1497
|
-
throw new SmtParseError(
|
|
1498
|
-
`invalid sorted variable, ')' expected got ${getLastId(extra) ?? getLastId(declaration.items[1]) ?? name.text}`,
|
|
1499
|
-
extra,
|
|
1500
|
-
);
|
|
1597
|
+
throw new SmtParseError(`invalid sorted variable, ')' expected got ${extra.lastId}`, extra);
|
|
1501
1598
|
}
|
|
1502
1599
|
beginScope();
|
|
1503
1600
|
binders.depth += varSorts.length;
|
|
@@ -1571,13 +1668,17 @@ export const createSmtlibReader = (
|
|
|
1571
1668
|
|
|
1572
1669
|
const mkBvApp = (name: string, args: number[], indices: number[], at: SExpr) => {
|
|
1573
1670
|
const op = BV_OP_NAMES.get(name) ?? -1;
|
|
1574
|
-
const
|
|
1575
|
-
|
|
1576
|
-
|
|
1577
|
-
|
|
1578
|
-
indices,
|
|
1579
|
-
);
|
|
1671
|
+
const argSorts = args.map((arg) => manager.sorts[arg]);
|
|
1672
|
+
if (op !== OP_INT2BV && op !== OP_MKBV && (args.length === 0 || !manager.isBvSort(argSorts[0])))
|
|
1673
|
+
throw new SmtParseError("operator is applied to arguments of the wrong sort", at);
|
|
1674
|
+
const signature = getBvSignature(manager, op, argSorts, indices);
|
|
1580
1675
|
if (typeof signature === "string") throw new SmtParseError(signature, at);
|
|
1676
|
+
const mismatched = getMismatchedArgument(signature, argSorts);
|
|
1677
|
+
if (mismatched !== -1)
|
|
1678
|
+
throw new SmtParseError(
|
|
1679
|
+
`Argument ${printExpr(manager, { options: DEFAULT_PRINT_OPTIONS, isUsed, isClashing }, args[mismatched])} at position ${mismatched} has sort ${manager.getSortName(argSorts[mismatched])} it does not match declaration (declare-fun ${signature.name} (${signature.domain.map((sort) => manager.getSortName(sort)).join(" ")}) ${manager.getSortName(signature.range)})`,
|
|
1680
|
+
at,
|
|
1681
|
+
);
|
|
1581
1682
|
const decl = manager.mkBvDecl(op, signature.name, indices, signature.domain, signature.range);
|
|
1582
1683
|
return manager.mkApp(decl, args, signature.range);
|
|
1583
1684
|
};
|
|
@@ -1649,8 +1750,10 @@ export const createSmtlibReader = (
|
|
|
1649
1750
|
return mkSeqAppOf(manager, signature, args);
|
|
1650
1751
|
};
|
|
1651
1752
|
|
|
1753
|
+
const upolynomials = new UpolynomialManager(manager.limit);
|
|
1754
|
+
|
|
1652
1755
|
const parseUpolynomial = (sexpr: SExpr): bigint[] => {
|
|
1653
|
-
if (sexpr.kind === "numeral") return
|
|
1756
|
+
if (sexpr.kind === "numeral") return upolynomials.set([BigInt(sexpr.text)]);
|
|
1654
1757
|
if (sexpr.kind === "decimal") {
|
|
1655
1758
|
const parts = sexpr.text.split(".");
|
|
1656
1759
|
const value = Rational.of(BigInt(parts[0] + parts[1]), 10n ** BigInt(parts[1].length));
|
|
@@ -1659,7 +1762,7 @@ export const createSmtlibReader = (
|
|
|
1659
1762
|
"invalid univariate polynomial, integer coefficient expected",
|
|
1660
1763
|
sexpr,
|
|
1661
1764
|
);
|
|
1662
|
-
return
|
|
1765
|
+
return upolynomials.set([value.num]);
|
|
1663
1766
|
}
|
|
1664
1767
|
if (sexpr.kind === "symbol") {
|
|
1665
1768
|
if (sexpr.text !== "x")
|
|
@@ -1684,15 +1787,15 @@ export const createSmtlibReader = (
|
|
|
1684
1787
|
"invalid univariate polynomial, exponent must be an unsigned integer",
|
|
1685
1788
|
exponent,
|
|
1686
1789
|
);
|
|
1687
|
-
return
|
|
1790
|
+
return upolynomials.pw(parseUpolynomial(operands[0]), Number(exponent.text));
|
|
1688
1791
|
}
|
|
1689
1792
|
const combine =
|
|
1690
1793
|
head.text === "+"
|
|
1691
|
-
?
|
|
1794
|
+
? upolynomials.add
|
|
1692
1795
|
: head.text === "-"
|
|
1693
|
-
?
|
|
1796
|
+
? upolynomials.sub
|
|
1694
1797
|
: head.text === "*"
|
|
1695
|
-
?
|
|
1798
|
+
? upolynomials.mul
|
|
1696
1799
|
: undefined;
|
|
1697
1800
|
if (combine === undefined)
|
|
1698
1801
|
throw new SmtParseError(
|
|
@@ -1705,11 +1808,11 @@ export const createSmtlibReader = (
|
|
|
1705
1808
|
sexpr,
|
|
1706
1809
|
);
|
|
1707
1810
|
const first = parseUpolynomial(operands[0]);
|
|
1708
|
-
if (head.text === "-" && operands.length === 1) return
|
|
1811
|
+
if (head.text === "-" && operands.length === 1) return upolynomials.neg(first);
|
|
1709
1812
|
return operands
|
|
1710
1813
|
.slice(1)
|
|
1711
1814
|
.reduce(
|
|
1712
|
-
(result, operand) => combine.call(
|
|
1815
|
+
(result, operand) => combine.call(upolynomials, result, parseUpolynomial(operand)),
|
|
1713
1816
|
first,
|
|
1714
1817
|
);
|
|
1715
1818
|
};
|
|
@@ -1727,7 +1830,10 @@ export const createSmtlibReader = (
|
|
|
1727
1830
|
if (BigInt(index.text) === 0n)
|
|
1728
1831
|
throw new SmtParseError("invalid root-obj, index must be >= 1", index);
|
|
1729
1832
|
if (list.items.length > 3)
|
|
1730
|
-
throw new SmtParseError(
|
|
1833
|
+
throw new SmtParseError(
|
|
1834
|
+
`invalid root-obj, ')' expected got ${list.items[3].lastId}`,
|
|
1835
|
+
list.items[3],
|
|
1836
|
+
);
|
|
1731
1837
|
const coeffs = parseUpolynomial(polynomial);
|
|
1732
1838
|
const follower = list.follower ?? list.end;
|
|
1733
1839
|
if (coeffs.length === 0)
|
|
@@ -1753,7 +1859,7 @@ export const createSmtlibReader = (
|
|
|
1753
1859
|
if (!isSymbol(name))
|
|
1754
1860
|
throw new SmtParseError("invalid indexed identifier, symbol expected", name ?? list.end);
|
|
1755
1861
|
for (const index of list.items.slice(2)) {
|
|
1756
|
-
if (index.kind === "string")
|
|
1862
|
+
if (index.kind === "string" || index.kind === "eof")
|
|
1757
1863
|
throw new SmtParseError(
|
|
1758
1864
|
"invalid indexed identifier, integer, identifier or '(' expected",
|
|
1759
1865
|
index,
|
|
@@ -1778,7 +1884,7 @@ export const createSmtlibReader = (
|
|
|
1778
1884
|
const target = list.items[1];
|
|
1779
1885
|
if (target === undefined || (target.kind !== "symbol" && target.kind !== "list"))
|
|
1780
1886
|
throw new SmtParseError(
|
|
1781
|
-
`invalid (indexed) identifier, '(_' or symbol expected got ${
|
|
1887
|
+
`invalid (indexed) identifier, '(_' or symbol expected got ${(target ?? list.end).lastId}`,
|
|
1782
1888
|
target ?? list.end,
|
|
1783
1889
|
);
|
|
1784
1890
|
if (target.kind === "list") {
|
|
@@ -1793,7 +1899,7 @@ export const createSmtlibReader = (
|
|
|
1793
1899
|
const extra = list.items[3];
|
|
1794
1900
|
if (extra !== undefined)
|
|
1795
1901
|
throw new SmtParseError(
|
|
1796
|
-
`invalid qualified identifier, ')' expected got ${
|
|
1902
|
+
`invalid qualified identifier, ')' expected got ${extra.lastId}`,
|
|
1797
1903
|
extra,
|
|
1798
1904
|
);
|
|
1799
1905
|
return sort;
|
|
@@ -1857,18 +1963,19 @@ export const createSmtlibReader = (
|
|
|
1857
1963
|
const sort = parseQualifierSort(list);
|
|
1858
1964
|
const target = list.items[1];
|
|
1859
1965
|
const local = isSymbol(target) ? locals.get(target.text) : undefined;
|
|
1860
|
-
if (isSymbol(target) && local === undefined)
|
|
1861
|
-
return
|
|
1862
|
-
|
|
1863
|
-
: parseApp(target, [], at, [], sort);
|
|
1966
|
+
if (isSymbol(target) && local === undefined && hasArrays && target.text === "const")
|
|
1967
|
+
return mkArrayTerm(OP_CONST_ARRAY, [], [sort], at);
|
|
1968
|
+
// A macro takes no range, so check_qualifier catches the sort of the term it stands for.
|
|
1864
1969
|
const term =
|
|
1865
|
-
local
|
|
1866
|
-
?
|
|
1867
|
-
|
|
1868
|
-
|
|
1869
|
-
|
|
1870
|
-
|
|
1871
|
-
|
|
1970
|
+
local !== undefined
|
|
1971
|
+
? getLocalTerm(local)
|
|
1972
|
+
: isSymbol(target)
|
|
1973
|
+
? parseApp(target, [], at, [], sort)
|
|
1974
|
+
: parseIndexedTerm(
|
|
1975
|
+
expectList(target, "invalid indexed identifier, '_' expected", list),
|
|
1976
|
+
at,
|
|
1977
|
+
sort,
|
|
1978
|
+
);
|
|
1872
1979
|
if (manager.sorts[term] !== sort)
|
|
1873
1980
|
throw new SmtParseError(
|
|
1874
1981
|
`sort mismatch in qualified identifier, expected: ${manager.getSortName(sort)}, got: ${manager.getSortName(manager.sorts[term])}`,
|
|
@@ -2005,7 +2112,15 @@ export const createSmtlibReader = (
|
|
|
2005
2112
|
const argSort = args.length === 1 ? manager.sorts[args[0]] : -1;
|
|
2006
2113
|
if (argSort === -1 || !manager.isDatatypeSort(argSort))
|
|
2007
2114
|
throw new SmtParseError(IS_PARAMETER_MESSAGE, at);
|
|
2008
|
-
const
|
|
2115
|
+
const constructors = (() => {
|
|
2116
|
+
try {
|
|
2117
|
+
return getDatatypeConstructors(manager, argSort);
|
|
2118
|
+
} catch (error) {
|
|
2119
|
+
if (!(error instanceof SmtDefaultError)) throw error;
|
|
2120
|
+
throw new SmtParseError(error.message, at);
|
|
2121
|
+
}
|
|
2122
|
+
})();
|
|
2123
|
+
const constructor = constructors.find(
|
|
2009
2124
|
(decl) => manager.funcDecls[decl].name === constructorName.text,
|
|
2010
2125
|
);
|
|
2011
2126
|
if (constructor === undefined)
|
|
@@ -2163,10 +2278,19 @@ export const createSmtlibReader = (
|
|
|
2163
2278
|
const transcendentalOp = isTranscendental ? TRANSCENDENTAL_OPS.get(builtin) : undefined;
|
|
2164
2279
|
if (isTranscendental && transcendentalOp === undefined)
|
|
2165
2280
|
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
2166
|
-
const
|
|
2281
|
+
const builtinOp =
|
|
2167
2282
|
builtin === "~"
|
|
2168
2283
|
? OP_UMINUS
|
|
2169
|
-
:
|
|
2284
|
+
: builtin === "true"
|
|
2285
|
+
? OP_TRUE
|
|
2286
|
+
: builtin === "false"
|
|
2287
|
+
? OP_FALSE
|
|
2288
|
+
: (CHAINABLE_OPS.get(builtin) ?? BUILTIN_OPS.get(builtin) ?? transcendentalOp);
|
|
2289
|
+
// load_plugin registers the operators of arithmetic only for a logic that has it.
|
|
2290
|
+
const named =
|
|
2291
|
+
builtinOp !== undefined && manager.funcDecls[builtinOp].family === FAMILY_ARITH && !hasArith
|
|
2292
|
+
? undefined
|
|
2293
|
+
: builtinOp;
|
|
2170
2294
|
if (
|
|
2171
2295
|
args.length === 0 &&
|
|
2172
2296
|
named !== undefined &&
|
|
@@ -2177,7 +2301,17 @@ export const createSmtlibReader = (
|
|
|
2177
2301
|
const op = named === OP_SUB && args.length === 1 ? OP_UMINUS : named;
|
|
2178
2302
|
const domainSort = op === undefined ? -1 : getDomainSort(op, args, at);
|
|
2179
2303
|
if (op !== undefined && domainSort !== -1) return mkApp(op, args, at, domainSort);
|
|
2180
|
-
if (
|
|
2304
|
+
if (
|
|
2305
|
+
op === undefined &&
|
|
2306
|
+
!isPortedTheoryOperator(name) &&
|
|
2307
|
+
((THEORY_OPERATOR.test(name) &&
|
|
2308
|
+
(name.startsWith("bv")
|
|
2309
|
+
? hasBv
|
|
2310
|
+
: name.startsWith("fp.")
|
|
2311
|
+
? hasFpa
|
|
2312
|
+
: name.startsWith("ff.") || hasSeq)) ||
|
|
2313
|
+
THEORY_OPERATORS.has(name))
|
|
2314
|
+
)
|
|
2181
2315
|
throw new SmtUnsupportedError(`the operator ${name}`);
|
|
2182
2316
|
const instance = mkDatatypeInstanceApp(name, args, at);
|
|
2183
2317
|
if (instance !== undefined) return instance;
|
|
@@ -2214,7 +2348,9 @@ export const createSmtlibReader = (
|
|
|
2214
2348
|
throw new SmtParseError(
|
|
2215
2349
|
sexpr.kind === "keyword"
|
|
2216
2350
|
? "invalid expression, unexpected keyword"
|
|
2217
|
-
:
|
|
2351
|
+
: sexpr.kind === "eof"
|
|
2352
|
+
? "invalid expression, unexpected input"
|
|
2353
|
+
: "invalid expression, unexpected ')'",
|
|
2218
2354
|
sexpr,
|
|
2219
2355
|
);
|
|
2220
2356
|
};
|
|
@@ -2234,8 +2370,10 @@ export const createSmtlibReader = (
|
|
|
2234
2370
|
manager.incRef(expr);
|
|
2235
2371
|
lastNamed.name = name;
|
|
2236
2372
|
lastNamed.expr = expr;
|
|
2237
|
-
manager.mkMacro(name, expr);
|
|
2238
|
-
declare(
|
|
2373
|
+
const decl = manager.mkMacro(name, expr);
|
|
2374
|
+
declare(funcs, name, [...(funcs.get(name) ?? []), decl]);
|
|
2375
|
+
scopedFuncs.push(decl);
|
|
2376
|
+
insertMacro(name, { domain: [], range: manager.sorts[expr], body: expr });
|
|
2239
2377
|
};
|
|
2240
2378
|
|
|
2241
2379
|
// push_app_frame's parse_qualified_identifier_core, on a head that is (_ <symbol> <index>*) or
|
|
@@ -2295,6 +2433,106 @@ export const createSmtlibReader = (
|
|
|
2295
2433
|
return { head: name, indices: [] };
|
|
2296
2434
|
};
|
|
2297
2435
|
|
|
2436
|
+
const parseMatchPattern = (sexpr: SExpr, sort: number, after: SExpr) => {
|
|
2437
|
+
if (sexpr.kind !== "list" && sexpr.kind !== "symbol")
|
|
2438
|
+
throw new SmtParseError(
|
|
2439
|
+
"expecting a constructor, _, variable or constructor application",
|
|
2440
|
+
sexpr,
|
|
2441
|
+
);
|
|
2442
|
+
const name = sexpr.kind === "list" ? (sexpr.items[0] ?? sexpr.end) : sexpr;
|
|
2443
|
+
if (!isSymbol(name)) throw new SmtParseError("constructor symbol expected", name);
|
|
2444
|
+
const vars: string[] = [];
|
|
2445
|
+
if (sexpr.kind === "list")
|
|
2446
|
+
for (const [index, item] of sexpr.items.slice(1).entries()) {
|
|
2447
|
+
if (!isSymbol(item)) throw new SmtParseError("variable symbol expected", item);
|
|
2448
|
+
if (item.text !== "_" && vars.includes(item.text))
|
|
2449
|
+
throw new SmtParseError(
|
|
2450
|
+
"unexpected repeated variable in pattern expression",
|
|
2451
|
+
sexpr.items[index + 2] ?? sexpr.end,
|
|
2452
|
+
);
|
|
2453
|
+
vars.push(item.text);
|
|
2454
|
+
}
|
|
2455
|
+
const decl = funcs
|
|
2456
|
+
.get(name.text)
|
|
2457
|
+
?.find(
|
|
2458
|
+
(candidate) =>
|
|
2459
|
+
manager.funcDecls[candidate].range === sort &&
|
|
2460
|
+
manager.funcDecls[candidate].domain.length === vars.length,
|
|
2461
|
+
);
|
|
2462
|
+
if (decl === undefined && vars.length > 0)
|
|
2463
|
+
throw new SmtParseError(
|
|
2464
|
+
`invalid function declaration reference, unknown indexed function ${name.text}`,
|
|
2465
|
+
after,
|
|
2466
|
+
);
|
|
2467
|
+
if (decl === undefined && (name.text === "true" || name.text === "false"))
|
|
2468
|
+
throw new SmtParseError("expecting a constructor", after);
|
|
2469
|
+
if (decl === undefined && BUILTIN_NAMES.has(name.text))
|
|
2470
|
+
throw new SmtUnsupportedError("a builtin name as a pattern of match");
|
|
2471
|
+
if (decl === undefined) {
|
|
2472
|
+
binders.depth++;
|
|
2473
|
+
const variable = manager.mkVar(0, sort);
|
|
2474
|
+
if (name.text !== "_") insertLocal(name.text, variable);
|
|
2475
|
+
return variable;
|
|
2476
|
+
}
|
|
2477
|
+
if (manager.funcDecls[decl].op !== OP_DT_CONSTRUCTOR)
|
|
2478
|
+
throw new SmtParseError("expecting a constructor", after);
|
|
2479
|
+
binders.depth += vars.length;
|
|
2480
|
+
const args = vars.map((variable, index) => {
|
|
2481
|
+
const boundVar = manager.mkVar(index, manager.funcDecls[decl].domain[index]);
|
|
2482
|
+
if (variable !== "_") insertLocal(variable, boundVar);
|
|
2483
|
+
return boundVar;
|
|
2484
|
+
});
|
|
2485
|
+
return manager.mkApp(decl, args, sort);
|
|
2486
|
+
};
|
|
2487
|
+
|
|
2488
|
+
const compileMatch = (term: number, patterns: number[], bodies: number[], at: SExpr) => {
|
|
2489
|
+
const sort = manager.sorts[term];
|
|
2490
|
+
if (!manager.isDatatypeSort(sort))
|
|
2491
|
+
throw new SmtParseError("pattern matching is only supported for algebraic datatypes", at);
|
|
2492
|
+
const constructors = getDatatypeConstructors(manager, sort);
|
|
2493
|
+
if (!patterns.some((pattern) => manager.kinds[pattern] === KIND_VAR)) {
|
|
2494
|
+
if (patterns.length < constructors.length)
|
|
2495
|
+
throw new SmtParseError("non-exhaustive pattern match", at);
|
|
2496
|
+
const marked = new Set(patterns.map((pattern) => manager.decls[pattern]));
|
|
2497
|
+
if (constructors.some((constructor) => !marked.has(constructor)))
|
|
2498
|
+
throw new SmtParseError("a constructor is missing from pattern match", at);
|
|
2499
|
+
}
|
|
2500
|
+
const subst = new VarSubst(manager, false);
|
|
2501
|
+
let result = -1;
|
|
2502
|
+
for (let index = patterns.length - 1; index >= 0; index--) {
|
|
2503
|
+
const pattern = patterns[index];
|
|
2504
|
+
const isVar = manager.kinds[pattern] === KIND_VAR;
|
|
2505
|
+
const recognizer = isVar ? -1 : getConstructorIs(manager, manager.decls[pattern]);
|
|
2506
|
+
const accessors = isVar ? [] : getConstructorAccessors(manager, manager.decls[pattern]);
|
|
2507
|
+
const shifted = shiftFreeVars(term, isVar ? 1 : accessors.length);
|
|
2508
|
+
manager.incRef(shifted);
|
|
2509
|
+
const substitution = isVar
|
|
2510
|
+
? [shifted]
|
|
2511
|
+
: accessors.map((accessor) =>
|
|
2512
|
+
manager.mkApp(accessor, [shifted], manager.funcDecls[accessor].range),
|
|
2513
|
+
);
|
|
2514
|
+
for (const expr of substitution) manager.incRef(expr);
|
|
2515
|
+
const condition = isVar ? manager.trueExpr : manager.mkApp(recognizer, [term], SORT_BOOL);
|
|
2516
|
+
manager.incRef(condition);
|
|
2517
|
+
manager.decRef(shifted);
|
|
2518
|
+
const substituted = subst.apply(bodies[index], substitution);
|
|
2519
|
+
const shifter = new InvVarShifter(manager);
|
|
2520
|
+
const body = shifter.shift(substituted, substitution.length);
|
|
2521
|
+
manager.decRef(substituted);
|
|
2522
|
+
shifter.release();
|
|
2523
|
+
const args = [condition, body, result];
|
|
2524
|
+
const next = result === -1 ? body : mkApp(OP_ITE, args, at, getDomainSort(OP_ITE, args, at));
|
|
2525
|
+
manager.incRef(next);
|
|
2526
|
+
if (result !== -1) manager.decRef(result);
|
|
2527
|
+
result = next;
|
|
2528
|
+
manager.decRef(body);
|
|
2529
|
+
manager.decRef(condition);
|
|
2530
|
+
for (const expr of substitution) manager.decRef(expr);
|
|
2531
|
+
}
|
|
2532
|
+
subst.release();
|
|
2533
|
+
return result;
|
|
2534
|
+
};
|
|
2535
|
+
|
|
2298
2536
|
// parse_expr. Z3 leaves the term on its stack until the command ends. A tail term is one whose
|
|
2299
2537
|
// value is the value of the whole: it stays off the stack, in parsed, so that the caller of
|
|
2300
2538
|
// parseTerm can have a term that nothing else holds without a reference of the parser's.
|
|
@@ -2329,6 +2567,7 @@ export const createSmtlibReader = (
|
|
|
2329
2567
|
// Z3 skips a bad pattern as an s-expression, which cannot start with ')'.
|
|
2330
2568
|
if (value.kind === ")")
|
|
2331
2569
|
throw new SmtParseError("invalid s-expression, unexpected ')'", value);
|
|
2570
|
+
expectClosed(value);
|
|
2332
2571
|
frame.next++;
|
|
2333
2572
|
exprStack.push(-1);
|
|
2334
2573
|
return;
|
|
@@ -2396,12 +2635,25 @@ export const createSmtlibReader = (
|
|
|
2396
2635
|
deliver(parseRootObj(current), isTail, exprStack.length);
|
|
2397
2636
|
return;
|
|
2398
2637
|
}
|
|
2399
|
-
if (head.text === "match")
|
|
2638
|
+
if (head.text === "match") {
|
|
2639
|
+
frames.push({
|
|
2640
|
+
kind: "match",
|
|
2641
|
+
list: current,
|
|
2642
|
+
cases: [],
|
|
2643
|
+
isCaseForm: false,
|
|
2644
|
+
depth: -1,
|
|
2645
|
+
isTail,
|
|
2646
|
+
start: exprStack.length,
|
|
2647
|
+
next: -1,
|
|
2648
|
+
});
|
|
2649
|
+
enter(current.items[1] ?? current.end, false);
|
|
2650
|
+
return;
|
|
2651
|
+
}
|
|
2400
2652
|
if (head.text === "let") {
|
|
2401
2653
|
const bindings = current.items[1];
|
|
2402
2654
|
if (bindings?.kind !== "list")
|
|
2403
2655
|
throw new SmtParseError(
|
|
2404
|
-
`invalid let declaration, '(' expected got ${
|
|
2656
|
+
`invalid let declaration, '(' expected got ${(bindings ?? current.end).lastId}`,
|
|
2405
2657
|
bindings ?? current.end,
|
|
2406
2658
|
);
|
|
2407
2659
|
frames.push({
|
|
@@ -2444,7 +2696,7 @@ export const createSmtlibReader = (
|
|
|
2444
2696
|
}
|
|
2445
2697
|
// push_quant_frame.
|
|
2446
2698
|
const start = exprStack.length;
|
|
2447
|
-
const bound = bindSortedVars(current.items[1], current.end
|
|
2699
|
+
const bound = bindSortedVars(current.items[1], current.end);
|
|
2448
2700
|
if (bound.varSorts.length === 0)
|
|
2449
2701
|
throw new SmtParseError(
|
|
2450
2702
|
"invalid quantifier, list of sorted variables is empty",
|
|
@@ -2476,7 +2728,7 @@ export const createSmtlibReader = (
|
|
|
2476
2728
|
// push_let_decl_frame.
|
|
2477
2729
|
if (declaration.kind !== "list")
|
|
2478
2730
|
throw new SmtParseError(
|
|
2479
|
-
`invalid let declaration, '(' expected got ${
|
|
2731
|
+
`invalid let declaration, '(' expected got ${declaration.lastId}`,
|
|
2480
2732
|
declaration,
|
|
2481
2733
|
);
|
|
2482
2734
|
const name = declaration.items[0];
|
|
@@ -2512,6 +2764,64 @@ export const createSmtlibReader = (
|
|
|
2512
2764
|
continue;
|
|
2513
2765
|
}
|
|
2514
2766
|
const items = frame.list.items;
|
|
2767
|
+
if (frame.kind === "match") {
|
|
2768
|
+
if (frame.next === -1) {
|
|
2769
|
+
const bindings = items[2] ?? frame.list.end;
|
|
2770
|
+
if (bindings.kind !== "list")
|
|
2771
|
+
throw new SmtParseError(
|
|
2772
|
+
`pattern bindings should be enclosed in a parenthesis got ${bindings.lastId}`,
|
|
2773
|
+
bindings,
|
|
2774
|
+
);
|
|
2775
|
+
// curr_id_is_case reads the last identifier, which a '(' leaves as it was.
|
|
2776
|
+
frame.isCaseForm = (bindings.items[0] ?? bindings.end).lastId === "case";
|
|
2777
|
+
frame.cases = frame.isCaseForm ? items.slice(2) : bindings.items;
|
|
2778
|
+
frame.next = 0;
|
|
2779
|
+
} else if (frame.depth !== -1) {
|
|
2780
|
+
binders.depth = frame.depth;
|
|
2781
|
+
frame.depth = -1;
|
|
2782
|
+
endScope();
|
|
2783
|
+
const binding = frame.cases[frame.next - 1];
|
|
2784
|
+
const extra =
|
|
2785
|
+
binding.kind === "list" ? binding.items[frame.isCaseForm ? 3 : 2] : undefined;
|
|
2786
|
+
if (extra !== undefined)
|
|
2787
|
+
throw new SmtParseError(
|
|
2788
|
+
`invalid pattern binding, ')' expected got ${extra.lastId}`,
|
|
2789
|
+
extra,
|
|
2790
|
+
);
|
|
2791
|
+
}
|
|
2792
|
+
const binding = frame.cases[frame.next];
|
|
2793
|
+
if (binding !== undefined) {
|
|
2794
|
+
if (frame.isCaseForm && !(binding.kind === "list" && isSymbol(binding.items[0], "case")))
|
|
2795
|
+
throw new SmtUnsupportedError("the terms after the cases of match");
|
|
2796
|
+
if (binding.kind !== "list")
|
|
2797
|
+
throw new SmtParseError(
|
|
2798
|
+
`invalid pattern binding, '(' expected got ${binding.lastId}`,
|
|
2799
|
+
binding,
|
|
2800
|
+
);
|
|
2801
|
+
frame.next++;
|
|
2802
|
+
beginScope();
|
|
2803
|
+
frame.depth = binders.depth;
|
|
2804
|
+
const offset = frame.isCaseForm ? 1 : 0;
|
|
2805
|
+
const body = binding.items[offset + 1] ?? binding.end;
|
|
2806
|
+
const sort = manager.sorts[exprStack[frame.start]];
|
|
2807
|
+
pushRef(exprStack, parseMatchPattern(binding.items[offset] ?? binding.end, sort, body));
|
|
2808
|
+
enter(body, false);
|
|
2809
|
+
continue;
|
|
2810
|
+
}
|
|
2811
|
+
if (!frame.isCaseForm && items.length > 3)
|
|
2812
|
+
throw new SmtUnsupportedError("the terms after the cases of match");
|
|
2813
|
+
frames.pop();
|
|
2814
|
+
const term = exprStack[frame.start];
|
|
2815
|
+
const cases = exprStack.slice(frame.start + 1);
|
|
2816
|
+
const patterns = cases.filter((_expr, index) => index % 2 === 0);
|
|
2817
|
+
const bodies = cases.filter((_expr, index) => index % 2 === 1);
|
|
2818
|
+
const result = compileMatch(term, patterns, bodies, frame.list.end);
|
|
2819
|
+
// push_match_frame releases the bodies, then the patterns, then the term.
|
|
2820
|
+
exprStack.splice(frame.start, cases.length + 1, ...bodies, ...patterns, term);
|
|
2821
|
+
deliver(result, frame.isTail, frame.start);
|
|
2822
|
+
manager.decRef(result);
|
|
2823
|
+
continue;
|
|
2824
|
+
}
|
|
2515
2825
|
if (frame.kind === "attribute") {
|
|
2516
2826
|
// consume_attributes.
|
|
2517
2827
|
if (exprStack.length === frame.start) {
|
|
@@ -2574,6 +2884,7 @@ export const createSmtlibReader = (
|
|
|
2574
2884
|
// Z3 warns of an unknown attribute and skips its value as an s-expression.
|
|
2575
2885
|
if (value.kind === ")")
|
|
2576
2886
|
throw new SmtParseError("invalid s-expression, unexpected ')'", value);
|
|
2887
|
+
expectClosed(value);
|
|
2577
2888
|
frame.next += 2;
|
|
2578
2889
|
} else if (quantifier === undefined)
|
|
2579
2890
|
throw new SmtParseError("invalid attribute, not in the scope of a quantifier", keyword);
|
|
@@ -2653,13 +2964,13 @@ export const createSmtlibReader = (
|
|
|
2653
2964
|
return expr;
|
|
2654
2965
|
};
|
|
2655
2966
|
|
|
2656
|
-
const parseDomain = (sexpr: SExpr
|
|
2967
|
+
const parseDomain = (sexpr: SExpr) => {
|
|
2657
2968
|
const context = "Parsing function declaration. Expecting sort list '('";
|
|
2658
|
-
return
|
|
2969
|
+
return expectListNext(sexpr, context).items.map((item) => parseSort(item, context));
|
|
2659
2970
|
};
|
|
2660
2971
|
|
|
2661
|
-
const parseSortParameters = (sexpr: SExpr
|
|
2662
|
-
|
|
2972
|
+
const parseSortParameters = (sexpr: SExpr, message: string) =>
|
|
2973
|
+
expectListNext(sexpr, "invalid sort declaration, parameters missing").items.map(
|
|
2663
2974
|
(item) => expectSymbol(item, message, item).text,
|
|
2664
2975
|
);
|
|
2665
2976
|
|
|
@@ -2673,8 +2984,12 @@ export const createSmtlibReader = (
|
|
|
2673
2984
|
missing: string[],
|
|
2674
2985
|
) => {
|
|
2675
2986
|
if (sexpr.kind === "list") return parseSort(sexpr, "", bindings);
|
|
2987
|
+
if (sexpr.kind === ")") throw new SmtParseError("invalid sort, unexpected ')'", sexpr);
|
|
2676
2988
|
if (sexpr.kind !== "symbol")
|
|
2677
|
-
throw new SmtParseError(
|
|
2989
|
+
throw new SmtParseError(
|
|
2990
|
+
`invalid sort, symbol, '_' or '(' expected got ${sexpr.lastId}`,
|
|
2991
|
+
sexpr,
|
|
2992
|
+
);
|
|
2678
2993
|
if (sortDecls.has(sexpr.text) || bindings.has(sexpr.text))
|
|
2679
2994
|
return parseSort(sexpr, "", bindings);
|
|
2680
2995
|
const index = datatypeIndexes.get(sexpr.text);
|
|
@@ -2697,21 +3012,16 @@ export const createSmtlibReader = (
|
|
|
2697
3012
|
);
|
|
2698
3013
|
return items.map((item) => {
|
|
2699
3014
|
if (isSymbol(item)) return { name: item.text, recognizer: `is-${item.text}`, accessors: [] };
|
|
2700
|
-
const constructor =
|
|
2701
|
-
item,
|
|
2702
|
-
"invalid datatype declaration, '(' or ')' expected",
|
|
2703
|
-
item,
|
|
2704
|
-
);
|
|
3015
|
+
const constructor = expectListNext(item, "invalid datatype declaration, '(' or ')' expected");
|
|
2705
3016
|
const name = expectSymbol(
|
|
2706
3017
|
constructor.items[0],
|
|
2707
3018
|
"invalid constructor declaration, symbol (constructor name) expected",
|
|
2708
3019
|
constructor,
|
|
2709
3020
|
).text;
|
|
2710
3021
|
const accessors = constructor.items.slice(1).map((accessorItem) => {
|
|
2711
|
-
const accessor =
|
|
3022
|
+
const accessor = expectListNext(
|
|
2712
3023
|
accessorItem,
|
|
2713
3024
|
"invalid datatype declaration, '(' or ')' expected",
|
|
2714
|
-
accessorItem,
|
|
2715
3025
|
);
|
|
2716
3026
|
const accessorName = expectSymbol(
|
|
2717
3027
|
accessor.items[0],
|
|
@@ -2725,7 +3035,10 @@ export const createSmtlibReader = (
|
|
|
2725
3035
|
missing,
|
|
2726
3036
|
);
|
|
2727
3037
|
if (accessor.items.length > 2)
|
|
2728
|
-
throw new SmtParseError(
|
|
3038
|
+
throw new SmtParseError(
|
|
3039
|
+
`invalid accessor declaration, ')' expected got ${accessor.items[2].lastId}`,
|
|
3040
|
+
accessor.items[2],
|
|
3041
|
+
);
|
|
2729
3042
|
return { name: accessorName, range };
|
|
2730
3043
|
});
|
|
2731
3044
|
return { name, recognizer: `is-${name}`, accessors };
|
|
@@ -2733,27 +3046,29 @@ export const createSmtlibReader = (
|
|
|
2733
3046
|
};
|
|
2734
3047
|
|
|
2735
3048
|
const parseDatatypeBody = (
|
|
2736
|
-
sexpr: SExpr
|
|
3049
|
+
sexpr: SExpr,
|
|
2737
3050
|
datatypeIndexes: ReadonlyMap<string, number>,
|
|
2738
3051
|
missing: string[],
|
|
2739
|
-
|
|
3052
|
+
name?: string,
|
|
2740
3053
|
) => {
|
|
2741
|
-
const body =
|
|
2742
|
-
if (!isSymbol(body.items[0], "par"))
|
|
3054
|
+
const body = expectListNext(sexpr, "invalid datatype declaration, '(' expected");
|
|
3055
|
+
if (!isSymbol(body.items[0], "par")) {
|
|
3056
|
+
if (name !== undefined) declareDatatypeSort(name, 0, body.items[0] ?? body.end);
|
|
2743
3057
|
return {
|
|
2744
3058
|
parameters: [],
|
|
2745
3059
|
constructors: parseConstructors(body.items, NO_BINDINGS, datatypeIndexes, missing, body),
|
|
2746
3060
|
};
|
|
3061
|
+
}
|
|
2747
3062
|
const parameters = parseSortParameters(
|
|
2748
|
-
body.items[1],
|
|
3063
|
+
body.items[1] ?? body.end,
|
|
2749
3064
|
"invalid sort parameter, symbol or ')' expected",
|
|
2750
|
-
body,
|
|
2751
3065
|
);
|
|
2752
|
-
const constructors =
|
|
2753
|
-
body.items[2],
|
|
3066
|
+
const constructors = expectListNext(
|
|
3067
|
+
body.items[2] ?? body.end,
|
|
2754
3068
|
"invalid constructor declaration after par, '(' expected",
|
|
2755
|
-
body,
|
|
2756
3069
|
);
|
|
3070
|
+
if (name !== undefined && parameters.length > 0)
|
|
3071
|
+
declareDatatypeSort(name, parameters.length, constructors.items[0] ?? constructors.end);
|
|
2757
3072
|
return {
|
|
2758
3073
|
parameters: parameters.map((_name, index) => manager.mkTypeParameter(index)),
|
|
2759
3074
|
constructors: parseConstructors(
|
|
@@ -2793,11 +3108,17 @@ export const createSmtlibReader = (
|
|
|
2793
3108
|
declare(sortDecls, name, decl);
|
|
2794
3109
|
};
|
|
2795
3110
|
|
|
3111
|
+
const declareDatatypeSort = (name: string, arity: number, at: SExpr) =>
|
|
3112
|
+
declareSortDecl(
|
|
3113
|
+
name,
|
|
3114
|
+
{ kind: "datatype", name, arity, siblings: [], instances: new Map() },
|
|
3115
|
+
at,
|
|
3116
|
+
);
|
|
3117
|
+
|
|
2796
3118
|
const declareDatatypes = (list: SmtList) => {
|
|
2797
|
-
const declaration =
|
|
2798
|
-
list.items[1],
|
|
3119
|
+
const declaration = expectListNext(
|
|
3120
|
+
list.items[1] ?? list.end,
|
|
2799
3121
|
"invalid sort declaration, parameters missing",
|
|
2800
|
-
list,
|
|
2801
3122
|
);
|
|
2802
3123
|
const isSmt26 = declaration.items[0]?.kind === "list";
|
|
2803
3124
|
const datatypeIndexes = new Map<string, number>();
|
|
@@ -2811,11 +3132,11 @@ export const createSmtlibReader = (
|
|
|
2811
3132
|
);
|
|
2812
3133
|
return;
|
|
2813
3134
|
}
|
|
2814
|
-
const sortDeclaration =
|
|
3135
|
+
const sortDeclaration = expectListNext(item, "invalid sort declaration, '(' expected");
|
|
2815
3136
|
const name = expectSymbol(
|
|
2816
3137
|
sortDeclaration.items[0],
|
|
2817
3138
|
"invalid sort name, identified expected",
|
|
2818
|
-
sortDeclaration,
|
|
3139
|
+
sortDeclaration.end,
|
|
2819
3140
|
).text;
|
|
2820
3141
|
const arity = sortDeclaration.items[1];
|
|
2821
3142
|
if (arity?.kind !== "numeral")
|
|
@@ -2823,26 +3144,25 @@ export const createSmtlibReader = (
|
|
|
2823
3144
|
"invalid sort declaration, arity expected",
|
|
2824
3145
|
arity ?? sortDeclaration.end,
|
|
2825
3146
|
);
|
|
2826
|
-
if (sortDeclaration.items.length > 2)
|
|
2827
|
-
throw new SmtParseError("invalid sort declaration, ')' expected", sortDeclaration.items[2]);
|
|
2828
3147
|
datatypeIndexes.set(name, index);
|
|
2829
3148
|
names.push(name);
|
|
2830
3149
|
arities.push(Number(arity.text));
|
|
2831
|
-
|
|
3150
|
+
declareDatatypeSort(
|
|
2832
3151
|
name,
|
|
2833
|
-
|
|
2834
|
-
sortDeclaration,
|
|
3152
|
+
Number(arity.text),
|
|
3153
|
+
sortDeclaration.items[2] ?? sortDeclaration.end,
|
|
2835
3154
|
);
|
|
3155
|
+
if (sortDeclaration.items.length > 2)
|
|
3156
|
+
throw new SmtParseError("invalid sort declaration, ')' expected", sortDeclaration.items[2]);
|
|
2836
3157
|
});
|
|
2837
|
-
const bodies =
|
|
3158
|
+
const bodies = expectListNext(
|
|
3159
|
+
list.items[2] ?? list.end,
|
|
3160
|
+
"invalid datatype declaration, '(' expected",
|
|
3161
|
+
);
|
|
2838
3162
|
// A datatype of the older syntax may refer to any datatype of its declaration.
|
|
2839
3163
|
if (!isSmt26)
|
|
2840
3164
|
bodies.items.forEach((item, index) => {
|
|
2841
|
-
const datatype =
|
|
2842
|
-
item,
|
|
2843
|
-
"invalid datatype declaration, '(' or ')' expected",
|
|
2844
|
-
item,
|
|
2845
|
-
);
|
|
3165
|
+
const datatype = expectListNext(item, "invalid datatype declaration, '(' or ')' expected");
|
|
2846
3166
|
const name = expectSymbol(
|
|
2847
3167
|
datatype.items[0],
|
|
2848
3168
|
"invalid datatype declaration, symbol (datatype name) expected",
|
|
@@ -2867,10 +3187,10 @@ export const createSmtlibReader = (
|
|
|
2867
3187
|
Array.from({ length: arities[index] }, (_unused, parameter) =>
|
|
2868
3188
|
manager.mkTypeParameter(parameter),
|
|
2869
3189
|
),
|
|
2870
|
-
parseDatatypeBody(item, datatypeIndexes, missing
|
|
3190
|
+
parseDatatypeBody(item, datatypeIndexes, missing).constructors,
|
|
2871
3191
|
);
|
|
2872
3192
|
}
|
|
2873
|
-
const datatype =
|
|
3193
|
+
const datatype = expectListNext(item, "invalid datatype declaration, '(' or ')' expected");
|
|
2874
3194
|
return mkDatatypeDef(
|
|
2875
3195
|
manager,
|
|
2876
3196
|
names[index],
|
|
@@ -2903,29 +3223,21 @@ export const createSmtlibReader = (
|
|
|
2903
3223
|
};
|
|
2904
3224
|
|
|
2905
3225
|
const declareDatatype = (list: SmtList) => {
|
|
2906
|
-
const name = expectSymbol(list.items[1], "unexpected token used as datatype name", list);
|
|
3226
|
+
const name = expectSymbol(list.items[1], "unexpected token used as datatype name", list.end);
|
|
2907
3227
|
const missing: string[] = [];
|
|
2908
|
-
const
|
|
2909
|
-
|
|
2910
|
-
|
|
2911
|
-
|
|
2912
|
-
bodyList.items[1]?.kind === "list"
|
|
2913
|
-
? bodyList.items[1].items.length
|
|
2914
|
-
: 0;
|
|
2915
|
-
declareSortDecl(
|
|
3228
|
+
const body = parseDatatypeBody(
|
|
3229
|
+
list.items[2] ?? list.end,
|
|
3230
|
+
new Map([[name.text, 0]]),
|
|
3231
|
+
missing,
|
|
2916
3232
|
name.text,
|
|
2917
|
-
{ kind: "datatype", name: name.text, arity, siblings: [], instances: new Map() },
|
|
2918
|
-
name,
|
|
2919
3233
|
);
|
|
2920
|
-
const body = parseDatatypeBody(bodyList, new Map([[name.text, 0]]), missing, list);
|
|
2921
|
-
if (list.items.length > 3)
|
|
2922
|
-
throw new SmtParseError("invalid end of datatype declaration, ')' expected", list.items[3]);
|
|
2923
3234
|
commitDatatypes(
|
|
2924
3235
|
[mkDatatypeDef(manager, name.text, body.parameters, body.constructors)],
|
|
2925
3236
|
missing,
|
|
2926
3237
|
name,
|
|
2927
|
-
list.end,
|
|
3238
|
+
list.items[3] ?? list.end,
|
|
2928
3239
|
);
|
|
3240
|
+
expectEnd(list.items[3], "invalid end of datatype declaration, ')' expected");
|
|
2929
3241
|
};
|
|
2930
3242
|
|
|
2931
3243
|
// parse_rec_fun_decl: the variables are bound only while the range is parsed, and Z3 holds them
|
|
@@ -2936,7 +3248,7 @@ export const createSmtlibReader = (
|
|
|
2936
3248
|
"invalid function/constant definition, symbol expected",
|
|
2937
3249
|
at,
|
|
2938
3250
|
);
|
|
2939
|
-
const bound = bindSortedVars(items[1], at
|
|
3251
|
+
const bound = bindSortedVars(items[1], at);
|
|
2940
3252
|
const range = parseSort(items[2] ?? at, "Invalid recursive function definition");
|
|
2941
3253
|
unbindSortedVars(bound.varSorts.length);
|
|
2942
3254
|
return manager.mkRecFuncDecl(symbol.text, bound.varSorts, range);
|
|
@@ -2945,7 +3257,7 @@ export const createSmtlibReader = (
|
|
|
2945
3257
|
// parse_rec_fun_body: Z3 reports a body of another sort at the token after it.
|
|
2946
3258
|
const defineRecFun = (decl: number, variables: SExpr, body: SExpr, next: SExpr) => {
|
|
2947
3259
|
const start = exprStack.length;
|
|
2948
|
-
const bound = bindSortedVars(variables, body
|
|
3260
|
+
const bound = bindSortedVars(variables, body);
|
|
2949
3261
|
runTerm(body, false);
|
|
2950
3262
|
const parsedBody = exprStack[exprStack.length - 1];
|
|
2951
3263
|
unbindSortedVars(bound.varSorts.length);
|
|
@@ -2973,12 +3285,15 @@ export const createSmtlibReader = (
|
|
|
2973
3285
|
subst.release();
|
|
2974
3286
|
}
|
|
2975
3287
|
for (const [index, sort] of domain.entries()) manager.incRef(manager.mkVar(index, sort));
|
|
2976
|
-
const reversedVars = domain.map((
|
|
3288
|
+
const reversedVars = domain.map((_value, index) =>
|
|
3289
|
+
manager.mkVar(index, domain[count - index - 1]),
|
|
3290
|
+
);
|
|
2977
3291
|
for (const reversedVar of reversedVars) manager.incRef(reversedVar);
|
|
2978
3292
|
const decl = manager.mkRecFuncDecl(name, domain, manager.sorts[body]);
|
|
2979
3293
|
for (const reversedVar of reversedVars) manager.decRef(reversedVar);
|
|
2980
3294
|
setRecFunDefinition(manager, manager.recFunDefs.get(decl)!, true, body);
|
|
2981
3295
|
declare(funcs, name, [...(funcs.get(name) ?? []), decl]);
|
|
3296
|
+
scopedFuncs.push(decl);
|
|
2982
3297
|
};
|
|
2983
3298
|
|
|
2984
3299
|
const declareCommand = (list: SmtList) => {
|
|
@@ -2988,6 +3303,7 @@ export const createSmtlibReader = (
|
|
|
2988
3303
|
const decl = declareRecFun(list.items.slice(1), list.end);
|
|
2989
3304
|
insertFunc(decl, list.items[4] ?? list.end);
|
|
2990
3305
|
defineRecFun(decl, list.items[2], list.items[4] ?? list.end, list.items[5] ?? list.end);
|
|
3306
|
+
expectEnd(list.items[5], "invalid function/constant definition, ')' expected");
|
|
2991
3307
|
shrinkRefs(exprStack, 0);
|
|
2992
3308
|
return;
|
|
2993
3309
|
}
|
|
@@ -3016,9 +3332,11 @@ export const createSmtlibReader = (
|
|
|
3016
3332
|
bodies.items[index + 1] ?? bodies.end,
|
|
3017
3333
|
);
|
|
3018
3334
|
});
|
|
3019
|
-
|
|
3020
|
-
|
|
3021
|
-
|
|
3335
|
+
expectEnd(
|
|
3336
|
+
bodies.items[signatures.length],
|
|
3337
|
+
"invalid recursive function definition, ')' expected",
|
|
3338
|
+
);
|
|
3339
|
+
expectEnd(list.items[3], "invalid function/constant definition, ')' expected");
|
|
3022
3340
|
shrinkRefs(exprStack, 0);
|
|
3023
3341
|
return;
|
|
3024
3342
|
}
|
|
@@ -3030,7 +3348,26 @@ export const createSmtlibReader = (
|
|
|
3030
3348
|
declareDatatype(list);
|
|
3031
3349
|
return;
|
|
3032
3350
|
}
|
|
3033
|
-
const symbol =
|
|
3351
|
+
const symbol = list.items[1];
|
|
3352
|
+
// check_nonreserved_identifier rejects _ and as, which define-const's check_identifier takes.
|
|
3353
|
+
if (
|
|
3354
|
+
!isSymbol(symbol) ||
|
|
3355
|
+
(name !== "define-const" && (symbol.text === "_" || symbol.text === "as"))
|
|
3356
|
+
)
|
|
3357
|
+
throw new SmtParseError(
|
|
3358
|
+
name === "declare-sort"
|
|
3359
|
+
? "invalid sort declaration, symbol expected"
|
|
3360
|
+
: name === "define-sort"
|
|
3361
|
+
? "invalid sort definition, symbol expected"
|
|
3362
|
+
: name === "define-fun"
|
|
3363
|
+
? "invalid function/constant definition, symbol expected"
|
|
3364
|
+
: name === "define-const"
|
|
3365
|
+
? "invalid constant definition, symbol expected"
|
|
3366
|
+
: name === "declare-fun"
|
|
3367
|
+
? "invalid function declaration, symbol expected"
|
|
3368
|
+
: "invalid constant declaration, symbol expected",
|
|
3369
|
+
symbol ?? list.end,
|
|
3370
|
+
);
|
|
3034
3371
|
if (name === "declare-sort") {
|
|
3035
3372
|
if (sortDecls.has(symbol.text))
|
|
3036
3373
|
throw new SmtParseError("invalid sort declaration, sort already declared/defined", symbol);
|
|
@@ -3040,8 +3377,6 @@ export const createSmtlibReader = (
|
|
|
3040
3377
|
"invalid sort declaration, arity (<numeral>) or ')' expected",
|
|
3041
3378
|
arity,
|
|
3042
3379
|
);
|
|
3043
|
-
if (list.items.length > 3)
|
|
3044
|
-
throw new SmtParseError("invalid sort declaration, ')' expected", list.items[3]);
|
|
3045
3380
|
declare(
|
|
3046
3381
|
sortDecls,
|
|
3047
3382
|
symbol.text,
|
|
@@ -3049,26 +3384,25 @@ export const createSmtlibReader = (
|
|
|
3049
3384
|
? { kind: "sort", sort: manager.mkSort(symbol.text) }
|
|
3050
3385
|
: { kind: "user", name: symbol.text, arity: Number(arity.text) },
|
|
3051
3386
|
);
|
|
3387
|
+
expectEnd(list.items[3], "invalid sort declaration, ')' expected");
|
|
3052
3388
|
return;
|
|
3053
3389
|
}
|
|
3054
3390
|
if (name === "define-sort") {
|
|
3055
3391
|
if (sortDecls.has(symbol.text))
|
|
3056
3392
|
throw new SmtParseError("invalid sort definition, sort already declared/defined", symbol);
|
|
3057
3393
|
const parameters = parseSortParameters(
|
|
3058
|
-
list.items[2],
|
|
3394
|
+
list.items[2] ?? list.end,
|
|
3059
3395
|
"invalid sort parameter, symbol or ')' expected",
|
|
3060
|
-
list,
|
|
3061
3396
|
);
|
|
3062
3397
|
const body = list.items[3] ?? list.end;
|
|
3063
3398
|
checkPsort(body, bindTypeParameters(parameters));
|
|
3064
3399
|
declare(sortDecls, symbol.text, { kind: "definition", parameters, body });
|
|
3400
|
+
expectEnd(list.items[4], "invalid sort definition, ')' expected");
|
|
3065
3401
|
return;
|
|
3066
3402
|
}
|
|
3067
3403
|
if (name === "define-fun" || name === "define-const") {
|
|
3068
3404
|
const isConst = name === "define-const";
|
|
3069
|
-
const bound = isConst
|
|
3070
|
-
? { names: [], varSorts: [] }
|
|
3071
|
-
: bindSortedVars(list.items[2], list.end, symbol.text);
|
|
3405
|
+
const bound = isConst ? { names: [], varSorts: [] } : bindSortedVars(list.items[2], list.end);
|
|
3072
3406
|
const range = parseSort(
|
|
3073
3407
|
list.items[isConst ? 2 : 3] ?? list.end,
|
|
3074
3408
|
isConst ? "Invalid constant definition" : "Invalid function definition",
|
|
@@ -3076,20 +3410,27 @@ export const createSmtlibReader = (
|
|
|
3076
3410
|
runTerm(list.items[isConst ? 3 : 4] ?? list.end, false);
|
|
3077
3411
|
const body = exprStack[exprStack.length - 1];
|
|
3078
3412
|
if (!isConst) unbindSortedVars(bound.varSorts.length);
|
|
3413
|
+
const extra = list.items[isConst ? 4 : 5];
|
|
3079
3414
|
if (manager.sorts[body] !== range)
|
|
3080
3415
|
throw new SmtParseError(
|
|
3081
3416
|
isConst
|
|
3082
3417
|
? "invalid constant definition, sort mismatch"
|
|
3083
3418
|
: "invalid function/constant definition, sort mismatch",
|
|
3084
|
-
list.end,
|
|
3419
|
+
extra ?? list.end,
|
|
3085
3420
|
);
|
|
3086
3421
|
manager.incRef(body);
|
|
3087
|
-
|
|
3422
|
+
insertMacro(symbol.text, { domain: bound.varSorts, range, body });
|
|
3088
3423
|
defineMacroFunc(symbol.text, bound.varSorts, body);
|
|
3424
|
+
expectEnd(
|
|
3425
|
+
extra,
|
|
3426
|
+
isConst
|
|
3427
|
+
? "invalid constant definition, ')' expected"
|
|
3428
|
+
: "invalid function/constant definition, ')' expected",
|
|
3429
|
+
);
|
|
3089
3430
|
shrinkRefs(exprStack, 0);
|
|
3090
3431
|
return;
|
|
3091
3432
|
}
|
|
3092
|
-
const domain = name === "declare-fun" ? parseDomain(list.items[2]
|
|
3433
|
+
const domain = name === "declare-fun" ? parseDomain(list.items[2] ?? list.end) : [];
|
|
3093
3434
|
const range = parseSort(
|
|
3094
3435
|
list.items[name === "declare-fun" ? 3 : 2] ?? list.end,
|
|
3095
3436
|
name === "declare-fun" ? "Invalid function declaration" : "Invalid constant declaration",
|
|
@@ -3101,45 +3442,60 @@ export const createSmtlibReader = (
|
|
|
3101
3442
|
for (const domainVar of vars) manager.decRef(domainVar);
|
|
3102
3443
|
}
|
|
3103
3444
|
const decl = manager.mkFuncDecl(symbol.text, domain, range);
|
|
3104
|
-
|
|
3445
|
+
const extra = list.items[name === "declare-fun" ? 4 : 3];
|
|
3446
|
+
checkDecl(decl, extra ?? list.end);
|
|
3105
3447
|
if (macros.has(symbol.text))
|
|
3106
3448
|
throw new SmtUnsupportedError(`the overloaded symbol ${symbol.text}`);
|
|
3107
3449
|
const existing = funcs.get(symbol.text) ?? [];
|
|
3108
3450
|
if (existing.some((other) => hasSignature(other, domain, range)))
|
|
3109
3451
|
throw new SmtParseError(
|
|
3110
3452
|
`invalid declaration, ${domain.length === 0 ? "constant" : "function"} '${symbol.text}' (with the given signature) already declared`,
|
|
3111
|
-
list.end,
|
|
3453
|
+
extra ?? list.end,
|
|
3112
3454
|
);
|
|
3113
3455
|
declare(funcs, symbol.text, [...existing, decl]);
|
|
3456
|
+
expectEnd(
|
|
3457
|
+
extra,
|
|
3458
|
+
name === "declare-fun"
|
|
3459
|
+
? "invalid function declaration, ')' expected"
|
|
3460
|
+
: "invalid constant declaration, ')' expected",
|
|
3461
|
+
);
|
|
3114
3462
|
};
|
|
3115
3463
|
|
|
3116
|
-
// The caller takes the reference
|
|
3117
|
-
const parseFormula = (
|
|
3464
|
+
// The caller takes the stack's reference. Z3 reports a non-Boolean term at the token after it.
|
|
3465
|
+
const parseFormula = (
|
|
3466
|
+
sexpr: SExpr,
|
|
3467
|
+
follower: SmtPosition,
|
|
3468
|
+
message = "invalid assert command, term is not Boolean",
|
|
3469
|
+
) => {
|
|
3118
3470
|
runTerm(sexpr, false);
|
|
3119
3471
|
const assertion = exprStack[exprStack.length - 1];
|
|
3120
|
-
if (manager.sorts[assertion] !== SORT_BOOL)
|
|
3121
|
-
throw new SmtParseError("invalid assert command, term is not Boolean", sexpr);
|
|
3472
|
+
if (manager.sorts[assertion] !== SORT_BOOL) throw new SmtParseError(message, follower);
|
|
3122
3473
|
exprStack.pop();
|
|
3123
3474
|
return assertion;
|
|
3124
3475
|
};
|
|
3125
3476
|
|
|
3126
3477
|
// An assertion is named when the last name of its term is its own.
|
|
3127
|
-
const parseAssertion = (sexpr: SExpr) => {
|
|
3478
|
+
const parseAssertion = (sexpr: SExpr, follower: SmtPosition) => {
|
|
3128
3479
|
releasePending();
|
|
3129
3480
|
lastNamed.expr = -1;
|
|
3130
|
-
const formula = parseFormula(sexpr);
|
|
3481
|
+
const formula = parseFormula(sexpr, follower);
|
|
3131
3482
|
return { formula, name: lastNamed.expr === formula ? lastNamed.name : undefined };
|
|
3132
3483
|
};
|
|
3133
3484
|
|
|
3134
3485
|
const push = () => {
|
|
3135
3486
|
releasePending();
|
|
3136
3487
|
scopeStarts.push(undo.length);
|
|
3488
|
+
scopedFuncStarts.push(scopedFuncs.length);
|
|
3137
3489
|
};
|
|
3138
3490
|
|
|
3139
|
-
const pop = () => {
|
|
3491
|
+
const pop = (count: number) => {
|
|
3140
3492
|
releasePending();
|
|
3141
|
-
const
|
|
3493
|
+
const funcStart = scopedFuncStarts.splice(scopedFuncStarts.length - count)[0];
|
|
3494
|
+
for (const decl of scopedFuncs.splice(funcStart)) manager.eraseRecFunDef(decl);
|
|
3495
|
+
const start = scopeStarts.splice(scopeStarts.length - count)[0];
|
|
3142
3496
|
for (const restore of undo.splice(start).reverse()) restore();
|
|
3497
|
+
// cmd_context::pop resets the plugin through its datatype handler.
|
|
3498
|
+
resetDatatypePlugin(manager);
|
|
3143
3499
|
};
|
|
3144
3500
|
|
|
3145
3501
|
// parser::reset, after an error: Z3 frees its stacks, and with them the terms that only the
|
|
@@ -3202,7 +3558,7 @@ export const createSmtlibReader = (
|
|
|
3202
3558
|
getFuncs: (name: string) => funcs.get(name) ?? [],
|
|
3203
3559
|
hasDefinitions,
|
|
3204
3560
|
parseTerm,
|
|
3205
|
-
parseSort: (sexpr: SExpr) => parseSort(sexpr,
|
|
3561
|
+
parseSort: (sexpr: SExpr, context: string) => parseSort(sexpr, context),
|
|
3206
3562
|
parseFormula,
|
|
3207
3563
|
parseAssertion,
|
|
3208
3564
|
getLogicError: logicChecker.checkExpr,
|
|
@@ -3210,9 +3566,15 @@ export const createSmtlibReader = (
|
|
|
3210
3566
|
pop,
|
|
3211
3567
|
reset,
|
|
3212
3568
|
restrictSorts,
|
|
3569
|
+
registerList,
|
|
3213
3570
|
isUsed,
|
|
3214
3571
|
isClashing,
|
|
3215
3572
|
getDeclaredFuncs,
|
|
3573
|
+
getConstantMacros: () =>
|
|
3574
|
+
[...macroDictionary.values()].flatMap((name) => {
|
|
3575
|
+
const macro = macros.get(name);
|
|
3576
|
+
return macro?.domain.length === 0 ? [{ name, body: macro.body }] : [];
|
|
3577
|
+
}),
|
|
3216
3578
|
};
|
|
3217
3579
|
};
|
|
3218
3580
|
|
|
@@ -3273,7 +3635,10 @@ export const parseSmtlib = (
|
|
|
3273
3635
|
state.reader.declareCommand(list);
|
|
3274
3636
|
} else if (name === "assert") {
|
|
3275
3637
|
state.isInUse = true;
|
|
3276
|
-
const assertion = state.reader.parseFormula(
|
|
3638
|
+
const assertion = state.reader.parseFormula(
|
|
3639
|
+
list.items[1] ?? list.end,
|
|
3640
|
+
list.items[2] ?? list.end,
|
|
3641
|
+
);
|
|
3277
3642
|
const logicError = state.reader.getLogicError(assertion);
|
|
3278
3643
|
if (logicError !== undefined) {
|
|
3279
3644
|
manager.decRef(assertion);
|
|
@@ -3286,7 +3651,7 @@ export const parseSmtlib = (
|
|
|
3286
3651
|
};
|
|
3287
3652
|
for (;;) {
|
|
3288
3653
|
try {
|
|
3289
|
-
const list = commands.
|
|
3654
|
+
const list = commands.readCommand();
|
|
3290
3655
|
if (list === undefined) return { assertions, hasCheckSat: false, rlimit: state.rlimit };
|
|
3291
3656
|
if (isSymbol(list.items[0], "check-sat"))
|
|
3292
3657
|
return { assertions, hasCheckSat: true, rlimit: state.rlimit };
|