Branch data Line data Source code
1 : : /******************************************************************************
2 : : * This file is part of the cvc5 project.
3 : : *
4 : : * Copyright (c) 2009-2026 by the authors listed in the file AUTHORS
5 : : * in the top-level source directory and their institutional affiliations.
6 : : * All rights reserved. See the file COPYING in the top-level source
7 : : * directory for licensing information.
8 : : * ****************************************************************************
9 : : *
10 : : * The cvc5 C++ API.
11 : : *
12 : : * A brief note on how to guard API functions:
13 : : *
14 : : * In general, we think of API guards as a fence -- they are supposed to make
15 : : * sure that no invalid arguments get passed into internal realms of cvc5.
16 : : * Thus we always want to catch such cases on the API level (and can then
17 : : * assert internally that no invalid argument is passed in).
18 : : *
19 : : * The only special case is when we use 3rd party back-ends we have no control
20 : : * over, and which throw (invalid_argument) exceptions anyways. In this case,
21 : : * we do not replicate argument checks but delegate them to the back-end,
22 : : * catch thrown exceptions, and raise a CVC5ApiException.
23 : : *
24 : : * Our Integer implementation, e.g., is such a special case since we support
25 : : * two different back end implementations (GMP, CLN). Be aware that they do
26 : : * not fully agree on what is (in)valid input, which requires extra checks for
27 : : * consistent behavior (see Solver::mkRealOrIntegerFromStrHelper for example).
28 : : */
29 : :
30 : : #include <cvc5/cvc5.h>
31 : :
32 : : #include <cstring>
33 : : #include <sstream>
34 : :
35 : : #include "api/cpp/cvc5_checks.h"
36 : : #include "base/check.h"
37 : : #include "base/configuration.h"
38 : : #include "expr/array_store_all.h"
39 : : #include "expr/ascription_type.h"
40 : : #include "expr/cardinality_constraint.h"
41 : : #include "expr/dtype.h"
42 : : #include "expr/dtype_cons.h"
43 : : #include "expr/dtype_selector.h"
44 : : #include "expr/emptybag.h"
45 : : #include "expr/emptyset.h"
46 : : #include "expr/kind.h"
47 : : #include "expr/metakind.h"
48 : : #include "expr/node.h"
49 : : #include "expr/node_algorithm.h"
50 : : #include "expr/node_builder.h"
51 : : #include "expr/node_manager.h"
52 : : #include "expr/plugin.h"
53 : : #include "expr/sequence.h"
54 : : #include "expr/skolem_manager.h"
55 : : #include "expr/sygus_grammar.h"
56 : : #include "expr/type_node.h"
57 : : #include "options/base_options.h"
58 : : #include "options/expr_options.h"
59 : : #include "options/main_options.h"
60 : : #include "options/options.h"
61 : : #include "options/options_public.h"
62 : : #include "options/quantifiers_options.h"
63 : : #include "options/smt_options.h"
64 : : #include "proof/proof_node.h"
65 : : #include "proof/unsat_core.h"
66 : : #include "smt/env.h"
67 : : #include "smt/model.h"
68 : : #include "smt/smt_mode.h"
69 : : #include "smt/solver_engine.h"
70 : : #include "theory/arith/nl/poly_conversion.h"
71 : : #include "theory/datatypes/project_op.h"
72 : : #include "theory/logic_info.h"
73 : : #include "theory/theory_model.h"
74 : : #include "util/bitvector.h"
75 : : #include "util/divisible.h"
76 : : #include "util/finite_field_value.h"
77 : : #include "util/floatingpoint.h"
78 : : #include "util/iand.h"
79 : : #include "util/random.h"
80 : : #include "util/regexp.h"
81 : : #include "util/result.h"
82 : : #include "util/roundingmode.h"
83 : : #include "util/statistics_registry.h"
84 : : #include "util/statistics_stats.h"
85 : : #include "util/statistics_value.h"
86 : : #include "util/string.h"
87 : : #include "util/synth_result.h"
88 : : #include "util/uninterpreted_sort_value.h"
89 : : #include "util/utility.h"
90 : :
91 : : namespace cvc5 {
92 : :
93 : : /* -------------------------------------------------------------------------- */
94 : : /* APIStatistics */
95 : : /* -------------------------------------------------------------------------- */
96 : :
97 : : struct APIStatistics
98 : : {
99 : : internal::HistogramStat<internal::TypeConstant> d_consts;
100 : : internal::HistogramStat<internal::TypeConstant> d_vars;
101 : : internal::HistogramStat<Kind> d_terms;
102 : : };
103 : :
104 : : /* -------------------------------------------------------------------------- */
105 : : /* Kind */
106 : : /* -------------------------------------------------------------------------- */
107 : :
108 : : #define KIND_ENUM(external_name, internal_name) \
109 : : {external_name, \
110 : : std::make_pair(internal_name, std::string(#external_name).substr(6))}
111 : :
112 : : /* Mapping from external (API) kind to internal kind. */
113 : : const static std::unordered_map<Kind, std::pair<internal::Kind, std::string>>
114 : : s_kinds{
115 : : KIND_ENUM(Kind::INTERNAL_KIND, internal::Kind::UNDEFINED_KIND),
116 : : KIND_ENUM(Kind::UNDEFINED_KIND, internal::Kind::UNDEFINED_KIND),
117 : : KIND_ENUM(Kind::NULL_TERM, internal::Kind::NULL_EXPR),
118 : : /* Builtin ---------------------------------------------------------- */
119 : : KIND_ENUM(Kind::UNINTERPRETED_SORT_VALUE,
120 : : internal::Kind::UNINTERPRETED_SORT_VALUE),
121 : : KIND_ENUM(Kind::EQUAL, internal::Kind::EQUAL),
122 : : KIND_ENUM(Kind::DISTINCT, internal::Kind::DISTINCT),
123 : : KIND_ENUM(Kind::CONSTANT, internal::Kind::VARIABLE),
124 : : KIND_ENUM(Kind::VARIABLE, internal::Kind::BOUND_VARIABLE),
125 : : KIND_ENUM(Kind::SKOLEM, internal::Kind::SKOLEM),
126 : : KIND_ENUM(Kind::SEXPR, internal::Kind::SEXPR),
127 : : KIND_ENUM(Kind::LAMBDA, internal::Kind::LAMBDA),
128 : : KIND_ENUM(Kind::WITNESS, internal::Kind::WITNESS),
129 : : /* Boolean ---------------------------------------------------------- */
130 : : KIND_ENUM(Kind::CONST_BOOLEAN, internal::Kind::CONST_BOOLEAN),
131 : : KIND_ENUM(Kind::NOT, internal::Kind::NOT),
132 : : KIND_ENUM(Kind::AND, internal::Kind::AND),
133 : : KIND_ENUM(Kind::IMPLIES, internal::Kind::IMPLIES),
134 : : KIND_ENUM(Kind::OR, internal::Kind::OR),
135 : : KIND_ENUM(Kind::XOR, internal::Kind::XOR),
136 : : KIND_ENUM(Kind::ITE, internal::Kind::ITE),
137 : : /* UF --------------------------------------------------------------- */
138 : : KIND_ENUM(Kind::APPLY_UF, internal::Kind::APPLY_UF),
139 : : KIND_ENUM(Kind::CARDINALITY_CONSTRAINT,
140 : : internal::Kind::CARDINALITY_CONSTRAINT),
141 : : KIND_ENUM(Kind::HO_APPLY, internal::Kind::HO_APPLY),
142 : : /* Arithmetic ------------------------------------------------------- */
143 : : KIND_ENUM(Kind::ADD, internal::Kind::ADD),
144 : : KIND_ENUM(Kind::MULT, internal::Kind::MULT),
145 : : KIND_ENUM(Kind::IAND, internal::Kind::IAND),
146 : : KIND_ENUM(Kind::PIAND, internal::Kind::PIAND),
147 : : KIND_ENUM(Kind::POW2, internal::Kind::POW2),
148 : : KIND_ENUM(Kind::LOG2, internal::Kind::INTS_LOG2),
149 : : KIND_ENUM(Kind::SUB, internal::Kind::SUB),
150 : : KIND_ENUM(Kind::NEG, internal::Kind::NEG),
151 : : KIND_ENUM(Kind::DIVISION, internal::Kind::DIVISION),
152 : : KIND_ENUM(Kind::DIVISION_TOTAL, internal::Kind::DIVISION_TOTAL),
153 : : KIND_ENUM(Kind::INTS_DIVISION, internal::Kind::INTS_DIVISION),
154 : : KIND_ENUM(Kind::INTS_DIVISION_TOTAL,
155 : : internal::Kind::INTS_DIVISION_TOTAL),
156 : : KIND_ENUM(Kind::INTS_MODULUS, internal::Kind::INTS_MODULUS),
157 : : KIND_ENUM(Kind::INTS_MODULUS_TOTAL, internal::Kind::INTS_MODULUS_TOTAL),
158 : : KIND_ENUM(Kind::ABS, internal::Kind::ABS),
159 : : KIND_ENUM(Kind::DIVISIBLE, internal::Kind::DIVISIBLE),
160 : : KIND_ENUM(Kind::POW, internal::Kind::POW),
161 : : KIND_ENUM(Kind::EXPONENTIAL, internal::Kind::EXPONENTIAL),
162 : : KIND_ENUM(Kind::SINE, internal::Kind::SINE),
163 : : KIND_ENUM(Kind::COSINE, internal::Kind::COSINE),
164 : : KIND_ENUM(Kind::TANGENT, internal::Kind::TANGENT),
165 : : KIND_ENUM(Kind::COSECANT, internal::Kind::COSECANT),
166 : : KIND_ENUM(Kind::SECANT, internal::Kind::SECANT),
167 : : KIND_ENUM(Kind::COTANGENT, internal::Kind::COTANGENT),
168 : : KIND_ENUM(Kind::ARCSINE, internal::Kind::ARCSINE),
169 : : KIND_ENUM(Kind::ARCCOSINE, internal::Kind::ARCCOSINE),
170 : : KIND_ENUM(Kind::ARCTANGENT, internal::Kind::ARCTANGENT),
171 : : KIND_ENUM(Kind::ARCCOSECANT, internal::Kind::ARCCOSECANT),
172 : : KIND_ENUM(Kind::ARCSECANT, internal::Kind::ARCSECANT),
173 : : KIND_ENUM(Kind::ARCCOTANGENT, internal::Kind::ARCCOTANGENT),
174 : : KIND_ENUM(Kind::SQRT, internal::Kind::SQRT),
175 : : KIND_ENUM(Kind::CONST_RATIONAL, internal::Kind::CONST_RATIONAL),
176 : : KIND_ENUM(Kind::CONST_INTEGER, internal::Kind::CONST_INTEGER),
177 : : KIND_ENUM(Kind::LT, internal::Kind::LT),
178 : : KIND_ENUM(Kind::LEQ, internal::Kind::LEQ),
179 : : KIND_ENUM(Kind::GT, internal::Kind::GT),
180 : : KIND_ENUM(Kind::GEQ, internal::Kind::GEQ),
181 : : KIND_ENUM(Kind::IS_INTEGER, internal::Kind::IS_INTEGER),
182 : : KIND_ENUM(Kind::TO_INTEGER, internal::Kind::TO_INTEGER),
183 : : KIND_ENUM(Kind::TO_REAL, internal::Kind::TO_REAL),
184 : : KIND_ENUM(Kind::PI, internal::Kind::PI),
185 : : /* BV --------------------------------------------------------------- */
186 : : KIND_ENUM(Kind::CONST_BITVECTOR, internal::Kind::CONST_BITVECTOR),
187 : : KIND_ENUM(Kind::BITVECTOR_CONCAT, internal::Kind::BITVECTOR_CONCAT),
188 : : KIND_ENUM(Kind::BITVECTOR_AND, internal::Kind::BITVECTOR_AND),
189 : : KIND_ENUM(Kind::BITVECTOR_OR, internal::Kind::BITVECTOR_OR),
190 : : KIND_ENUM(Kind::BITVECTOR_XOR, internal::Kind::BITVECTOR_XOR),
191 : : KIND_ENUM(Kind::BITVECTOR_NOT, internal::Kind::BITVECTOR_NOT),
192 : : KIND_ENUM(Kind::BITVECTOR_NAND, internal::Kind::BITVECTOR_NAND),
193 : : KIND_ENUM(Kind::BITVECTOR_NOR, internal::Kind::BITVECTOR_NOR),
194 : : KIND_ENUM(Kind::BITVECTOR_XNOR, internal::Kind::BITVECTOR_XNOR),
195 : : KIND_ENUM(Kind::BITVECTOR_COMP, internal::Kind::BITVECTOR_COMP),
196 : : KIND_ENUM(Kind::BITVECTOR_MULT, internal::Kind::BITVECTOR_MULT),
197 : : KIND_ENUM(Kind::BITVECTOR_ADD, internal::Kind::BITVECTOR_ADD),
198 : : KIND_ENUM(Kind::BITVECTOR_SUB, internal::Kind::BITVECTOR_SUB),
199 : : KIND_ENUM(Kind::BITVECTOR_NEG, internal::Kind::BITVECTOR_NEG),
200 : : KIND_ENUM(Kind::BITVECTOR_UDIV, internal::Kind::BITVECTOR_UDIV),
201 : : KIND_ENUM(Kind::BITVECTOR_UREM, internal::Kind::BITVECTOR_UREM),
202 : : KIND_ENUM(Kind::BITVECTOR_SDIV, internal::Kind::BITVECTOR_SDIV),
203 : : KIND_ENUM(Kind::BITVECTOR_SREM, internal::Kind::BITVECTOR_SREM),
204 : : KIND_ENUM(Kind::BITVECTOR_SMOD, internal::Kind::BITVECTOR_SMOD),
205 : : KIND_ENUM(Kind::BITVECTOR_SHL, internal::Kind::BITVECTOR_SHL),
206 : : KIND_ENUM(Kind::BITVECTOR_LSHR, internal::Kind::BITVECTOR_LSHR),
207 : : KIND_ENUM(Kind::BITVECTOR_ASHR, internal::Kind::BITVECTOR_ASHR),
208 : : KIND_ENUM(Kind::BITVECTOR_ULT, internal::Kind::BITVECTOR_ULT),
209 : : KIND_ENUM(Kind::BITVECTOR_ULE, internal::Kind::BITVECTOR_ULE),
210 : : KIND_ENUM(Kind::BITVECTOR_UGT, internal::Kind::BITVECTOR_UGT),
211 : : KIND_ENUM(Kind::BITVECTOR_UGE, internal::Kind::BITVECTOR_UGE),
212 : : KIND_ENUM(Kind::BITVECTOR_SLT, internal::Kind::BITVECTOR_SLT),
213 : : KIND_ENUM(Kind::BITVECTOR_SLE, internal::Kind::BITVECTOR_SLE),
214 : : KIND_ENUM(Kind::BITVECTOR_SGT, internal::Kind::BITVECTOR_SGT),
215 : : KIND_ENUM(Kind::BITVECTOR_SGE, internal::Kind::BITVECTOR_SGE),
216 : : KIND_ENUM(Kind::BITVECTOR_ULTBV, internal::Kind::BITVECTOR_ULTBV),
217 : : KIND_ENUM(Kind::BITVECTOR_SLTBV, internal::Kind::BITVECTOR_SLTBV),
218 : : KIND_ENUM(Kind::BITVECTOR_NEGO, internal::Kind::BITVECTOR_NEGO),
219 : : KIND_ENUM(Kind::BITVECTOR_UADDO, internal::Kind::BITVECTOR_UADDO),
220 : : KIND_ENUM(Kind::BITVECTOR_SADDO, internal::Kind::BITVECTOR_SADDO),
221 : : KIND_ENUM(Kind::BITVECTOR_UMULO, internal::Kind::BITVECTOR_UMULO),
222 : : KIND_ENUM(Kind::BITVECTOR_SMULO, internal::Kind::BITVECTOR_SMULO),
223 : : KIND_ENUM(Kind::BITVECTOR_USUBO, internal::Kind::BITVECTOR_USUBO),
224 : : KIND_ENUM(Kind::BITVECTOR_SSUBO, internal::Kind::BITVECTOR_SSUBO),
225 : : KIND_ENUM(Kind::BITVECTOR_SDIVO, internal::Kind::BITVECTOR_SDIVO),
226 : : KIND_ENUM(Kind::BITVECTOR_ITE, internal::Kind::BITVECTOR_ITE),
227 : : KIND_ENUM(Kind::BITVECTOR_REDOR, internal::Kind::BITVECTOR_REDOR),
228 : : KIND_ENUM(Kind::BITVECTOR_REDAND, internal::Kind::BITVECTOR_REDAND),
229 : : KIND_ENUM(Kind::BITVECTOR_EXTRACT, internal::Kind::BITVECTOR_EXTRACT),
230 : : KIND_ENUM(Kind::BITVECTOR_REPEAT, internal::Kind::BITVECTOR_REPEAT),
231 : : KIND_ENUM(Kind::BITVECTOR_ZERO_EXTEND,
232 : : internal::Kind::BITVECTOR_ZERO_EXTEND),
233 : : KIND_ENUM(Kind::BITVECTOR_SIGN_EXTEND,
234 : : internal::Kind::BITVECTOR_SIGN_EXTEND),
235 : : KIND_ENUM(Kind::BITVECTOR_ROTATE_LEFT,
236 : : internal::Kind::BITVECTOR_ROTATE_LEFT),
237 : : KIND_ENUM(Kind::BITVECTOR_ROTATE_RIGHT,
238 : : internal::Kind::BITVECTOR_ROTATE_RIGHT),
239 : : KIND_ENUM(Kind::INT_TO_BITVECTOR, internal::Kind::INT_TO_BITVECTOR),
240 : : KIND_ENUM(Kind::BITVECTOR_UBV_TO_INT,
241 : : internal::Kind::BITVECTOR_UBV_TO_INT),
242 : : KIND_ENUM(Kind::BITVECTOR_SBV_TO_INT,
243 : : internal::Kind::BITVECTOR_SBV_TO_INT),
244 : : // note we silently change BITVECTOR_TO_NAT to BITVECTOR_UBV_TO_INT
245 : : KIND_ENUM(Kind::BITVECTOR_TO_NAT, internal::Kind::BITVECTOR_UBV_TO_INT),
246 : : KIND_ENUM(Kind::BITVECTOR_FROM_BOOLS,
247 : : internal::Kind::BITVECTOR_FROM_BOOLS),
248 : : KIND_ENUM(Kind::BITVECTOR_BIT, internal::Kind::BITVECTOR_BIT),
249 : : /* Finite Fields --------------------------------------------------- */
250 : : KIND_ENUM(Kind::CONST_FINITE_FIELD, internal::Kind::CONST_FINITE_FIELD),
251 : : KIND_ENUM(Kind::FINITE_FIELD_BITSUM,
252 : : internal::Kind::FINITE_FIELD_BITSUM),
253 : : KIND_ENUM(Kind::FINITE_FIELD_MULT, internal::Kind::FINITE_FIELD_MULT),
254 : : KIND_ENUM(Kind::FINITE_FIELD_ADD, internal::Kind::FINITE_FIELD_ADD),
255 : : KIND_ENUM(Kind::FINITE_FIELD_NEG, internal::Kind::FINITE_FIELD_NEG),
256 : : /* FP --------------------------------------------------------------- */
257 : : KIND_ENUM(Kind::CONST_FLOATINGPOINT,
258 : : internal::Kind::CONST_FLOATINGPOINT),
259 : : KIND_ENUM(Kind::CONST_ROUNDINGMODE, internal::Kind::CONST_ROUNDINGMODE),
260 : : KIND_ENUM(Kind::FLOATINGPOINT_FP, internal::Kind::FLOATINGPOINT_FP),
261 : : KIND_ENUM(Kind::FLOATINGPOINT_EQ, internal::Kind::FLOATINGPOINT_EQ),
262 : : KIND_ENUM(Kind::FLOATINGPOINT_ABS, internal::Kind::FLOATINGPOINT_ABS),
263 : : KIND_ENUM(Kind::FLOATINGPOINT_NEG, internal::Kind::FLOATINGPOINT_NEG),
264 : : KIND_ENUM(Kind::FLOATINGPOINT_ADD, internal::Kind::FLOATINGPOINT_ADD),
265 : : KIND_ENUM(Kind::FLOATINGPOINT_SUB, internal::Kind::FLOATINGPOINT_SUB),
266 : : KIND_ENUM(Kind::FLOATINGPOINT_MULT, internal::Kind::FLOATINGPOINT_MULT),
267 : : KIND_ENUM(Kind::FLOATINGPOINT_DIV, internal::Kind::FLOATINGPOINT_DIV),
268 : : KIND_ENUM(Kind::FLOATINGPOINT_FMA, internal::Kind::FLOATINGPOINT_FMA),
269 : : KIND_ENUM(Kind::FLOATINGPOINT_SQRT, internal::Kind::FLOATINGPOINT_SQRT),
270 : : KIND_ENUM(Kind::FLOATINGPOINT_REM, internal::Kind::FLOATINGPOINT_REM),
271 : : KIND_ENUM(Kind::FLOATINGPOINT_RTI, internal::Kind::FLOATINGPOINT_RTI),
272 : : KIND_ENUM(Kind::FLOATINGPOINT_MIN, internal::Kind::FLOATINGPOINT_MIN),
273 : : KIND_ENUM(Kind::FLOATINGPOINT_MAX, internal::Kind::FLOATINGPOINT_MAX),
274 : : KIND_ENUM(Kind::FLOATINGPOINT_LEQ, internal::Kind::FLOATINGPOINT_LEQ),
275 : : KIND_ENUM(Kind::FLOATINGPOINT_LT, internal::Kind::FLOATINGPOINT_LT),
276 : : KIND_ENUM(Kind::FLOATINGPOINT_GEQ, internal::Kind::FLOATINGPOINT_GEQ),
277 : : KIND_ENUM(Kind::FLOATINGPOINT_GT, internal::Kind::FLOATINGPOINT_GT),
278 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_NORMAL,
279 : : internal::Kind::FLOATINGPOINT_IS_NORMAL),
280 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_SUBNORMAL,
281 : : internal::Kind::FLOATINGPOINT_IS_SUBNORMAL),
282 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_ZERO,
283 : : internal::Kind::FLOATINGPOINT_IS_ZERO),
284 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_INF,
285 : : internal::Kind::FLOATINGPOINT_IS_INF),
286 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_NAN,
287 : : internal::Kind::FLOATINGPOINT_IS_NAN),
288 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_NEG,
289 : : internal::Kind::FLOATINGPOINT_IS_NEG),
290 : : KIND_ENUM(Kind::FLOATINGPOINT_IS_POS,
291 : : internal::Kind::FLOATINGPOINT_IS_POS),
292 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_FP_FROM_FP,
293 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP),
294 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
295 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV),
296 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
297 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL),
298 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
299 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV),
300 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_FP_FROM_UBV,
301 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV),
302 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_UBV,
303 : : internal::Kind::FLOATINGPOINT_TO_UBV),
304 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_SBV,
305 : : internal::Kind::FLOATINGPOINT_TO_SBV),
306 : : KIND_ENUM(Kind::FLOATINGPOINT_TO_REAL,
307 : : internal::Kind::FLOATINGPOINT_TO_REAL),
308 : : /* Arrays ----------------------------------------------------------- */
309 : : KIND_ENUM(Kind::SELECT, internal::Kind::SELECT),
310 : : KIND_ENUM(Kind::STORE, internal::Kind::STORE),
311 : : KIND_ENUM(Kind::CONST_ARRAY, internal::Kind::STORE_ALL),
312 : : KIND_ENUM(Kind::EQ_RANGE, internal::Kind::EQ_RANGE),
313 : : /* Datatypes -------------------------------------------------------- */
314 : : KIND_ENUM(Kind::APPLY_SELECTOR, internal::Kind::APPLY_SELECTOR),
315 : : KIND_ENUM(Kind::APPLY_CONSTRUCTOR, internal::Kind::APPLY_CONSTRUCTOR),
316 : : KIND_ENUM(Kind::APPLY_TESTER, internal::Kind::APPLY_TESTER),
317 : : KIND_ENUM(Kind::APPLY_UPDATER, internal::Kind::APPLY_UPDATER),
318 : : KIND_ENUM(Kind::MATCH, internal::Kind::MATCH),
319 : : KIND_ENUM(Kind::MATCH_CASE, internal::Kind::MATCH_CASE),
320 : : KIND_ENUM(Kind::MATCH_BIND_CASE, internal::Kind::MATCH_BIND_CASE),
321 : : KIND_ENUM(Kind::TUPLE_PROJECT, internal::Kind::TUPLE_PROJECT),
322 : : KIND_ENUM(Kind::NULLABLE_LIFT, internal::Kind::NULLABLE_LIFT),
323 : : /* Separation Logic ------------------------------------------------- */
324 : : KIND_ENUM(Kind::SEP_NIL, internal::Kind::SEP_NIL),
325 : : KIND_ENUM(Kind::SEP_EMP, internal::Kind::SEP_EMP),
326 : : KIND_ENUM(Kind::SEP_PTO, internal::Kind::SEP_PTO),
327 : : KIND_ENUM(Kind::SEP_STAR, internal::Kind::SEP_STAR),
328 : : KIND_ENUM(Kind::SEP_WAND, internal::Kind::SEP_WAND),
329 : : /* Sets ------------------------------------------------------------- */
330 : : KIND_ENUM(Kind::SET_EMPTY, internal::Kind::SET_EMPTY),
331 : : KIND_ENUM(Kind::SET_UNION, internal::Kind::SET_UNION),
332 : : KIND_ENUM(Kind::SET_INTER, internal::Kind::SET_INTER),
333 : : KIND_ENUM(Kind::SET_MINUS, internal::Kind::SET_MINUS),
334 : : KIND_ENUM(Kind::SET_SUBSET, internal::Kind::SET_SUBSET),
335 : : KIND_ENUM(Kind::SET_MEMBER, internal::Kind::SET_MEMBER),
336 : : KIND_ENUM(Kind::SET_SINGLETON, internal::Kind::SET_SINGLETON),
337 : : KIND_ENUM(Kind::SET_INSERT, internal::Kind::SET_INSERT),
338 : : KIND_ENUM(Kind::SET_CARD, internal::Kind::SET_CARD),
339 : : KIND_ENUM(Kind::SET_COMPLEMENT, internal::Kind::SET_COMPLEMENT),
340 : : KIND_ENUM(Kind::SET_UNIVERSE, internal::Kind::SET_UNIVERSE),
341 : : KIND_ENUM(Kind::SET_COMPREHENSION, internal::Kind::SET_COMPREHENSION),
342 : : KIND_ENUM(Kind::SET_CHOOSE, internal::Kind::SET_CHOOSE),
343 : : KIND_ENUM(Kind::SET_IS_EMPTY, internal::Kind::SET_IS_EMPTY),
344 : : KIND_ENUM(Kind::SET_IS_SINGLETON, internal::Kind::SET_IS_SINGLETON),
345 : : KIND_ENUM(Kind::SET_MAP, internal::Kind::SET_MAP),
346 : : KIND_ENUM(Kind::SET_FILTER, internal::Kind::SET_FILTER),
347 : : KIND_ENUM(Kind::SET_ALL, internal::Kind::SET_ALL),
348 : : KIND_ENUM(Kind::SET_SOME, internal::Kind::SET_SOME),
349 : : KIND_ENUM(Kind::SET_FOLD, internal::Kind::SET_FOLD),
350 : : /* Relations -------------------------------------------------------- */
351 : : KIND_ENUM(Kind::RELATION_JOIN, internal::Kind::RELATION_JOIN),
352 : : KIND_ENUM(Kind::RELATION_TABLE_JOIN,
353 : : internal::Kind::RELATION_TABLE_JOIN),
354 : : KIND_ENUM(Kind::RELATION_PRODUCT, internal::Kind::RELATION_PRODUCT),
355 : : KIND_ENUM(Kind::RELATION_TRANSPOSE, internal::Kind::RELATION_TRANSPOSE),
356 : : KIND_ENUM(Kind::RELATION_TCLOSURE, internal::Kind::RELATION_TCLOSURE),
357 : : KIND_ENUM(Kind::RELATION_JOIN_IMAGE,
358 : : internal::Kind::RELATION_JOIN_IMAGE),
359 : : KIND_ENUM(Kind::RELATION_IDEN, internal::Kind::RELATION_IDEN),
360 : : KIND_ENUM(Kind::RELATION_GROUP, internal::Kind::RELATION_GROUP),
361 : : KIND_ENUM(Kind::RELATION_AGGREGATE, internal::Kind::RELATION_AGGREGATE),
362 : : KIND_ENUM(Kind::RELATION_PROJECT, internal::Kind::RELATION_PROJECT),
363 : : /* Bags ------------------------------------------------------------- */
364 : : KIND_ENUM(Kind::BAG_UNION_MAX, internal::Kind::BAG_UNION_MAX),
365 : : KIND_ENUM(Kind::BAG_UNION_DISJOINT, internal::Kind::BAG_UNION_DISJOINT),
366 : : KIND_ENUM(Kind::BAG_INTER_MIN, internal::Kind::BAG_INTER_MIN),
367 : : KIND_ENUM(Kind::BAG_DIFFERENCE_SUBTRACT,
368 : : internal::Kind::BAG_DIFFERENCE_SUBTRACT),
369 : : KIND_ENUM(Kind::BAG_DIFFERENCE_REMOVE,
370 : : internal::Kind::BAG_DIFFERENCE_REMOVE),
371 : : KIND_ENUM(Kind::BAG_SUBBAG, internal::Kind::BAG_SUBBAG),
372 : : KIND_ENUM(Kind::BAG_COUNT, internal::Kind::BAG_COUNT),
373 : : KIND_ENUM(Kind::BAG_MEMBER, internal::Kind::BAG_MEMBER),
374 : : KIND_ENUM(Kind::BAG_SETOF, internal::Kind::BAG_SETOF),
375 : : KIND_ENUM(Kind::BAG_MAKE, internal::Kind::BAG_MAKE),
376 : : KIND_ENUM(Kind::BAG_EMPTY, internal::Kind::BAG_EMPTY),
377 : : KIND_ENUM(Kind::BAG_CARD, internal::Kind::BAG_CARD),
378 : : KIND_ENUM(Kind::BAG_CHOOSE, internal::Kind::BAG_CHOOSE),
379 : : KIND_ENUM(Kind::BAG_MAP, internal::Kind::BAG_MAP),
380 : : KIND_ENUM(Kind::BAG_FILTER, internal::Kind::BAG_FILTER),
381 : : KIND_ENUM(Kind::BAG_ALL, internal::Kind::BAG_ALL),
382 : : KIND_ENUM(Kind::BAG_SOME, internal::Kind::BAG_SOME),
383 : : KIND_ENUM(Kind::BAG_FOLD, internal::Kind::BAG_FOLD),
384 : : KIND_ENUM(Kind::BAG_PARTITION, internal::Kind::BAG_PARTITION),
385 : : KIND_ENUM(Kind::TABLE_PRODUCT, internal::Kind::TABLE_PRODUCT),
386 : : KIND_ENUM(Kind::TABLE_PROJECT, internal::Kind::TABLE_PROJECT),
387 : : KIND_ENUM(Kind::TABLE_AGGREGATE, internal::Kind::TABLE_AGGREGATE),
388 : : KIND_ENUM(Kind::TABLE_JOIN, internal::Kind::TABLE_JOIN),
389 : : KIND_ENUM(Kind::TABLE_GROUP, internal::Kind::TABLE_GROUP),
390 : : /* Strings ---------------------------------------------------------- */
391 : : KIND_ENUM(Kind::STRING_CONCAT, internal::Kind::STRING_CONCAT),
392 : : KIND_ENUM(Kind::STRING_IN_REGEXP, internal::Kind::STRING_IN_REGEXP),
393 : : KIND_ENUM(Kind::STRING_LENGTH, internal::Kind::STRING_LENGTH),
394 : : KIND_ENUM(Kind::STRING_SUBSTR, internal::Kind::STRING_SUBSTR),
395 : : KIND_ENUM(Kind::STRING_UPDATE, internal::Kind::STRING_UPDATE),
396 : : KIND_ENUM(Kind::STRING_CHARAT, internal::Kind::STRING_CHARAT),
397 : : KIND_ENUM(Kind::STRING_CONTAINS, internal::Kind::STRING_CONTAINS),
398 : : KIND_ENUM(Kind::STRING_INDEXOF, internal::Kind::STRING_INDEXOF),
399 : : KIND_ENUM(Kind::STRING_INDEXOF_RE, internal::Kind::STRING_INDEXOF_RE),
400 : : KIND_ENUM(Kind::STRING_REPLACE, internal::Kind::STRING_REPLACE),
401 : : KIND_ENUM(Kind::STRING_REPLACE_ALL, internal::Kind::STRING_REPLACE_ALL),
402 : : KIND_ENUM(Kind::STRING_REPLACE_RE, internal::Kind::STRING_REPLACE_RE),
403 : : KIND_ENUM(Kind::STRING_REPLACE_RE_ALL,
404 : : internal::Kind::STRING_REPLACE_RE_ALL),
405 : : KIND_ENUM(Kind::STRING_TO_LOWER, internal::Kind::STRING_TO_LOWER),
406 : : KIND_ENUM(Kind::STRING_TO_UPPER, internal::Kind::STRING_TO_UPPER),
407 : : KIND_ENUM(Kind::STRING_REV, internal::Kind::STRING_REV),
408 : : KIND_ENUM(Kind::STRING_FROM_CODE, internal::Kind::STRING_FROM_CODE),
409 : : KIND_ENUM(Kind::STRING_TO_CODE, internal::Kind::STRING_TO_CODE),
410 : : KIND_ENUM(Kind::STRING_LT, internal::Kind::STRING_LT),
411 : : KIND_ENUM(Kind::STRING_LEQ, internal::Kind::STRING_LEQ),
412 : : KIND_ENUM(Kind::STRING_PREFIX, internal::Kind::STRING_PREFIX),
413 : : KIND_ENUM(Kind::STRING_SUFFIX, internal::Kind::STRING_SUFFIX),
414 : : KIND_ENUM(Kind::STRING_IS_DIGIT, internal::Kind::STRING_IS_DIGIT),
415 : : KIND_ENUM(Kind::STRING_FROM_INT, internal::Kind::STRING_ITOS),
416 : : KIND_ENUM(Kind::STRING_TO_INT, internal::Kind::STRING_STOI),
417 : : KIND_ENUM(Kind::CONST_STRING, internal::Kind::CONST_STRING),
418 : : KIND_ENUM(Kind::STRING_TO_REGEXP, internal::Kind::STRING_TO_REGEXP),
419 : : KIND_ENUM(Kind::REGEXP_CONCAT, internal::Kind::REGEXP_CONCAT),
420 : : KIND_ENUM(Kind::REGEXP_UNION, internal::Kind::REGEXP_UNION),
421 : : KIND_ENUM(Kind::REGEXP_INTER, internal::Kind::REGEXP_INTER),
422 : : KIND_ENUM(Kind::REGEXP_DIFF, internal::Kind::REGEXP_DIFF),
423 : : KIND_ENUM(Kind::REGEXP_STAR, internal::Kind::REGEXP_STAR),
424 : : KIND_ENUM(Kind::REGEXP_PLUS, internal::Kind::REGEXP_PLUS),
425 : : KIND_ENUM(Kind::REGEXP_OPT, internal::Kind::REGEXP_OPT),
426 : : KIND_ENUM(Kind::REGEXP_RANGE, internal::Kind::REGEXP_RANGE),
427 : : KIND_ENUM(Kind::REGEXP_REPEAT, internal::Kind::REGEXP_REPEAT),
428 : : KIND_ENUM(Kind::REGEXP_LOOP, internal::Kind::REGEXP_LOOP),
429 : : KIND_ENUM(Kind::REGEXP_NONE, internal::Kind::REGEXP_NONE),
430 : : KIND_ENUM(Kind::REGEXP_ALL, internal::Kind::REGEXP_ALL),
431 : : KIND_ENUM(Kind::REGEXP_ALLCHAR, internal::Kind::REGEXP_ALLCHAR),
432 : : KIND_ENUM(Kind::REGEXP_COMPLEMENT, internal::Kind::REGEXP_COMPLEMENT),
433 : : // maps to the same kind as the string versions
434 : : KIND_ENUM(Kind::SEQ_CONCAT, internal::Kind::STRING_CONCAT),
435 : : KIND_ENUM(Kind::SEQ_LENGTH, internal::Kind::STRING_LENGTH),
436 : : KIND_ENUM(Kind::SEQ_EXTRACT, internal::Kind::STRING_SUBSTR),
437 : : KIND_ENUM(Kind::SEQ_UPDATE, internal::Kind::STRING_UPDATE),
438 : : KIND_ENUM(Kind::SEQ_AT, internal::Kind::STRING_CHARAT),
439 : : KIND_ENUM(Kind::SEQ_CONTAINS, internal::Kind::STRING_CONTAINS),
440 : : KIND_ENUM(Kind::SEQ_INDEXOF, internal::Kind::STRING_INDEXOF),
441 : : KIND_ENUM(Kind::SEQ_REPLACE, internal::Kind::STRING_REPLACE),
442 : : KIND_ENUM(Kind::SEQ_REPLACE_ALL, internal::Kind::STRING_REPLACE_ALL),
443 : : KIND_ENUM(Kind::SEQ_REV, internal::Kind::STRING_REV),
444 : : KIND_ENUM(Kind::SEQ_PREFIX, internal::Kind::STRING_PREFIX),
445 : : KIND_ENUM(Kind::SEQ_SUFFIX, internal::Kind::STRING_SUFFIX),
446 : : KIND_ENUM(Kind::CONST_SEQUENCE, internal::Kind::CONST_SEQUENCE),
447 : : KIND_ENUM(Kind::SEQ_UNIT, internal::Kind::SEQ_UNIT),
448 : : KIND_ENUM(Kind::SEQ_NTH, internal::Kind::SEQ_NTH),
449 : : /* Quantifiers ------------------------------------------------------ */
450 : : KIND_ENUM(Kind::FORALL, internal::Kind::FORALL),
451 : : KIND_ENUM(Kind::EXISTS, internal::Kind::EXISTS),
452 : : KIND_ENUM(Kind::VARIABLE_LIST, internal::Kind::BOUND_VAR_LIST),
453 : : KIND_ENUM(Kind::INST_PATTERN, internal::Kind::INST_PATTERN),
454 : : KIND_ENUM(Kind::INST_NO_PATTERN, internal::Kind::INST_NO_PATTERN),
455 : : KIND_ENUM(Kind::INST_POOL, internal::Kind::INST_POOL),
456 : : KIND_ENUM(Kind::INST_ADD_TO_POOL, internal::Kind::INST_ADD_TO_POOL),
457 : : KIND_ENUM(Kind::SKOLEM_ADD_TO_POOL, internal::Kind::SKOLEM_ADD_TO_POOL),
458 : : KIND_ENUM(Kind::INST_ATTRIBUTE, internal::Kind::INST_ATTRIBUTE),
459 : : KIND_ENUM(Kind::INST_PATTERN_LIST, internal::Kind::INST_PATTERN_LIST),
460 : : KIND_ENUM(Kind::LAST_KIND, internal::Kind::LAST_KIND),
461 : : };
462 : :
463 : : /* -------------------------------------------------------------------------- */
464 : : /* SortKind */
465 : : /* -------------------------------------------------------------------------- */
466 : :
467 : : #define SORT_KIND_ENUM(external_name, internal_name) \
468 : : {external_name, \
469 : : std::make_pair(internal_name, std::string(#external_name).substr(10))}
470 : :
471 : : /* Mapping from external (API) kind to internal kind. */
472 : : const static std::unordered_map<SortKind,
473 : : std::pair<internal::Kind, std::string>>
474 : : s_sort_kinds{
475 : : SORT_KIND_ENUM(SortKind::INTERNAL_SORT_KIND,
476 : : internal::Kind::UNDEFINED_KIND),
477 : : SORT_KIND_ENUM(SortKind::UNDEFINED_SORT_KIND,
478 : : internal::Kind::UNDEFINED_KIND),
479 : : SORT_KIND_ENUM(SortKind::NULL_SORT, internal::Kind::NULL_EXPR),
480 : : /* Sorts ------------------------------------------------------------ */
481 : : // Note that many entries in this map (e.g. for type constants) are
482 : : // given only for completeness and are not used since we don't
483 : : // construct sorts based on SortKind.
484 : : SORT_KIND_ENUM(SortKind::ABSTRACT_SORT, internal::Kind::ABSTRACT_TYPE),
485 : : SORT_KIND_ENUM(SortKind::ARRAY_SORT, internal::Kind::ARRAY_TYPE),
486 : : SORT_KIND_ENUM(SortKind::BAG_SORT, internal::Kind::BAG_TYPE),
487 : : SORT_KIND_ENUM(SortKind::BITVECTOR_SORT,
488 : : internal::Kind::BITVECTOR_TYPE),
489 : : SORT_KIND_ENUM(SortKind::BOOLEAN_SORT, internal::Kind::TYPE_CONSTANT),
490 : : SORT_KIND_ENUM(SortKind::DATATYPE_SORT, internal::Kind::DATATYPE_TYPE),
491 : : SORT_KIND_ENUM(SortKind::FINITE_FIELD_SORT,
492 : : internal::Kind::FINITE_FIELD_TYPE),
493 : : SORT_KIND_ENUM(SortKind::FLOATINGPOINT_SORT,
494 : : internal::Kind::FLOATINGPOINT_TYPE),
495 : : SORT_KIND_ENUM(SortKind::FUNCTION_SORT, internal::Kind::FUNCTION_TYPE),
496 : : SORT_KIND_ENUM(SortKind::INTEGER_SORT, internal::Kind::TYPE_CONSTANT),
497 : : SORT_KIND_ENUM(SortKind::REAL_SORT, internal::Kind::TYPE_CONSTANT),
498 : : SORT_KIND_ENUM(SortKind::REGLAN_SORT, internal::Kind::TYPE_CONSTANT),
499 : : SORT_KIND_ENUM(SortKind::ROUNDINGMODE_SORT,
500 : : internal::Kind::TYPE_CONSTANT),
501 : : SORT_KIND_ENUM(SortKind::SEQUENCE_SORT, internal::Kind::SEQUENCE_TYPE),
502 : : SORT_KIND_ENUM(SortKind::SET_SORT, internal::Kind::SET_TYPE),
503 : : SORT_KIND_ENUM(SortKind::STRING_SORT, internal::Kind::TYPE_CONSTANT),
504 : : SORT_KIND_ENUM(SortKind::TUPLE_SORT, internal::Kind::TUPLE_TYPE),
505 : : SORT_KIND_ENUM(SortKind::NULLABLE_SORT, internal::Kind::NULLABLE_TYPE),
506 : : SORT_KIND_ENUM(SortKind::UNINTERPRETED_SORT, internal::Kind::SORT_TYPE),
507 : : SORT_KIND_ENUM(SortKind::LAST_SORT_KIND, internal::Kind::LAST_KIND),
508 : : };
509 : :
510 : : /* Mapping from internal kind to external (API) kind. */
511 : : const static std::unordered_map<internal::Kind,
512 : : Kind,
513 : : internal::kind::KindHashFunction>
514 : : s_kinds_internal{
515 : : {internal::Kind::UNDEFINED_KIND, Kind::UNDEFINED_KIND},
516 : : {internal::Kind::NULL_EXPR, Kind::NULL_TERM},
517 : : /* Builtin --------------------------------------------------------- */
518 : : {internal::Kind::UNINTERPRETED_SORT_VALUE,
519 : : Kind::UNINTERPRETED_SORT_VALUE},
520 : : {internal::Kind::EQUAL, Kind::EQUAL},
521 : : {internal::Kind::DISTINCT, Kind::DISTINCT},
522 : : {internal::Kind::VARIABLE, Kind::CONSTANT},
523 : : {internal::Kind::SKOLEM, Kind::SKOLEM},
524 : : {internal::Kind::BOUND_VARIABLE, Kind::VARIABLE},
525 : : {internal::Kind::SEXPR, Kind::SEXPR},
526 : : {internal::Kind::LAMBDA, Kind::LAMBDA},
527 : : {internal::Kind::WITNESS, Kind::WITNESS},
528 : : /* Boolean --------------------------------------------------------- */
529 : : {internal::Kind::CONST_BOOLEAN, Kind::CONST_BOOLEAN},
530 : : {internal::Kind::NOT, Kind::NOT},
531 : : {internal::Kind::AND, Kind::AND},
532 : : {internal::Kind::IMPLIES, Kind::IMPLIES},
533 : : {internal::Kind::OR, Kind::OR},
534 : : {internal::Kind::XOR, Kind::XOR},
535 : : {internal::Kind::ITE, Kind::ITE},
536 : : /* UF -------------------------------------------------------------- */
537 : : {internal::Kind::APPLY_UF, Kind::APPLY_UF},
538 : : {internal::Kind::CARDINALITY_CONSTRAINT, Kind::CARDINALITY_CONSTRAINT},
539 : : {internal::Kind::HO_APPLY, Kind::HO_APPLY},
540 : : /* Arithmetic ------------------------------------------------------ */
541 : : {internal::Kind::ADD, Kind::ADD},
542 : : {internal::Kind::MULT, Kind::MULT},
543 : : {internal::Kind::NONLINEAR_MULT, Kind::MULT},
544 : : {internal::Kind::IAND, Kind::IAND},
545 : : {internal::Kind::PIAND, Kind::PIAND},
546 : : {internal::Kind::POW2, Kind::POW2},
547 : : {internal::Kind::INTS_LOG2, Kind::LOG2},
548 : : {internal::Kind::SUB, Kind::SUB},
549 : : {internal::Kind::NEG, Kind::NEG},
550 : : {internal::Kind::DIVISION, Kind::DIVISION},
551 : : {internal::Kind::DIVISION_TOTAL, Kind::DIVISION_TOTAL},
552 : : {internal::Kind::INTS_DIVISION, Kind::INTS_DIVISION},
553 : : {internal::Kind::INTS_DIVISION_TOTAL, Kind::INTS_DIVISION_TOTAL},
554 : : {internal::Kind::INTS_MODULUS, Kind::INTS_MODULUS},
555 : : {internal::Kind::INTS_MODULUS_TOTAL, Kind::INTS_MODULUS_TOTAL},
556 : : {internal::Kind::ABS, Kind::ABS},
557 : : {internal::Kind::DIVISIBLE, Kind::DIVISIBLE},
558 : : {internal::Kind::POW, Kind::POW},
559 : : {internal::Kind::EXPONENTIAL, Kind::EXPONENTIAL},
560 : : {internal::Kind::SINE, Kind::SINE},
561 : : {internal::Kind::COSINE, Kind::COSINE},
562 : : {internal::Kind::TANGENT, Kind::TANGENT},
563 : : {internal::Kind::COSECANT, Kind::COSECANT},
564 : : {internal::Kind::SECANT, Kind::SECANT},
565 : : {internal::Kind::COTANGENT, Kind::COTANGENT},
566 : : {internal::Kind::ARCSINE, Kind::ARCSINE},
567 : : {internal::Kind::ARCCOSINE, Kind::ARCCOSINE},
568 : : {internal::Kind::ARCTANGENT, Kind::ARCTANGENT},
569 : : {internal::Kind::ARCCOSECANT, Kind::ARCCOSECANT},
570 : : {internal::Kind::ARCSECANT, Kind::ARCSECANT},
571 : : {internal::Kind::ARCCOTANGENT, Kind::ARCCOTANGENT},
572 : : {internal::Kind::SQRT, Kind::SQRT},
573 : : {internal::Kind::DIVISIBLE_OP, Kind::DIVISIBLE},
574 : : {internal::Kind::CONST_RATIONAL, Kind::CONST_RATIONAL},
575 : : {internal::Kind::CONST_INTEGER, Kind::CONST_INTEGER},
576 : : {internal::Kind::LT, Kind::LT},
577 : : {internal::Kind::LEQ, Kind::LEQ},
578 : : {internal::Kind::GT, Kind::GT},
579 : : {internal::Kind::GEQ, Kind::GEQ},
580 : : {internal::Kind::IS_INTEGER, Kind::IS_INTEGER},
581 : : {internal::Kind::TO_INTEGER, Kind::TO_INTEGER},
582 : : {internal::Kind::TO_REAL, Kind::TO_REAL},
583 : : {internal::Kind::PI, Kind::PI},
584 : : {internal::Kind::IAND_OP, Kind::IAND},
585 : : /* BV -------------------------------------------------------------- */
586 : : {internal::Kind::CONST_BITVECTOR, Kind::CONST_BITVECTOR},
587 : : {internal::Kind::BITVECTOR_CONCAT, Kind::BITVECTOR_CONCAT},
588 : : {internal::Kind::BITVECTOR_AND, Kind::BITVECTOR_AND},
589 : : {internal::Kind::BITVECTOR_OR, Kind::BITVECTOR_OR},
590 : : {internal::Kind::BITVECTOR_XOR, Kind::BITVECTOR_XOR},
591 : : {internal::Kind::BITVECTOR_NOT, Kind::BITVECTOR_NOT},
592 : : {internal::Kind::BITVECTOR_NAND, Kind::BITVECTOR_NAND},
593 : : {internal::Kind::BITVECTOR_NOR, Kind::BITVECTOR_NOR},
594 : : {internal::Kind::BITVECTOR_XNOR, Kind::BITVECTOR_XNOR},
595 : : {internal::Kind::BITVECTOR_COMP, Kind::BITVECTOR_COMP},
596 : : {internal::Kind::BITVECTOR_MULT, Kind::BITVECTOR_MULT},
597 : : {internal::Kind::BITVECTOR_ADD, Kind::BITVECTOR_ADD},
598 : : {internal::Kind::BITVECTOR_SUB, Kind::BITVECTOR_SUB},
599 : : {internal::Kind::BITVECTOR_NEG, Kind::BITVECTOR_NEG},
600 : : {internal::Kind::BITVECTOR_UDIV, Kind::BITVECTOR_UDIV},
601 : : {internal::Kind::BITVECTOR_UREM, Kind::BITVECTOR_UREM},
602 : : {internal::Kind::BITVECTOR_SDIV, Kind::BITVECTOR_SDIV},
603 : : {internal::Kind::BITVECTOR_SREM, Kind::BITVECTOR_SREM},
604 : : {internal::Kind::BITVECTOR_SMOD, Kind::BITVECTOR_SMOD},
605 : : {internal::Kind::BITVECTOR_SHL, Kind::BITVECTOR_SHL},
606 : : {internal::Kind::BITVECTOR_LSHR, Kind::BITVECTOR_LSHR},
607 : : {internal::Kind::BITVECTOR_ASHR, Kind::BITVECTOR_ASHR},
608 : : {internal::Kind::BITVECTOR_ULT, Kind::BITVECTOR_ULT},
609 : : {internal::Kind::BITVECTOR_ULE, Kind::BITVECTOR_ULE},
610 : : {internal::Kind::BITVECTOR_UGT, Kind::BITVECTOR_UGT},
611 : : {internal::Kind::BITVECTOR_UGE, Kind::BITVECTOR_UGE},
612 : : {internal::Kind::BITVECTOR_SLT, Kind::BITVECTOR_SLT},
613 : : {internal::Kind::BITVECTOR_SLE, Kind::BITVECTOR_SLE},
614 : : {internal::Kind::BITVECTOR_SGT, Kind::BITVECTOR_SGT},
615 : : {internal::Kind::BITVECTOR_SGE, Kind::BITVECTOR_SGE},
616 : : {internal::Kind::BITVECTOR_ULTBV, Kind::BITVECTOR_ULTBV},
617 : : {internal::Kind::BITVECTOR_SLTBV, Kind::BITVECTOR_SLTBV},
618 : : {internal::Kind::BITVECTOR_NEGO, Kind::BITVECTOR_NEGO},
619 : : {internal::Kind::BITVECTOR_UADDO, Kind::BITVECTOR_UADDO},
620 : : {internal::Kind::BITVECTOR_SADDO, Kind::BITVECTOR_SADDO},
621 : : {internal::Kind::BITVECTOR_UMULO, Kind::BITVECTOR_UMULO},
622 : : {internal::Kind::BITVECTOR_SMULO, Kind::BITVECTOR_SMULO},
623 : : {internal::Kind::BITVECTOR_USUBO, Kind::BITVECTOR_USUBO},
624 : : {internal::Kind::BITVECTOR_SSUBO, Kind::BITVECTOR_SSUBO},
625 : : {internal::Kind::BITVECTOR_SDIVO, Kind::BITVECTOR_SDIVO},
626 : : {internal::Kind::BITVECTOR_ITE, Kind::BITVECTOR_ITE},
627 : : {internal::Kind::BITVECTOR_REDOR, Kind::BITVECTOR_REDOR},
628 : : {internal::Kind::BITVECTOR_REDAND, Kind::BITVECTOR_REDAND},
629 : : {internal::Kind::BITVECTOR_BIT_OP, Kind::BITVECTOR_BIT},
630 : : {internal::Kind::BITVECTOR_EXTRACT_OP, Kind::BITVECTOR_EXTRACT},
631 : : {internal::Kind::BITVECTOR_REPEAT_OP, Kind::BITVECTOR_REPEAT},
632 : : {internal::Kind::BITVECTOR_ZERO_EXTEND_OP, Kind::BITVECTOR_ZERO_EXTEND},
633 : : {internal::Kind::BITVECTOR_SIGN_EXTEND_OP, Kind::BITVECTOR_SIGN_EXTEND},
634 : : {internal::Kind::BITVECTOR_ROTATE_LEFT_OP, Kind::BITVECTOR_ROTATE_LEFT},
635 : : {internal::Kind::BITVECTOR_ROTATE_RIGHT_OP,
636 : : Kind::BITVECTOR_ROTATE_RIGHT},
637 : : {internal::Kind::BITVECTOR_EXTRACT, Kind::BITVECTOR_EXTRACT},
638 : : {internal::Kind::BITVECTOR_REPEAT, Kind::BITVECTOR_REPEAT},
639 : : {internal::Kind::BITVECTOR_ZERO_EXTEND, Kind::BITVECTOR_ZERO_EXTEND},
640 : : {internal::Kind::BITVECTOR_SIGN_EXTEND, Kind::BITVECTOR_SIGN_EXTEND},
641 : : {internal::Kind::BITVECTOR_ROTATE_LEFT, Kind::BITVECTOR_ROTATE_LEFT},
642 : : {internal::Kind::BITVECTOR_ROTATE_RIGHT, Kind::BITVECTOR_ROTATE_RIGHT},
643 : : {internal::Kind::INT_TO_BITVECTOR_OP, Kind::INT_TO_BITVECTOR},
644 : : {internal::Kind::INT_TO_BITVECTOR, Kind::INT_TO_BITVECTOR},
645 : : // note that BITVECTOR_TO_NAT does not exist internally, only the
646 : : // case for BITVECTOR_UBV_TO_INT is given
647 : : {internal::Kind::BITVECTOR_UBV_TO_INT, Kind::BITVECTOR_UBV_TO_INT},
648 : : {internal::Kind::BITVECTOR_SBV_TO_INT, Kind::BITVECTOR_SBV_TO_INT},
649 : : {internal::Kind::BITVECTOR_FROM_BOOLS, Kind::BITVECTOR_FROM_BOOLS},
650 : : {internal::Kind::BITVECTOR_BIT_OP, Kind::BITVECTOR_BIT},
651 : : {internal::Kind::BITVECTOR_BIT, Kind::BITVECTOR_BIT},
652 : : /* Finite Fields --------------------------------------------------- */
653 : : {internal::Kind::CONST_FINITE_FIELD, Kind::CONST_FINITE_FIELD},
654 : : {internal::Kind::FINITE_FIELD_BITSUM, Kind::FINITE_FIELD_BITSUM},
655 : : {internal::Kind::FINITE_FIELD_MULT, Kind::FINITE_FIELD_MULT},
656 : : {internal::Kind::FINITE_FIELD_ADD, Kind::FINITE_FIELD_ADD},
657 : : {internal::Kind::FINITE_FIELD_NEG, Kind::FINITE_FIELD_NEG},
658 : : /* FP -------------------------------------------------------------- */
659 : : {internal::Kind::CONST_FLOATINGPOINT, Kind::CONST_FLOATINGPOINT},
660 : : {internal::Kind::CONST_ROUNDINGMODE, Kind::CONST_ROUNDINGMODE},
661 : : {internal::Kind::FLOATINGPOINT_FP, Kind::FLOATINGPOINT_FP},
662 : : {internal::Kind::FLOATINGPOINT_EQ, Kind::FLOATINGPOINT_EQ},
663 : : {internal::Kind::FLOATINGPOINT_ABS, Kind::FLOATINGPOINT_ABS},
664 : : {internal::Kind::FLOATINGPOINT_NEG, Kind::FLOATINGPOINT_NEG},
665 : : {internal::Kind::FLOATINGPOINT_ADD, Kind::FLOATINGPOINT_ADD},
666 : : {internal::Kind::FLOATINGPOINT_SUB, Kind::FLOATINGPOINT_SUB},
667 : : {internal::Kind::FLOATINGPOINT_MULT, Kind::FLOATINGPOINT_MULT},
668 : : {internal::Kind::FLOATINGPOINT_DIV, Kind::FLOATINGPOINT_DIV},
669 : : {internal::Kind::FLOATINGPOINT_FMA, Kind::FLOATINGPOINT_FMA},
670 : : {internal::Kind::FLOATINGPOINT_SQRT, Kind::FLOATINGPOINT_SQRT},
671 : : {internal::Kind::FLOATINGPOINT_REM, Kind::FLOATINGPOINT_REM},
672 : : {internal::Kind::FLOATINGPOINT_RTI, Kind::FLOATINGPOINT_RTI},
673 : : {internal::Kind::FLOATINGPOINT_MIN, Kind::FLOATINGPOINT_MIN},
674 : : {internal::Kind::FLOATINGPOINT_MAX, Kind::FLOATINGPOINT_MAX},
675 : : {internal::Kind::FLOATINGPOINT_LEQ, Kind::FLOATINGPOINT_LEQ},
676 : : {internal::Kind::FLOATINGPOINT_LT, Kind::FLOATINGPOINT_LT},
677 : : {internal::Kind::FLOATINGPOINT_GEQ, Kind::FLOATINGPOINT_GEQ},
678 : : {internal::Kind::FLOATINGPOINT_GT, Kind::FLOATINGPOINT_GT},
679 : : {internal::Kind::FLOATINGPOINT_IS_NORMAL,
680 : : Kind::FLOATINGPOINT_IS_NORMAL},
681 : : {internal::Kind::FLOATINGPOINT_IS_SUBNORMAL,
682 : : Kind::FLOATINGPOINT_IS_SUBNORMAL},
683 : : {internal::Kind::FLOATINGPOINT_IS_ZERO, Kind::FLOATINGPOINT_IS_ZERO},
684 : : {internal::Kind::FLOATINGPOINT_IS_INF, Kind::FLOATINGPOINT_IS_INF},
685 : : {internal::Kind::FLOATINGPOINT_IS_NAN, Kind::FLOATINGPOINT_IS_NAN},
686 : : {internal::Kind::FLOATINGPOINT_IS_NEG, Kind::FLOATINGPOINT_IS_NEG},
687 : : {internal::Kind::FLOATINGPOINT_IS_POS, Kind::FLOATINGPOINT_IS_POS},
688 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP,
689 : : Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV},
690 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
691 : : Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV},
692 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP_OP,
693 : : Kind::FLOATINGPOINT_TO_FP_FROM_FP},
694 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP,
695 : : Kind::FLOATINGPOINT_TO_FP_FROM_FP},
696 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL_OP,
697 : : Kind::FLOATINGPOINT_TO_FP_FROM_REAL},
698 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
699 : : Kind::FLOATINGPOINT_TO_FP_FROM_REAL},
700 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV_OP,
701 : : Kind::FLOATINGPOINT_TO_FP_FROM_SBV},
702 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
703 : : Kind::FLOATINGPOINT_TO_FP_FROM_SBV},
704 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV_OP,
705 : : Kind::FLOATINGPOINT_TO_FP_FROM_UBV},
706 : : {internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV,
707 : : Kind::FLOATINGPOINT_TO_FP_FROM_UBV},
708 : : {internal::Kind::FLOATINGPOINT_TO_UBV_OP, Kind::FLOATINGPOINT_TO_UBV},
709 : : {internal::Kind::FLOATINGPOINT_TO_UBV, Kind::FLOATINGPOINT_TO_UBV},
710 : : {internal::Kind::FLOATINGPOINT_TO_UBV_TOTAL_OP, Kind::INTERNAL_KIND},
711 : : {internal::Kind::FLOATINGPOINT_TO_UBV_TOTAL, Kind::INTERNAL_KIND},
712 : : {internal::Kind::FLOATINGPOINT_TO_SBV_OP, Kind::FLOATINGPOINT_TO_SBV},
713 : : {internal::Kind::FLOATINGPOINT_TO_SBV, Kind::FLOATINGPOINT_TO_SBV},
714 : : {internal::Kind::FLOATINGPOINT_TO_SBV_TOTAL_OP, Kind::INTERNAL_KIND},
715 : : {internal::Kind::FLOATINGPOINT_TO_SBV_TOTAL, Kind::INTERNAL_KIND},
716 : : {internal::Kind::FLOATINGPOINT_TO_REAL, Kind::FLOATINGPOINT_TO_REAL},
717 : : {internal::Kind::FLOATINGPOINT_TO_REAL_TOTAL, Kind::INTERNAL_KIND},
718 : : /* Arrays ---------------------------------------------------------- */
719 : : {internal::Kind::SELECT, Kind::SELECT},
720 : : {internal::Kind::STORE, Kind::STORE},
721 : : {internal::Kind::STORE_ALL, Kind::CONST_ARRAY},
722 : : /* Datatypes ------------------------------------------------------- */
723 : : {internal::Kind::APPLY_SELECTOR, Kind::APPLY_SELECTOR},
724 : : {internal::Kind::APPLY_CONSTRUCTOR, Kind::APPLY_CONSTRUCTOR},
725 : : {internal::Kind::APPLY_TESTER, Kind::APPLY_TESTER},
726 : : {internal::Kind::APPLY_UPDATER, Kind::APPLY_UPDATER},
727 : : {internal::Kind::MATCH, Kind::MATCH},
728 : : {internal::Kind::MATCH_CASE, Kind::MATCH_CASE},
729 : : {internal::Kind::MATCH_BIND_CASE, Kind::MATCH_BIND_CASE},
730 : : {internal::Kind::TUPLE_PROJECT, Kind::TUPLE_PROJECT},
731 : : {internal::Kind::TUPLE_PROJECT_OP, Kind::TUPLE_PROJECT},
732 : : {internal::Kind::NULLABLE_LIFT, Kind::NULLABLE_LIFT},
733 : : /* Separation Logic ------------------------------------------------ */
734 : : {internal::Kind::SEP_NIL, Kind::SEP_NIL},
735 : : {internal::Kind::SEP_EMP, Kind::SEP_EMP},
736 : : {internal::Kind::SEP_PTO, Kind::SEP_PTO},
737 : : {internal::Kind::SEP_STAR, Kind::SEP_STAR},
738 : : {internal::Kind::SEP_WAND, Kind::SEP_WAND},
739 : : /* Sets ------------------------------------------------------------ */
740 : : {internal::Kind::SET_EMPTY, Kind::SET_EMPTY},
741 : : {internal::Kind::SET_UNION, Kind::SET_UNION},
742 : : {internal::Kind::SET_INTER, Kind::SET_INTER},
743 : : {internal::Kind::SET_MINUS, Kind::SET_MINUS},
744 : : {internal::Kind::SET_SUBSET, Kind::SET_SUBSET},
745 : : {internal::Kind::SET_MEMBER, Kind::SET_MEMBER},
746 : : {internal::Kind::SET_SINGLETON, Kind::SET_SINGLETON},
747 : : {internal::Kind::SET_INSERT, Kind::SET_INSERT},
748 : : {internal::Kind::SET_CARD, Kind::SET_CARD},
749 : : {internal::Kind::SET_COMPLEMENT, Kind::SET_COMPLEMENT},
750 : : {internal::Kind::SET_UNIVERSE, Kind::SET_UNIVERSE},
751 : : {internal::Kind::SET_COMPREHENSION, Kind::SET_COMPREHENSION},
752 : : {internal::Kind::SET_CHOOSE, Kind::SET_CHOOSE},
753 : : {internal::Kind::SET_IS_EMPTY, Kind::SET_IS_EMPTY},
754 : : {internal::Kind::SET_IS_SINGLETON, Kind::SET_IS_SINGLETON},
755 : : {internal::Kind::SET_MAP, Kind::SET_MAP},
756 : : {internal::Kind::SET_FILTER, Kind::SET_FILTER},
757 : : {internal::Kind::SET_ALL, Kind::SET_ALL},
758 : : {internal::Kind::SET_SOME, Kind::SET_SOME},
759 : : {internal::Kind::SET_FOLD, Kind::SET_FOLD},
760 : : /* Relations ------------------------------------------------------- */
761 : : {internal::Kind::RELATION_JOIN, Kind::RELATION_JOIN},
762 : : {internal::Kind::RELATION_TABLE_JOIN, Kind::RELATION_TABLE_JOIN},
763 : : {internal::Kind::RELATION_TABLE_JOIN_OP, Kind::RELATION_TABLE_JOIN},
764 : : {internal::Kind::RELATION_PRODUCT, Kind::RELATION_PRODUCT},
765 : : {internal::Kind::RELATION_TRANSPOSE, Kind::RELATION_TRANSPOSE},
766 : : {internal::Kind::RELATION_TCLOSURE, Kind::RELATION_TCLOSURE},
767 : : {internal::Kind::RELATION_JOIN_IMAGE, Kind::RELATION_JOIN_IMAGE},
768 : : {internal::Kind::RELATION_IDEN, Kind::RELATION_IDEN},
769 : : {internal::Kind::RELATION_GROUP, Kind::RELATION_GROUP},
770 : : {internal::Kind::RELATION_AGGREGATE_OP, Kind::RELATION_AGGREGATE},
771 : : {internal::Kind::RELATION_AGGREGATE, Kind::RELATION_AGGREGATE},
772 : : {internal::Kind::RELATION_PROJECT_OP, Kind::RELATION_PROJECT},
773 : : {internal::Kind::RELATION_PROJECT, Kind::RELATION_PROJECT},
774 : : /* Bags ------------------------------------------------------------ */
775 : : {internal::Kind::BAG_UNION_MAX, Kind::BAG_UNION_MAX},
776 : : {internal::Kind::BAG_UNION_DISJOINT, Kind::BAG_UNION_DISJOINT},
777 : : {internal::Kind::BAG_INTER_MIN, Kind::BAG_INTER_MIN},
778 : : {internal::Kind::BAG_DIFFERENCE_SUBTRACT,
779 : : Kind::BAG_DIFFERENCE_SUBTRACT},
780 : : {internal::Kind::BAG_DIFFERENCE_REMOVE, Kind::BAG_DIFFERENCE_REMOVE},
781 : : {internal::Kind::BAG_SUBBAG, Kind::BAG_SUBBAG},
782 : : {internal::Kind::BAG_COUNT, Kind::BAG_COUNT},
783 : : {internal::Kind::BAG_MEMBER, Kind::BAG_MEMBER},
784 : : {internal::Kind::BAG_SETOF, Kind::BAG_SETOF},
785 : : {internal::Kind::BAG_MAKE, Kind::BAG_MAKE},
786 : : {internal::Kind::BAG_EMPTY, Kind::BAG_EMPTY},
787 : : {internal::Kind::BAG_CARD, Kind::BAG_CARD},
788 : : {internal::Kind::BAG_CHOOSE, Kind::BAG_CHOOSE},
789 : : {internal::Kind::BAG_MAP, Kind::BAG_MAP},
790 : : {internal::Kind::BAG_FILTER, Kind::BAG_FILTER},
791 : : {internal::Kind::BAG_ALL, Kind::BAG_ALL},
792 : : {internal::Kind::BAG_SOME, Kind::BAG_SOME},
793 : : {internal::Kind::BAG_FOLD, Kind::BAG_FOLD},
794 : : {internal::Kind::BAG_PARTITION, Kind::BAG_PARTITION},
795 : : {internal::Kind::TABLE_PRODUCT, Kind::TABLE_PRODUCT},
796 : : {internal::Kind::TABLE_PROJECT, Kind::TABLE_PROJECT},
797 : : {internal::Kind::TABLE_PROJECT_OP, Kind::TABLE_PROJECT},
798 : : {internal::Kind::TABLE_AGGREGATE_OP, Kind::TABLE_AGGREGATE},
799 : : {internal::Kind::TABLE_AGGREGATE, Kind::TABLE_AGGREGATE},
800 : : {internal::Kind::TABLE_JOIN_OP, Kind::TABLE_JOIN},
801 : : {internal::Kind::TABLE_JOIN, Kind::TABLE_JOIN},
802 : : {internal::Kind::TABLE_GROUP_OP, Kind::TABLE_GROUP},
803 : : {internal::Kind::TABLE_GROUP, Kind::TABLE_GROUP},
804 : : /* Strings --------------------------------------------------------- */
805 : : {internal::Kind::STRING_CONCAT, Kind::STRING_CONCAT},
806 : : {internal::Kind::STRING_IN_REGEXP, Kind::STRING_IN_REGEXP},
807 : : {internal::Kind::STRING_LENGTH, Kind::STRING_LENGTH},
808 : : {internal::Kind::STRING_SUBSTR, Kind::STRING_SUBSTR},
809 : : {internal::Kind::STRING_UPDATE, Kind::STRING_UPDATE},
810 : : {internal::Kind::STRING_CHARAT, Kind::STRING_CHARAT},
811 : : {internal::Kind::STRING_CONTAINS, Kind::STRING_CONTAINS},
812 : : {internal::Kind::STRING_INDEXOF, Kind::STRING_INDEXOF},
813 : : {internal::Kind::STRING_INDEXOF_RE, Kind::STRING_INDEXOF_RE},
814 : : {internal::Kind::STRING_REPLACE, Kind::STRING_REPLACE},
815 : : {internal::Kind::STRING_REPLACE_ALL, Kind::STRING_REPLACE_ALL},
816 : : {internal::Kind::STRING_REPLACE_RE, Kind::STRING_REPLACE_RE},
817 : : {internal::Kind::STRING_REPLACE_RE_ALL, Kind::STRING_REPLACE_RE_ALL},
818 : : {internal::Kind::STRING_TO_LOWER, Kind::STRING_TO_LOWER},
819 : : {internal::Kind::STRING_TO_UPPER, Kind::STRING_TO_UPPER},
820 : : {internal::Kind::STRING_REV, Kind::STRING_REV},
821 : : {internal::Kind::STRING_FROM_CODE, Kind::STRING_FROM_CODE},
822 : : {internal::Kind::STRING_TO_CODE, Kind::STRING_TO_CODE},
823 : : {internal::Kind::STRING_LT, Kind::STRING_LT},
824 : : {internal::Kind::STRING_LEQ, Kind::STRING_LEQ},
825 : : {internal::Kind::STRING_PREFIX, Kind::STRING_PREFIX},
826 : : {internal::Kind::STRING_SUFFIX, Kind::STRING_SUFFIX},
827 : : {internal::Kind::STRING_IS_DIGIT, Kind::STRING_IS_DIGIT},
828 : : {internal::Kind::STRING_ITOS, Kind::STRING_FROM_INT},
829 : : {internal::Kind::STRING_STOI, Kind::STRING_TO_INT},
830 : : {internal::Kind::CONST_STRING, Kind::CONST_STRING},
831 : : {internal::Kind::STRING_TO_REGEXP, Kind::STRING_TO_REGEXP},
832 : : {internal::Kind::REGEXP_CONCAT, Kind::REGEXP_CONCAT},
833 : : {internal::Kind::REGEXP_UNION, Kind::REGEXP_UNION},
834 : : {internal::Kind::REGEXP_INTER, Kind::REGEXP_INTER},
835 : : {internal::Kind::REGEXP_DIFF, Kind::REGEXP_DIFF},
836 : : {internal::Kind::REGEXP_STAR, Kind::REGEXP_STAR},
837 : : {internal::Kind::REGEXP_PLUS, Kind::REGEXP_PLUS},
838 : : {internal::Kind::REGEXP_OPT, Kind::REGEXP_OPT},
839 : : {internal::Kind::REGEXP_RANGE, Kind::REGEXP_RANGE},
840 : : {internal::Kind::REGEXP_REPEAT, Kind::REGEXP_REPEAT},
841 : : {internal::Kind::REGEXP_REPEAT_OP, Kind::REGEXP_REPEAT},
842 : : {internal::Kind::REGEXP_LOOP, Kind::REGEXP_LOOP},
843 : : {internal::Kind::REGEXP_LOOP_OP, Kind::REGEXP_LOOP},
844 : : {internal::Kind::REGEXP_NONE, Kind::REGEXP_NONE},
845 : : {internal::Kind::REGEXP_ALL, Kind::REGEXP_ALL},
846 : : {internal::Kind::REGEXP_ALLCHAR, Kind::REGEXP_ALLCHAR},
847 : : {internal::Kind::REGEXP_COMPLEMENT, Kind::REGEXP_COMPLEMENT},
848 : : {internal::Kind::CONST_SEQUENCE, Kind::CONST_SEQUENCE},
849 : : {internal::Kind::SEQ_UNIT, Kind::SEQ_UNIT},
850 : : {internal::Kind::SEQ_NTH, Kind::SEQ_NTH},
851 : : /* Quantifiers ----------------------------------------------------- */
852 : : {internal::Kind::FORALL, Kind::FORALL},
853 : : {internal::Kind::EXISTS, Kind::EXISTS},
854 : : {internal::Kind::BOUND_VAR_LIST, Kind::VARIABLE_LIST},
855 : : {internal::Kind::INST_PATTERN, Kind::INST_PATTERN},
856 : : {internal::Kind::INST_NO_PATTERN, Kind::INST_NO_PATTERN},
857 : : {internal::Kind::INST_POOL, Kind::INST_POOL},
858 : : {internal::Kind::INST_ADD_TO_POOL, Kind::INST_ADD_TO_POOL},
859 : : {internal::Kind::SKOLEM_ADD_TO_POOL, Kind::SKOLEM_ADD_TO_POOL},
860 : : {internal::Kind::INST_ATTRIBUTE, Kind::INST_ATTRIBUTE},
861 : : {internal::Kind::INST_PATTERN_LIST, Kind::INST_PATTERN_LIST},
862 : : /* ----------------------------------------------------------------- */
863 : : {internal::Kind::LAST_KIND, Kind::LAST_KIND},
864 : : };
865 : :
866 : : /* Mapping from internal kind to external (API) sort kind. */
867 : : const static std::
868 : : unordered_map<internal::Kind, SortKind, internal::kind::KindHashFunction>
869 : : s_sort_kinds_internal{
870 : : {internal::Kind::UNDEFINED_KIND, SortKind::UNDEFINED_SORT_KIND},
871 : : {internal::Kind::NULL_EXPR, SortKind::NULL_SORT},
872 : : {internal::Kind::ABSTRACT_TYPE, SortKind::ABSTRACT_SORT},
873 : : {internal::Kind::ARRAY_TYPE, SortKind::ARRAY_SORT},
874 : : {internal::Kind::BAG_TYPE, SortKind::BAG_SORT},
875 : : {internal::Kind::BITVECTOR_TYPE, SortKind::BITVECTOR_SORT},
876 : : {internal::Kind::DATATYPE_TYPE, SortKind::DATATYPE_SORT},
877 : : {internal::Kind::FINITE_FIELD_TYPE, SortKind::FINITE_FIELD_SORT},
878 : : {internal::Kind::FLOATINGPOINT_TYPE, SortKind::FLOATINGPOINT_SORT},
879 : : {internal::Kind::FUNCTION_TYPE, SortKind::FUNCTION_SORT},
880 : : {internal::Kind::SEQUENCE_TYPE, SortKind::SEQUENCE_SORT},
881 : : {internal::Kind::SET_TYPE, SortKind::SET_SORT},
882 : : {internal::Kind::SORT_TYPE, SortKind::UNINTERPRETED_SORT},
883 : : {internal::Kind::TUPLE_TYPE, SortKind::TUPLE_SORT},
884 : : {internal::Kind::NULLABLE_TYPE, SortKind::NULLABLE_SORT},
885 : : };
886 : :
887 : : /* Set of kinds for indexed operators */
888 : : const static std::unordered_set<Kind> s_indexed_kinds(
889 : : {Kind::DIVISIBLE,
890 : : Kind::IAND,
891 : : Kind::BITVECTOR_REPEAT,
892 : : Kind::BITVECTOR_ZERO_EXTEND,
893 : : Kind::BITVECTOR_SIGN_EXTEND,
894 : : Kind::BITVECTOR_ROTATE_LEFT,
895 : : Kind::BITVECTOR_ROTATE_RIGHT,
896 : : Kind::INT_TO_BITVECTOR,
897 : : Kind::BITVECTOR_BIT,
898 : : Kind::FLOATINGPOINT_TO_UBV,
899 : : Kind::FLOATINGPOINT_TO_SBV,
900 : : Kind::BITVECTOR_EXTRACT,
901 : : Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
902 : : Kind::FLOATINGPOINT_TO_FP_FROM_FP,
903 : : Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
904 : : Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
905 : : Kind::FLOATINGPOINT_TO_FP_FROM_UBV});
906 : :
907 : : /**
908 : : * Mapping from external (API) kind to the corresponding internal operator kind.
909 : : */
910 : : const static std::unordered_map<Kind, internal::Kind> s_op_kinds{
911 : : {Kind::BITVECTOR_BIT, internal::Kind::BITVECTOR_BIT_OP},
912 : : {Kind::BITVECTOR_EXTRACT, internal::Kind::BITVECTOR_EXTRACT_OP},
913 : : {Kind::BITVECTOR_REPEAT, internal::Kind::BITVECTOR_REPEAT_OP},
914 : : {Kind::BITVECTOR_ROTATE_LEFT, internal::Kind::BITVECTOR_ROTATE_LEFT_OP},
915 : : {Kind::BITVECTOR_ROTATE_RIGHT, internal::Kind::BITVECTOR_ROTATE_RIGHT_OP},
916 : : {Kind::BITVECTOR_SIGN_EXTEND, internal::Kind::BITVECTOR_SIGN_EXTEND_OP},
917 : : {Kind::BITVECTOR_ZERO_EXTEND, internal::Kind::BITVECTOR_ZERO_EXTEND_OP},
918 : : {Kind::DIVISIBLE, internal::Kind::DIVISIBLE_OP},
919 : : {Kind::FLOATINGPOINT_TO_SBV, internal::Kind::FLOATINGPOINT_TO_SBV_OP},
920 : : {Kind::FLOATINGPOINT_TO_UBV, internal::Kind::FLOATINGPOINT_TO_UBV_OP},
921 : : {Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV,
922 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV_OP},
923 : : {Kind::FLOATINGPOINT_TO_FP_FROM_FP,
924 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_FP_OP},
925 : : {Kind::FLOATINGPOINT_TO_FP_FROM_REAL,
926 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_REAL_OP},
927 : : {Kind::FLOATINGPOINT_TO_FP_FROM_SBV,
928 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_SBV_OP},
929 : : {Kind::FLOATINGPOINT_TO_FP_FROM_UBV,
930 : : internal::Kind::FLOATINGPOINT_TO_FP_FROM_UBV_OP},
931 : : {Kind::IAND, internal::Kind::IAND_OP},
932 : : {Kind::INT_TO_BITVECTOR, internal::Kind::INT_TO_BITVECTOR_OP},
933 : : {Kind::REGEXP_REPEAT, internal::Kind::REGEXP_REPEAT_OP},
934 : : {Kind::REGEXP_LOOP, internal::Kind::REGEXP_LOOP_OP},
935 : : {Kind::TUPLE_PROJECT, internal::Kind::TUPLE_PROJECT_OP},
936 : : {Kind::RELATION_AGGREGATE, internal::Kind::RELATION_AGGREGATE_OP},
937 : : {Kind::RELATION_GROUP, internal::Kind::RELATION_GROUP_OP},
938 : : {Kind::RELATION_PROJECT, internal::Kind::RELATION_PROJECT_OP},
939 : : {Kind::RELATION_TABLE_JOIN, internal::Kind::RELATION_TABLE_JOIN_OP},
940 : : {Kind::TABLE_PROJECT, internal::Kind::TABLE_PROJECT_OP},
941 : : {Kind::TABLE_AGGREGATE, internal::Kind::TABLE_AGGREGATE_OP},
942 : : {Kind::TABLE_JOIN, internal::Kind::TABLE_JOIN_OP},
943 : : {Kind::TABLE_GROUP, internal::Kind::TABLE_GROUP_OP},
944 : : };
945 : :
946 : : /* -------------------------------------------------------------------------- */
947 : : /* Rounding Mode for Floating Points */
948 : : /* -------------------------------------------------------------------------- */
949 : :
950 : : const static std::unordered_map<RoundingMode, cvc5::internal::RoundingMode>
951 : : s_rmodes{
952 : : {RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
953 : : cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN},
954 : : {RoundingMode::ROUND_TOWARD_POSITIVE,
955 : : cvc5::internal::RoundingMode::ROUND_TOWARD_POSITIVE},
956 : : {RoundingMode::ROUND_TOWARD_NEGATIVE,
957 : : cvc5::internal::RoundingMode::ROUND_TOWARD_NEGATIVE},
958 : : {RoundingMode::ROUND_TOWARD_ZERO,
959 : : cvc5::internal::RoundingMode::ROUND_TOWARD_ZERO},
960 : : {RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
961 : : cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
962 : : };
963 : :
964 : : const static std::unordered_map<cvc5::internal::RoundingMode, RoundingMode>
965 : : s_rmodes_internal{
966 : : {cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_EVEN,
967 : : RoundingMode::ROUND_NEAREST_TIES_TO_EVEN},
968 : : {cvc5::internal::RoundingMode::ROUND_TOWARD_POSITIVE,
969 : : RoundingMode::ROUND_TOWARD_POSITIVE},
970 : : {cvc5::internal::RoundingMode::ROUND_TOWARD_NEGATIVE,
971 : : RoundingMode::ROUND_TOWARD_NEGATIVE},
972 : : {cvc5::internal::RoundingMode::ROUND_TOWARD_ZERO,
973 : : RoundingMode::ROUND_TOWARD_ZERO},
974 : : {cvc5::internal::RoundingMode::ROUND_NEAREST_TIES_TO_AWAY,
975 : : RoundingMode::ROUND_NEAREST_TIES_TO_AWAY},
976 : : };
977 : :
978 : : /* -------------------------------------------------------------------------- */
979 : : /* Helpers */
980 : : /* -------------------------------------------------------------------------- */
981 : :
982 : : namespace {
983 : :
984 : : /** Convert a internal::Kind (internal) to a cvc5::Kind (external).
985 : : */
986 : 7050 : cvc5::Kind intToExtKind(internal::Kind k)
987 : : {
988 : 7050 : auto it = s_kinds_internal.find(k);
989 [ + + ]: 7050 : if (it == s_kinds_internal.end())
990 : : {
991 : 3627 : return Kind::INTERNAL_KIND;
992 : : }
993 : 3423 : return it->second;
994 : : }
995 : : /** Convert a internal::Kind (internal) to a cvc5::Kind (external).
996 : : */
997 : 14 : SortKind intToExtSortKind(internal::Kind k)
998 : : {
999 : 14 : auto it = s_sort_kinds_internal.find(k);
1000 [ - + ]: 14 : if (it == s_sort_kinds_internal.end())
1001 : : {
1002 : 0 : return SortKind::INTERNAL_SORT_KIND;
1003 : : }
1004 : 14 : return it->second;
1005 : : }
1006 : :
1007 : : /** Convert a cvc5::Kind (external) to a internal::Kind (internal).
1008 : : */
1009 : 58393134 : internal::Kind extToIntKind(cvc5::Kind k)
1010 : : {
1011 : 58393134 : auto it = s_kinds.find(k);
1012 [ - + ]: 58393134 : if (it == s_kinds.end())
1013 : : {
1014 : 0 : return internal::Kind::UNDEFINED_KIND;
1015 : : }
1016 : 58393134 : return it->second.first;
1017 : : }
1018 : :
1019 : : /** Convert a cvc5::SortKind (external) to a internal::Kind (internal).
1020 : : */
1021 : 27 : internal::Kind extToIntSortKind(SortKind k)
1022 : : {
1023 : 27 : auto it = s_sort_kinds.find(k);
1024 [ - + ]: 27 : if (it == s_sort_kinds.end())
1025 : : {
1026 : 0 : return internal::Kind::UNDEFINED_KIND;
1027 : : }
1028 : 27 : return it->second.first;
1029 : : }
1030 : :
1031 : : /** Return true if given kind is a defined external kind. */
1032 : 26078262 : bool isDefinedKind(Kind k)
1033 : : {
1034 [ + - ][ + - ]: 26078262 : return k > Kind::UNDEFINED_KIND && k < Kind::LAST_KIND;
1035 : : }
1036 : :
1037 : : /**
1038 : : * Return true if the internal kind is one where the API term structure
1039 : : * differs from internal structure. This happens for APPLY_* kinds.
1040 : : * The API takes a "higher-order" perspective and treats functions as well
1041 : : * as datatype constructors/selectors/testers as terms
1042 : : * but interally they are not
1043 : : */
1044 : 12919002 : bool isApplyKind(internal::Kind k)
1045 : : {
1046 : : return (k == internal::Kind::APPLY_UF
1047 [ + + ]: 11394470 : || k == internal::Kind::APPLY_CONSTRUCTOR
1048 [ + + ]: 11351688 : || k == internal::Kind::APPLY_SELECTOR
1049 [ + + ]: 11299047 : || k == internal::Kind::APPLY_TESTER
1050 [ + + ][ + + ]: 24313472 : || k == internal::Kind::APPLY_UPDATER);
1051 : : }
1052 : :
1053 : : #ifdef CVC5_ASSERTIONS
1054 : : /** Return true if given kind is a defined internal kind. */
1055 : 19371228 : bool isDefinedIntKind(internal::Kind k)
1056 : : {
1057 [ + - ][ + - ]: 19371228 : return k != internal::Kind::UNDEFINED_KIND && k != internal::Kind::LAST_KIND;
1058 : : }
1059 : : #endif
1060 : :
1061 : : /** Return the minimum arity of given kind. */
1062 : 6457083 : uint32_t minArity(Kind k)
1063 : : {
1064 [ - + ][ - + ]: 6457083 : Assert(isDefinedKind(k));
[ - - ]
1065 [ - + ][ - + ]: 6457083 : Assert(isDefinedIntKind(extToIntKind(k)));
[ - - ]
1066 : 6457083 : uint32_t min = internal::kind::metakind::getMinArityForKind(extToIntKind(k));
1067 : :
1068 : : // At the API level, we treat functions/constructors/selectors/testers as
1069 : : // normal terms instead of making them part of the operator
1070 [ + + ]: 6457083 : if (isApplyKind(extToIntKind(k)))
1071 : : {
1072 : 812821 : min++;
1073 : : }
1074 : 6457083 : return min;
1075 : : }
1076 : :
1077 : : /** Return the maximum arity of given kind. */
1078 : 6457069 : uint32_t maxArity(Kind k)
1079 : : {
1080 [ - + ][ - + ]: 6457069 : Assert(isDefinedKind(k));
[ - - ]
1081 [ - + ][ - + ]: 6457069 : Assert(isDefinedIntKind(extToIntKind(k)));
[ - - ]
1082 : 6457069 : uint32_t max = internal::kind::metakind::getMaxArityForKind(extToIntKind(k));
1083 : :
1084 : : // At the API level, we treat functions/constructors/selectors/testers as
1085 : : // normal terms instead of making them part of the operator
1086 : 6457069 : if (isApplyKind(extToIntKind(k))
1087 [ + + ][ + - ]: 6457069 : && max != std::numeric_limits<uint32_t>::max()) // be careful not to
[ + + ]
1088 : : // overflow
1089 : : {
1090 : 812815 : max++;
1091 : : }
1092 : 6457069 : return max;
1093 : : }
1094 : :
1095 : : } // namespace
1096 : :
1097 : : /**
1098 : : * Class that acts as a converter from an external to an internal plugin.
1099 : : */
1100 : : class PluginInternal : public internal::Plugin
1101 : : {
1102 : : public:
1103 : 6 : PluginInternal(NodeManagerSharedPtr nm, cvc5::Plugin& e)
1104 : 6 : : internal::Plugin(nm.get()), d_nm(std::move(nm)), d_external(e)
1105 : : {
1106 : 6 : }
1107 : : /** Check method */
1108 : 25 : std::vector<internal::Node> check() override
1109 : : {
1110 : 25 : std::vector<Term> lemsExt = d_external.check();
1111 : 50 : return Term::termVectorToNodes(lemsExt);
1112 : 25 : }
1113 : : /** Notify SAT clause method */
1114 : 10 : void notifySatClause(const internal::Node& n) override
1115 : : {
1116 : 10 : Term t = Term(d_nm, n);
1117 : 20 : return d_external.notifySatClause(t);
1118 : 10 : }
1119 : : /** Notify theory lemma method */
1120 : 18 : void notifyTheoryLemma(const internal::Node& n) override
1121 : : {
1122 : 18 : Term t = Term(d_nm, n);
1123 : 36 : return d_external.notifyTheoryLemma(t);
1124 : 18 : }
1125 : : /** Get name */
1126 : 6 : std::string getName() override { return d_external.getName(); }
1127 : :
1128 : : private:
1129 : : /** Reference to the node manager */
1130 : : NodeManagerSharedPtr d_nm;
1131 : : /** Reference to the external (user-provided) plugin */
1132 : : cvc5::Plugin& d_external;
1133 : : };
1134 : :
1135 : 297 : std::string kindToString(Kind k)
1136 : : {
1137 : 297 : auto it = s_kinds.find(k);
1138 [ - + ]: 297 : if (it == s_kinds.end())
1139 : : {
1140 : 0 : return "Kind::UNDEFINED_KIND";
1141 : : }
1142 : 297 : return it->second.second;
1143 : : }
1144 : :
1145 : 14 : std::ostream& operator<<(std::ostream& out, Kind k)
1146 : : {
1147 : 14 : return out << std::to_string(k);
1148 : : }
1149 : :
1150 : 23 : std::string sortKindToString(SortKind k)
1151 : : {
1152 : 23 : auto it = s_sort_kinds.find(k);
1153 [ - + ]: 23 : if (it == s_sort_kinds.end())
1154 : : {
1155 : 0 : return "Kind::UNDEFINED_SORT_KIND";
1156 : : }
1157 : 23 : return it->second.second;
1158 : : }
1159 : :
1160 : 28 : std::ostream& operator<<(std::ostream& out, SortKind k)
1161 : : {
1162 : 28 : return out << std::to_string(k);
1163 : : }
1164 : :
1165 : : /* -------------------------------------------------------------------------- */
1166 : : /* Result */
1167 : : /* -------------------------------------------------------------------------- */
1168 : :
1169 : 20742 : Result::Result(const internal::Result& r) : d_result(new internal::Result(r)) {}
1170 : :
1171 : 749201 : Result::Result() : d_result(new internal::Result()) {}
1172 : :
1173 : 128 : bool Result::isNull() const
1174 : : {
1175 : 128 : return d_result->getStatus() == internal::Result::NONE;
1176 : : }
1177 : :
1178 : 31329 : bool Result::isSat(void) const
1179 : : {
1180 : 31329 : return d_result->getStatus() == internal::Result::SAT;
1181 : : }
1182 : :
1183 : 31429 : bool Result::isUnsat(void) const
1184 : : {
1185 : 31429 : return d_result->getStatus() == internal::Result::UNSAT;
1186 : : }
1187 : :
1188 : 57 : bool Result::isUnknown(void) const
1189 : : {
1190 : 57 : return d_result->getStatus() == internal::Result::UNKNOWN;
1191 : : }
1192 : :
1193 : 15 : bool Result::operator==(const Result& r) const
1194 : : {
1195 : 15 : return *d_result == *r.d_result;
1196 : : }
1197 : :
1198 : 3 : bool Result::operator!=(const Result& r) const
1199 : : {
1200 : 3 : return *d_result != *r.d_result;
1201 : : }
1202 : :
1203 : 6 : UnknownExplanation Result::getUnknownExplanation(void) const
1204 : : {
1205 : 6 : return d_result->getUnknownExplanation();
1206 : : }
1207 : :
1208 : 20568 : std::string Result::toString(void) const { return d_result->toString(); }
1209 : :
1210 : 20420 : std::ostream& operator<<(std::ostream& out, const Result& r)
1211 : : {
1212 : 20420 : out << r.toString();
1213 : 20420 : return out;
1214 : : }
1215 : :
1216 : : } // namespace cvc5
1217 : :
1218 : : namespace std {
1219 : :
1220 : 142 : size_t hash<cvc5::Result>::operator()(const cvc5::Result& result) const
1221 : : {
1222 : 142 : return std::hash<std::string>{}(result.toString());
1223 : : }
1224 : : } // namespace std
1225 : :
1226 : : namespace cvc5 {
1227 : :
1228 : : /* -------------------------------------------------------------------------- */
1229 : : /* SynthResult */
1230 : : /* -------------------------------------------------------------------------- */
1231 : :
1232 : 490 : SynthResult::SynthResult(const internal::SynthResult& r)
1233 : 490 : : d_result(new internal::SynthResult(r))
1234 : : {
1235 : 490 : }
1236 : :
1237 : 950 : SynthResult::SynthResult() : d_result(new internal::SynthResult()) {}
1238 : :
1239 : 18 : bool SynthResult::isNull() const
1240 : : {
1241 : 18 : return d_result->getStatus() == internal::SynthResult::NONE;
1242 : : }
1243 : :
1244 : 1389 : bool SynthResult::hasSolution(void) const
1245 : : {
1246 : 1389 : return d_result->getStatus() == internal::SynthResult::SOLUTION;
1247 : : }
1248 : :
1249 : 35 : bool SynthResult::hasNoSolution() const
1250 : : {
1251 : 35 : return d_result->getStatus() == internal::SynthResult::NO_SOLUTION;
1252 : : }
1253 : :
1254 : 5 : bool SynthResult::isUnknown() const
1255 : : {
1256 : 5 : return d_result->getStatus() == internal::SynthResult::UNKNOWN;
1257 : : }
1258 : :
1259 : 6 : bool SynthResult::operator==(const SynthResult& r) const
1260 : : {
1261 : 6 : return *d_result == *r.d_result;
1262 : : }
1263 : :
1264 : 5 : bool SynthResult::operator!=(const SynthResult& r) const
1265 : : {
1266 : 5 : return *d_result != *r.d_result;
1267 : : }
1268 : :
1269 : 34 : std::string SynthResult::toString(void) const { return d_result->toString(); }
1270 : :
1271 : 2 : std::ostream& operator<<(std::ostream& out, const SynthResult& sr)
1272 : : {
1273 : 2 : out << sr.toString();
1274 : 2 : return out;
1275 : : }
1276 : :
1277 : : } // namespace cvc5
1278 : :
1279 : : namespace std {
1280 : :
1281 : 29 : size_t hash<cvc5::SynthResult>::operator()(
1282 : : const cvc5::SynthResult& result) const
1283 : : {
1284 : 29 : return std::hash<std::string>{}(result.toString());
1285 : : }
1286 : : } // namespace std
1287 : :
1288 : : namespace cvc5 {
1289 : :
1290 : : /* -------------------------------------------------------------------------- */
1291 : : /* Sort */
1292 : : /* -------------------------------------------------------------------------- */
1293 : :
1294 : 6070025 : Sort::Sort(NodeManagerSharedPtr nm, const internal::TypeNode& t)
1295 : 6070025 : : d_nm(std::move(nm)), d_type(new internal::TypeNode(t))
1296 : : {
1297 : 6070025 : }
1298 : :
1299 : 914270 : Sort::Sort() : d_nm(nullptr), d_type(new internal::TypeNode()) {}
1300 : :
1301 : 11325756 : Sort::~Sort()
1302 : : {
1303 [ + + ][ + - ]: 11325756 : Assert(isNull() || d_nm != nullptr);
[ - + ][ - + ]
1304 : 11325756 : d_type.reset();
1305 : 11325756 : }
1306 : :
1307 : 199548 : std::vector<internal::TypeNode> Sort::sortVectorToTypeNodes(
1308 : : const std::vector<Sort>& sorts)
1309 : : {
1310 : 199548 : std::vector<internal::TypeNode> typeNodes;
1311 [ + + ]: 343036 : for (const Sort& sort : sorts)
1312 : : {
1313 : 143488 : typeNodes.push_back(sort.getTypeNode());
1314 : : }
1315 : 199548 : return typeNodes;
1316 : 0 : }
1317 : :
1318 : 6190 : std::vector<Sort> Sort::typeNodeVectorToSorts(
1319 : : NodeManagerSharedPtr nm, const std::vector<internal::TypeNode>& types)
1320 : : {
1321 : 6190 : std::vector<Sort> sorts;
1322 [ + + ]: 15096 : for (size_t i = 0, tsize = types.size(); i < tsize; i++)
1323 : : {
1324 : 8906 : sorts.push_back(Sort(nm, types[i]));
1325 : : }
1326 : 6190 : return sorts;
1327 : 0 : }
1328 : :
1329 : 931994 : bool Sort::operator==(const Sort& s) const
1330 : : {
1331 : : CVC5_API_TRY_CATCH_BEGIN;
1332 : : //////// all checks before this line
1333 : 931994 : return *d_type == *s.d_type;
1334 : : ////////
1335 : : CVC5_API_TRY_CATCH_END;
1336 : : }
1337 : :
1338 : 3369 : bool Sort::operator!=(const Sort& s) const
1339 : : {
1340 : : CVC5_API_TRY_CATCH_BEGIN;
1341 : : //////// all checks before this line
1342 : 3369 : return *d_type != *s.d_type;
1343 : : ////////
1344 : : CVC5_API_TRY_CATCH_END;
1345 : : }
1346 : :
1347 : 491638 : bool Sort::operator<(const Sort& s) const
1348 : : {
1349 : : CVC5_API_TRY_CATCH_BEGIN;
1350 : : //////// all checks before this line
1351 : 491638 : return *d_type < *s.d_type;
1352 : : ////////
1353 : : CVC5_API_TRY_CATCH_END;
1354 : : }
1355 : :
1356 : 4 : bool Sort::operator>(const Sort& s) const
1357 : : {
1358 : : CVC5_API_TRY_CATCH_BEGIN;
1359 : : //////// all checks before this line
1360 : 4 : return *d_type > *s.d_type;
1361 : : ////////
1362 : : CVC5_API_TRY_CATCH_END;
1363 : : }
1364 : :
1365 : 3 : bool Sort::operator<=(const Sort& s) const
1366 : : {
1367 : : CVC5_API_TRY_CATCH_BEGIN;
1368 : : //////// all checks before this line
1369 : 3 : return *d_type <= *s.d_type;
1370 : : ////////
1371 : : CVC5_API_TRY_CATCH_END;
1372 : : }
1373 : :
1374 : 4 : bool Sort::operator>=(const Sort& s) const
1375 : : {
1376 : : CVC5_API_TRY_CATCH_BEGIN;
1377 : : //////// all checks before this line
1378 : 4 : return *d_type >= *s.d_type;
1379 : : ////////
1380 : : CVC5_API_TRY_CATCH_END;
1381 : : }
1382 : :
1383 : 12 : SortKind Sort::getKind() const
1384 : : {
1385 : : CVC5_API_TRY_CATCH_BEGIN;
1386 [ - + ][ - + ]: 12 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1387 : : //////// all checks before this line
1388 : 12 : internal::Kind tk = d_type->getKind();
1389 : : // Base types are type constants, which have to be special cased to return
1390 : : // the appropriate kind.
1391 [ + + ]: 12 : if (tk == internal::Kind::TYPE_CONSTANT)
1392 : : {
1393 : 2 : switch (d_type->getConst<internal::TypeConstant>())
1394 : : {
1395 : 2 : case internal::BOOLEAN_TYPE: return SortKind::BOOLEAN_SORT; break;
1396 : 0 : case internal::REAL_TYPE: return SortKind::REAL_SORT; break;
1397 : 0 : case internal::INTEGER_TYPE: return SortKind::INTEGER_SORT; break;
1398 : 0 : case internal::STRING_TYPE: return SortKind::STRING_SORT; break;
1399 : 0 : case internal::REGEXP_TYPE: return SortKind::REGLAN_SORT; break;
1400 : 0 : case internal::ROUNDINGMODE_TYPE:
1401 : 0 : return SortKind::ROUNDINGMODE_SORT;
1402 : : break;
1403 : 0 : default: return SortKind::INTERNAL_SORT_KIND; break;
1404 : : }
1405 : : }
1406 : : // otherwise we rely on the mapping
1407 : 10 : return intToExtSortKind(tk);
1408 : : ////////
1409 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1410 : : }
1411 : :
1412 : 15 : bool Sort::hasSymbol() const
1413 : : {
1414 : : CVC5_API_TRY_CATCH_BEGIN;
1415 [ + + ][ + + ]: 15 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1416 : : //////// all checks before this line
1417 : 14 : return d_type->hasName();
1418 : : ////////
1419 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1420 : : }
1421 : :
1422 : 11 : std::string Sort::getSymbol() const
1423 : : {
1424 : : CVC5_API_TRY_CATCH_BEGIN;
1425 [ + + ][ + + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1426 [ + + ][ + + ]: 13 : CVC5_API_CHECK(d_type->hasName())
[ - - ]
1427 : : << "invalid call to '" << __PRETTY_FUNCTION__
1428 : 3 : << "', expected the sort to have a symbol.";
1429 : : //////// all checks before this line
1430 : 7 : return d_type->getName();
1431 : : ////////
1432 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1433 [ - + ]: 4 : }
1434 : :
1435 : 14138282 : bool Sort::isNull() const
1436 : : {
1437 : : CVC5_API_TRY_CATCH_BEGIN;
1438 : : //////// all checks before this line
1439 : 14138282 : return isNullHelper();
1440 : : ////////
1441 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1442 : : }
1443 : :
1444 : 13 : bool Sort::isBoolean() const
1445 : : {
1446 : : CVC5_API_TRY_CATCH_BEGIN;
1447 : : //////// all checks before this line
1448 : 13 : return d_type->isBoolean();
1449 : : ////////
1450 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1451 : : }
1452 : :
1453 : 110655 : bool Sort::isInteger() const
1454 : : {
1455 : : CVC5_API_TRY_CATCH_BEGIN;
1456 : : //////// all checks before this line
1457 : 110655 : return d_type->isInteger();
1458 : : ////////
1459 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1460 : : }
1461 : :
1462 : 1192223 : bool Sort::isReal() const
1463 : : {
1464 : : CVC5_API_TRY_CATCH_BEGIN;
1465 : : //////// all checks before this line
1466 : : // notice that we do not expose internal subtyping to the user
1467 [ + + ][ + - ]: 1192223 : return d_type->isReal() && !d_type->isInteger();
1468 : : ////////
1469 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1470 : : }
1471 : :
1472 : 4 : bool Sort::isString() const
1473 : : {
1474 : : CVC5_API_TRY_CATCH_BEGIN;
1475 : : //////// all checks before this line
1476 : 4 : return d_type->isString();
1477 : : ////////
1478 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1479 : : }
1480 : :
1481 : 4 : bool Sort::isRegExp() const
1482 : : {
1483 : : CVC5_API_TRY_CATCH_BEGIN;
1484 : : //////// all checks before this line
1485 : 4 : return d_type->isRegExp();
1486 : : ////////
1487 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1488 : : }
1489 : :
1490 : 202 : bool Sort::isRoundingMode() const
1491 : : {
1492 : : CVC5_API_TRY_CATCH_BEGIN;
1493 : : //////// all checks before this line
1494 : 202 : return d_type->isRoundingMode();
1495 : : ////////
1496 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1497 : : }
1498 : :
1499 : 11 : bool Sort::isBitVector() const
1500 : : {
1501 : : CVC5_API_TRY_CATCH_BEGIN;
1502 : : //////// all checks before this line
1503 : 11 : return d_type->isBitVector();
1504 : : ////////
1505 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1506 : : }
1507 : :
1508 : 202 : bool Sort::isFloatingPoint() const
1509 : : {
1510 : : CVC5_API_TRY_CATCH_BEGIN;
1511 : : //////// all checks before this line
1512 : 202 : return d_type->isFloatingPoint();
1513 : : ////////
1514 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1515 : : }
1516 : :
1517 : 2106 : bool Sort::isDatatype() const
1518 : : {
1519 : : CVC5_API_TRY_CATCH_BEGIN;
1520 : : //////// all checks before this line
1521 : 2106 : return d_type->isDatatype();
1522 : : ////////
1523 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1524 : : }
1525 : :
1526 : 87817 : bool Sort::isDatatypeConstructor() const
1527 : : {
1528 : : CVC5_API_TRY_CATCH_BEGIN;
1529 : : //////// all checks before this line
1530 : 87817 : return d_type->isDatatypeConstructor();
1531 : : ////////
1532 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1533 : : }
1534 : :
1535 : 52397 : bool Sort::isDatatypeSelector() const
1536 : : {
1537 : : CVC5_API_TRY_CATCH_BEGIN;
1538 : : //////// all checks before this line
1539 : 52397 : return d_type->isDatatypeSelector();
1540 : : ////////
1541 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1542 : : }
1543 : :
1544 : 26180 : bool Sort::isDatatypeTester() const
1545 : : {
1546 : : CVC5_API_TRY_CATCH_BEGIN;
1547 : : //////// all checks before this line
1548 : 26180 : return d_type->isDatatypeTester();
1549 : : ////////
1550 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1551 : : }
1552 : :
1553 : 4 : bool Sort::isDatatypeUpdater() const
1554 : : {
1555 : : CVC5_API_TRY_CATCH_BEGIN;
1556 : : //////// all checks before this line
1557 : 4 : return d_type->isDatatypeUpdater();
1558 : : ////////
1559 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1560 : : }
1561 : :
1562 : 5086582 : bool Sort::isFunction() const
1563 : : {
1564 : : CVC5_API_TRY_CATCH_BEGIN;
1565 : : //////// all checks before this line
1566 : 5086582 : return d_type->isFunction();
1567 : : ////////
1568 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1569 : : }
1570 : :
1571 : 4 : bool Sort::isPredicate() const
1572 : : {
1573 : : CVC5_API_TRY_CATCH_BEGIN;
1574 : : //////// all checks before this line
1575 : 4 : return d_type->isPredicate();
1576 : : ////////
1577 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1578 : : }
1579 : :
1580 : 1998 : bool Sort::isTuple() const
1581 : : {
1582 : : CVC5_API_TRY_CATCH_BEGIN;
1583 : : //////// all checks before this line
1584 : 1998 : return d_type->isTuple();
1585 : : ////////
1586 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1587 : : }
1588 : :
1589 : 12290 : bool Sort::isNullable() const
1590 : : {
1591 : : CVC5_API_TRY_CATCH_BEGIN;
1592 : : //////// all checks before this line
1593 : 12290 : return d_type->isNullable();
1594 : : ////////
1595 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1596 : : }
1597 : :
1598 : 4 : bool Sort::isRecord() const
1599 : : {
1600 : : CVC5_API_TRY_CATCH_BEGIN;
1601 : : //////// all checks before this line
1602 : 4 : return d_type->isRecord();
1603 : : ////////
1604 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1605 : : }
1606 : :
1607 : 941 : bool Sort::isArray() const
1608 : : {
1609 : : CVC5_API_TRY_CATCH_BEGIN;
1610 : : //////// all checks before this line
1611 : 941 : return d_type->isArray();
1612 : : ////////
1613 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1614 : : }
1615 : :
1616 : 3298 : bool Sort::isFiniteField() const
1617 : : {
1618 : : CVC5_API_TRY_CATCH_BEGIN;
1619 : : //////// all checks before this line
1620 : 3298 : return d_type->isFiniteField();
1621 : : ////////
1622 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1623 : : }
1624 : :
1625 : 12300 : bool Sort::isSet() const
1626 : : {
1627 : : CVC5_API_TRY_CATCH_BEGIN;
1628 : : //////// all checks before this line
1629 : 12300 : return d_type->isSet();
1630 : : ////////
1631 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1632 : : }
1633 : :
1634 : 11664 : bool Sort::isBag() const
1635 : : {
1636 : : CVC5_API_TRY_CATCH_BEGIN;
1637 : : //////// all checks before this line
1638 : 11664 : return d_type->isBag();
1639 : : ////////
1640 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1641 : : }
1642 : :
1643 : 213 : bool Sort::isSequence() const
1644 : : {
1645 : : CVC5_API_TRY_CATCH_BEGIN;
1646 : : //////// all checks before this line
1647 : 213 : return d_type->isSequence();
1648 : : ////////
1649 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1650 : : }
1651 : :
1652 : 14 : bool Sort::isAbstract() const
1653 : : {
1654 : : CVC5_API_TRY_CATCH_BEGIN;
1655 : : //////// all checks before this line
1656 : 14 : return d_type->isAbstract();
1657 : : ////////
1658 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1659 : : }
1660 : :
1661 : 176 : bool Sort::isUninterpretedSort() const
1662 : : {
1663 : : CVC5_API_TRY_CATCH_BEGIN;
1664 : : //////// all checks before this line
1665 : 176 : return d_type->isUninterpretedSort();
1666 : : ////////
1667 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1668 : : }
1669 : :
1670 : 1052 : bool Sort::isUninterpretedSortConstructor() const
1671 : : {
1672 : : CVC5_API_TRY_CATCH_BEGIN;
1673 : : //////// all checks before this line
1674 : 1052 : return d_type->isUninterpretedSortConstructor();
1675 : : ////////
1676 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1677 : : }
1678 : :
1679 : 4 : Sort Sort::getUninterpretedSortConstructor() const
1680 : : {
1681 : : CVC5_API_TRY_CATCH_BEGIN;
1682 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1683 : 6 : CVC5_API_CHECK(d_type->isInstantiatedUninterpretedSort())
1684 : 2 : << "expected instantiated uninterpreted sort.";
1685 : : //////// all checks before this line
1686 : 2 : return Sort(d_nm, d_type->getUninterpretedSortConstructor());
1687 : : ////////
1688 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1689 [ - + ]: 2 : }
1690 : :
1691 : 22795 : Datatype Sort::getDatatype() const
1692 : : {
1693 : : CVC5_API_TRY_CATCH_BEGIN;
1694 [ - + ][ - + ]: 22795 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1695 [ + + ][ + + ]: 22795 : CVC5_API_CHECK(d_type->isDatatype()) << "expected datatype sort.";
[ - - ]
1696 : : //////// all checks before this line
1697 : 22793 : return Datatype(d_nm, d_type->getDType());
1698 : : ////////
1699 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1700 [ - + ]: 2 : }
1701 : :
1702 : 11 : bool Sort::isInstantiated() const
1703 : : {
1704 : : CVC5_API_TRY_CATCH_BEGIN;
1705 [ - + ][ - + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1706 : : //////// all checks before this line
1707 : 11 : return d_type->isInstantiated();
1708 : : ////////
1709 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1710 : : }
1711 : :
1712 : 1637 : Sort Sort::instantiate(const std::vector<Sort>& params) const
1713 : : {
1714 : : CVC5_API_TRY_CATCH_BEGIN;
1715 [ - + ][ - + ]: 1637 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1716 : 3521 : CVC5_API_CHECK_DOMAIN_SORTS(params);
1717 [ + + ][ + + ]: 1639 : CVC5_API_CHECK(d_type->isParametricDatatype()
[ + + ][ + + ]
[ - - ]
1718 : : || d_type->isUninterpretedSortConstructor())
1719 : 2 : << "expected parametric datatype or sort constructor sort.";
1720 [ + + ][ + + ]: 1636 : CVC5_API_CHECK(!d_type->isParametricDatatype()
[ + + ][ + + ]
[ - - ]
1721 : : || d_type->getNumChildren() == params.size() + 1)
1722 : 1 : << "arity mismatch for instantiated parametric datatype";
1723 [ + + ][ + + ]: 1636 : CVC5_API_CHECK(!d_type->isUninterpretedSortConstructor()
[ + + ][ + + ]
[ - - ]
1724 : : || d_type->getUninterpretedSortConstructorArity()
1725 : : == params.size())
1726 : 2 : << "arity mismatch for instantiated sort constructor";
1727 : : //////// all checks before this line
1728 : 1632 : std::vector<internal::TypeNode> tparams = sortVectorToTypeNodes(params);
1729 : 3264 : return Sort(d_nm, d_type->instantiate(tparams));
1730 : : ////////
1731 [ + - ][ - - ]: 1637 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1732 [ - + ]: 5 : }
1733 : :
1734 : 11 : std::vector<Sort> Sort::getInstantiatedParameters() const
1735 : : {
1736 : : CVC5_API_TRY_CATCH_BEGIN;
1737 [ - + ][ - + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1738 [ + + ][ + + ]: 18 : CVC5_API_CHECK(d_type->isInstantiated())
[ - - ]
1739 : 7 : << "expected instantiated parametric sort";
1740 : : //////// all checks before this line
1741 : 4 : return typeNodeVectorToSorts(d_nm, d_type->getInstantiatedParamTypes());
1742 : : ////////
1743 [ + - ][ - - ]: 7 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1744 [ - + ]: 7 : }
1745 : :
1746 : 4 : Sort Sort::substitute(const Sort& sort, const Sort& replacement) const
1747 : : {
1748 : : CVC5_API_TRY_CATCH_BEGIN;
1749 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1750 : 4 : CVC5_API_CHECK_SORT(sort);
1751 : 4 : CVC5_API_CHECK_SORT(replacement);
1752 : : //////// all checks before this line
1753 : : return Sort(
1754 : 4 : d_nm, d_type->substitute(sort.getTypeNode(), replacement.getTypeNode()));
1755 : : ////////
1756 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1757 [ - - ]: 0 : }
1758 : :
1759 : 5 : Sort Sort::substitute(const std::vector<Sort>& sorts,
1760 : : const std::vector<Sort>& replacements) const
1761 : : {
1762 : : CVC5_API_TRY_CATCH_BEGIN;
1763 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1764 : 12 : CVC5_API_CHECK_SORTS(sorts);
1765 : 12 : CVC5_API_CHECK_SORTS(replacements);
1766 : : //////// all checks before this line
1767 : :
1768 : 5 : std::vector<internal::TypeNode> tSorts = sortVectorToTypeNodes(sorts),
1769 : : tReplacements =
1770 : 5 : sortVectorToTypeNodes(replacements);
1771 : 5 : return Sort(d_nm,
1772 : 5 : d_type->substitute(tSorts.begin(),
1773 : : tSorts.end(),
1774 : : tReplacements.begin(),
1775 : 10 : tReplacements.end()));
1776 : : ////////
1777 [ - - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1778 [ - - ]: 0 : }
1779 : :
1780 : 77 : std::string Sort::toString() const
1781 : : {
1782 : : CVC5_API_TRY_CATCH_BEGIN;
1783 : : //////// all checks before this line
1784 : 154 : return d_type->toString();
1785 : : ////////
1786 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1787 : : }
1788 : :
1789 : 396639 : const internal::TypeNode& Sort::getTypeNode(void) const { return *d_type; }
1790 : :
1791 : : /* Constructor sort ------------------------------------------------------- */
1792 : :
1793 : 4 : size_t Sort::getDatatypeConstructorArity() const
1794 : : {
1795 : : CVC5_API_TRY_CATCH_BEGIN;
1796 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1797 : 6 : CVC5_API_CHECK(d_type->isDatatypeConstructor())
1798 : 2 : << "not a constructor sort: " << (*this);
1799 : : //////// all checks before this line
1800 : 2 : return d_type->getNumChildren() - 1;
1801 : : ////////
1802 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1803 : : }
1804 : :
1805 : 467 : std::vector<Sort> Sort::getDatatypeConstructorDomainSorts() const
1806 : : {
1807 : : CVC5_API_TRY_CATCH_BEGIN;
1808 [ - + ][ - + ]: 467 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1809 [ + + ][ + + ]: 469 : CVC5_API_CHECK(d_type->isDatatypeConstructor())
[ - - ]
1810 : 2 : << "not a constructor sort: " << (*this);
1811 : : //////// all checks before this line
1812 : 465 : return typeNodeVectorToSorts(d_nm, d_type->getArgTypes());
1813 : : ////////
1814 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1815 [ - + ]: 2 : }
1816 : :
1817 : 4858 : Sort Sort::getDatatypeConstructorCodomainSort() const
1818 : : {
1819 : : CVC5_API_TRY_CATCH_BEGIN;
1820 [ - + ][ - + ]: 4858 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1821 [ + + ][ + + ]: 4860 : CVC5_API_CHECK(d_type->isDatatypeConstructor())
[ - - ]
1822 : 2 : << "not a constructor sort: " << (*this);
1823 : : //////// all checks before this line
1824 : 4856 : return Sort(d_nm, d_type->getDatatypeConstructorRangeType());
1825 : : ////////
1826 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1827 [ - + ]: 2 : }
1828 : :
1829 : : /* Selector sort ------------------------------------------------------- */
1830 : :
1831 : 395 : Sort Sort::getDatatypeSelectorDomainSort() const
1832 : : {
1833 : : CVC5_API_TRY_CATCH_BEGIN;
1834 [ - + ][ - + ]: 395 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1835 [ + + ][ + + ]: 397 : CVC5_API_CHECK(d_type->isDatatypeSelector())
[ - - ]
1836 : 2 : << "not a selector sort: " << (*this);
1837 : : //////// all checks before this line
1838 : 393 : return Sort(d_nm, d_type->getDatatypeSelectorDomainType());
1839 : : ////////
1840 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1841 [ - + ]: 2 : }
1842 : :
1843 : 281 : Sort Sort::getDatatypeSelectorCodomainSort() const
1844 : : {
1845 : : CVC5_API_TRY_CATCH_BEGIN;
1846 [ - + ][ - + ]: 281 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1847 [ + + ][ + + ]: 283 : CVC5_API_CHECK(d_type->isDatatypeSelector())
[ - - ]
1848 : 2 : << "not a selector sort: " << (*this);
1849 : : //////// all checks before this line
1850 : 279 : return Sort(d_nm, d_type->getDatatypeSelectorRangeType());
1851 : : ////////
1852 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1853 [ - + ]: 2 : }
1854 : :
1855 : : /* Tester sort ------------------------------------------------------- */
1856 : :
1857 : 4 : Sort Sort::getDatatypeTesterDomainSort() const
1858 : : {
1859 : : CVC5_API_TRY_CATCH_BEGIN;
1860 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1861 : 6 : CVC5_API_CHECK(d_type->isDatatypeTester())
1862 : 2 : << "not a tester sort: " << (*this);
1863 : : //////// all checks before this line
1864 : 2 : return Sort(d_nm, d_type->getDatatypeTesterDomainType());
1865 : : ////////
1866 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1867 [ - + ]: 2 : }
1868 : :
1869 : 4 : Sort Sort::getDatatypeTesterCodomainSort() const
1870 : : {
1871 : : CVC5_API_TRY_CATCH_BEGIN;
1872 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1873 : 6 : CVC5_API_CHECK(d_type->isDatatypeTester())
1874 : 2 : << "not a tester sort: " << (*this);
1875 : : //////// all checks before this line
1876 : 2 : return Sort(d_nm, d_nm->booleanType());
1877 : : ////////
1878 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1879 [ - + ]: 2 : }
1880 : :
1881 : : /* Function sort ------------------------------------------------------- */
1882 : :
1883 : 763459 : size_t Sort::getFunctionArity() const
1884 : : {
1885 : : CVC5_API_TRY_CATCH_BEGIN;
1886 [ - + ][ - + ]: 763459 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1887 [ + + ][ + + ]: 763459 : CVC5_API_CHECK(isFunction()) << "not a function sort: " << (*this);
[ - - ]
1888 : : //////// all checks before this line
1889 : 763457 : return d_type->getNumChildren() - 1;
1890 : : ////////
1891 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1892 : : }
1893 : :
1894 : 1557 : std::vector<Sort> Sort::getFunctionDomainSorts() const
1895 : : {
1896 : : CVC5_API_TRY_CATCH_BEGIN;
1897 [ - + ][ - + ]: 1557 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1898 [ + + ][ + + ]: 1557 : CVC5_API_CHECK(isFunction()) << "not a function sort: " << (*this);
[ - - ]
1899 : : //////// all checks before this line
1900 : 1555 : return typeNodeVectorToSorts(d_nm, d_type->getArgTypes());
1901 : : ////////
1902 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1903 [ - + ]: 2 : }
1904 : :
1905 : 1562 : Sort Sort::getFunctionCodomainSort() const
1906 : : {
1907 : : CVC5_API_TRY_CATCH_BEGIN;
1908 [ - + ][ - + ]: 1562 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1909 [ + + ][ + + ]: 1562 : CVC5_API_CHECK(isFunction()) << "not a function sort" << (*this);
[ - - ]
1910 : : //////// all checks before this line
1911 : 1560 : return Sort(d_nm, d_type->getRangeType());
1912 : : ////////
1913 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1914 [ - + ]: 2 : }
1915 : :
1916 : : /* Array sort ---------------------------------------------------------- */
1917 : :
1918 : 6 : Sort Sort::getArrayIndexSort() const
1919 : : {
1920 : : CVC5_API_TRY_CATCH_BEGIN;
1921 [ - + ][ - + ]: 6 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1922 [ + + ][ + + ]: 6 : CVC5_API_CHECK(isArray()) << "not an array sort.";
[ - - ]
1923 : : //////// all checks before this line
1924 : 4 : return Sort(d_nm, d_type->getArrayIndexType());
1925 : : ////////
1926 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1927 [ - + ]: 2 : }
1928 : :
1929 : 466 : Sort Sort::getArrayElementSort() const
1930 : : {
1931 : : CVC5_API_TRY_CATCH_BEGIN;
1932 [ - + ][ - + ]: 466 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1933 [ + + ][ + + ]: 466 : CVC5_API_CHECK(isArray()) << "not an array sort.";
[ - - ]
1934 : : //////// all checks before this line
1935 : 464 : return Sort(d_nm, d_type->getArrayConstituentType());
1936 : : ////////
1937 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1938 [ - + ]: 2 : }
1939 : :
1940 : : /* Set sort ------------------------------------------------------------ */
1941 : :
1942 : 5 : Sort Sort::getSetElementSort() const
1943 : : {
1944 : : CVC5_API_TRY_CATCH_BEGIN;
1945 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1946 [ + + ][ + + ]: 5 : CVC5_API_CHECK(isSet()) << "not a set sort.";
[ - - ]
1947 : : //////// all checks before this line
1948 : 3 : return Sort(d_nm, d_type->getSetElementType());
1949 : : ////////
1950 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1951 [ - + ]: 2 : }
1952 : :
1953 : : /* Bag sort ------------------------------------------------------------ */
1954 : :
1955 : 5 : Sort Sort::getBagElementSort() const
1956 : : {
1957 : : CVC5_API_TRY_CATCH_BEGIN;
1958 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1959 [ + + ][ + + ]: 5 : CVC5_API_CHECK(isBag()) << "not a bag sort.";
[ - - ]
1960 : : //////// all checks before this line
1961 : 3 : return Sort(d_nm, d_type->getBagElementType());
1962 : : ////////
1963 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1964 [ - + ]: 2 : }
1965 : :
1966 : : /* Sequence sort ------------------------------------------------------- */
1967 : :
1968 : 106 : Sort Sort::getSequenceElementSort() const
1969 : : {
1970 : : CVC5_API_TRY_CATCH_BEGIN;
1971 [ - + ][ - + ]: 106 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1972 [ + + ][ + + ]: 106 : CVC5_API_CHECK(isSequence()) << "not a sequence sort.";
[ - - ]
1973 : : //////// all checks before this line
1974 : 104 : return Sort(d_nm, d_type->getSequenceElementType());
1975 : : ////////
1976 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1977 [ - + ]: 2 : }
1978 : :
1979 : : /* Abstract sort ------------------------------------------------------- */
1980 : :
1981 : 6 : SortKind Sort::getAbstractedKind() const
1982 : : {
1983 : : CVC5_API_TRY_CATCH_BEGIN;
1984 [ - + ][ - + ]: 6 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1985 [ + + ][ + + ]: 6 : CVC5_API_CHECK(isAbstract()) << "not an abstract sort.";
[ - - ]
1986 : : //////// all checks before this line
1987 : 4 : return intToExtSortKind(d_type->getAbstractedKind());
1988 : : ////////
1989 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
1990 : : }
1991 : :
1992 : : /* Sort constructor sort ----------------------------------------------- */
1993 : :
1994 : 4 : size_t Sort::getUninterpretedSortConstructorArity() const
1995 : : {
1996 : : CVC5_API_TRY_CATCH_BEGIN;
1997 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
1998 : 6 : CVC5_API_CHECK(d_type->isUninterpretedSortConstructor())
1999 : 2 : << "not a sort constructor sort.";
2000 : : //////// all checks before this line
2001 : 2 : return d_type->getUninterpretedSortConstructorArity();
2002 : : ////////
2003 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2004 : : }
2005 : :
2006 : : /* Bit-vector sort ----------------------------------------------------- */
2007 : :
2008 : 7 : uint32_t Sort::getBitVectorSize() const
2009 : : {
2010 : : CVC5_API_TRY_CATCH_BEGIN;
2011 [ - + ][ - + ]: 7 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2012 [ + + ][ + + ]: 7 : CVC5_API_CHECK(isBitVector()) << "not a bit-vector sort.";
[ - - ]
2013 : : //////// all checks before this line
2014 : 5 : return d_type->getBitVectorSize();
2015 : : ////////
2016 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2017 : : }
2018 : :
2019 : : /* Finite field sort --------------------------------------------------- */
2020 : :
2021 : 10 : std::string Sort::getFiniteFieldSize() const
2022 : : {
2023 : : CVC5_API_TRY_CATCH_BEGIN;
2024 [ + + ][ + + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2025 [ + + ][ + + ]: 9 : CVC5_API_CHECK(isFiniteField()) << "not a finite field sort.";
[ - - ]
2026 : : //////// all checks before this line
2027 : 7 : return d_type->getFfSize().toString();
2028 : : ////////
2029 [ + - ][ - - ]: 3 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2030 [ - + ]: 3 : }
2031 : :
2032 : : /* Floating-point sort ------------------------------------------------- */
2033 : :
2034 : 4 : uint32_t Sort::getFloatingPointExponentSize() const
2035 : : {
2036 : : CVC5_API_TRY_CATCH_BEGIN;
2037 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2038 : 4 : CVC5_API_CHECK(d_type->isFloatingPoint()) << "not a floating-point sort.";
2039 : : //////// all checks before this line
2040 : 2 : return d_type->getFloatingPointExponentSize();
2041 : : ////////
2042 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2043 : : }
2044 : :
2045 : 4 : uint32_t Sort::getFloatingPointSignificandSize() const
2046 : : {
2047 : : CVC5_API_TRY_CATCH_BEGIN;
2048 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2049 : 4 : CVC5_API_CHECK(d_type->isFloatingPoint()) << "not a floating-point sort.";
2050 : : //////// all checks before this line
2051 : 2 : return d_type->getFloatingPointSignificandSize();
2052 : : ////////
2053 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2054 : : }
2055 : :
2056 : : /* Datatype sort ------------------------------------------------------- */
2057 : :
2058 : 6 : size_t Sort::getDatatypeArity() const
2059 : : {
2060 : : CVC5_API_TRY_CATCH_BEGIN;
2061 [ - + ][ - + ]: 6 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2062 [ + + ][ + + ]: 6 : CVC5_API_CHECK(d_type->isDatatype()) << "not a datatype sort.";
[ - - ]
2063 : : //////// all checks before this line
2064 [ - + ]: 4 : return d_type->isParametricDatatype() ? d_type->getNumChildren() - 1 : 0;
2065 : : ////////
2066 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2067 : : }
2068 : :
2069 : : /* Tuple sort ---------------------------------------------------------- */
2070 : :
2071 : 999 : size_t Sort::getTupleLength() const
2072 : : {
2073 : : CVC5_API_TRY_CATCH_BEGIN;
2074 [ - + ][ - + ]: 999 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2075 [ + + ][ + + ]: 999 : CVC5_API_CHECK(isTuple()) << "not a tuple sort.";
[ - - ]
2076 : : //////// all checks before this line
2077 : 997 : return d_type->getTupleLength();
2078 : : ////////
2079 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2080 : : }
2081 : :
2082 : 4 : std::vector<Sort> Sort::getTupleSorts() const
2083 : : {
2084 : : CVC5_API_TRY_CATCH_BEGIN;
2085 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2086 : 4 : CVC5_API_CHECK(d_type->isTuple()) << "not a tuple sort.";
2087 : : //////// all checks before this line
2088 : 2 : return typeNodeVectorToSorts(d_nm, d_type->getTupleTypes());
2089 : : ////////
2090 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2091 [ - + ]: 2 : }
2092 : :
2093 : 5 : Sort Sort::getNullableElementSort() const
2094 : : {
2095 : : CVC5_API_TRY_CATCH_BEGIN;
2096 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2097 [ + + ][ + + ]: 5 : CVC5_API_CHECK(isNullable()) << "not a nullable sort.";
[ - - ]
2098 : : //////// all checks before this line
2099 : 3 : return Sort(d_nm, d_type->getNullableElementType());
2100 : : ////////
2101 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2102 [ - + ]: 2 : }
2103 : :
2104 : : /* --------------------------------------------------------------------- */
2105 : :
2106 : 66 : std::ostream& operator<<(std::ostream& out, const Sort& s)
2107 : : {
2108 : 66 : out << s.toString();
2109 : 66 : return out;
2110 : : }
2111 : :
2112 : : /* Helpers */
2113 : : /* -------------------------------------------------------------------------- */
2114 : :
2115 : : /* Split out to avoid nested API calls (problematic with API tracing). */
2116 : : /* .......................................................................... */
2117 : :
2118 : 14937015 : bool Sort::isNullHelper() const { return d_type->isNull(); }
2119 : :
2120 : : /* -------------------------------------------------------------------------- */
2121 : : /* Op */
2122 : : /* -------------------------------------------------------------------------- */
2123 : :
2124 : 395971 : Op::Op() : d_nm(nullptr), d_kind(Kind::NULL_TERM), d_node(new internal::Node())
2125 : : {
2126 : 395971 : }
2127 : :
2128 : 178 : Op::Op(NodeManagerSharedPtr nm, const Kind k)
2129 : 178 : : d_nm(std::move(nm)), d_kind(k), d_node(new internal::Node())
2130 : : {
2131 : 178 : }
2132 : :
2133 : 197541 : Op::Op(NodeManagerSharedPtr nm, const Kind k, const internal::Node& n)
2134 : 197541 : : d_nm(std::move(nm)), d_kind(k), d_node(new internal::Node(n))
2135 : : {
2136 : 197541 : }
2137 : :
2138 : 791409 : Op::~Op()
2139 : : {
2140 [ + + ][ + - ]: 791409 : Assert(isNull() || d_nm != nullptr);
[ - + ][ - + ]
2141 : 791409 : d_node.reset();
2142 : 791409 : }
2143 : :
2144 : : /* Public methods */
2145 : 27 : bool Op::operator==(const Op& t) const
2146 : : {
2147 : : CVC5_API_TRY_CATCH_BEGIN;
2148 : : //////// all checks before this line
2149 [ + + ][ + + ]: 27 : if (d_node->isNull() && t.d_node->isNull())
[ + + ]
2150 : : {
2151 : 14 : return (d_kind == t.d_kind);
2152 : : }
2153 [ + + ][ - + ]: 13 : else if (d_node->isNull() || t.d_node->isNull())
[ + + ]
2154 : : {
2155 : 1 : return false;
2156 : : }
2157 [ + - ][ + + ]: 12 : return (d_kind == t.d_kind) && (*d_node == *t.d_node);
2158 : : ////////
2159 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2160 : : }
2161 : :
2162 : 2 : bool Op::operator!=(const Op& t) const
2163 : : {
2164 : : CVC5_API_TRY_CATCH_BEGIN;
2165 : : //////// all checks before this line
2166 : 2 : return !(*this == t);
2167 : : ////////
2168 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2169 : : }
2170 : :
2171 : 197611 : Kind Op::getKind() const
2172 : : {
2173 [ - + ][ - + ]: 197611 : CVC5_API_CHECK(d_kind != Kind::NULL_TERM) << "expected a non-null Kind";
[ - - ]
2174 : : //////// all checks before this line
2175 : 197611 : return d_kind;
2176 : : }
2177 : :
2178 : 1186684 : bool Op::isNull() const
2179 : : {
2180 : : CVC5_API_TRY_CATCH_BEGIN;
2181 : : //////// all checks before this line
2182 : 1186684 : return isNullHelper();
2183 : : ////////
2184 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2185 : : }
2186 : :
2187 : 8 : bool Op::isIndexed() const
2188 : : {
2189 : : CVC5_API_TRY_CATCH_BEGIN;
2190 : : //////// all checks before this line
2191 : 8 : return isIndexedHelper();
2192 : : ////////
2193 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2194 : : }
2195 : :
2196 : 50 : size_t Op::getNumIndices() const
2197 : : {
2198 : : CVC5_API_TRY_CATCH_BEGIN;
2199 [ - + ][ - + ]: 50 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2200 : : //////// all checks before this line
2201 : 50 : return getNumIndicesHelper();
2202 : : ////////
2203 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2204 : : }
2205 : :
2206 : 127 : size_t Op::getNumIndicesHelper() const
2207 : : {
2208 [ + + ]: 127 : if (!isIndexedHelper())
2209 : : {
2210 : 3 : return 0;
2211 : : }
2212 : :
2213 : 124 : Kind k = intToExtKind(d_node->getKind());
2214 : 124 : size_t size = 0;
2215 [ + + ][ + + ]: 124 : switch (k)
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - ]
2216 : : {
2217 : 4 : case Kind::DIVISIBLE: size = 1; break;
2218 : 4 : case Kind::BITVECTOR_REPEAT: size = 1; break;
2219 : 4 : case Kind::BITVECTOR_ZERO_EXTEND: size = 1; break;
2220 : 4 : case Kind::BITVECTOR_SIGN_EXTEND: size = 1; break;
2221 : 4 : case Kind::BITVECTOR_ROTATE_LEFT: size = 1; break;
2222 : 4 : case Kind::BITVECTOR_ROTATE_RIGHT: size = 1; break;
2223 : 4 : case Kind::BITVECTOR_BIT: size = 1; break;
2224 : 4 : case Kind::INT_TO_BITVECTOR: size = 1; break;
2225 : 4 : case Kind::IAND: size = 1; break;
2226 : 4 : case Kind::FLOATINGPOINT_TO_UBV: size = 1; break;
2227 : 4 : case Kind::FLOATINGPOINT_TO_SBV: size = 1; break;
2228 : 2 : case Kind::REGEXP_REPEAT: size = 1; break;
2229 : 8 : case Kind::BITVECTOR_EXTRACT: size = 2; break;
2230 : 6 : case Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV: size = 2; break;
2231 : 6 : case Kind::FLOATINGPOINT_TO_FP_FROM_FP: size = 2; break;
2232 : 6 : case Kind::FLOATINGPOINT_TO_FP_FROM_REAL: size = 2; break;
2233 : 6 : case Kind::FLOATINGPOINT_TO_FP_FROM_SBV: size = 2; break;
2234 : 6 : case Kind::FLOATINGPOINT_TO_FP_FROM_UBV: size = 2; break;
2235 : 6 : case Kind::REGEXP_LOOP: size = 2; break;
2236 : 34 : case Kind::TUPLE_PROJECT:
2237 : : case Kind::RELATION_AGGREGATE:
2238 : : case Kind::RELATION_GROUP:
2239 : : case Kind::RELATION_PROJECT:
2240 : : case Kind::RELATION_TABLE_JOIN:
2241 : : case Kind::TABLE_AGGREGATE:
2242 : : case Kind::TABLE_GROUP:
2243 : : case Kind::TABLE_JOIN:
2244 : : case Kind::TABLE_PROJECT:
2245 : : {
2246 : 34 : size = d_node->getConst<internal::ProjectOp>().getIndices().size();
2247 : 34 : break;
2248 : : }
2249 : 0 : default: CVC5_API_CHECK(false) << "Unhandled kind " << k;
2250 : : }
2251 : 124 : return size;
2252 : : }
2253 : :
2254 : 79 : Term Op::operator[](size_t index) { return getIndexHelper(index); }
2255 : :
2256 : 79 : Term Op::getIndexHelper(size_t index)
2257 : : {
2258 : : CVC5_API_TRY_CATCH_BEGIN;
2259 [ - + ][ - + ]: 79 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2260 [ + + ][ + + ]: 81 : CVC5_API_CHECK(!d_node->isNull())
[ - - ]
2261 : 2 : << "expected a non-null internal expression. This Op is not indexed.";
2262 [ - + ][ - + ]: 77 : CVC5_API_CHECK(index < getNumIndicesHelper()) << "index out of bound";
[ - - ]
2263 : 77 : Kind k = intToExtKind(d_node->getKind());
2264 : 77 : Term t;
2265 [ + + ][ + + ]: 77 : switch (k)
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - ]
2266 : : {
2267 : 2 : case Kind::DIVISIBLE:
2268 : : {
2269 : 4 : t = TermManager::mkRationalValHelper(
2270 : 2 : d_nm,
2271 : 4 : internal::Rational(d_node->getConst<internal::Divisible>().k),
2272 : 2 : true);
2273 : 2 : break;
2274 : : }
2275 : 2 : case Kind::BITVECTOR_REPEAT:
2276 : : {
2277 : 4 : t = TermManager::mkRationalValHelper(
2278 : 2 : d_nm,
2279 : 2 : d_node->getConst<internal::BitVectorRepeat>().d_repeatAmount,
2280 : 2 : true);
2281 : 2 : break;
2282 : : }
2283 : 2 : case Kind::BITVECTOR_ZERO_EXTEND:
2284 : : {
2285 : 4 : t = TermManager::mkRationalValHelper(
2286 : 2 : d_nm,
2287 : 2 : d_node->getConst<internal::BitVectorZeroExtend>().d_zeroExtendAmount,
2288 : 2 : true);
2289 : 2 : break;
2290 : : }
2291 : 2 : case Kind::BITVECTOR_SIGN_EXTEND:
2292 : : {
2293 : 4 : t = TermManager::mkRationalValHelper(
2294 : 2 : d_nm,
2295 : 2 : d_node->getConst<internal::BitVectorSignExtend>().d_signExtendAmount,
2296 : 2 : true);
2297 : 2 : break;
2298 : : }
2299 : 2 : case Kind::BITVECTOR_ROTATE_LEFT:
2300 : : {
2301 : 4 : t = TermManager::mkRationalValHelper(
2302 : 2 : d_nm,
2303 : 2 : d_node->getConst<internal::BitVectorRotateLeft>().d_rotateLeftAmount,
2304 : 2 : true);
2305 : 2 : break;
2306 : : }
2307 : 2 : case Kind::BITVECTOR_ROTATE_RIGHT:
2308 : : {
2309 : 4 : t = TermManager::mkRationalValHelper(
2310 : 2 : d_nm,
2311 : 2 : d_node->getConst<internal::BitVectorRotateRight>()
2312 : 2 : .d_rotateRightAmount,
2313 : 2 : true);
2314 : 2 : break;
2315 : : }
2316 : 2 : case Kind::INT_TO_BITVECTOR:
2317 : : {
2318 : 4 : t = TermManager::mkRationalValHelper(
2319 : 4 : d_nm, d_node->getConst<internal::IntToBitVector>().d_size, true);
2320 : 2 : break;
2321 : : }
2322 : 2 : case Kind::BITVECTOR_BIT:
2323 : : {
2324 : 4 : t = TermManager::mkRationalValHelper(
2325 : 4 : d_nm, d_node->getConst<internal::BitVectorBit>().d_bitIndex, true);
2326 : 2 : break;
2327 : : }
2328 : 2 : case Kind::IAND:
2329 : : {
2330 : 4 : t = TermManager::mkRationalValHelper(
2331 : 4 : d_nm, d_node->getConst<internal::IntAnd>().d_size, true);
2332 : 2 : break;
2333 : : }
2334 : 2 : case Kind::FLOATINGPOINT_TO_UBV:
2335 : : {
2336 : 4 : t = TermManager::mkRationalValHelper(
2337 : 2 : d_nm,
2338 : 2 : d_node->getConst<internal::FloatingPointToUBV>().d_bv_size.d_size,
2339 : 2 : true);
2340 : 2 : break;
2341 : : }
2342 : 2 : case Kind::FLOATINGPOINT_TO_SBV:
2343 : : {
2344 : 4 : t = TermManager::mkRationalValHelper(
2345 : 2 : d_nm,
2346 : 2 : d_node->getConst<internal::FloatingPointToSBV>().d_bv_size.d_size,
2347 : 2 : true);
2348 : 2 : break;
2349 : : }
2350 : 2 : case Kind::REGEXP_REPEAT:
2351 : : {
2352 : 4 : t = TermManager::mkRationalValHelper(
2353 : 2 : d_nm,
2354 : 2 : d_node->getConst<internal::RegExpRepeat>().d_repeatAmount,
2355 : 2 : true);
2356 : 2 : break;
2357 : : }
2358 : 5 : case Kind::BITVECTOR_EXTRACT:
2359 : : {
2360 : : internal::BitVectorExtract ext =
2361 : 5 : d_node->getConst<internal::BitVectorExtract>();
2362 : 12 : t = index == 0 ? TermManager::mkRationalValHelper(d_nm, ext.d_high, true)
2363 : 7 : : TermManager::mkRationalValHelper(d_nm, ext.d_low, true);
2364 : 5 : break;
2365 : : }
2366 : 4 : case Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV:
2367 : : {
2368 : : internal::FloatingPointToFPIEEEBitVector ext =
2369 : 4 : d_node->getConst<internal::FloatingPointToFPIEEEBitVector>();
2370 : :
2371 : 20 : t = index == 0 ? TermManager::mkRationalValHelper(
2372 : 4 : d_nm, ext.getSize().exponentWidth(), true)
2373 : : : TermManager::mkRationalValHelper(
2374 [ + + ]: 12 : d_nm, ext.getSize().significandWidth(), true);
2375 : 4 : break;
2376 : : }
2377 : 4 : case Kind::FLOATINGPOINT_TO_FP_FROM_FP:
2378 : : {
2379 : : internal::FloatingPointToFPFloatingPoint ext =
2380 : 4 : d_node->getConst<internal::FloatingPointToFPFloatingPoint>();
2381 : 20 : t = index == 0 ? TermManager::mkRationalValHelper(
2382 : 4 : d_nm, ext.getSize().exponentWidth(), true)
2383 : : : TermManager::mkRationalValHelper(
2384 [ + + ]: 12 : d_nm, ext.getSize().significandWidth(), true);
2385 : 4 : break;
2386 : : }
2387 : 4 : case Kind::FLOATINGPOINT_TO_FP_FROM_REAL:
2388 : : {
2389 : : internal::FloatingPointToFPReal ext =
2390 : 4 : d_node->getConst<internal::FloatingPointToFPReal>();
2391 : :
2392 : 20 : t = index == 0 ? TermManager::mkRationalValHelper(
2393 : 4 : d_nm, ext.getSize().exponentWidth(), true)
2394 : : : TermManager::mkRationalValHelper(
2395 [ + + ]: 12 : d_nm, ext.getSize().significandWidth(), true);
2396 : 4 : break;
2397 : : }
2398 : 4 : case Kind::FLOATINGPOINT_TO_FP_FROM_SBV:
2399 : : {
2400 : : internal::FloatingPointToFPSignedBitVector ext =
2401 : 4 : d_node->getConst<internal::FloatingPointToFPSignedBitVector>();
2402 : 20 : t = index == 0 ? TermManager::mkRationalValHelper(
2403 : 4 : d_nm, ext.getSize().exponentWidth(), true)
2404 : : : TermManager::mkRationalValHelper(
2405 [ + + ]: 12 : d_nm, ext.getSize().significandWidth(), true);
2406 : 4 : break;
2407 : : }
2408 : 4 : case Kind::FLOATINGPOINT_TO_FP_FROM_UBV:
2409 : : {
2410 : : internal::FloatingPointToFPUnsignedBitVector ext =
2411 : 4 : d_node->getConst<internal::FloatingPointToFPUnsignedBitVector>();
2412 : 20 : t = index == 0 ? TermManager::mkRationalValHelper(
2413 : 4 : d_nm, ext.getSize().exponentWidth(), true)
2414 : : : TermManager::mkRationalValHelper(
2415 [ + + ]: 12 : d_nm, ext.getSize().significandWidth(), true);
2416 : 4 : break;
2417 : : }
2418 : 4 : case Kind::REGEXP_LOOP:
2419 : : {
2420 : 4 : internal::RegExpLoop ext = d_node->getConst<internal::RegExpLoop>();
2421 : : t = index == 0
2422 : 10 : ? TermManager::mkRationalValHelper(d_nm, ext.d_loopMinOcc, true)
2423 : 6 : : TermManager::mkRationalValHelper(d_nm, ext.d_loopMaxOcc, true);
2424 : :
2425 : 4 : break;
2426 : : }
2427 : 24 : case Kind::TUPLE_PROJECT:
2428 : : case Kind::RELATION_AGGREGATE:
2429 : : case Kind::RELATION_GROUP:
2430 : : case Kind::RELATION_PROJECT:
2431 : : case Kind::RELATION_TABLE_JOIN:
2432 : : case Kind::TABLE_AGGREGATE:
2433 : : case Kind::TABLE_GROUP:
2434 : : case Kind::TABLE_JOIN:
2435 : : case Kind::TABLE_PROJECT:
2436 : : {
2437 : : const std::vector<uint32_t>& projectionIndices =
2438 : 24 : d_node->getConst<internal::ProjectOp>().getIndices();
2439 : 72 : t = TermManager::mkRationalValHelper(
2440 : 72 : d_nm, projectionIndices[index], true);
2441 : 24 : break;
2442 : : }
2443 : 0 : default:
2444 : : {
2445 : 0 : CVC5_API_CHECK(false) << "Unhandled kind " << k;
2446 : 0 : break;
2447 : : }
2448 : : }
2449 : :
2450 : : //////// all checks before this line
2451 : 154 : return t;
2452 : : ////////
2453 [ + - ][ - - ]: 79 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2454 [ - + ]: 2 : }
2455 : :
2456 : 7 : std::string Op::toString() const
2457 : : {
2458 : : CVC5_API_TRY_CATCH_BEGIN;
2459 : : //////// all checks before this line
2460 [ - + ]: 7 : if (d_node->isNull())
2461 : : {
2462 : 0 : return std::to_string(d_kind);
2463 : : }
2464 : : else
2465 : : {
2466 [ - + ][ - + ]: 7 : CVC5_API_CHECK(!d_node->isNull())
[ - - ]
2467 : 0 : << "expected a non-null internal expression";
2468 [ + - ][ + - ]: 7 : Assert(isNull() || d_nm != nullptr);
[ - + ][ - + ]
[ - - ]
2469 : 7 : return d_node->toString();
2470 : : }
2471 : : ////////
2472 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2473 [ - - ]: 0 : }
2474 : :
2475 : 2 : std::ostream& operator<<(std::ostream& out, const Op& t)
2476 : : {
2477 : 2 : out << t.toString();
2478 : 2 : return out;
2479 : : }
2480 : :
2481 : : /* Helpers */
2482 : : /* -------------------------------------------------------------------------- */
2483 : :
2484 : : /* Split out to avoid nested API calls (problematic with API tracing). */
2485 : : /* .......................................................................... */
2486 : :
2487 : 1186813 : bool Op::isNullHelper() const
2488 : : {
2489 [ + + ][ + + ]: 1186813 : return (d_node->isNull() && (d_kind == Kind::NULL_TERM));
2490 : : }
2491 : :
2492 : 197879 : bool Op::isIndexedHelper() const { return !d_node->isNull(); }
2493 : :
2494 : : /* -------------------------------------------------------------------------- */
2495 : : /* Term */
2496 : : /* -------------------------------------------------------------------------- */
2497 : :
2498 : 42183104 : Term::Term() : d_nm(nullptr), d_node(new internal::Node()) {}
2499 : :
2500 : 8888497 : Term::Term(NodeManagerSharedPtr nm, const internal::Node& n)
2501 : 8888497 : : d_nm(std::move(nm))
2502 : : {
2503 : 8888497 : d_node.reset(new internal::Node(n));
2504 : 8888497 : }
2505 : :
2506 : 134638143 : Term::~Term()
2507 : : {
2508 [ + + ][ + - ]: 134638143 : Assert(isNull() || d_nm != nullptr);
[ - + ][ - + ]
2509 : 134638143 : d_node.reset();
2510 : 134638143 : }
2511 : :
2512 : 273890 : bool Term::operator==(const Term& t) const
2513 : : {
2514 : : CVC5_API_TRY_CATCH_BEGIN;
2515 : : //////// all checks before this line
2516 : 273890 : return *d_node == *t.d_node;
2517 : : ////////
2518 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2519 : : }
2520 : :
2521 : 2455 : bool Term::operator!=(const Term& t) const
2522 : : {
2523 : : CVC5_API_TRY_CATCH_BEGIN;
2524 : : //////// all checks before this line
2525 : 2455 : return *d_node != *t.d_node;
2526 : : ////////
2527 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2528 : : }
2529 : :
2530 : 44878 : bool Term::operator<(const Term& t) const
2531 : : {
2532 : : CVC5_API_TRY_CATCH_BEGIN;
2533 : : //////// all checks before this line
2534 : 44878 : return *d_node < *t.d_node;
2535 : : ////////
2536 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2537 : : }
2538 : :
2539 : 3 : bool Term::operator>(const Term& t) const
2540 : : {
2541 : : CVC5_API_TRY_CATCH_BEGIN;
2542 : : //////// all checks before this line
2543 : 3 : return *d_node > *t.d_node;
2544 : : ////////
2545 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2546 : : }
2547 : :
2548 : 2 : bool Term::operator<=(const Term& t) const
2549 : : {
2550 : : CVC5_API_TRY_CATCH_BEGIN;
2551 : : //////// all checks before this line
2552 : 2 : return *d_node <= *t.d_node;
2553 : : ////////
2554 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2555 : : }
2556 : :
2557 : 3 : bool Term::operator>=(const Term& t) const
2558 : : {
2559 : : CVC5_API_TRY_CATCH_BEGIN;
2560 : : //////// all checks before this line
2561 : 3 : return *d_node >= *t.d_node;
2562 : : ////////
2563 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2564 : : }
2565 : :
2566 : 2173 : size_t Term::getNumChildren() const
2567 : : {
2568 : : CVC5_API_TRY_CATCH_BEGIN;
2569 [ + + ][ + + ]: 2173 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2570 : : //////// all checks before this line
2571 : :
2572 : : // special case for apply kinds
2573 [ + + ]: 2172 : if (isApplyKind(d_node->getKind()))
2574 : : {
2575 : 2097 : return d_node->getNumChildren() + 1;
2576 : : }
2577 : 75 : return d_node->getNumChildren();
2578 : : ////////
2579 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2580 : : }
2581 : :
2582 : 1121 : Term Term::operator[](size_t index) const
2583 : : {
2584 : : CVC5_API_TRY_CATCH_BEGIN;
2585 [ + + ][ + + ]: 1121 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2586 [ - + ][ - + ]: 1120 : CVC5_API_CHECK(index < getNumChildren()) << "index out of bound";
[ - - ]
2587 [ + + ][ + - ]: 1120 : CVC5_API_CHECK(!isApplyKind(d_node->getKind()) || d_node->hasOperator())
[ - + ][ - + ]
[ - - ]
2588 : 0 : << "expected apply kind to have operator when accessing child of Term";
2589 : : //////// all checks before this line
2590 : :
2591 : : // special cases for apply kinds
2592 [ + + ]: 1120 : if (isApplyKind(d_node->getKind()))
2593 : : {
2594 [ + + ]: 1050 : if (index == 0)
2595 : : {
2596 : : // return the operator
2597 : 1047 : return Term(d_nm, d_node->getOperator());
2598 : : }
2599 : : else
2600 : : {
2601 : 3 : index -= 1;
2602 : : }
2603 : : }
2604 : : // otherwise we are looking up child at (index-1)
2605 : 73 : return Term(d_nm, (*d_node)[index]);
2606 : : ////////
2607 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2608 [ - + ]: 1 : }
2609 : :
2610 : 11 : uint64_t Term::getId() const
2611 : : {
2612 : : CVC5_API_TRY_CATCH_BEGIN;
2613 [ + + ][ + + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2614 : : //////// all checks before this line
2615 : 10 : return d_node->getId();
2616 : : ////////
2617 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2618 : : }
2619 : :
2620 : 6827 : Kind Term::getKind() const
2621 : : {
2622 : : CVC5_API_TRY_CATCH_BEGIN;
2623 [ + + ][ + + ]: 6827 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2624 : : //////// all checks before this line
2625 : 6826 : return getKindHelper();
2626 : : ////////
2627 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2628 : : }
2629 : :
2630 : 4676019 : Sort Term::getSort() const
2631 : : {
2632 : : CVC5_API_TRY_CATCH_BEGIN;
2633 [ + + ][ + + ]: 4676019 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2634 : : //////// all checks before this line
2635 : 4676018 : return Sort(d_nm, d_node->getType());
2636 : : ////////
2637 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2638 [ - + ]: 1 : }
2639 : :
2640 : 32 : Term Term::substitute(const Term& term, const Term& replacement) const
2641 : : {
2642 : : CVC5_API_TRY_CATCH_BEGIN;
2643 [ + + ][ + + ]: 32 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2644 : 31 : CVC5_API_CHECK_TERM(term);
2645 : 30 : CVC5_API_CHECK_TERM(replacement);
2646 [ + + ][ + + ]: 89 : CVC5_API_CHECK(CVC5_EQUAL(term.getSort(), replacement.getSort()))
[ - - ]
2647 : 2 : << "expected terms of the same sort in substitute";
2648 : : //////// all checks before this line
2649 : 27 : return Term(d_nm,
2650 : 81 : d_node->substitute(internal::TNode(*term.d_node),
2651 : 81 : internal::TNode(*replacement.d_node)));
2652 : : ////////
2653 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2654 [ - + ]: 5 : }
2655 : :
2656 : 8 : Term Term::substitute(const std::vector<Term>& terms,
2657 : : const std::vector<Term>& replacements) const
2658 : : {
2659 : : CVC5_API_TRY_CATCH_BEGIN;
2660 [ + + ][ + + ]: 8 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2661 [ + + ][ + + ]: 8 : CVC5_API_CHECK(terms.size() == replacements.size())
[ - - ]
2662 : 1 : << "expected vectors of the same arity in substitute";
2663 : 34 : CVC5_API_TERM_CHECK_TERMS_WITH_TERMS_SORT_EQUAL_TO(terms, replacements);
2664 : : //////// all checks before this line
2665 : 2 : std::vector<internal::Node> nodes = Term::termVectorToNodes(terms);
2666 : : std::vector<internal::Node> nodeReplacements =
2667 : 2 : Term::termVectorToNodes(replacements);
2668 : 2 : return Term(d_nm,
2669 : 2 : d_node->substitute(nodes.begin(),
2670 : : nodes.end(),
2671 : : nodeReplacements.begin(),
2672 : 4 : nodeReplacements.end()));
2673 : : ////////
2674 [ + - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2675 [ - + ]: 6 : }
2676 : :
2677 : 22 : bool Term::hasOp() const
2678 : : {
2679 : : CVC5_API_TRY_CATCH_BEGIN;
2680 [ - + ][ - + ]: 22 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2681 : : //////// all checks before this line
2682 : 22 : return d_node->hasOperator();
2683 : : ////////
2684 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2685 : : }
2686 : :
2687 : 29 : Op Term::getOp() const
2688 : : {
2689 : : CVC5_API_TRY_CATCH_BEGIN;
2690 [ - + ][ - + ]: 29 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2691 [ + + ][ + + ]: 33 : CVC5_API_CHECK(d_node->hasOperator())
[ - - ]
2692 : 4 : << "expected Term to have an Op when calling getOp()";
2693 : : //////// all checks before this line
2694 : :
2695 : : // special cases for parameterized operators that are not indexed operators
2696 : : // the API level differs from the internal structure
2697 : : // indexed operators are stored in Ops
2698 : : // whereas functions and datatype operators are terms, and the Op
2699 : : // is one of the APPLY_* kinds
2700 [ + + ]: 25 : if (isApplyKind(d_node->getKind()))
2701 : : {
2702 : 12 : return Op(d_nm, intToExtKind(d_node->getKind()));
2703 : : }
2704 [ + + ]: 13 : else if (d_node->getMetaKind() == internal::kind::metakind::PARAMETERIZED)
2705 : : {
2706 : : // it's an indexed operator
2707 : : // so we should return the indexed op
2708 : 8 : internal::Node op = d_node->getOperator();
2709 : 8 : return Op(d_nm, intToExtKind(d_node->getKind()), op);
2710 : 8 : }
2711 : : // Notice this is the only case where getKindHelper is used, since the
2712 : : // cases above do not have special cases for intToExtKind.
2713 : 5 : return Op(d_nm, getKindHelper());
2714 : : ////////
2715 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2716 [ - + ]: 4 : }
2717 : :
2718 : 27918 : bool Term::hasSymbol() const
2719 : : {
2720 : : CVC5_API_TRY_CATCH_BEGIN;
2721 [ + + ][ + + ]: 27918 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2722 : : //////// all checks before this line
2723 : 27917 : return d_node->hasName();
2724 : : ////////
2725 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2726 : : }
2727 : :
2728 : 27885 : std::string Term::getSymbol() const
2729 : : {
2730 : : CVC5_API_TRY_CATCH_BEGIN;
2731 [ + + ][ + + ]: 27885 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2732 [ + + ][ + + ]: 27885 : CVC5_API_CHECK(d_node->hasName())
[ - - ]
2733 : : << "invalid call to '" << __PRETTY_FUNCTION__
2734 : 1 : << "', expected the term to have a symbol.";
2735 : : //////// all checks before this line
2736 : 27883 : return d_node->getName();
2737 : : ////////
2738 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2739 [ - + ]: 2 : }
2740 : :
2741 : 213591402 : bool Term::isNull() const
2742 : : {
2743 : : CVC5_API_TRY_CATCH_BEGIN;
2744 : : //////// all checks before this line
2745 : 213591402 : return isNullHelper();
2746 : : ////////
2747 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2748 : : }
2749 : :
2750 : 41 : Term Term::notTerm() const
2751 : : {
2752 : : CVC5_API_TRY_CATCH_BEGIN;
2753 [ + + ][ + + ]: 41 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2754 : : //////// all checks before this line
2755 : 40 : internal::Node res = d_node->notNode();
2756 : 40 : (void)res.getType(true); /* kick off type checking */
2757 : 68 : return Term(d_nm, res);
2758 : : ////////
2759 [ + - ][ - + ]: 47 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2760 [ - + ]: 7 : }
2761 : :
2762 : 48 : Term Term::andTerm(const Term& t) const
2763 : : {
2764 : : CVC5_API_TRY_CATCH_BEGIN;
2765 [ + + ][ + + ]: 48 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2766 : 47 : CVC5_API_CHECK_TERM(t);
2767 : : //////// all checks before this line
2768 : 46 : internal::Node res = d_node->andNode(*t.d_node);
2769 : 46 : (void)res.getType(true); /* kick off type checking */
2770 : 14 : return Term(d_nm, res);
2771 : : ////////
2772 [ + - ][ - + ]: 87 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2773 [ - + ]: 41 : }
2774 : :
2775 : 48 : Term Term::orTerm(const Term& t) const
2776 : : {
2777 : : CVC5_API_TRY_CATCH_BEGIN;
2778 [ + + ][ + + ]: 48 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2779 : 47 : CVC5_API_CHECK_TERM(t);
2780 : : //////// all checks before this line
2781 : 46 : internal::Node res = d_node->orNode(*t.d_node);
2782 : 46 : (void)res.getType(true); /* kick off type checking */
2783 : 14 : return Term(d_nm, res);
2784 : : ////////
2785 [ + - ][ - + ]: 87 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2786 [ - + ]: 41 : }
2787 : :
2788 : 50 : Term Term::xorTerm(const Term& t) const
2789 : : {
2790 : : CVC5_API_TRY_CATCH_BEGIN;
2791 [ + + ][ + + ]: 50 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2792 : 49 : CVC5_API_CHECK_TERM(t);
2793 : : //////// all checks before this line
2794 : 48 : internal::Node res = d_node->xorNode(*t.d_node);
2795 : 48 : (void)res.getType(true); /* kick off type checking */
2796 : 18 : return Term(d_nm, res);
2797 : : ////////
2798 [ + - ][ - + ]: 89 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2799 [ - + ]: 41 : }
2800 : :
2801 : 75 : Term Term::eqTerm(const Term& t) const
2802 : : {
2803 : : CVC5_API_TRY_CATCH_BEGIN;
2804 [ + + ][ + + ]: 75 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2805 : 74 : CVC5_API_CHECK_TERM(t);
2806 : : //////// all checks before this line
2807 : 73 : internal::Node res = d_node->eqNode(*t.d_node);
2808 : 73 : (void)res.getType(true); /* kick off type checking */
2809 : 86 : return Term(d_nm, res);
2810 : : ////////
2811 [ + - ][ - + ]: 105 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2812 [ - + ]: 32 : }
2813 : :
2814 : 49 : Term Term::impTerm(const Term& t) const
2815 : : {
2816 : : CVC5_API_TRY_CATCH_BEGIN;
2817 [ + + ][ + + ]: 49 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2818 : 48 : CVC5_API_CHECK_TERM(t);
2819 : : //////// all checks before this line
2820 : 47 : internal::Node res = d_node->impNode(*t.d_node);
2821 : 47 : (void)res.getType(true); /* kick off type checking */
2822 : 16 : return Term(d_nm, res);
2823 : : ////////
2824 [ + - ][ - + ]: 88 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2825 [ - + ]: 41 : }
2826 : :
2827 : 28 : Term Term::iteTerm(const Term& then_t, const Term& else_t) const
2828 : : {
2829 : : CVC5_API_TRY_CATCH_BEGIN;
2830 [ + + ][ + + ]: 28 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
2831 : 27 : CVC5_API_CHECK_TERM(then_t);
2832 : 26 : CVC5_API_CHECK_TERM(else_t);
2833 : : //////// all checks before this line
2834 : 25 : internal::Node res = d_node->iteNode(*then_t.d_node, *else_t.d_node);
2835 : 25 : (void)res.getType(true); /* kick off type checking */
2836 : 20 : return Term(d_nm, res);
2837 : : ////////
2838 [ + - ][ - + ]: 43 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
2839 [ - + ]: 18 : }
2840 : :
2841 : 5431 : std::string Term::toString() const
2842 : : {
2843 : : CVC5_API_TRY_CATCH_BEGIN;
2844 : : //////// all checks before this line
2845 : 10862 : return d_node->toString();
2846 : : ////////
2847 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
2848 : : }
2849 : :
2850 : 2 : Term::const_iterator::const_iterator()
2851 : 2 : : d_nm(nullptr), d_origNode(nullptr), d_pos(0)
2852 : : {
2853 : 2 : }
2854 : :
2855 : 334 : Term::const_iterator::const_iterator(NodeManagerSharedPtr nm,
2856 : : const std::shared_ptr<internal::Node>& n,
2857 : 334 : uint32_t p)
2858 : 334 : : d_nm(std::move(nm)), d_origNode(n), d_pos(p)
2859 : : {
2860 : 334 : }
2861 : :
2862 : 574 : bool Term::const_iterator::operator==(const const_iterator& it) const
2863 : : {
2864 [ + - ][ - + ]: 574 : if (d_origNode == nullptr || it.d_origNode == nullptr)
[ - + ]
2865 : : {
2866 : 0 : return false;
2867 : : }
2868 [ + - ]: 1148 : return (d_nm == it.d_nm && *d_origNode == *it.d_origNode)
2869 [ + - ][ + + ]: 1148 : && (d_pos == it.d_pos);
2870 : : }
2871 : :
2872 : 572 : bool Term::const_iterator::operator!=(const const_iterator& it) const
2873 : : {
2874 : 572 : return !(*this == it);
2875 : : }
2876 : :
2877 : 340 : Term::const_iterator& Term::const_iterator::operator++()
2878 : : {
2879 [ - + ][ - + ]: 340 : Assert(d_origNode != nullptr);
[ - - ]
2880 : 340 : ++d_pos;
2881 : 340 : return *this;
2882 : : }
2883 : :
2884 : 2 : Term::const_iterator Term::const_iterator::operator++(int)
2885 : : {
2886 [ - + ][ - + ]: 2 : Assert(d_origNode != nullptr);
[ - - ]
2887 : 2 : const_iterator it = *this;
2888 : 2 : ++d_pos;
2889 : 2 : return it;
2890 : : }
2891 : :
2892 : 218 : Term Term::const_iterator::operator*() const
2893 : : {
2894 [ - + ][ - + ]: 218 : Assert(d_origNode != nullptr);
[ - - ]
2895 : : // this term has an extra child (mismatch between API and internal structure)
2896 : : // the extra child will be the first child
2897 : 218 : bool extra_child = isApplyKind(d_origNode->getKind());
2898 : :
2899 [ + + ][ + + ]: 218 : if (!d_pos && extra_child)
2900 : : {
2901 : 88 : return Term(d_nm, d_origNode->getOperator());
2902 : : }
2903 : : else
2904 : : {
2905 : 130 : uint32_t idx = d_pos;
2906 [ + + ]: 130 : if (extra_child)
2907 : : {
2908 [ - + ][ - + ]: 4 : Assert(idx > 0);
[ - - ]
2909 : 4 : --idx;
2910 : : }
2911 : 130 : return Term(d_nm, (*d_origNode)[idx]);
2912 : : }
2913 : : }
2914 : :
2915 : 139 : Term::const_iterator Term::begin() const
2916 : : {
2917 : 139 : return Term::const_iterator(d_nm, d_node, 0);
2918 : : }
2919 : :
2920 : 195 : Term::const_iterator Term::end() const
2921 : : {
2922 : 195 : int endpos = d_node->getNumChildren();
2923 : : // special cases for APPLY_*
2924 : : // the API differs from the internal structure
2925 : : // the API takes a "higher-order" perspective and the applied
2926 : : // function or datatype constructor/selector/tester is a Term
2927 : : // which means it needs to be one of the children, even though
2928 : : // internally it is not
2929 [ + + ]: 195 : if (isApplyKind(d_node->getKind()))
2930 : : {
2931 : : // one more child if this is a UF application (count the UF as a child)
2932 : 88 : ++endpos;
2933 : : }
2934 : 195 : return Term::const_iterator(d_nm, d_node, endpos);
2935 : : }
2936 : :
2937 : 14369185 : const internal::Node& Term::getNode(void) const { return *d_node; }
2938 : :
2939 : : namespace detail {
2940 : 107 : const internal::Rational& getRational(const internal::Node& node)
2941 : : {
2942 [ + - ]: 107 : switch (node.getKind())
2943 : : {
2944 : 107 : case internal::Kind::CONST_INTEGER:
2945 : : case internal::Kind::CONST_RATIONAL:
2946 : 107 : return node.getConst<internal::Rational>();
2947 : 0 : default:
2948 : 0 : CVC5_API_CHECK(false) << "Node is not a rational.";
2949 : 0 : return node.getConst<internal::Rational>();
2950 : : }
2951 : : }
2952 : 427 : internal::Integer getInteger(const internal::Node& node)
2953 : : {
2954 : 427 : return node.getConst<internal::Rational>().getNumerator();
2955 : : }
2956 : : template <typename T>
2957 : 356 : bool checkIntegerBounds(const internal::Integer& i)
2958 : : {
2959 [ - - ]: 712 : return i >= std::numeric_limits<T>::min()
2960 [ + + ][ + + ]: 1068 : && i <= std::numeric_limits<T>::max();
[ + + ][ + - ]
[ - - ]
2961 : : }
2962 : 20 : bool checkReal32Bounds(const internal::Rational& r)
2963 : : {
2964 [ - - ]: 20 : return checkIntegerBounds<std::int32_t>(r.getNumerator())
2965 [ + - ][ + - ]: 40 : && checkIntegerBounds<std::uint32_t>(r.getDenominator());
[ + - ][ + - ]
[ - - ]
2966 : : }
2967 : 28 : bool checkReal64Bounds(const internal::Rational& r)
2968 : : {
2969 [ - - ]: 28 : return checkIntegerBounds<std::int64_t>(r.getNumerator())
2970 [ + - ][ + - ]: 56 : && checkIntegerBounds<std::uint64_t>(r.getDenominator());
[ + - ][ + - ]
[ - - ]
2971 : : }
2972 : :
2973 : 92 : bool isReal(const internal::Node& node)
2974 : : {
2975 : 92 : return node.getKind() == internal::Kind::CONST_RATIONAL
2976 [ - + ][ - - ]: 92 : || node.getKind() == internal::Kind::CONST_INTEGER;
2977 : : }
2978 : 20 : bool isReal32(const internal::Node& node)
2979 : : {
2980 [ + - ][ + - ]: 20 : return isReal(node) && checkReal32Bounds(getRational(node));
2981 : : }
2982 : 28 : bool isReal64(const internal::Node& node)
2983 : : {
2984 [ + - ][ + - ]: 28 : return isReal(node) && checkReal64Bounds(getRational(node));
2985 : : }
2986 : :
2987 : 306 : bool isInteger(const internal::Node& node)
2988 : : {
2989 : 306 : return (node.getKind() == internal::Kind::CONST_RATIONAL
2990 [ + - ]: 306 : || node.getKind() == internal::Kind::CONST_INTEGER)
2991 [ + - ][ + - ]: 612 : && node.getConst<internal::Rational>().isIntegral();
2992 : : }
2993 : 32 : bool isInt32(const internal::Node& node)
2994 : : {
2995 [ + - ][ + + ]: 32 : return isInteger(node) && checkIntegerBounds<std::int32_t>(getInteger(node));
[ + - ][ - - ]
2996 : : }
2997 : 148 : bool isUInt32(const internal::Node& node)
2998 : : {
2999 [ + - ][ + + ]: 148 : return isInteger(node) && checkIntegerBounds<std::uint32_t>(getInteger(node));
[ + - ][ - - ]
3000 : : }
3001 : 44 : bool isInt64(const internal::Node& node)
3002 : : {
3003 [ + - ][ + + ]: 44 : return isInteger(node) && checkIntegerBounds<std::int64_t>(getInteger(node));
[ + - ][ - - ]
3004 : : }
3005 : 34 : bool isUInt64(const internal::Node& node)
3006 : : {
3007 [ + - ][ + + ]: 34 : return isInteger(node) && checkIntegerBounds<std::uint64_t>(getInteger(node));
[ + - ][ - - ]
3008 : : }
3009 : : } // namespace detail
3010 : :
3011 : 15 : int32_t Term::getRealOrIntegerValueSign() const
3012 : : {
3013 : : CVC5_API_TRY_CATCH_BEGIN;
3014 [ - + ][ - + ]: 15 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3015 : : //////// all checks before this line
3016 : 15 : const internal::Rational& r = detail::getRational(*d_node);
3017 : 15 : return static_cast<int32_t>(r.sgn());
3018 : : ////////
3019 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3020 : : }
3021 : :
3022 : 23 : bool Term::isInt32Value() const
3023 : : {
3024 : : CVC5_API_TRY_CATCH_BEGIN;
3025 [ - + ][ - + ]: 23 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3026 : : //////// all checks before this line
3027 : 23 : return detail::isInt32(*d_node);
3028 : : ////////
3029 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3030 : : }
3031 : :
3032 : 9 : std::int32_t Term::getInt32Value() const
3033 : : {
3034 : : CVC5_API_TRY_CATCH_BEGIN;
3035 [ - + ][ - + ]: 9 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3036 : 9 : CVC5_API_ARG_CHECK_EXPECTED(detail::isInt32(*d_node), *d_node)
3037 : 0 : << "Term to be a 32-bit integer value when calling getInt32Value()";
3038 : : //////// all checks before this line
3039 : 9 : return detail::getInteger(*d_node).getSignedInt();
3040 : : ////////
3041 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3042 : : }
3043 : :
3044 : 45 : bool Term::isUInt32Value() const
3045 : : {
3046 : : CVC5_API_TRY_CATCH_BEGIN;
3047 [ - + ][ - + ]: 45 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3048 : : //////// all checks before this line
3049 : 45 : return detail::isUInt32(*d_node);
3050 : : ////////
3051 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3052 : : }
3053 : 103 : std::uint32_t Term::getUInt32Value() const
3054 : : {
3055 : : CVC5_API_TRY_CATCH_BEGIN;
3056 [ - + ][ - + ]: 103 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3057 : 103 : CVC5_API_ARG_CHECK_EXPECTED(detail::isUInt32(*d_node), *d_node)
3058 : : << "Term to be a unsigned 32-bit integer value when calling "
3059 : 0 : "getUInt32Value()";
3060 : : //////// all checks before this line
3061 : 103 : return detail::getInteger(*d_node).getUnsignedInt();
3062 : : ////////
3063 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3064 : : }
3065 : :
3066 : 23 : bool Term::isInt64Value() const
3067 : : {
3068 : : CVC5_API_TRY_CATCH_BEGIN;
3069 [ - + ][ - + ]: 23 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3070 : : //////// all checks before this line
3071 : 23 : return detail::isInt64(*d_node);
3072 : : ////////
3073 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3074 : : }
3075 : 21 : std::int64_t Term::getInt64Value() const
3076 : : {
3077 : : CVC5_API_TRY_CATCH_BEGIN;
3078 [ - + ][ - + ]: 21 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3079 : 21 : CVC5_API_ARG_CHECK_EXPECTED(detail::isInt64(*d_node), *d_node)
3080 : 0 : << "Term to be a 64-bit integer value when calling getInt64Value()";
3081 : : //////// all checks before this line
3082 : 21 : return detail::getInteger(*d_node).getSigned64();
3083 : : ////////
3084 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3085 : : }
3086 : :
3087 : 23 : bool Term::isUInt64Value() const
3088 : : {
3089 : : CVC5_API_TRY_CATCH_BEGIN;
3090 [ - + ][ - + ]: 23 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3091 : : //////// all checks before this line
3092 : 23 : return detail::isUInt64(*d_node);
3093 : : ////////
3094 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3095 : : }
3096 : :
3097 : 11 : std::uint64_t Term::getUInt64Value() const
3098 : : {
3099 : : CVC5_API_TRY_CATCH_BEGIN;
3100 [ - + ][ - + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3101 : 11 : CVC5_API_ARG_CHECK_EXPECTED(detail::isUInt64(*d_node), *d_node)
3102 : : << "Term to be a unsigned 64-bit integer value when calling "
3103 : 0 : "getUInt64Value()";
3104 : : //////// all checks before this line
3105 : 11 : return detail::getInteger(*d_node).getUnsigned64();
3106 : : ////////
3107 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3108 : : }
3109 : :
3110 : 25 : bool Term::isIntegerValue() const
3111 : : {
3112 : : CVC5_API_TRY_CATCH_BEGIN;
3113 [ - + ][ - + ]: 25 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3114 : : //////// all checks before this line
3115 : 25 : return detail::isInteger(*d_node);
3116 : : ////////
3117 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3118 : : }
3119 : 23 : std::string Term::getIntegerValue() const
3120 : : {
3121 : : CVC5_API_TRY_CATCH_BEGIN;
3122 [ - + ][ - + ]: 23 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3123 : 23 : CVC5_API_ARG_CHECK_EXPECTED(detail::isInteger(*d_node), *d_node)
3124 : 0 : << "Term to be an integer value when calling getIntegerValue()";
3125 : : //////// all checks before this line
3126 : 23 : return detail::getInteger(*d_node).toString();
3127 : : ////////
3128 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3129 [ - - ]: 0 : }
3130 : :
3131 : 2 : bool Term::isStringValue() const
3132 : : {
3133 : : CVC5_API_TRY_CATCH_BEGIN;
3134 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3135 : : //////// all checks before this line
3136 : 2 : return d_node->getKind() == internal::Kind::CONST_STRING;
3137 : : ////////
3138 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3139 : : }
3140 : :
3141 : 2 : std::wstring Term::getStringValue() const
3142 : : {
3143 : : CVC5_API_TRY_CATCH_BEGIN;
3144 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3145 : 2 : CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == internal::Kind::CONST_STRING,
3146 : : *d_node)
3147 : 0 : << "Term to be a string value when calling getStringValue()";
3148 : : //////// all checks before this line
3149 : 2 : return d_node->getConst<internal::String>().toWString();
3150 : : ////////
3151 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3152 [ - - ]: 0 : }
3153 : :
3154 : 4 : std::u32string Term::getU32StringValue() const
3155 : : {
3156 : : CVC5_API_TRY_CATCH_BEGIN;
3157 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3158 : 4 : CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == internal::Kind::CONST_STRING,
3159 : : *d_node)
3160 : 0 : << "Term to be a string value when calling getU32StringValue()";
3161 : : //////// all checks before this line
3162 : 4 : return d_node->getConst<internal::String>().toU32String();
3163 : : ////////
3164 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3165 [ - - ]: 0 : }
3166 : :
3167 : 6725790 : std::vector<internal::Node> Term::termVectorToNodes(
3168 : : const std::vector<Term>& terms)
3169 : : {
3170 : 6725790 : std::vector<internal::Node> res;
3171 [ + + ]: 21051207 : for (const Term& t : terms)
3172 : : {
3173 : 14325417 : res.push_back(t.getNode());
3174 : : }
3175 : 6725790 : return res;
3176 : 0 : }
3177 : :
3178 : 66 : std::vector<Term> Term::nodeVectorToTerms(
3179 : : NodeManagerSharedPtr nm, const std::vector<internal::Node>& nodes)
3180 : : {
3181 : 66 : std::vector<Term> res;
3182 [ + + ]: 144 : for (const internal::Node& n : nodes)
3183 : : {
3184 : 78 : res.push_back(Term(nm, n));
3185 : : }
3186 : 66 : return res;
3187 : 0 : }
3188 : :
3189 : 10 : bool Term::isReal32Value() const
3190 : : {
3191 : : CVC5_API_TRY_CATCH_BEGIN;
3192 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3193 : : //////// all checks before this line
3194 : 10 : return detail::isReal32(*d_node);
3195 : : ////////
3196 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3197 : : }
3198 : 10 : std::pair<std::int32_t, std::uint32_t> Term::getReal32Value() const
3199 : : {
3200 : : CVC5_API_TRY_CATCH_BEGIN;
3201 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3202 : 10 : CVC5_API_ARG_CHECK_EXPECTED(detail::isReal32(*d_node), *d_node)
3203 : 0 : << "Term to be a 32-bit rational value when calling getReal32Value()";
3204 : : //////// all checks before this line
3205 : 10 : const internal::Rational& r = detail::getRational(*d_node);
3206 : 20 : return std::make_pair(r.getNumerator().getSignedInt(),
3207 : 30 : r.getDenominator().getUnsignedInt());
3208 : : ////////
3209 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3210 : : }
3211 : 14 : bool Term::isReal64Value() const
3212 : : {
3213 : : CVC5_API_TRY_CATCH_BEGIN;
3214 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3215 : : //////// all checks before this line
3216 : 14 : return detail::isReal64(*d_node);
3217 : : ////////
3218 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3219 : : }
3220 : 14 : std::pair<std::int64_t, std::uint64_t> Term::getReal64Value() const
3221 : : {
3222 : : CVC5_API_TRY_CATCH_BEGIN;
3223 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3224 : 14 : CVC5_API_ARG_CHECK_EXPECTED(detail::isReal64(*d_node), *d_node)
3225 : 0 : << "Term to be a 64-bit rational value when calling getReal64Value()";
3226 : : //////// all checks before this line
3227 : 14 : const internal::Rational& r = detail::getRational(*d_node);
3228 : 28 : return std::make_pair(r.getNumerator().getSigned64(),
3229 : 42 : r.getDenominator().getUnsigned64());
3230 : : ////////
3231 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3232 : : }
3233 : 24 : bool Term::isRealValue() const
3234 : : {
3235 : : CVC5_API_TRY_CATCH_BEGIN;
3236 [ - + ][ - + ]: 24 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3237 : : //////// all checks before this line
3238 : 24 : return detail::isReal(*d_node);
3239 : : ////////
3240 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3241 : : }
3242 : 20 : std::string Term::getRealValue() const
3243 : : {
3244 : : CVC5_API_TRY_CATCH_BEGIN;
3245 [ - + ][ - + ]: 20 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3246 : 20 : CVC5_API_ARG_CHECK_EXPECTED(detail::isReal(*d_node), *d_node)
3247 : 0 : << "Term to be a rational value when calling getRealValue()";
3248 : : //////// all checks before this line
3249 : 20 : const internal::Rational& rat = detail::getRational(*d_node);
3250 : 20 : std::string res = rat.toString();
3251 [ + + ]: 20 : if (rat.isIntegral())
3252 : : {
3253 : 10 : return res + "/1";
3254 : : }
3255 : 10 : return res;
3256 : : ////////
3257 [ - - ][ - - ]: 20 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3258 [ - - ]: 0 : }
3259 : :
3260 : 2 : bool Term::isConstArray() const
3261 : : {
3262 : : CVC5_API_TRY_CATCH_BEGIN;
3263 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3264 : : //////// all checks before this line
3265 : 2 : return d_node->getKind() == internal::Kind::STORE_ALL;
3266 : : ////////
3267 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3268 : : }
3269 : 10 : Term Term::getConstArrayBase() const
3270 : : {
3271 : : CVC5_API_TRY_CATCH_BEGIN;
3272 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3273 : 16 : CVC5_API_ARG_CHECK_EXPECTED(d_node->getKind() == internal::Kind::STORE_ALL,
3274 : : *d_node)
3275 : 6 : << "Term to be a constant array when calling getConstArrayBase()";
3276 : : //////// all checks before this line
3277 : 4 : const auto& ar = d_node->getConst<internal::ArrayStoreAll>();
3278 : 4 : return Term(d_nm, ar.getValue());
3279 : : ////////
3280 [ + - ][ - - ]: 6 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3281 [ - + ]: 6 : }
3282 : :
3283 : 4 : bool Term::isBooleanValue() const
3284 : : {
3285 : : CVC5_API_TRY_CATCH_BEGIN;
3286 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3287 : : //////// all checks before this line
3288 : 4 : return d_node->getKind() == internal::Kind::CONST_BOOLEAN;
3289 : : ////////
3290 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3291 : : }
3292 : 10 : bool Term::getBooleanValue() const
3293 : : {
3294 : : CVC5_API_TRY_CATCH_BEGIN;
3295 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3296 : 10 : CVC5_API_ARG_CHECK_EXPECTED(
3297 : : d_node->getKind() == internal::Kind::CONST_BOOLEAN, *d_node)
3298 : 0 : << "Term to be a Boolean value when calling getBooleanValue()";
3299 : : //////// all checks before this line
3300 : 10 : return d_node->getConst<bool>();
3301 : : ////////
3302 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3303 : : }
3304 : :
3305 : 14 : bool Term::isBitVectorValue() const
3306 : : {
3307 : : CVC5_API_TRY_CATCH_BEGIN;
3308 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3309 : : //////// all checks before this line
3310 : 14 : return d_node->getKind() == internal::Kind::CONST_BITVECTOR;
3311 : : ////////
3312 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3313 : : }
3314 : 42 : std::string Term::getBitVectorValue(std::uint32_t base) const
3315 : : {
3316 : : CVC5_API_TRY_CATCH_BEGIN;
3317 [ - + ][ - + ]: 42 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3318 : 42 : CVC5_API_ARG_CHECK_EXPECTED(
3319 : : d_node->getKind() == internal::Kind::CONST_BITVECTOR, *d_node)
3320 : 0 : << "Term to be a bit-vector value when calling getBitVectorValue()";
3321 : : //////// all checks before this line
3322 : 42 : return d_node->getConst<internal::BitVector>().toString(base);
3323 : : ////////
3324 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3325 [ - - ]: 0 : }
3326 : :
3327 : 4 : bool Term::isFiniteFieldValue() const
3328 : : {
3329 : : CVC5_API_TRY_CATCH_BEGIN;
3330 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3331 : : //////// all checks before this line
3332 : 4 : return d_node->getKind() == internal::Kind::CONST_FINITE_FIELD;
3333 : : ////////
3334 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3335 : : }
3336 : 13 : std::string Term::getFiniteFieldValue() const
3337 : : {
3338 : : CVC5_API_TRY_CATCH_BEGIN;
3339 [ + + ][ + + ]: 13 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3340 : 14 : CVC5_API_ARG_CHECK_EXPECTED(
3341 : : d_node->getKind() == internal::Kind::CONST_FINITE_FIELD, *d_node)
3342 : 2 : << "Term to be a finite field value when calling getFiniteFieldValue()";
3343 : : //////// all checks before this line
3344 : 10 : return d_node->getConst<internal::FiniteFieldValue>()
3345 : 20 : .toSignedInteger()
3346 : 20 : .toString();
3347 : : ////////
3348 [ + - ][ - - ]: 3 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3349 [ - + ]: 3 : }
3350 : :
3351 : 4 : bool Term::isUninterpretedSortValue() const
3352 : : {
3353 : : CVC5_API_TRY_CATCH_BEGIN;
3354 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3355 : : //////// all checks before this line
3356 : 4 : return d_node->getKind() == internal::Kind::UNINTERPRETED_SORT_VALUE;
3357 : : ////////
3358 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3359 : : }
3360 : 22 : std::string Term::getUninterpretedSortValue() const
3361 : : {
3362 : : CVC5_API_TRY_CATCH_BEGIN;
3363 [ - + ][ - + ]: 22 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3364 : 22 : CVC5_API_ARG_CHECK_EXPECTED(
3365 : : d_node->getKind() == internal::Kind::UNINTERPRETED_SORT_VALUE, *d_node)
3366 : : << "Term to be an abstract value when calling "
3367 : 0 : "getUninterpretedSortValue()";
3368 : : //////// all checks before this line
3369 : 22 : return d_node->getConst<internal::UninterpretedSortValue>().getSymbol();
3370 : : ////////
3371 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3372 [ - - ]: 0 : }
3373 : :
3374 : 2 : bool Term::isTupleValue() const
3375 : : {
3376 : : CVC5_API_TRY_CATCH_BEGIN;
3377 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3378 : : //////// all checks before this line
3379 : 2 : return d_node->getKind() == internal::Kind::APPLY_CONSTRUCTOR
3380 [ + - ][ + - ]: 4 : && d_node->isConst() && d_node->getType().getDType().isTuple();
[ + - ][ + - ]
[ - - ]
3381 : : ////////
3382 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3383 : : }
3384 : 2 : std::vector<Term> Term::getTupleValue() const
3385 : : {
3386 : : CVC5_API_TRY_CATCH_BEGIN;
3387 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3388 : 2 : CVC5_API_ARG_CHECK_EXPECTED(
3389 : : d_node->getKind() == internal::Kind::APPLY_CONSTRUCTOR
3390 : : && d_node->isConst() && d_node->getType().getDType().isTuple(),
3391 : : *d_node)
3392 : 0 : << "Term to be a tuple value when calling getTupleValue()";
3393 : : //////// all checks before this line
3394 : 2 : std::vector<Term> res;
3395 [ + + ]: 8 : for (size_t i = 0, n = d_node->getNumChildren(); i < n; ++i)
3396 : : {
3397 : 6 : res.emplace_back(Term(d_nm, (*d_node)[i]));
3398 : : }
3399 : 4 : return res;
3400 : : ////////
3401 [ - - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3402 [ - - ]: 0 : }
3403 : :
3404 : 6 : bool Term::isRoundingModeValue() const
3405 : : {
3406 : : CVC5_API_TRY_CATCH_BEGIN;
3407 [ - + ][ - + ]: 6 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3408 : : //////// all checks before this line
3409 : 6 : return d_node->getKind() == internal::Kind::CONST_ROUNDINGMODE;
3410 : : ////////
3411 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3412 : : }
3413 : 12 : RoundingMode Term::getRoundingModeValue() const
3414 : : {
3415 : : CVC5_API_TRY_CATCH_BEGIN;
3416 [ - + ][ - + ]: 12 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3417 : 14 : CVC5_API_ARG_CHECK_EXPECTED(
3418 : : d_node->getKind() == internal::Kind::CONST_ROUNDINGMODE, *d_node)
3419 : : << "Term to be a floating-point rounding mode value when calling "
3420 : 2 : "getRoundingModeValue()";
3421 : : //////// all checks before this line
3422 : 10 : return s_rmodes_internal.at(d_node->getConst<cvc5::internal::RoundingMode>());
3423 : : ////////
3424 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3425 : : }
3426 : :
3427 : 4 : bool Term::isFloatingPointPosZero() const
3428 : : {
3429 : : CVC5_API_TRY_CATCH_BEGIN;
3430 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3431 : : //////// all checks before this line
3432 [ + - ]: 4 : if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
3433 : : {
3434 : 4 : const auto& fp = d_node->getConst<internal::FloatingPoint>();
3435 [ + + ][ + - ]: 4 : return fp.isZero() && fp.isPositive();
3436 : : }
3437 : 0 : return false;
3438 : : ////////
3439 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3440 : : }
3441 : 4 : bool Term::isFloatingPointNegZero() const
3442 : : {
3443 : : CVC5_API_TRY_CATCH_BEGIN;
3444 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3445 : : //////// all checks before this line
3446 [ + - ]: 4 : if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
3447 : : {
3448 : 4 : const auto& fp = d_node->getConst<internal::FloatingPoint>();
3449 [ + + ][ + - ]: 4 : return fp.isZero() && fp.isNegative();
3450 : : }
3451 : 0 : return false;
3452 : : ////////
3453 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3454 : : }
3455 : 4 : bool Term::isFloatingPointPosInf() const
3456 : : {
3457 : : CVC5_API_TRY_CATCH_BEGIN;
3458 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3459 : : //////// all checks before this line
3460 [ + - ]: 4 : if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
3461 : : {
3462 : 4 : const auto& fp = d_node->getConst<internal::FloatingPoint>();
3463 [ + + ][ + - ]: 4 : return fp.isInfinite() && fp.isPositive();
3464 : : }
3465 : 0 : return false;
3466 : : ////////
3467 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3468 : : }
3469 : 4 : bool Term::isFloatingPointNegInf() const
3470 : : {
3471 : : CVC5_API_TRY_CATCH_BEGIN;
3472 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3473 : : //////// all checks before this line
3474 [ + - ]: 4 : if (d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT)
3475 : : {
3476 : 4 : const auto& fp = d_node->getConst<internal::FloatingPoint>();
3477 [ + + ][ + - ]: 4 : return fp.isInfinite() && fp.isNegative();
3478 : : }
3479 : 0 : return false;
3480 : : ////////
3481 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3482 : : }
3483 : 4 : bool Term::isFloatingPointNaN() const
3484 : : {
3485 : : CVC5_API_TRY_CATCH_BEGIN;
3486 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3487 : : //////// all checks before this line
3488 : 4 : return d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT
3489 [ + - ][ + + ]: 4 : && d_node->getConst<internal::FloatingPoint>().isNaN();
3490 : : ////////
3491 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3492 : : }
3493 : 2 : bool Term::isFloatingPointValue() const
3494 : : {
3495 : : CVC5_API_TRY_CATCH_BEGIN;
3496 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3497 : : //////// all checks before this line
3498 : 2 : return d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT;
3499 : : ////////
3500 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3501 : : }
3502 : 2 : std::tuple<std::uint32_t, std::uint32_t, Term> Term::getFloatingPointValue()
3503 : : const
3504 : : {
3505 : : CVC5_API_TRY_CATCH_BEGIN;
3506 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3507 : 2 : CVC5_API_ARG_CHECK_EXPECTED(
3508 : : d_node->getKind() == internal::Kind::CONST_FLOATINGPOINT, *d_node)
3509 : : << "Term to be a floating-point value when calling "
3510 : 0 : "getFloatingPointValue()";
3511 : : //////// all checks before this line
3512 : 2 : const auto& fp = d_node->getConst<internal::FloatingPoint>();
3513 : 2 : return std::make_tuple(fp.getSize().exponentWidth(),
3514 : 2 : fp.getSize().significandWidth(),
3515 : 4 : TermManager::mkValHelper(d_nm, fp.pack()));
3516 : : ////////
3517 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3518 [ - - ]: 0 : }
3519 : :
3520 : 12 : bool Term::isSetValue() const
3521 : : {
3522 : : CVC5_API_TRY_CATCH_BEGIN;
3523 [ - + ][ - + ]: 12 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3524 : : //////// all checks before this line
3525 [ + - ][ + + ]: 12 : return d_node->getType().isSet() && d_node->isConst();
[ + - ][ - - ]
3526 : : ////////
3527 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3528 : : }
3529 : :
3530 : 14 : void Term::collectSet(std::set<Term>& set,
3531 : : const internal::Node& node,
3532 : : const NodeManagerSharedPtr& nm)
3533 : : {
3534 : : // We asserted that node has a set type, and node.isConst()
3535 : : // Thus, node only contains of SET_EMPTY, SET_UNION and SET_SINGLETON.
3536 [ + + ][ + - ]: 14 : switch (node.getKind())
3537 : : {
3538 : 2 : case internal::Kind::SET_EMPTY: break;
3539 : 10 : case internal::Kind::SET_SINGLETON: set.emplace(Term(nm, node[0])); break;
3540 : 2 : case internal::Kind::SET_UNION:
3541 : : {
3542 [ + + ]: 6 : for (const auto& sub : node)
3543 : : {
3544 : 4 : collectSet(set, sub, nm);
3545 : 4 : }
3546 : 2 : break;
3547 : : }
3548 : 0 : default:
3549 : 0 : CVC5_API_ARG_CHECK_EXPECTED(false, node)
3550 : 0 : << "Term to be a set value when calling getSetValue()";
3551 : 0 : break;
3552 : : }
3553 : 14 : }
3554 : :
3555 : 10 : std::set<Term> Term::getSetValue() const
3556 : : {
3557 : : CVC5_API_TRY_CATCH_BEGIN;
3558 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3559 : 10 : CVC5_API_ARG_CHECK_EXPECTED(d_node->getType().isSet() && d_node->isConst(),
3560 : : *d_node)
3561 : 0 : << "Term to be a set value when calling getSetValue()";
3562 : : //////// all checks before this line
3563 : 10 : std::set<Term> res;
3564 : 10 : Term::collectSet(res, *d_node, d_nm);
3565 : 20 : return res;
3566 : : ////////
3567 [ - - ][ - - ]: 10 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3568 [ - - ]: 0 : }
3569 : :
3570 : 14 : bool Term::isSequenceValue() const
3571 : : {
3572 : : CVC5_API_TRY_CATCH_BEGIN;
3573 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3574 : : //////// all checks before this line
3575 : 14 : return d_node->getKind() == internal::Kind::CONST_SEQUENCE;
3576 : : ////////
3577 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3578 : : }
3579 : 115 : std::vector<Term> Term::getSequenceValue() const
3580 : : {
3581 : : CVC5_API_TRY_CATCH_BEGIN;
3582 [ - + ][ - + ]: 115 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3583 : 117 : CVC5_API_ARG_CHECK_EXPECTED(
3584 : : d_node->getKind() == internal::Kind::CONST_SEQUENCE, *d_node)
3585 : 2 : << "Term to be a sequence value when calling getSequenceValue()";
3586 : : //////// all checks before this line
3587 : 113 : std::vector<Term> res;
3588 : 113 : const internal::Sequence& seq = d_node->getConst<internal::Sequence>();
3589 [ + + ]: 125 : for (const auto& node : seq.getVec())
3590 : : {
3591 : 12 : res.emplace_back(Term(d_nm, node));
3592 : : }
3593 : 226 : return res;
3594 : : ////////
3595 [ + - ][ - - ]: 115 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3596 [ - + ]: 2 : }
3597 : :
3598 : 5 : bool Term::isCardinalityConstraint() const
3599 : : {
3600 : : CVC5_API_TRY_CATCH_BEGIN;
3601 [ + + ][ + + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3602 : : //////// all checks before this line
3603 : 4 : return d_node->getKind() == internal::Kind::CARDINALITY_CONSTRAINT;
3604 : : ////////
3605 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3606 : : }
3607 : :
3608 : 4 : std::pair<Sort, uint32_t> Term::getCardinalityConstraint() const
3609 : : {
3610 : : CVC5_API_TRY_CATCH_BEGIN;
3611 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3612 : 6 : CVC5_API_ARG_CHECK_EXPECTED(
3613 : : d_node->getKind() == internal::Kind::CARDINALITY_CONSTRAINT, *d_node)
3614 : : << "Term to be a cardinality constraint when calling "
3615 : 2 : "getCardinalityConstraint()";
3616 : : // this should never happen since we restrict what the user can create
3617 : 2 : CVC5_API_ARG_CHECK_EXPECTED(
3618 : : detail::checkIntegerBounds<std::uint32_t>(
3619 : : d_node->getOperator()
3620 : : .getConst<internal::CardinalityConstraint>()
3621 : : .getUpperBound()),
3622 : : *d_node)
3623 : 0 : << "Upper bound for cardinality constraint does not fit uint32_t";
3624 : : //////// all checks before this line
3625 : : const internal::CardinalityConstraint& cc =
3626 : 2 : d_node->getOperator().getConst<internal::CardinalityConstraint>();
3627 : 4 : return std::make_pair(Sort(d_nm, cc.getType()),
3628 : 6 : cc.getUpperBound().getUnsignedInt());
3629 : : ////////
3630 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3631 [ - + ]: 2 : }
3632 : :
3633 : 2 : bool Term::isRealAlgebraicNumber() const
3634 : : {
3635 : : CVC5_API_TRY_CATCH_BEGIN;
3636 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3637 : : //////// all checks before this line
3638 : 2 : return d_node->getKind() == internal::Kind::REAL_ALGEBRAIC_NUMBER;
3639 : : ////////
3640 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3641 : : }
3642 : :
3643 : 4 : Term Term::getRealAlgebraicNumberDefiningPolynomial(const Term& v) const
3644 : : {
3645 : : CVC5_API_TRY_CATCH_BEGIN;
3646 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3647 : 4 : CVC5_API_ARG_CHECK_EXPECTED(
3648 : : d_node->getKind() == internal::Kind::REAL_ALGEBRAIC_NUMBER, *d_node)
3649 : : << "Term to be a real algebraic number when calling "
3650 : 0 : "getRealAlgebraicNumberDefiningPolynomial()";
3651 : 6 : CVC5_API_ARG_CHECK_EXPECTED(v.getKind() == Kind::VARIABLE, v)
3652 : : << "expected a variable as argument when calling "
3653 : 2 : "getRealAlgebraicNumberDefiningPolynomial()";
3654 : : #ifndef CVC5_POLY_IMP
3655 : : throw CVC5ApiException(
3656 : : "expected libpoly enabled build when calling "
3657 : : "getRealAlgebraicNumberDefiningPolynomial");
3658 : : #endif
3659 : : //////// all checks before this line
3660 : : #ifdef CVC5_POLY_IMP
3661 : : const internal::RealAlgebraicNumber& ran =
3662 : 2 : d_node->getOperator().getConst<internal::RealAlgebraicNumber>();
3663 : 2 : return Term(d_nm,
3664 : 4 : internal::PolyConverter::ran_to_defining_polynomial(
3665 : 6 : ran, *v.d_node.get()));
3666 : : #else
3667 : : return Term();
3668 : : #endif
3669 : : ////////
3670 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3671 [ - + ]: 2 : }
3672 : :
3673 : 2 : Term Term::getRealAlgebraicNumberLowerBound() const
3674 : : {
3675 : : CVC5_API_TRY_CATCH_BEGIN;
3676 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3677 : 2 : CVC5_API_ARG_CHECK_EXPECTED(
3678 : : d_node->getKind() == internal::Kind::REAL_ALGEBRAIC_NUMBER, *d_node)
3679 : : << "Term to be a real algebraic number when calling "
3680 : 0 : "getRealAlgebraicNumberDefiningPolynomial()";
3681 : : #ifndef CVC5_POLY_IMP
3682 : : throw CVC5ApiException(
3683 : : "expected libpoly enabled build when calling "
3684 : : "getRealAlgebraicNumberLowerBound");
3685 : : #endif
3686 : : //////// all checks before this line
3687 : : #ifdef CVC5_POLY_IMP
3688 : : const internal::RealAlgebraicNumber& ran =
3689 : 2 : d_node->getOperator().getConst<internal::RealAlgebraicNumber>();
3690 : 2 : return Term(d_nm, internal::PolyConverter::ran_to_lower(d_nm.get(), ran));
3691 : : #else
3692 : : return Term();
3693 : : #endif
3694 : : ////////
3695 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3696 [ - - ]: 0 : }
3697 : :
3698 : 2 : Term Term::getRealAlgebraicNumberUpperBound() const
3699 : : {
3700 : : CVC5_API_TRY_CATCH_BEGIN;
3701 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3702 : 2 : CVC5_API_ARG_CHECK_EXPECTED(
3703 : : d_node->getKind() == internal::Kind::REAL_ALGEBRAIC_NUMBER, *d_node)
3704 : : << "Term to be a real algebraic number when calling "
3705 : 0 : "getRealAlgebraicNumberDefiningPolynomial()";
3706 : : #ifndef CVC5_POLY_IMP
3707 : : throw CVC5ApiException(
3708 : : "expected libpoly enabled build when calling "
3709 : : "getRealAlgebraicNumberUpperBound");
3710 : : #endif
3711 : : //////// all checks before this line
3712 : : #ifdef CVC5_POLY_IMP
3713 : : const internal::RealAlgebraicNumber& ran =
3714 : 2 : d_node->getOperator().getConst<internal::RealAlgebraicNumber>();
3715 : 2 : return Term(d_nm, internal::PolyConverter::ran_to_upper(d_nm.get(), ran));
3716 : : #else
3717 : : return Term();
3718 : : #endif
3719 : : ////////
3720 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3721 [ - - ]: 0 : }
3722 : :
3723 : 5 : bool Term::isSkolem() const
3724 : : {
3725 : : CVC5_API_TRY_CATCH_BEGIN;
3726 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3727 : : //////// all checks before this line
3728 : 5 : return d_node->getKind() == internal::Kind::SKOLEM;
3729 : : ////////
3730 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3731 : : }
3732 : :
3733 : 5 : SkolemId Term::getSkolemId() const
3734 : : {
3735 : : CVC5_API_TRY_CATCH_BEGIN;
3736 [ - + ][ - + ]: 5 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3737 : 7 : CVC5_API_ARG_CHECK_EXPECTED(d_node->isSkolem(), *d_node)
3738 : 2 : << "Term to be a skolem when calling getSkolemId";
3739 : : //////// all checks before this line
3740 : 3 : return d_node->getSkolemId();
3741 : : ////////
3742 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3743 : : }
3744 : :
3745 : 6 : std::vector<Term> Term::getSkolemIndices() const
3746 : : {
3747 : : CVC5_API_TRY_CATCH_BEGIN;
3748 [ - + ][ - + ]: 6 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3749 : 8 : CVC5_API_ARG_CHECK_EXPECTED(d_node->isSkolem(), *d_node)
3750 : 2 : << "Term to be a skolem when calling getSkolemIndices";
3751 : : //////// all checks before this line
3752 : 4 : std::vector<internal::Node> indices = d_node->getSkolemIndices();
3753 : 8 : return Term::nodeVectorToTerms(d_nm, indices);
3754 : : ////////
3755 [ + - ][ - - ]: 6 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3756 [ - + ]: 2 : }
3757 : :
3758 : 571 : std::ostream& operator<<(std::ostream& out, const Term& t)
3759 : : {
3760 : : // Note that this ignores the options::ioutils properties of `out`.
3761 : 571 : out << t.toString();
3762 : 571 : return out;
3763 : : }
3764 : :
3765 : 2 : std::ostream& operator<<(std::ostream& out, const std::vector<Term>& vector)
3766 : : {
3767 : 2 : internal::container_to_stream(out, vector);
3768 : 2 : return out;
3769 : : }
3770 : :
3771 : 2 : std::ostream& operator<<(std::ostream& out, const std::set<Term>& set)
3772 : : {
3773 : 2 : internal::container_to_stream(out, set);
3774 : 2 : return out;
3775 : : }
3776 : :
3777 : 2 : std::ostream& operator<<(std::ostream& out,
3778 : : const std::unordered_set<Term>& unordered_set)
3779 : : {
3780 : 2 : internal::container_to_stream(out, unordered_set);
3781 : 2 : return out;
3782 : : }
3783 : :
3784 : : template <typename V>
3785 : : std::ostream& operator<<(std::ostream& out, const std::map<Term, V>& map)
3786 : : {
3787 : : internal::container_to_stream(out, map);
3788 : : return out;
3789 : : }
3790 : :
3791 : : template <typename V>
3792 : : std::ostream& operator<<(std::ostream& out,
3793 : : const std::unordered_map<Term, V>& unordered_map)
3794 : : {
3795 : : internal::container_to_stream(out, unordered_map);
3796 : : return out;
3797 : : }
3798 : :
3799 : : /* Helpers */
3800 : : /* -------------------------------------------------------------------------- */
3801 : :
3802 : : /* Split out to avoid nested API calls (problematic with API tracing). */
3803 : : /* .......................................................................... */
3804 : :
3805 : 218334564 : bool Term::isNullHelper() const
3806 : : {
3807 : : /* Split out to avoid nested API calls (problematic with API tracing). */
3808 : 218334564 : return d_node->isNull();
3809 : : }
3810 : :
3811 : 6831 : Kind Term::getKindHelper() const
3812 : : {
3813 : : /* Sequence kinds do not exist internally, so we must convert their internal
3814 : : * (string) versions back to sequence. All operators where this is
3815 : : * necessary are such that their first child is of sequence type, which
3816 : : * we check here. */
3817 : 6831 : if (d_node->getNumChildren() > 0 && (*d_node)[0].getType().isSequence())
3818 : : {
3819 [ + - ][ - - ]: 2 : switch (d_node->getKind())
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3820 : : {
3821 : 2 : case internal::Kind::STRING_CONCAT: return Kind::SEQ_CONCAT;
3822 : 0 : case internal::Kind::STRING_LENGTH: return Kind::SEQ_LENGTH;
3823 : 0 : case internal::Kind::STRING_SUBSTR: return Kind::SEQ_EXTRACT;
3824 : 0 : case internal::Kind::STRING_UPDATE: return Kind::SEQ_UPDATE;
3825 : 0 : case internal::Kind::STRING_CHARAT: return Kind::SEQ_AT;
3826 : 0 : case internal::Kind::STRING_CONTAINS: return Kind::SEQ_CONTAINS;
3827 : 0 : case internal::Kind::STRING_INDEXOF: return Kind::SEQ_INDEXOF;
3828 : 0 : case internal::Kind::STRING_REPLACE: return Kind::SEQ_REPLACE;
3829 : 0 : case internal::Kind::STRING_REPLACE_ALL: return Kind::SEQ_REPLACE_ALL;
3830 : 0 : case internal::Kind::STRING_REV: return Kind::SEQ_REV;
3831 : 0 : case internal::Kind::STRING_PREFIX: return Kind::SEQ_PREFIX;
3832 : 0 : case internal::Kind::STRING_SUFFIX: return Kind::SEQ_SUFFIX;
3833 : 0 : default:
3834 : : // fall through to conversion below
3835 : 0 : break;
3836 : : }
3837 : : }
3838 : : // Notice that kinds like APPLY_TYPE_ASCRIPTION will be converted to
3839 : : // INTERNAL_KIND.
3840 : 6829 : return intToExtKind(d_node->getKind());
3841 : : }
3842 : :
3843 : : /* -------------------------------------------------------------------------- */
3844 : : /* Datatypes */
3845 : : /* -------------------------------------------------------------------------- */
3846 : :
3847 : : /* DatatypeConstructorDecl -------------------------------------------------- */
3848 : :
3849 : 5 : DatatypeConstructorDecl::DatatypeConstructorDecl()
3850 : 5 : : d_nm(nullptr), d_ctor(nullptr)
3851 : : {
3852 : 5 : }
3853 : :
3854 : 9735 : DatatypeConstructorDecl::DatatypeConstructorDecl(NodeManagerSharedPtr nm,
3855 : 9735 : const std::string& name)
3856 : 9735 : : d_nm(std::move(nm)), d_ctor(new internal::DTypeConstructor(name))
3857 : : {
3858 : 9735 : }
3859 : 10086 : DatatypeConstructorDecl::~DatatypeConstructorDecl()
3860 : : {
3861 [ + + ]: 10086 : if (d_ctor != nullptr)
3862 : : {
3863 : 10084 : d_ctor.reset();
3864 : : }
3865 : 10086 : }
3866 : :
3867 : 29 : bool DatatypeConstructorDecl::operator==(
3868 : : const DatatypeConstructorDecl& decl) const
3869 : : {
3870 : : CVC5_API_TRY_CATCH_BEGIN;
3871 [ - + ][ - + ]: 29 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3872 : : //////// all checks before this line
3873 : 29 : return d_ctor == decl.d_ctor;
3874 : : ////////
3875 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3876 : : }
3877 : :
3878 : 8781 : void DatatypeConstructorDecl::addSelector(const std::string& name,
3879 : : const Sort& sort)
3880 : : {
3881 : : CVC5_API_TRY_CATCH_BEGIN;
3882 [ - + ][ - + ]: 8781 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3883 : 8781 : CVC5_API_CHECK_SORT(sort);
3884 [ - + ][ - + ]: 8780 : CVC5_API_ARG_CHECK_EXPECTED(!sort.isNull(), sort)
[ - - ]
3885 : 0 : << "non-null codomain sort for selector";
3886 : : //////// all checks before this line
3887 : 8780 : d_ctor->addArg(name, *sort.d_type);
3888 : : ////////
3889 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3890 : 8780 : }
3891 : :
3892 : 63 : void DatatypeConstructorDecl::addSelectorSelf(const std::string& name)
3893 : : {
3894 : : CVC5_API_TRY_CATCH_BEGIN;
3895 [ - + ][ - + ]: 63 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3896 : : //////// all checks before this line
3897 : 63 : d_ctor->addArgSelf(name);
3898 : : ////////
3899 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3900 : 63 : }
3901 : :
3902 : 10 : void DatatypeConstructorDecl::addSelectorUnresolved(
3903 : : const std::string& name, const std::string& unresDataypeName)
3904 : : {
3905 : : CVC5_API_TRY_CATCH_BEGIN;
3906 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3907 : : //////// all checks before this line
3908 : : // make the unresolved sort with the given name
3909 : 10 : internal::TypeNode usort = d_nm->mkUnresolvedDatatypeSort(unresDataypeName);
3910 : 10 : d_ctor->addArg(name, usort);
3911 : : ////////
3912 [ - - ][ - - ]: 10 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3913 : 10 : }
3914 : :
3915 : 10069 : bool DatatypeConstructorDecl::isNull() const
3916 : : {
3917 : : CVC5_API_TRY_CATCH_BEGIN;
3918 : : //////// all checks before this line
3919 : 10069 : return isNullHelper();
3920 : : ////////
3921 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3922 : : }
3923 : :
3924 : 4 : std::string DatatypeConstructorDecl::toString() const
3925 : : {
3926 : : CVC5_API_TRY_CATCH_BEGIN;
3927 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3928 : : //////// all checks before this line
3929 : 4 : std::stringstream ss;
3930 : 4 : ss << *d_ctor;
3931 : 8 : return ss.str();
3932 : : ////////
3933 [ - - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3934 [ - - ]: 0 : }
3935 : :
3936 : 2 : std::ostream& operator<<(std::ostream& out,
3937 : : const DatatypeConstructorDecl& ctordecl)
3938 : : {
3939 : 2 : out << ctordecl.toString();
3940 : 2 : return out;
3941 : : }
3942 : :
3943 : 2 : std::ostream& operator<<(std::ostream& out,
3944 : : const std::vector<DatatypeConstructorDecl>& vector)
3945 : : {
3946 : 2 : internal::container_to_stream(out, vector);
3947 : 2 : return out;
3948 : : }
3949 : :
3950 : 18956 : bool DatatypeConstructorDecl::isNullHelper() const { return d_ctor == nullptr; }
3951 : :
3952 : 32 : bool DatatypeConstructorDecl::isResolved() const
3953 : : {
3954 [ + - ][ + + ]: 32 : return d_ctor == nullptr || d_ctor->isResolved();
3955 : : }
3956 : :
3957 : : /* DatatypeDecl ------------------------------------------------------------- */
3958 : :
3959 : 5 : DatatypeDecl::DatatypeDecl() : d_nm(nullptr), d_dtype(nullptr) {}
3960 : :
3961 : 139 : DatatypeDecl::DatatypeDecl(NodeManagerSharedPtr nm,
3962 : : const std::string& name,
3963 : 139 : bool isCoDatatype)
3964 : 139 : : d_nm(std::move(nm)), d_dtype(new internal::DType(name, isCoDatatype))
3965 : : {
3966 : 139 : }
3967 : :
3968 : 5367 : DatatypeDecl::DatatypeDecl(NodeManagerSharedPtr nm,
3969 : : const std::string& name,
3970 : : const std::vector<Sort>& params,
3971 : 5367 : bool isCoDatatype)
3972 : 5367 : : d_nm(std::move(nm))
3973 : : {
3974 : 5367 : std::vector<internal::TypeNode> tparams = Sort::sortVectorToTypeNodes(params);
3975 : 16101 : d_dtype = std::shared_ptr<internal::DType>(
3976 : 10734 : new internal::DType(name, tparams, isCoDatatype));
3977 : 5367 : }
3978 : :
3979 : 10 : bool DatatypeDecl::operator==(const DatatypeDecl& decl) const
3980 : : {
3981 : : CVC5_API_TRY_CATCH_BEGIN;
3982 [ - + ][ - + ]: 10 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
3983 : : //////// all checks before this line
3984 : 10 : return d_dtype == decl.d_dtype;
3985 : : ////////
3986 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
3987 : : }
3988 : :
3989 : 15398 : bool DatatypeDecl::isNullHelper() const { return !d_dtype; }
3990 : :
3991 : 12858 : DatatypeDecl::~DatatypeDecl()
3992 : : {
3993 [ + + ]: 12858 : if (d_dtype != nullptr)
3994 : : {
3995 : 12855 : d_dtype.reset();
3996 : : }
3997 : 12858 : }
3998 : :
3999 : 5477 : bool DatatypeDecl::isResolved() const
4000 : : {
4001 [ - + ]: 5477 : if (d_dtype == nullptr)
4002 : : {
4003 : 0 : return true;
4004 : : }
4005 : : // We are resolved if a constructor is resolved. Note that since
4006 : : // internal::DType objects are copied in Solver::mkDatatypeSorts, the
4007 : : // constructors of d_dtype are passed to NodeManager but not d_type itself.
4008 : : // Thus, we must check whether our constructors are resolved.
4009 : : // This is a workaround; a clearer implementation would avoid the
4010 : : // copying of DType in Solver::mkDatatypeSorts.
4011 : : const std::vector<std::shared_ptr<internal::DTypeConstructor>>& cons =
4012 : 5477 : d_dtype->getConstructors();
4013 [ + + ]: 15149 : for (const std::shared_ptr<internal::DTypeConstructor>& c : cons)
4014 : : {
4015 [ + + ]: 9681 : if (c->isResolved())
4016 : : {
4017 : 9 : return true;
4018 : : }
4019 : : }
4020 [ - + ][ - + ]: 5468 : Assert(!d_dtype->isResolved());
[ - - ]
4021 : 5468 : return false;
4022 : : }
4023 : :
4024 : 9726 : void DatatypeDecl::addConstructor(const DatatypeConstructorDecl& ctor)
4025 : : {
4026 : : CVC5_API_TRY_CATCH_BEGIN;
4027 [ - + ][ - + ]: 9726 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4028 [ - + ][ - + ]: 9726 : CVC5_API_ARG_CHECK_NOT_NULL(ctor);
[ - - ]
4029 [ - + ][ - + ]: 9726 : CVC5_API_ARG_CHECK_TM("datatype constructor declaration", ctor);
[ - - ]
4030 : : //////// all checks before this line
4031 : 9726 : d_dtype->addConstructor(ctor.d_ctor);
4032 : : ////////
4033 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4034 : 9726 : }
4035 : :
4036 : 2 : size_t DatatypeDecl::getNumConstructors() const
4037 : : {
4038 : : CVC5_API_TRY_CATCH_BEGIN;
4039 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4040 : : //////// all checks before this line
4041 : 2 : return d_dtype->getNumConstructors();
4042 : : ////////
4043 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4044 : : }
4045 : :
4046 : 2 : bool DatatypeDecl::isParametric() const
4047 : : {
4048 : : CVC5_API_TRY_CATCH_BEGIN;
4049 [ - + ][ - + ]: 2 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4050 : : //////// all checks before this line
4051 : 2 : return d_dtype->isParametric();
4052 : : ////////
4053 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4054 : : }
4055 : :
4056 : 4 : std::string DatatypeDecl::toString() const
4057 : : {
4058 : : CVC5_API_TRY_CATCH_BEGIN;
4059 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4060 : : //////// all checks before this line
4061 : 4 : std::stringstream ss;
4062 : 4 : ss << *d_dtype;
4063 : 8 : return ss.str();
4064 : : ////////
4065 [ - - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4066 [ - - ]: 0 : }
4067 : :
4068 : 13 : std::string DatatypeDecl::getName() const
4069 : : {
4070 : : CVC5_API_TRY_CATCH_BEGIN;
4071 [ + + ][ + + ]: 13 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4072 : : //////// all checks before this line
4073 : 12 : return d_dtype->getName();
4074 : : ////////
4075 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4076 [ - + ]: 1 : }
4077 : :
4078 : 5641 : bool DatatypeDecl::isNull() const
4079 : : {
4080 : : CVC5_API_TRY_CATCH_BEGIN;
4081 : : //////// all checks before this line
4082 : 5641 : return isNullHelper();
4083 : : ////////
4084 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4085 : : }
4086 : :
4087 : 3 : std::ostream& operator<<(std::ostream& out, const DatatypeDecl& dtdecl)
4088 : : {
4089 : 3 : out << dtdecl.toString();
4090 : 3 : return out;
4091 : : }
4092 : :
4093 : 10847 : internal::DType& DatatypeDecl::getDatatype(void) const { return *d_dtype; }
4094 : :
4095 : : /* DatatypeSelector --------------------------------------------------------- */
4096 : :
4097 : 3 : DatatypeSelector::DatatypeSelector() : d_nm(nullptr), d_stor(nullptr) {}
4098 : :
4099 : 18225 : DatatypeSelector::DatatypeSelector(NodeManagerSharedPtr nm,
4100 : 18225 : const internal::DTypeSelector& stor)
4101 : 18225 : : d_nm(std::move(nm)), d_stor(new internal::DTypeSelector(stor))
4102 : : {
4103 [ - + ][ - + ]: 18225 : CVC5_API_CHECK(d_stor->isResolved()) << "expected resolved datatype selector";
[ - - ]
4104 : 18225 : }
4105 : :
4106 : 18297 : DatatypeSelector::~DatatypeSelector()
4107 : : {
4108 [ + + ]: 18297 : if (d_stor != nullptr)
4109 : : {
4110 : 18295 : d_stor.reset();
4111 : : }
4112 : 18297 : }
4113 : :
4114 : 11 : bool DatatypeSelector::operator==(const DatatypeSelector& sel) const
4115 : : {
4116 : : CVC5_API_TRY_CATCH_BEGIN;
4117 [ - + ][ - + ]: 11 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4118 : : //////// all checks before this line
4119 : 11 : return d_stor == sel.d_stor;
4120 : : ////////
4121 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4122 : : }
4123 : :
4124 : 17048 : std::string DatatypeSelector::getName() const
4125 : : {
4126 : : CVC5_API_TRY_CATCH_BEGIN;
4127 [ - + ][ - + ]: 17048 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4128 : : //////// all checks before this line
4129 : 17048 : return d_stor->getName();
4130 : : ////////
4131 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4132 [ - - ]: 0 : }
4133 : :
4134 : 18028 : Term DatatypeSelector::getTerm() const
4135 : : {
4136 : : CVC5_API_TRY_CATCH_BEGIN;
4137 [ - + ][ - + ]: 18028 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4138 : : //////// all checks before this line
4139 : 18028 : return Term(d_nm, d_stor->getSelector());
4140 : : ////////
4141 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4142 [ - - ]: 0 : }
4143 : 160 : Term DatatypeSelector::getUpdaterTerm() const
4144 : : {
4145 : : CVC5_API_TRY_CATCH_BEGIN;
4146 [ - + ][ - + ]: 160 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4147 : : //////// all checks before this line
4148 : 160 : return Term(d_nm, d_stor->getUpdater());
4149 : : ////////
4150 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4151 [ - - ]: 0 : }
4152 : :
4153 : 14 : Sort DatatypeSelector::getCodomainSort() const
4154 : : {
4155 : : CVC5_API_TRY_CATCH_BEGIN;
4156 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4157 : : //////// all checks before this line
4158 : 14 : return Sort(d_nm, d_stor->getRangeType());
4159 : : ////////
4160 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4161 [ - - ]: 0 : }
4162 : :
4163 : 71 : bool DatatypeSelector::isNull() const
4164 : : {
4165 : : CVC5_API_TRY_CATCH_BEGIN;
4166 : : //////// all checks before this line
4167 : 71 : return isNullHelper();
4168 : : ////////
4169 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4170 : : }
4171 : :
4172 : 4 : std::string DatatypeSelector::toString() const
4173 : : {
4174 : : CVC5_API_TRY_CATCH_BEGIN;
4175 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4176 : : //////// all checks before this line
4177 : 4 : std::stringstream ss;
4178 : 4 : ss << *d_stor;
4179 : 8 : return ss.str();
4180 : : ////////
4181 [ - - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4182 [ - - ]: 0 : }
4183 : :
4184 : 2 : std::ostream& operator<<(std::ostream& out, const DatatypeSelector& stor)
4185 : : {
4186 : 2 : out << stor.toString();
4187 : 2 : return out;
4188 : : }
4189 : :
4190 : 35336 : bool DatatypeSelector::isNullHelper() const { return d_stor == nullptr; }
4191 : :
4192 : : /* DatatypeConstructor ------------------------------------------------------ */
4193 : :
4194 : 3 : DatatypeConstructor::DatatypeConstructor() : d_nm(nullptr), d_ctor(nullptr) {}
4195 : :
4196 : 24893 : DatatypeConstructor::DatatypeConstructor(NodeManagerSharedPtr nm,
4197 : 24893 : const internal::DTypeConstructor& ctor)
4198 : 24893 : : d_nm(std::move(nm)), d_ctor(new internal::DTypeConstructor(ctor))
4199 : : {
4200 [ - + ][ - + ]: 24893 : CVC5_API_CHECK(d_ctor->isResolved())
[ - - ]
4201 : 0 : << "expected resolved datatype constructor";
4202 : 24893 : }
4203 : :
4204 : 24976 : DatatypeConstructor::~DatatypeConstructor()
4205 : : {
4206 [ + + ]: 24976 : if (d_ctor != nullptr)
4207 : : {
4208 : 24974 : d_ctor.reset();
4209 : : }
4210 : 24976 : }
4211 : :
4212 : 12 : bool DatatypeConstructor::operator==(const DatatypeConstructor& cons) const
4213 : : {
4214 : : CVC5_API_TRY_CATCH_BEGIN;
4215 [ - + ][ - + ]: 12 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4216 : : //////// all checks before this line
4217 : 12 : return d_ctor == cons.d_ctor;
4218 : : ////////
4219 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4220 : : }
4221 : :
4222 : 18984 : std::string DatatypeConstructor::getName() const
4223 : : {
4224 : : CVC5_API_TRY_CATCH_BEGIN;
4225 [ - + ][ - + ]: 18984 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4226 : : //////// all checks before this line
4227 : 18984 : return d_ctor->getName();
4228 : : ////////
4229 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4230 [ - - ]: 0 : }
4231 : :
4232 : 19182 : Term DatatypeConstructor::getTerm() const
4233 : : {
4234 : : CVC5_API_TRY_CATCH_BEGIN;
4235 [ - + ][ - + ]: 19182 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4236 : : //////// all checks before this line
4237 : 19182 : return Term(d_nm, d_ctor->getConstructor());
4238 : : ////////
4239 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4240 [ - - ]: 0 : }
4241 : :
4242 : 125 : Term DatatypeConstructor::getInstantiatedTerm(const Sort& retSort) const
4243 : : {
4244 : : CVC5_API_TRY_CATCH_BEGIN;
4245 [ - + ][ - + ]: 125 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4246 [ - + ][ - + ]: 125 : CVC5_API_CHECK(d_ctor->isResolved())
[ - - ]
4247 : 0 : << "expected resolved datatype constructor";
4248 [ + + ][ + + ]: 127 : CVC5_API_CHECK(retSort.isDatatype())
[ - - ]
4249 : 2 : << "cannot get specialized constructor type for non-datatype type "
4250 : : << retSort;
4251 : : //////// all checks before this line
4252 : 123 : internal::Node ret = d_ctor->getInstantiatedConstructor(*retSort.d_type);
4253 : 123 : (void)ret.getType(true); /* kick off type checking */
4254 : : // apply type ascription to the operator
4255 : 123 : Term sctor = Term(d_nm, ret);
4256 : 246 : return sctor;
4257 : : ////////
4258 [ + - ][ - - ]: 125 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4259 [ - + ]: 2 : }
4260 : :
4261 : 13861 : Term DatatypeConstructor::getTesterTerm() const
4262 : : {
4263 : : CVC5_API_TRY_CATCH_BEGIN;
4264 [ - + ][ - + ]: 13861 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4265 : : //////// all checks before this line
4266 : 13861 : return Term(d_nm, d_ctor->getTester());
4267 : : ////////
4268 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4269 [ - - ]: 0 : }
4270 : :
4271 : 28336 : size_t DatatypeConstructor::getNumSelectors() const
4272 : : {
4273 : : CVC5_API_TRY_CATCH_BEGIN;
4274 [ - + ][ - + ]: 28336 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4275 : : //////// all checks before this line
4276 : 28336 : return d_ctor->getNumArgs();
4277 : : ////////
4278 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4279 : : }
4280 : :
4281 : 18063 : DatatypeSelector DatatypeConstructor::operator[](size_t index) const
4282 : : {
4283 : : CVC5_API_TRY_CATCH_BEGIN;
4284 [ - + ][ - + ]: 18063 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4285 [ + + ][ + + ]: 18063 : CVC5_API_CHECK(index < d_ctor->getNumArgs()) << "index out of bounds";
[ - - ]
4286 : : //////// all checks before this line
4287 : 18061 : return DatatypeSelector(d_nm, (*d_ctor)[index]);
4288 : : ////////
4289 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4290 [ - + ]: 2 : }
4291 : :
4292 : 3 : DatatypeSelector DatatypeConstructor::operator[](const std::string& name) const
4293 : : {
4294 : : CVC5_API_TRY_CATCH_BEGIN;
4295 [ - + ][ - + ]: 3 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4296 : : //////// all checks before this line
4297 : 3 : return getSelectorForName(name);
4298 : : ////////
4299 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4300 [ - - ]: 0 : }
4301 : :
4302 : 29 : DatatypeSelector DatatypeConstructor::getSelector(const std::string& name) const
4303 : : {
4304 : : CVC5_API_TRY_CATCH_BEGIN;
4305 [ - + ][ - + ]: 29 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4306 : : //////// all checks before this line
4307 : 29 : return getSelectorForName(name);
4308 : : ////////
4309 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4310 [ - + ]: 2 : }
4311 : :
4312 : 5 : DatatypeConstructor::const_iterator DatatypeConstructor::begin() const
4313 : : {
4314 : 5 : return DatatypeConstructor::const_iterator(d_nm, *d_ctor, true);
4315 : : }
4316 : :
4317 : 7 : DatatypeConstructor::const_iterator DatatypeConstructor::end() const
4318 : : {
4319 : 7 : return DatatypeConstructor::const_iterator(d_nm, *d_ctor, false);
4320 : : }
4321 : :
4322 : 12 : DatatypeConstructor::const_iterator::const_iterator(
4323 : 12 : NodeManagerSharedPtr nm, const internal::DTypeConstructor& ctor, bool begin)
4324 : : {
4325 : 12 : d_nm = std::move(nm);
4326 : 12 : d_int_stors = &ctor.getArgs();
4327 : :
4328 : : const std::vector<std::shared_ptr<internal::DTypeSelector>>& sels =
4329 : 12 : ctor.getArgs();
4330 [ + + ]: 24 : for (const std::shared_ptr<internal::DTypeSelector>& s : sels)
4331 : : {
4332 : : /* Can not use emplace_back here since constructor is private. */
4333 : 12 : d_stors.push_back(DatatypeSelector(d_nm, *s.get()));
4334 : : }
4335 [ + + ]: 12 : d_idx = begin ? 0 : sels.size();
4336 : 12 : }
4337 : :
4338 : 2 : DatatypeConstructor::const_iterator::const_iterator()
4339 : 2 : : d_nm(nullptr), d_int_stors(nullptr), d_idx(0)
4340 : : {
4341 : 2 : }
4342 : :
4343 : 4 : const DatatypeSelector& DatatypeConstructor::const_iterator::operator*() const
4344 : : {
4345 : 4 : return d_stors[d_idx];
4346 : : }
4347 : :
4348 : 2 : const DatatypeSelector* DatatypeConstructor::const_iterator::operator->() const
4349 : : {
4350 : 2 : return &d_stors[d_idx];
4351 : : }
4352 : :
4353 : : DatatypeConstructor::const_iterator&
4354 : 4 : DatatypeConstructor::const_iterator::operator++()
4355 : : {
4356 : 4 : ++d_idx;
4357 : 4 : return *this;
4358 : : }
4359 : :
4360 : : DatatypeConstructor::const_iterator
4361 : 2 : DatatypeConstructor::const_iterator::operator++(int)
4362 : : {
4363 : 2 : DatatypeConstructor::const_iterator it(*this);
4364 : 2 : ++d_idx;
4365 : 2 : return it;
4366 : : }
4367 : :
4368 : 3 : bool DatatypeConstructor::const_iterator::operator==(
4369 : : const DatatypeConstructor::const_iterator& other) const
4370 : : {
4371 [ + - ][ + - ]: 3 : return d_int_stors == other.d_int_stors && d_idx == other.d_idx;
4372 : : }
4373 : :
4374 : 6 : bool DatatypeConstructor::const_iterator::operator!=(
4375 : : const DatatypeConstructor::const_iterator& other) const
4376 : : {
4377 [ + - ][ + + ]: 6 : return d_int_stors != other.d_int_stors || d_idx != other.d_idx;
4378 : : }
4379 : :
4380 : 83 : bool DatatypeConstructor::isNull() const
4381 : : {
4382 : : CVC5_API_TRY_CATCH_BEGIN;
4383 : : //////// all checks before this line
4384 : 83 : return isNullHelper();
4385 : : ////////
4386 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4387 : : }
4388 : :
4389 : 4 : std::string DatatypeConstructor::toString() const
4390 : : {
4391 : : CVC5_API_TRY_CATCH_BEGIN;
4392 : : //////// all checks before this line
4393 : 4 : std::stringstream ss;
4394 : 4 : ss << *d_ctor;
4395 : 8 : return ss.str();
4396 : : ////////
4397 [ - - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4398 : : }
4399 : :
4400 : 98678 : bool DatatypeConstructor::isNullHelper() const { return d_ctor == nullptr; }
4401 : :
4402 : 32 : DatatypeSelector DatatypeConstructor::getSelectorForName(
4403 : : const std::string& name) const
4404 : : {
4405 : 32 : bool foundSel = false;
4406 : 32 : size_t index = 0;
4407 [ + + ]: 42 : for (size_t i = 0, nsels = getNumSelectors(); i < nsels; i++)
4408 : : {
4409 [ + + ]: 40 : if ((*d_ctor)[i].getName() == name)
4410 : : {
4411 : 30 : index = i;
4412 : 30 : foundSel = true;
4413 : 30 : break;
4414 : : }
4415 : : }
4416 [ + + ]: 32 : if (!foundSel)
4417 : : {
4418 : 2 : std::stringstream snames;
4419 : 2 : snames << "{ ";
4420 [ + + ]: 6 : for (size_t i = 0, ncons = getNumSelectors(); i < ncons; i++)
4421 : : {
4422 : 4 : snames << (*d_ctor)[i].getName() << " ";
4423 : : }
4424 : 2 : snames << "} ";
4425 [ + - ][ - - ]: 6 : CVC5_API_CHECK(foundSel) << "no selector " << name << " for constructor "
4426 : 4 : << getName() << " exists among " << snames.str();
4427 : 2 : }
4428 : 30 : return DatatypeSelector(d_nm, (*d_ctor)[index]);
4429 [ - + ]: 2 : }
4430 : :
4431 : 2 : std::ostream& operator<<(std::ostream& out, const DatatypeConstructor& ctor)
4432 : : {
4433 : 2 : out << ctor.toString();
4434 : 2 : return out;
4435 : : }
4436 : :
4437 : : /* Datatype ----------------------------------------------------------------- */
4438 : :
4439 : 22793 : Datatype::Datatype(NodeManagerSharedPtr nm, const internal::DType& dtype)
4440 : 22793 : : d_nm(std::move(nm)), d_dtype(new internal::DType(dtype))
4441 : : {
4442 [ - + ][ - + ]: 22793 : CVC5_API_CHECK(d_dtype->isResolved()) << "expected resolved datatype";
[ - - ]
4443 : 22793 : }
4444 : :
4445 : 3 : Datatype::Datatype() : d_nm(nullptr), d_dtype(nullptr) {}
4446 : :
4447 : 22906 : Datatype::~Datatype()
4448 : : {
4449 [ + + ]: 22906 : if (d_dtype != nullptr)
4450 : : {
4451 : 22904 : d_dtype.reset();
4452 : : }
4453 : 22906 : }
4454 : :
4455 : 17 : bool Datatype::operator==(const Datatype& dt) const
4456 : : {
4457 : : CVC5_API_TRY_CATCH_BEGIN;
4458 [ - + ][ - + ]: 17 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4459 : : //////// all checks before this line
4460 : 17 : return d_dtype == dt.d_dtype;
4461 : : ////////
4462 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4463 : : }
4464 : :
4465 : 20016 : DatatypeConstructor Datatype::operator[](size_t idx) const
4466 : : {
4467 : : CVC5_API_TRY_CATCH_BEGIN;
4468 [ - + ][ - + ]: 20016 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4469 [ + + ][ + + ]: 20016 : CVC5_API_CHECK(idx < getNumConstructors()) << "index out of bounds.";
[ - - ]
4470 : : //////// all checks before this line
4471 : 20012 : return DatatypeConstructor(d_nm, (*d_dtype)[idx]);
4472 : : ////////
4473 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4474 [ - + ]: 4 : }
4475 : :
4476 : 14 : DatatypeConstructor Datatype::operator[](const std::string& name) const
4477 : : {
4478 : : CVC5_API_TRY_CATCH_BEGIN;
4479 [ - + ][ - + ]: 14 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4480 : : //////// all checks before this line
4481 : 14 : return getConstructorForName(name);
4482 : : ////////
4483 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4484 [ - - ]: 0 : }
4485 : :
4486 : 4860 : DatatypeConstructor Datatype::getConstructor(const std::string& name) const
4487 : : {
4488 : : CVC5_API_TRY_CATCH_BEGIN;
4489 [ - + ][ - + ]: 4860 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4490 : : //////// all checks before this line
4491 : 4860 : return getConstructorForName(name);
4492 : : ////////
4493 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4494 [ - + ]: 4 : }
4495 : :
4496 : 124 : DatatypeSelector Datatype::getSelector(const std::string& name) const
4497 : : {
4498 : : CVC5_API_TRY_CATCH_BEGIN;
4499 [ - + ][ - + ]: 124 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4500 : : //////// all checks before this line
4501 : 124 : return getSelectorForName(name);
4502 : : ////////
4503 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4504 [ - + ]: 2 : }
4505 : :
4506 : 10657 : std::string Datatype::getName() const
4507 : : {
4508 : : CVC5_API_TRY_CATCH_BEGIN;
4509 [ - + ][ - + ]: 10657 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4510 : : //////// all checks before this line
4511 : 10657 : return d_dtype->getName();
4512 : : ////////
4513 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4514 [ - - ]: 0 : }
4515 : :
4516 : 35748 : size_t Datatype::getNumConstructors() const
4517 : : {
4518 : : CVC5_API_TRY_CATCH_BEGIN;
4519 [ - + ][ - + ]: 35748 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4520 : : //////// all checks before this line
4521 : 35748 : return d_dtype->getNumConstructors();
4522 : : ////////
4523 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4524 : : }
4525 : :
4526 : 206 : std::vector<Sort> Datatype::getParameters() const
4527 : : {
4528 : : CVC5_API_TRY_CATCH_BEGIN;
4529 [ - + ][ - + ]: 206 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4530 [ + + ][ + + ]: 206 : CVC5_API_CHECK(isParametric()) << "expected parametric datatype";
[ - - ]
4531 : : //////// all checks before this line
4532 : 204 : std::vector<internal::TypeNode> params = d_dtype->getParameters();
4533 : 408 : return Sort::typeNodeVectorToSorts(d_nm, params);
4534 : : ////////
4535 [ + - ][ - - ]: 206 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4536 [ - + ]: 2 : }
4537 : :
4538 : 6523 : bool Datatype::isParametric() const
4539 : : {
4540 : : CVC5_API_TRY_CATCH_BEGIN;
4541 [ - + ][ - + ]: 6523 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4542 : : //////// all checks before this line
4543 : 6523 : return d_dtype->isParametric();
4544 : : ////////
4545 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4546 : : }
4547 : :
4548 : 4 : bool Datatype::isCodatatype() const
4549 : : {
4550 : : CVC5_API_TRY_CATCH_BEGIN;
4551 [ - + ][ - + ]: 4 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4552 : : //////// all checks before this line
4553 : 4 : return d_dtype->isCodatatype();
4554 : : ////////
4555 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4556 : : }
4557 : :
4558 : 7 : bool Datatype::isTuple() const
4559 : : {
4560 : : CVC5_API_TRY_CATCH_BEGIN;
4561 [ - + ][ - + ]: 7 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4562 : : //////// all checks before this line
4563 : 7 : return d_dtype->isTuple();
4564 : : ////////
4565 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4566 : : }
4567 : :
4568 : 7 : bool Datatype::isRecord() const
4569 : : {
4570 : : CVC5_API_TRY_CATCH_BEGIN;
4571 [ - + ][ - + ]: 7 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4572 : : //////// all checks before this line
4573 : 7 : return d_dtype->isRecord();
4574 : : ////////
4575 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4576 : : }
4577 : :
4578 : 22 : bool Datatype::isFinite() const
4579 : : {
4580 : : CVC5_API_TRY_CATCH_BEGIN;
4581 [ - + ][ - + ]: 22 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4582 [ + + ][ + + ]: 24 : CVC5_API_CHECK(!d_dtype->isParametric())
[ - - ]
4583 : 2 : << "invalid call to 'isFinite()', expected non-parametric datatype";
4584 : : //////// all checks before this line
4585 : : // we assume that finite model finding is disabled by passing false as the
4586 : : // second argument
4587 : 20 : return isCardinalityClassFinite(d_dtype->getCardinalityClass(), false);
4588 : : ////////
4589 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4590 : : }
4591 : :
4592 : 32 : bool Datatype::isWellFounded() const
4593 : : {
4594 : : CVC5_API_TRY_CATCH_BEGIN;
4595 [ - + ][ - + ]: 32 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4596 : : //////// all checks before this line
4597 : 32 : return d_dtype->isWellFounded();
4598 : : ////////
4599 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4600 : : }
4601 : :
4602 : 127 : bool Datatype::isNull() const
4603 : : {
4604 : : CVC5_API_TRY_CATCH_BEGIN;
4605 : : //////// all checks before this line
4606 : 127 : return isNullHelper();
4607 : : ////////
4608 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4609 : : }
4610 : :
4611 : 3 : std::string Datatype::toString() const
4612 : : {
4613 : : CVC5_API_TRY_CATCH_BEGIN;
4614 [ - + ][ - + ]: 3 : CVC5_API_CHECK_NOT_NULL;
[ - - ]
4615 : : //////// all checks before this line
4616 : 3 : return d_dtype->getName();
4617 : : ////////
4618 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4619 [ - - ]: 0 : }
4620 : :
4621 : 3 : Datatype::const_iterator Datatype::begin() const
4622 : : {
4623 : 3 : return Datatype::const_iterator(d_nm, *d_dtype, true);
4624 : : }
4625 : :
4626 : 6 : Datatype::const_iterator Datatype::end() const
4627 : : {
4628 : 6 : return Datatype::const_iterator(d_nm, *d_dtype, false);
4629 : : }
4630 : :
4631 : 4874 : DatatypeConstructor Datatype::getConstructorForName(
4632 : : const std::string& name) const
4633 : : {
4634 : 4874 : bool foundCons = false;
4635 : 4874 : size_t index = 0;
4636 [ + + ]: 9369 : for (size_t i = 0, ncons = getNumConstructors(); i < ncons; i++)
4637 : : {
4638 [ + + ]: 9365 : if ((*d_dtype)[i].getName() == name)
4639 : : {
4640 : 4870 : index = i;
4641 : 4870 : foundCons = true;
4642 : 4870 : break;
4643 : : }
4644 : : }
4645 [ + + ]: 4874 : if (!foundCons)
4646 : : {
4647 : 4 : std::stringstream snames;
4648 : 4 : snames << "{ ";
4649 [ + + ]: 12 : for (size_t i = 0, ncons = getNumConstructors(); i < ncons; i++)
4650 : : {
4651 : 8 : snames << (*d_dtype)[i].getName() << " ";
4652 : : }
4653 : 4 : snames << "}";
4654 [ + - ][ - - ]: 12 : CVC5_API_CHECK(foundCons) << "no constructor " << name << " for datatype "
4655 : 8 : << getName() << " exists, among " << snames.str();
4656 : 4 : }
4657 : 4870 : return DatatypeConstructor(d_nm, (*d_dtype)[index]);
4658 [ - + ]: 4 : }
4659 : :
4660 : 124 : DatatypeSelector Datatype::getSelectorForName(const std::string& name) const
4661 : : {
4662 : 124 : bool foundSel = false;
4663 : 124 : size_t index = 0;
4664 : 124 : size_t sindex = 0;
4665 [ + + ]: 152 : for (size_t i = 0, ncons = getNumConstructors(); i < ncons; i++)
4666 : : {
4667 : 150 : int si = (*d_dtype)[i].getSelectorIndexForName(name);
4668 [ + + ]: 150 : if (si >= 0)
4669 : : {
4670 : 122 : sindex = static_cast<size_t>(si);
4671 : 122 : index = i;
4672 : 122 : foundSel = true;
4673 : 122 : break;
4674 : : }
4675 : : }
4676 [ + + ]: 124 : if (!foundSel)
4677 : : {
4678 [ + - ][ - - ]: 6 : CVC5_API_CHECK(foundSel)
4679 [ + - ][ + - ]: 4 : << "no selector " << name << " for datatype " << getName() << " exists";
[ - - ]
4680 : : }
4681 : 122 : return DatatypeSelector(d_nm, (*d_dtype)[index][sindex]);
4682 [ - + ]: 2 : }
4683 : :
4684 : 9 : Datatype::const_iterator::const_iterator(NodeManagerSharedPtr nm,
4685 : : const internal::DType& dtype,
4686 : 9 : bool begin)
4687 : 9 : : d_nm(std::move(nm)), d_int_ctors(&dtype.getConstructors())
4688 : : {
4689 : : const std::vector<std::shared_ptr<internal::DTypeConstructor>>& cons =
4690 : 9 : dtype.getConstructors();
4691 [ + + ]: 20 : for (const std::shared_ptr<internal::DTypeConstructor>& c : cons)
4692 : : {
4693 : : /* Can not use emplace_back here since constructor is private. */
4694 : 11 : d_ctors.push_back(DatatypeConstructor(d_nm, *c.get()));
4695 : : }
4696 [ + + ]: 9 : d_idx = begin ? 0 : cons.size();
4697 : 9 : }
4698 : :
4699 : 2 : Datatype::const_iterator::const_iterator()
4700 : 2 : : d_nm(nullptr), d_int_ctors(nullptr), d_idx(0)
4701 : : {
4702 : 2 : }
4703 : :
4704 : 4 : const DatatypeConstructor& Datatype::const_iterator::operator*() const
4705 : : {
4706 : 4 : return d_ctors[d_idx];
4707 : : }
4708 : :
4709 : 2 : const DatatypeConstructor* Datatype::const_iterator::operator->() const
4710 : : {
4711 : 2 : return &d_ctors[d_idx];
4712 : : }
4713 : :
4714 : 4 : Datatype::const_iterator& Datatype::const_iterator::operator++()
4715 : : {
4716 : 4 : ++d_idx;
4717 : 4 : return *this;
4718 : : }
4719 : :
4720 : 2 : Datatype::const_iterator Datatype::const_iterator::operator++(int)
4721 : : {
4722 : 2 : Datatype::const_iterator it(*this);
4723 : 2 : ++d_idx;
4724 : 2 : return it;
4725 : : }
4726 : :
4727 : 3 : bool Datatype::const_iterator::operator==(
4728 : : const Datatype::const_iterator& other) const
4729 : : {
4730 [ + - ][ + - ]: 3 : return d_int_ctors == other.d_int_ctors && d_idx == other.d_idx;
4731 : : }
4732 : :
4733 : 5 : bool Datatype::const_iterator::operator!=(
4734 : : const Datatype::const_iterator& other) const
4735 : : {
4736 [ + - ][ + + ]: 5 : return d_int_ctors != other.d_int_ctors || d_idx != other.d_idx;
4737 : : }
4738 : :
4739 : 78367 : bool Datatype::isNullHelper() const { return d_dtype == nullptr; }
4740 : :
4741 : 2 : std::ostream& operator<<(std::ostream& out, const Datatype& dtype)
4742 : : {
4743 : 2 : return out << dtype.toString();
4744 : : }
4745 : :
4746 : : /* -------------------------------------------------------------------------- */
4747 : : /* Grammar */
4748 : : /* -------------------------------------------------------------------------- */
4749 : :
4750 : 5 : Grammar::Grammar() : d_nm(nullptr) {}
4751 : :
4752 : 860 : Grammar::Grammar(NodeManagerSharedPtr nm,
4753 : : const std::vector<Term>& sygusVars,
4754 : 860 : const std::vector<Term>& ntSymbols)
4755 : 860 : : d_nm(std::move(nm)),
4756 : 860 : d_grammar(std::make_shared<internal::SygusGrammar>(
4757 : 1720 : Term::termVectorToNodes(sygusVars),
4758 : 1720 : Term::termVectorToNodes(ntSymbols)))
4759 : : {
4760 : 860 : }
4761 : :
4762 : 927 : Grammar::~Grammar() { d_grammar.reset(); }
4763 : :
4764 : 876 : bool Grammar::isNull() const { return d_grammar == nullptr; }
4765 : :
4766 : 7627 : bool contains(const std::vector<internal::Node>& ns, const internal::Node& n)
4767 : : {
4768 : 7627 : return std::find(ns.cbegin(), ns.cend(), n) != ns.cend();
4769 : : }
4770 : :
4771 : 7429 : void Grammar::addRule(const Term& ntSymbol, const Term& rule)
4772 : : {
4773 : : CVC5_API_TRY_CATCH_BEGIN;
4774 [ + + ][ + + ]: 7431 : CVC5_API_CHECK(!d_grammar->isResolved())
[ - - ]
4775 : : << "Grammar cannot be modified after passing "
4776 : 2 : "it as an argument to synthFun";
4777 : 7427 : CVC5_API_CHECK_TERM(ntSymbol);
4778 : 7426 : CVC5_API_CHECK_TERM(rule);
4779 [ + + ][ + + ]: 7427 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
4780 : : contains(d_grammar->getNtSyms(), *ntSymbol.d_node), ntSymbol)
4781 : : << "ntSymbol to be one of the non-terminal symbols given in the "
4782 : 2 : "predeclaration";
4783 [ + + ][ + + ]: 7429 : CVC5_API_CHECK(
[ - - ]
4784 : : ntSymbol.d_node->getType().isInstanceOf(rule.d_node->getType()))
4785 : 2 : << "expected ntSymbol and rule to have the same sort";
4786 : : //////// all checks before this line
4787 : 7421 : d_grammar->addRule(*ntSymbol.d_node, *rule.d_node);
4788 : : ////////
4789 [ + - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4790 : 7421 : }
4791 : :
4792 : 21 : void Grammar::addRules(const Term& ntSymbol, const std::vector<Term>& rules)
4793 : : {
4794 : : CVC5_API_TRY_CATCH_BEGIN;
4795 [ + + ][ + + ]: 23 : CVC5_API_CHECK(!d_grammar->isResolved())
[ - - ]
4796 : : << "Grammar cannot be modified after passing "
4797 : 2 : "it as an argument to synthFun";
4798 : 19 : CVC5_API_CHECK_TERM(ntSymbol);
4799 : 67 : CVC5_API_CHECK_TERMS_WITH_SORT(rules, ntSymbol.getSort());
4800 [ + + ][ + + ]: 18 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
4801 : : contains(d_grammar->getNtSyms(), *ntSymbol.d_node), ntSymbol)
4802 : : << "ntSymbol to be one of the non-terminal symbols given in the "
4803 : 3 : "predeclaration";
4804 : : //////// all checks before this line
4805 : 12 : d_grammar->addRules(*ntSymbol.d_node, Term::termVectorToNodes(rules));
4806 : : ////////
4807 [ + - ][ - - ]: 9 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4808 : 12 : }
4809 : :
4810 : 129 : void Grammar::addAnyConstant(const Term& ntSymbol)
4811 : : {
4812 : : CVC5_API_TRY_CATCH_BEGIN;
4813 [ + + ][ + + ]: 131 : CVC5_API_CHECK(!d_grammar->isResolved())
[ - - ]
4814 : : << "Grammar cannot be modified after passing "
4815 : 2 : "it as an argument to synthFun";
4816 : 127 : CVC5_API_CHECK_TERM(ntSymbol);
4817 [ + + ][ + + ]: 128 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
4818 : : contains(d_grammar->getNtSyms(), *ntSymbol.d_node), ntSymbol)
4819 : : << "ntSymbol to be one of the non-terminal symbols given in the "
4820 : 2 : "predeclaration";
4821 : : //////// all checks before this line
4822 : 124 : d_grammar->addAnyConstant(*ntSymbol.d_node, ntSymbol.d_node->getType());
4823 : : ////////
4824 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4825 : 124 : }
4826 : :
4827 : 64 : void Grammar::addAnyVariable(const Term& ntSymbol)
4828 : : {
4829 : : CVC5_API_TRY_CATCH_BEGIN;
4830 [ + + ][ + + ]: 66 : CVC5_API_CHECK(!d_grammar->isResolved())
[ - - ]
4831 : : << "Grammar cannot be modified after passing "
4832 : 2 : "it as an argument to synthFun";
4833 : 62 : CVC5_API_CHECK_TERM(ntSymbol);
4834 [ + + ][ + + ]: 63 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
4835 : : contains(d_grammar->getNtSyms(), *ntSymbol.d_node), ntSymbol)
4836 : : << "ntSymbol to be one of the non-terminal symbols given in the "
4837 : 2 : "predeclaration";
4838 : : //////// all checks before this line
4839 : 59 : d_grammar->addAnyVariable(*ntSymbol.d_node);
4840 : : ////////
4841 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4842 : 59 : }
4843 : :
4844 : 8 : std::string Grammar::toString() const
4845 : : {
4846 : : CVC5_API_TRY_CATCH_BEGIN;
4847 : : //////// all checks before this line
4848 [ + - ][ + + ]: 8 : return d_grammar == nullptr || !d_grammar->hasRules() ? ""
4849 [ + + ][ - - ]: 19 : : d_grammar->toString();
4850 : : ////////
4851 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4852 : : }
4853 : :
4854 : 993 : Sort Grammar::resolve()
4855 : : {
4856 : : CVC5_API_TRY_CATCH_BEGIN;
4857 : : //////// all checks before this line
4858 : 993 : return Sort(d_nm, d_grammar->resolve());
4859 : : ////////
4860 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4861 : : }
4862 : :
4863 : 2 : std::ostream& operator<<(std::ostream& out, const Grammar& grammar)
4864 : : {
4865 : : CVC5_API_TRY_CATCH_BEGIN;
4866 : 2 : return out << grammar.toString();
4867 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4868 : : }
4869 : :
4870 : 72 : bool Grammar::operator==(const Grammar& grammar) const
4871 : : {
4872 : : CVC5_API_TRY_CATCH_BEGIN;
4873 : : //////// all checks before this line
4874 : 72 : return d_grammar == grammar.d_grammar;
4875 : : ////////
4876 : : CVC5_API_TRY_CATCH_END;
4877 : : }
4878 : :
4879 : 14 : bool Grammar::operator!=(const Grammar& grammar) const
4880 : : {
4881 : : CVC5_API_TRY_CATCH_BEGIN;
4882 : : //////// all checks before this line
4883 : 14 : return d_grammar != grammar.d_grammar;
4884 : : ////////
4885 : : CVC5_API_TRY_CATCH_END;
4886 : : }
4887 : :
4888 : : /* -------------------------------------------------------------------------- */
4889 : : /* Options */
4890 : : /* -------------------------------------------------------------------------- */
4891 : :
4892 : 688959 : DriverOptions::DriverOptions(const Solver& solver) : d_solver(solver) {}
4893 : :
4894 : 2 : std::istream& DriverOptions::in() const
4895 : : {
4896 : 2 : return *d_solver.d_slv->getOptions().base.in;
4897 : : }
4898 : 49255 : std::ostream& DriverOptions::err() const
4899 : : {
4900 : 49255 : return *d_solver.d_slv->getOptions().base.err;
4901 : : }
4902 : 610698 : std::ostream& DriverOptions::out() const
4903 : : {
4904 : 610698 : return *d_solver.d_slv->getOptions().base.out;
4905 : : }
4906 : :
4907 : : /* -------------------------------------------------------------------------- */
4908 : : /* Statistics */
4909 : : /* -------------------------------------------------------------------------- */
4910 : :
4911 : : struct Stat::StatData
4912 : : {
4913 : : internal::StatExportData data;
4914 : : template <typename T>
4915 : 34649 : StatData(T&& t) : data(std::forward<T>(t))
4916 : : {
4917 : 34649 : }
4918 : : StatData() : data() {}
4919 : : };
4920 : :
4921 : 569 : Stat::Stat() {}
4922 : 34652 : Stat::~Stat() {}
4923 : 23071 : Stat::Stat(const Stat& s) : d_internal(s.d_internal), d_default(s.d_default)
4924 : : {
4925 [ + - ]: 23071 : if (s.d_data)
4926 : : {
4927 : 23071 : d_data = std::make_unique<StatData>(s.d_data->data);
4928 : : }
4929 : 23071 : }
4930 : 567 : Stat& Stat::operator=(const Stat& s)
4931 : : {
4932 : 567 : d_internal = s.d_internal;
4933 : 567 : d_default = s.d_default;
4934 [ + + ]: 567 : if (s.d_data)
4935 : : {
4936 : 566 : d_data = std::make_unique<StatData>(s.d_data->data);
4937 : : }
4938 : 567 : return *this;
4939 : : }
4940 : :
4941 : 9 : bool Stat::isInternal() const { return d_internal; }
4942 : 7 : bool Stat::isDefault() const { return d_default; }
4943 : :
4944 : 10 : bool Stat::isInt() const
4945 : : {
4946 [ - + ]: 10 : if (!d_data) return false;
4947 : 10 : return std::holds_alternative<int64_t>(d_data->data);
4948 : : }
4949 : 4 : int64_t Stat::getInt() const
4950 : : {
4951 : : CVC5_API_TRY_CATCH_BEGIN;
4952 [ - + ][ - + ]: 4 : CVC5_API_RECOVERABLE_CHECK(static_cast<bool>(d_data))
[ - - ]
4953 : 0 : << "Stat holds no value";
4954 [ + + ][ + + ]: 4 : CVC5_API_RECOVERABLE_CHECK(isInt()) << "expected Stat of type int64_t.";
[ - - ]
4955 : 3 : return std::get<int64_t>(d_data->data);
4956 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4957 : : }
4958 : 9 : bool Stat::isDouble() const
4959 : : {
4960 [ - + ]: 9 : if (!d_data) return false;
4961 : 9 : return std::holds_alternative<double>(d_data->data);
4962 : : }
4963 : 3 : double Stat::getDouble() const
4964 : : {
4965 : : CVC5_API_TRY_CATCH_BEGIN;
4966 [ - + ][ - + ]: 3 : CVC5_API_RECOVERABLE_CHECK(static_cast<bool>(d_data))
[ - - ]
4967 : 0 : << "Stat holds no value";
4968 [ + + ][ + + ]: 3 : CVC5_API_RECOVERABLE_CHECK(isDouble()) << "expected Stat of type double.";
[ - - ]
4969 : 2 : return std::get<double>(d_data->data);
4970 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4971 : : }
4972 : 10 : bool Stat::isString() const
4973 : : {
4974 [ - + ]: 10 : if (!d_data) return false;
4975 : 10 : return std::holds_alternative<std::string>(d_data->data);
4976 : : }
4977 : 4 : const std::string& Stat::getString() const
4978 : : {
4979 : : CVC5_API_TRY_CATCH_BEGIN;
4980 [ - + ][ - + ]: 4 : CVC5_API_RECOVERABLE_CHECK(static_cast<bool>(d_data))
[ - - ]
4981 : 0 : << "Stat holds no value";
4982 [ + + ][ + + ]: 5 : CVC5_API_RECOVERABLE_CHECK(isString())
[ - - ]
4983 : 1 : << "expected Stat of type std::string.";
4984 : 3 : return std::get<std::string>(d_data->data);
4985 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
4986 : : }
4987 : 9 : bool Stat::isHistogram() const
4988 : : {
4989 [ - + ]: 9 : if (!d_data) return false;
4990 : 9 : return std::holds_alternative<HistogramData>(d_data->data);
4991 : : }
4992 : 4 : const Stat::HistogramData& Stat::getHistogram() const
4993 : : {
4994 : : CVC5_API_TRY_CATCH_BEGIN;
4995 [ - + ][ - + ]: 4 : CVC5_API_RECOVERABLE_CHECK(static_cast<bool>(d_data))
[ - - ]
4996 : 0 : << "Stat holds no value";
4997 [ + + ][ + + ]: 5 : CVC5_API_RECOVERABLE_CHECK(isHistogram())
[ - - ]
4998 : 1 : << "expected Stat of type histogram.";
4999 : 3 : return std::get<HistogramData>(d_data->data);
5000 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5001 : : }
5002 : :
5003 : 11012 : Stat::Stat(bool internal, bool defaulted, StatData&& sd)
5004 : 11012 : : d_internal(internal),
5005 : 11012 : d_default(defaulted),
5006 : 11012 : d_data(std::make_unique<StatData>(std::move(sd)))
5007 : : {
5008 : 11012 : }
5009 : :
5010 : 570 : std::string Stat::toString() const
5011 : : {
5012 : 570 : std::stringstream ss;
5013 : 570 : internal::detail::print(ss, d_data->data);
5014 : 1140 : return ss.str();
5015 : 570 : }
5016 : :
5017 : 1709 : std::ostream& operator<<(std::ostream& os, const Stat& stat)
5018 : : {
5019 : 1709 : return internal::detail::print(os, stat.d_data->data);
5020 : : }
5021 : :
5022 : 3399 : Statistics::BaseType::const_reference Statistics::iterator::operator*() const
5023 : : {
5024 : 3399 : return d_it.operator*();
5025 : : }
5026 : 565 : Statistics::BaseType::const_pointer Statistics::iterator::operator->() const
5027 : : {
5028 : 565 : return d_it.operator->();
5029 : : }
5030 : 3399 : Statistics::iterator& Statistics::iterator::operator++()
5031 : : {
5032 : : do
5033 : : {
5034 : 3399 : ++d_it;
5035 [ - + ]: 3399 : } while (!isVisible());
5036 : 3399 : return *this;
5037 : : }
5038 : 1130 : Statistics::iterator Statistics::iterator::operator++(int)
5039 : : {
5040 : 1130 : iterator tmp = *this;
5041 : : do
5042 : : {
5043 : 1130 : ++d_it;
5044 [ - + ]: 1130 : } while (!isVisible());
5045 : 1130 : return tmp;
5046 : : }
5047 : 565 : Statistics::iterator& Statistics::iterator::operator--()
5048 : : {
5049 : : do
5050 : : {
5051 : 565 : --d_it;
5052 [ - + ]: 565 : } while (!isVisible());
5053 : 565 : return *this;
5054 : : }
5055 : 565 : Statistics::iterator Statistics::iterator::operator--(int)
5056 : : {
5057 : 565 : iterator tmp = *this;
5058 : : do
5059 : : {
5060 : 565 : --d_it;
5061 [ - + ]: 565 : } while (!isVisible());
5062 : 565 : return tmp;
5063 : : }
5064 : 2822 : bool Statistics::iterator::operator==(const Statistics::iterator& rhs) const
5065 : : {
5066 : 2822 : return d_it == rhs.d_it;
5067 : : }
5068 : 3413 : bool Statistics::iterator::operator!=(const Statistics::iterator& rhs) const
5069 : : {
5070 : 3413 : return d_it != rhs.d_it;
5071 : : }
5072 : 1727 : Statistics::iterator::iterator(Statistics::BaseType::const_iterator it,
5073 : : const Statistics::BaseType& base,
5074 : : bool internal,
5075 : 1727 : bool defaulted)
5076 : 1727 : : d_it(it),
5077 : 1727 : d_base(&base),
5078 : 1727 : d_showInternal(internal),
5079 : 1727 : d_showDefault(defaulted)
5080 : : {
5081 [ - + ]: 1727 : while (!isVisible())
5082 : : {
5083 : 0 : ++d_it;
5084 : : }
5085 : 1727 : }
5086 : 7386 : bool Statistics::iterator::isVisible() const
5087 : : {
5088 [ + + ]: 7386 : if (d_it == d_base->end()) return true;
5089 [ - + ][ - - ]: 5662 : if (!d_showInternal && d_it->second.isInternal()) return false;
[ - + ]
5090 [ - + ][ - - ]: 5662 : if (!d_showDefault && d_it->second.isDefault()) return false;
[ - + ]
5091 : 5662 : return true;
5092 : : }
5093 : :
5094 : 19 : const Stat& Statistics::get(const std::string& name)
5095 : : {
5096 : : CVC5_API_TRY_CATCH_BEGIN;
5097 : 19 : auto it = d_stats.find(name);
5098 [ - + ][ - + ]: 19 : CVC5_API_RECOVERABLE_CHECK(it != d_stats.end())
[ - - ]
5099 : 0 : << "no statistic with name \"" << name << "\" exists.";
5100 : 19 : return it->second;
5101 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5102 : : }
5103 : :
5104 : 19 : Statistics::iterator Statistics::begin(bool internal, bool defaulted) const
5105 : : {
5106 : 19 : return iterator(d_stats.begin(), d_stats, internal, defaulted);
5107 : : }
5108 : 1708 : Statistics::iterator Statistics::end() const
5109 : : {
5110 : 1708 : return iterator(d_stats.end(), d_stats, false, false);
5111 : : }
5112 : :
5113 : 24 : Statistics::Statistics(const internal::StatisticsRegistry& reg)
5114 : : {
5115 [ + + ]: 11036 : for (const auto& svp : reg)
5116 : : {
5117 : 11012 : d_stats.emplace(svp.first,
5118 : 33036 : Stat(svp.second->d_internal,
5119 : 11012 : svp.second->isDefault(),
5120 : 22024 : svp.second->getViewer()));
5121 : : }
5122 : 24 : }
5123 : :
5124 : 6 : std::string Statistics::toString() const
5125 : : {
5126 : 6 : std::stringstream ss;
5127 [ + + ]: 1712 : for (const auto& stat : *this)
5128 : : {
5129 : 1706 : ss << stat.first << " = " << stat.second << std::endl;
5130 : : }
5131 : 12 : return ss.str();
5132 : 6 : }
5133 : :
5134 : 3 : std::ostream& operator<<(std::ostream& out, const Statistics& stats)
5135 : : {
5136 : 3 : out << stats.toString();
5137 : 3 : return out;
5138 : : }
5139 : :
5140 : : /*--------------------------------------------------------------------------- */
5141 : : /* Proof */
5142 : : /* -------------------------------------------------------------------------- */
5143 : :
5144 : 5 : Proof::Proof() : d_nm(nullptr) {}
5145 : :
5146 : 5419 : Proof::Proof(NodeManagerSharedPtr nm,
5147 : 5419 : const std::shared_ptr<internal::ProofNode> p)
5148 : 5419 : : d_nm(std::move(nm)), d_proofNode(p)
5149 : : {
5150 : 5419 : }
5151 : :
5152 : 21696 : Proof::~Proof() {}
5153 : :
5154 : 38 : bool Proof::isNull() const { return d_proofNode == nullptr; }
5155 : :
5156 : 27 : ProofRule Proof::getRule() const
5157 : : {
5158 : : CVC5_API_TRY_CATCH_BEGIN;
5159 : : //////// all checks before this line
5160 [ + + ]: 27 : if (d_proofNode != nullptr)
5161 : : {
5162 : 26 : return d_proofNode->getRule();
5163 : : }
5164 : 1 : return ProofRule::UNKNOWN;
5165 : : ////////
5166 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5167 : : }
5168 : :
5169 : 4 : ProofRewriteRule Proof::getRewriteRule() const
5170 : : {
5171 : : CVC5_API_TRY_CATCH_BEGIN;
5172 : 6 : CVC5_API_CHECK(d_proofNode->getRule() == ProofRule::DSL_REWRITE
5173 : : || d_proofNode->getRule() == ProofRule::THEORY_REWRITE)
5174 : : << "expected `getRule()` to return `DSL_REWRITE` or `THEORY_REWRITE`, "
5175 : 2 : "got "
5176 : 2 : << d_proofNode->getRule() << " instead.";
5177 : : //////// all checks before this line
5178 [ + - ]: 2 : if (d_proofNode != nullptr)
5179 : : {
5180 : : return static_cast<ProofRewriteRule>(
5181 : 2 : detail::getInteger(d_proofNode->getArguments()[0]).getUnsignedInt());
5182 : : }
5183 : 0 : return ProofRewriteRule::NONE;
5184 : : ////////
5185 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5186 : : }
5187 : :
5188 : 40 : Term Proof::getResult() const
5189 : : {
5190 : : CVC5_API_TRY_CATCH_BEGIN;
5191 : : //////// all checks before this line
5192 [ + + ]: 40 : if (d_proofNode != nullptr)
5193 : : {
5194 : 39 : return Term(d_nm, d_proofNode->getResult());
5195 : : }
5196 : 1 : return Term();
5197 : : ////////
5198 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5199 : : }
5200 : :
5201 : 25 : const std::vector<Proof> Proof::getChildren() const
5202 : : {
5203 : : CVC5_API_TRY_CATCH_BEGIN;
5204 : : //////// all checks before this line
5205 [ + + ]: 25 : if (d_proofNode != nullptr)
5206 : : {
5207 : 24 : std::vector<Proof> children;
5208 : : std::vector<std::shared_ptr<internal::ProofNode>> nodeChildren =
5209 : 24 : d_proofNode->getChildren();
5210 [ + + ]: 52 : for (size_t i = 0, psize = nodeChildren.size(); i < psize; i++)
5211 : : {
5212 : 28 : children.push_back(Proof(d_nm, nodeChildren[i]));
5213 : : }
5214 : 24 : return children;
5215 : 24 : }
5216 : 1 : return std::vector<Proof>();
5217 : : ////////
5218 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5219 : : }
5220 : :
5221 : 3 : const std::vector<Term> Proof::getArguments() const
5222 : : {
5223 : : CVC5_API_TRY_CATCH_BEGIN;
5224 : : //////// all checks before this line
5225 [ + + ]: 3 : if (d_proofNode != nullptr)
5226 : : {
5227 : 2 : std::vector<Term> args;
5228 : 2 : const std::vector<internal::Node> nodeArgs = d_proofNode->getArguments();
5229 [ - + ]: 2 : for (size_t i = 0, asize = nodeArgs.size(); i < asize; i++)
5230 : : {
5231 : 0 : args.push_back(Term(d_nm, nodeArgs[i]));
5232 : : }
5233 : 2 : return args;
5234 : 2 : }
5235 : 1 : return std::vector<Term>();
5236 : : ////////
5237 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5238 : : }
5239 : :
5240 : 8 : bool Proof::operator==(const Proof& p) const
5241 : : {
5242 : : CVC5_API_TRY_CATCH_BEGIN;
5243 : : //////// all checks before this line
5244 : 8 : return d_proofNode == p.d_proofNode;
5245 : : ////////
5246 : : CVC5_API_TRY_CATCH_END;
5247 : : }
5248 : :
5249 : 5 : bool Proof::operator!=(const Proof& p) const
5250 : : {
5251 : : CVC5_API_TRY_CATCH_BEGIN;
5252 : : //////// all checks before this line
5253 : 5 : return d_proofNode != p.d_proofNode;
5254 : : ////////
5255 : : CVC5_API_TRY_CATCH_END;
5256 : : }
5257 : :
5258 : : /* -------------------------------------------------------------------------- */
5259 : : /* Plugin */
5260 : : /* -------------------------------------------------------------------------- */
5261 : :
5262 : 6 : Plugin::Plugin(TermManager& tm)
5263 : 6 : : d_pExtToInt(new PluginInternal(tm.d_nm, *this))
5264 : : {
5265 : 6 : }
5266 : :
5267 : 18 : std::vector<Term> Plugin::check() { return {}; }
5268 : 7 : void Plugin::notifySatClause(CVC5_UNUSED const Term& clause) {}
5269 : 14 : void Plugin::notifyTheoryLemma(CVC5_UNUSED const Term& lemma) {}
5270 : :
5271 : : /* -------------------------------------------------------------------------- */
5272 : : /* TermManager */
5273 : : /* -------------------------------------------------------------------------- */
5274 : :
5275 : 30201 : TermManager::TermManager() : d_nm(std::make_unique<internal::NodeManager>())
5276 : : {
5277 : : if constexpr (internal::configuration::isStatisticsBuild())
5278 : : {
5279 : 30201 : d_statsReg.reset(new internal::StatisticsRegistry());
5280 : 30201 : resetStatistics();
5281 : : }
5282 : 30201 : }
5283 : :
5284 : 80469 : TermManager::~TermManager() {}
5285 : :
5286 : 2 : Statistics TermManager::getStatistics() const
5287 : : {
5288 : 2 : return Statistics(*d_statsReg);
5289 : : }
5290 : :
5291 : 2 : void TermManager::printStatisticsSafe(int fd) const
5292 : : {
5293 : 2 : d_statsReg->printSafe(fd);
5294 : 2 : }
5295 : :
5296 : : /* Helpers and private functions */
5297 : : /* -------------------------------------------------------------------------- */
5298 : :
5299 : 6706909 : void TermManager::increment_term_stats(Kind kind) const
5300 : : {
5301 : : if constexpr (internal::configuration::isStatisticsBuild())
5302 : : {
5303 : 6706909 : d_stats->d_terms << kind;
5304 : : }
5305 : 6706909 : }
5306 : :
5307 : 461498 : void TermManager::increment_vars_consts_stats(const internal::TypeNode& type,
5308 : : bool is_var) const
5309 : : {
5310 : : if constexpr (internal::configuration::isStatisticsBuild())
5311 : : {
5312 : 461498 : internal::TypeConstant tc = type.getKind() == internal::Kind::TYPE_CONSTANT
5313 [ + + ]: 461498 : ? type.getConst<internal::TypeConstant>()
5314 : 461498 : : internal::LAST_TYPE;
5315 [ + + ]: 461498 : if (is_var)
5316 : : {
5317 : 107097 : d_stats->d_vars << tc;
5318 : : }
5319 : : else
5320 : : {
5321 : 354401 : d_stats->d_consts << tc;
5322 : : }
5323 : : }
5324 : 461498 : }
5325 : :
5326 : 30201 : void TermManager::resetStatistics()
5327 : : {
5328 : 120804 : d_stats.reset(new APIStatistics{
5329 : 30201 : d_statsReg->registerHistogram<internal::TypeConstant>("cvc5::CONSTANT"),
5330 : 60402 : d_statsReg->registerHistogram<internal::TypeConstant>("cvc5::VARIABLE"),
5331 : 60402 : d_statsReg->registerHistogram<Kind>("cvc5::TERM"),
5332 : 30201 : });
5333 : 30201 : }
5334 : :
5335 : 2 : TermManager* TermManager::currentTM()
5336 : : {
5337 [ + - ]: 2 : thread_local static TermManager tm;
5338 : 2 : return &tm;
5339 : : }
5340 : :
5341 : 6457061 : void TermManager::checkMkTerm(Kind kind, uint32_t nchildren) const
5342 : : {
5343 : 6457061 : CVC5_API_KIND_CHECK(kind);
5344 [ - + ][ - + ]: 6457061 : Assert(isDefinedIntKind(extToIntKind(kind)));
[ - - ]
5345 : : const internal::kind::MetaKind mk =
5346 : 6457061 : internal::kind::metaKindOf(extToIntKind(kind));
5347 : 6457061 : CVC5_API_KIND_CHECK_EXPECTED(mk == internal::kind::metakind::PARAMETERIZED
5348 : : || mk == internal::kind::metakind::OPERATOR,
5349 : : kind)
5350 : : << "Only operator-style terms are created with mkTerm(), "
5351 : : "to create variables, constants and values see mkVar(), mkConst() "
5352 : : "and the respective theory-specific functions to create values, "
5353 : 0 : "e.g., mkBitVector().";
5354 : 12914144 : CVC5_API_KIND_CHECK_EXPECTED(
5355 : : nchildren >= minArity(kind) && nchildren <= maxArity(kind), kind)
5356 [ + + ][ + + ]: 6457083 : << "Terms with kind " << std::to_string(kind) << " must have at least "
[ - - ]
5357 : 22 : << minArity(kind) << " children and at most " << maxArity(kind)
5358 : 22 : << " children (the one under construction has " << nchildren << ")";
5359 : 6457039 : }
5360 : :
5361 : 763800 : bool TermManager::isValidInteger(const std::string& s) const
5362 : : {
5363 : : //////// all checks before this line
5364 [ + + ]: 763800 : if (s.length() == 0)
5365 : : {
5366 : : // string should not be empty
5367 : 4 : return false;
5368 : : }
5369 : :
5370 : 763796 : size_t index = 0;
5371 [ + + ]: 763796 : if (s[index] == '-')
5372 : : {
5373 [ + + ]: 77 : if (s.length() == 1)
5374 : : {
5375 : : // negative integers should contain at least one digit
5376 : 2 : return false;
5377 : : }
5378 : 75 : index = 1;
5379 : : }
5380 : :
5381 [ + + ][ + + ]: 763794 : if (s[index] == '0' && s.length() > (index + 1))
[ + + ]
5382 : : {
5383 : : // From SMT-Lib 2.6: A <numeral> is the digit 0 or a non-empty sequence of
5384 : : // digits not starting with 0. So integers like 001, 000 are not allowed
5385 : 13 : return false;
5386 : : }
5387 : :
5388 : : // all remaining characters should be decimal digits
5389 [ + + ]: 1662266 : for (; index < s.length(); ++index)
5390 : : {
5391 [ + + ]: 898509 : if (!std::isdigit(s[index]))
5392 : : {
5393 : 24 : return false;
5394 : : }
5395 : : }
5396 : :
5397 : 763757 : return true;
5398 : : }
5399 : :
5400 : : // This helpers are split out to avoid nested API calls (problematic with API
5401 : : // tracing).
5402 : :
5403 : 107065 : internal::Node TermManager::mkVarHelper(
5404 : : const internal::TypeNode& type, const std::optional<std::string>& symbol)
5405 : : {
5406 : 107019 : internal::Node res = symbol ? internal::NodeManager::mkBoundVar(*symbol, type)
5407 [ + + ]: 214084 : : internal::NodeManager::mkBoundVar(type);
5408 : 107065 : (void)res.getType(true); /* kick off type checking */
5409 : 107065 : increment_vars_consts_stats(type, true);
5410 : 107065 : return res;
5411 : 0 : }
5412 : :
5413 : 354401 : internal::Node TermManager::mkConstHelper(
5414 : : const internal::TypeNode& type,
5415 : : const std::optional<std::string>& symbol,
5416 : : bool fresh)
5417 : : {
5418 [ + + ][ + - ]: 354401 : Assert(fresh || symbol);
[ - + ][ - + ]
[ - - ]
5419 : : internal::Node res =
5420 [ + + ][ + + ]: 354401 : symbol ? d_nm->mkVar(*symbol, type, fresh) : d_nm->mkVar(type);
[ - - ]
5421 : 354401 : (void)res.getType(true); /* kick off type checking */
5422 : 354401 : increment_vars_consts_stats(type, false);
5423 : 354401 : return res;
5424 : 0 : }
5425 : :
5426 : : template <typename T>
5427 : 197534 : Op TermManager::mkOpHelper(Kind kind, const T& t)
5428 : : {
5429 : : //////// all checks before this line
5430 : 197534 : internal::Node res = d_nm->mkConst(s_op_kinds.at(kind), t);
5431 : 197534 : static_cast<void>(res.getType(true)); /* kick off type checking */
5432 : 395066 : return Op(d_nm, kind, res);
5433 : 197534 : }
5434 : :
5435 : : template <typename T>
5436 : 578314 : Term TermManager::mkValHelper(NodeManagerSharedPtr nm, const T& t)
5437 : : {
5438 : : //////// all checks before this line
5439 : 578314 : internal::Node res = nm->mkConst(t);
5440 : 578314 : (void)res.getType(true); /* kick off type checking */
5441 : 1156628 : return Term(nm, res);
5442 : 578314 : }
5443 : :
5444 : 907697 : Term TermManager::mkRationalValHelper(NodeManagerSharedPtr nm,
5445 : : const internal::Rational& r,
5446 : : bool isInt)
5447 : : {
5448 : : //////// all checks before this line
5449 [ + + ]: 907697 : internal::Node res = isInt ? nm->mkConstInt(r) : nm->mkConstReal(r);
5450 : 907697 : (void)res.getType(true); /* kick off type checking */
5451 : 1815394 : return Term(nm, res);
5452 : 907697 : }
5453 : :
5454 : 907305 : Term TermManager::mkRealOrIntegerFromStrHelper(const std::string& s, bool isInt)
5455 : : {
5456 : : //////// all checks before this line
5457 : : try
5458 : : {
5459 : 907305 : internal::Rational r;
5460 : 907305 : size_t spos = s.find('/');
5461 [ + + ]: 907305 : if (spos != std::string::npos)
5462 : : {
5463 : : // Ensure the denominator contains a non-zero digit. We catch this here to
5464 : : // avoid a floating point exception in GMP. This exception will be caught
5465 : : // and given the standard error message below.
5466 [ + + ]: 43 : if (s.find_first_not_of('0', spos + 1) == std::string::npos)
5467 : : {
5468 : 7 : throw std::invalid_argument("Zero denominator encountered");
5469 : : }
5470 : 36 : r = internal::Rational(s);
5471 : : }
5472 : : else
5473 : : {
5474 : 907262 : r = internal::Rational::fromDecimal(s);
5475 : : }
5476 : 1814576 : return TermManager::mkRationalValHelper(d_nm, r, isInt);
5477 : 907305 : }
5478 [ - + ]: 17 : catch (const std::invalid_argument& e)
5479 : : {
5480 : : /* Catch to throw with a more meaningful error message. To be caught in
5481 : : * enclosing CVC5_API_TRY_CATCH_* block to throw CVC5ApiException. */
5482 : 17 : std::stringstream message;
5483 : : message << "cannot construct Real or Int from string argument '" << s
5484 : 17 : << "'";
5485 : 17 : throw std::invalid_argument(message.str());
5486 : 34 : }
5487 : : }
5488 : :
5489 : 155 : Term TermManager::mkBVFromIntHelper(uint32_t size, uint64_t val)
5490 : : {
5491 [ + + ][ + + ]: 155 : CVC5_API_ARG_CHECK_EXPECTED(size > 0, size) << "a bit-width > 0";
[ - - ]
5492 : : //////// all checks before this line
5493 : 153 : return mkValHelper(d_nm, internal::BitVector(size, val));
5494 [ - + ]: 2 : }
5495 : :
5496 : 403940 : Term TermManager::mkBVFromStrHelper(uint32_t size,
5497 : : const std::string& s,
5498 : : uint32_t base)
5499 : : {
5500 [ + + ][ + + ]: 403940 : CVC5_API_ARG_CHECK_EXPECTED(size > 0, size) << "a bit-width > 0";
[ - - ]
5501 [ + + ][ + + ]: 403936 : CVC5_API_ARG_CHECK_EXPECTED(!s.empty(), s) << "a non-empty string";
[ - - ]
5502 [ + + ][ + + ]: 403940 : CVC5_API_ARG_CHECK_EXPECTED(base == 2 || base == 10 || base == 16, base)
[ + + ][ + + ]
[ + + ][ + + ]
[ - - ]
5503 : 6 : << "base 2, 10, or 16";
5504 : : //////// all checks before this line
5505 : :
5506 : 403928 : internal::Integer val(s, base);
5507 : :
5508 [ + + ]: 403920 : if (val.strictlyNegative())
5509 : : {
5510 [ + + ][ + + ]: 44 : CVC5_API_CHECK(val >= -internal::Integer(2).pow(size - 1))
[ - - ]
5511 : 6 : << "overflow in bit-vector construction (specified bit-vector size "
5512 : 6 : << size << " too small to hold value " << s << ")";
5513 : : }
5514 : : else
5515 : : {
5516 [ + + ][ + + ]: 403912 : CVC5_API_CHECK(val.modByPow2(size) == val)
[ - - ]
5517 : 6 : << "overflow in bit-vector construction (specified bit-vector size "
5518 : 6 : << size << " too small to hold value " << s << ")";
5519 : : }
5520 : 807816 : return mkValHelper(d_nm, internal::BitVector(size, val));
5521 [ - + ]: 403952 : }
5522 : :
5523 : 43264 : Sort TermManager::mkTupleSortHelper(const std::vector<Sort>& sorts)
5524 : : {
5525 : : // Note: Sorts are checked in the caller to avoid double checks
5526 : : //////// all checks before this line
5527 : : std::vector<internal::TypeNode> typeNodes =
5528 : 43264 : Sort::sortVectorToTypeNodes(sorts);
5529 : 86528 : return Sort(d_nm, d_nm->mkTupleType(typeNodes));
5530 : 43264 : }
5531 : :
5532 : 36 : Term TermManager::mkTermFromKind(Kind kind)
5533 : : {
5534 : 40 : CVC5_API_KIND_CHECK_EXPECTED(
5535 : : kind == Kind::PI || kind == Kind::REGEXP_NONE || kind == Kind::REGEXP_ALL
5536 : : || kind == Kind::REGEXP_ALLCHAR || kind == Kind::SEP_EMP,
5537 : : kind)
5538 : 4 : << "PI, REGEXP_NONE, REGEXP_ALL, REGEXP_ALLCHAR or SEP_EMP";
5539 : : //////// all checks before this line
5540 : 32 : internal::Node res;
5541 : 32 : internal::Kind k = extToIntKind(kind);
5542 [ + + ][ + - ]: 32 : if (kind == Kind::REGEXP_NONE || kind == Kind::REGEXP_ALL
5543 [ + + ]: 26 : || kind == Kind::REGEXP_ALLCHAR)
5544 : : {
5545 [ - + ][ - + ]: 15 : Assert(isDefinedIntKind(k));
[ - - ]
5546 : 15 : res = d_nm->mkNode(k, std::vector<internal::Node>());
5547 : : }
5548 [ + + ]: 17 : else if (kind == Kind::SEP_EMP)
5549 : : {
5550 : 6 : res = d_nm->mkNullaryOperator(d_nm->booleanType(), k);
5551 : : }
5552 : : else
5553 : : {
5554 [ - + ][ - + ]: 11 : Assert(kind == Kind::PI);
[ - - ]
5555 : 11 : res = d_nm->mkNullaryOperator(d_nm->realType(), k);
5556 : : }
5557 : 32 : (void)res.getType(true); /* kick off type checking */
5558 : 64 : return Term(d_nm, res);
5559 [ - + ]: 36 : }
5560 : :
5561 : 6509485 : Term TermManager::mkTermHelper(Kind kind, const std::vector<Term>& children)
5562 : : {
5563 : : // Note: Kind and children are checked in the caller to avoid double checks
5564 : : //////// all checks before this line
5565 [ + + ]: 6509485 : if (children.size() == 0)
5566 : : {
5567 : 36 : return mkTermFromKind(kind);
5568 : : }
5569 : 6509449 : std::vector<internal::Node> echildren = Term::termVectorToNodes(children);
5570 : 6509449 : internal::Kind k = extToIntKind(kind);
5571 : 6509449 : internal::Node res;
5572 [ + + ]: 6509449 : if (echildren.size() > 2)
5573 : : {
5574 [ + + ][ + + ]: 1325345 : if (kind == Kind::INTS_DIVISION || kind == Kind::XOR || kind == Kind::SUB
[ + + ]
5575 [ + + ][ + + ]: 1323582 : || kind == Kind::DIVISION || kind == Kind::HO_APPLY
5576 [ + + ][ + + ]: 1322853 : || kind == Kind::REGEXP_DIFF || kind == Kind::SET_UNION
5577 [ + + ][ + + ]: 1322806 : || kind == Kind::SET_INTER || kind == Kind::SET_MINUS
5578 [ + - ][ + + ]: 1322800 : || kind == Kind::BAG_INTER_MIN || kind == Kind::BAG_UNION_MAX
5579 [ + + ]: 1322797 : || kind == Kind::BAG_UNION_DISJOINT
5580 [ + - ]: 1322752 : || kind == Kind::BAG_DIFFERENCE_REMOVE
5581 [ + + ]: 1322752 : || kind == Kind::BAG_DIFFERENCE_SUBTRACT)
5582 : : {
5583 : : // left-associative, but cvc5 internally only supports 2 args
5584 : 2596 : res = d_nm->mkLeftAssociative(k, echildren);
5585 : : }
5586 [ + + ]: 1322749 : else if (kind == Kind::IMPLIES)
5587 : : {
5588 : : // right-associative, but cvc5 internally only supports 2 args
5589 : 65 : res = d_nm->mkRightAssociative(k, echildren);
5590 : : }
5591 [ + + ][ + + ]: 1322684 : else if (kind == Kind::EQUAL || kind == Kind::LT || kind == Kind::GT
[ + + ]
5592 [ + + ][ + + ]: 1321574 : || kind == Kind::LEQ || kind == Kind::GEQ)
5593 : : {
5594 : : // "chainable", but cvc5 internally only supports 2 args
5595 : 1364 : res = d_nm->mkChain(k, echildren);
5596 : : }
5597 [ + + ]: 1321320 : else if (internal::kind::isAssociative(k))
5598 : : {
5599 : : // mkAssociative has special treatment for associative operators with lots
5600 : : // of children
5601 : 245849 : res = d_nm->mkAssociative(k, echildren);
5602 : : }
5603 : : else
5604 : : {
5605 : : // default case, must check kind
5606 : 1075471 : checkMkTerm(kind, children.size());
5607 : 1075471 : res = d_nm->mkNode(k, echildren);
5608 : : }
5609 : : }
5610 [ + + ]: 5184104 : else if (internal::kind::isAssociative(k))
5611 : : {
5612 : : // associative case, same as above
5613 : 1581843 : checkMkTerm(kind, children.size());
5614 : 1581840 : res = d_nm->mkAssociative(k, echildren);
5615 : : }
5616 : : else
5617 : : {
5618 : : // default case, same as above
5619 : 3602261 : checkMkTerm(kind, children.size());
5620 : : // make the term
5621 : 3602253 : res = d_nm->mkNode(k, echildren);
5622 : : }
5623 : :
5624 : 6509435 : (void)res.getType(true); /* kick off type checking */
5625 : 6509411 : return Term(d_nm, res);
5626 : 6509487 : }
5627 : :
5628 : 197629 : Term TermManager::mkTermHelper(const Op& op, const std::vector<Term>& children)
5629 : : {
5630 [ + + ]: 197629 : if (!op.isIndexedHelper())
5631 : : {
5632 : 143 : return mkTermHelper(op.d_kind, children);
5633 : : }
5634 : :
5635 : : // Note: Op and children are checked in the caller to avoid double checks
5636 : 197486 : checkMkTerm(op.d_kind, children.size());
5637 : : //////// all checks before this line
5638 : :
5639 : 197475 : const internal::Kind int_kind = extToIntKind(op.d_kind);
5640 : 197475 : std::vector<internal::Node> echildren = Term::termVectorToNodes(children);
5641 : :
5642 : 197475 : internal::NodeBuilder nb(d_nm.get(), int_kind);
5643 : 197475 : nb << *op.d_node;
5644 : 197475 : nb.append(echildren);
5645 : 197475 : internal::Node res = nb.constructNode();
5646 : :
5647 : 197475 : (void)res.getType(true); /* kick off type checking */
5648 : 197466 : return Term(d_nm, res);
5649 : 197493 : }
5650 : :
5651 : : /* Sorts -------------------------------------------------------------------- */
5652 : :
5653 : 252500 : Sort TermManager::getBooleanSort(void)
5654 : : {
5655 : : CVC5_API_TRY_CATCH_BEGIN;
5656 : : //////// all checks before this line
5657 : 252500 : return Sort(d_nm, d_nm->booleanType());
5658 : : ////////
5659 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5660 : : }
5661 : :
5662 : 795468 : Sort TermManager::getIntegerSort(void)
5663 : : {
5664 : : CVC5_API_TRY_CATCH_BEGIN;
5665 : : //////// all checks before this line
5666 : 795468 : return Sort(d_nm, d_nm->integerType());
5667 : : ////////
5668 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5669 : : }
5670 : :
5671 : 14607 : Sort TermManager::getRealSort(void)
5672 : : {
5673 : : CVC5_API_TRY_CATCH_BEGIN;
5674 : : //////// all checks before this line
5675 : 14607 : return Sort(d_nm, d_nm->realType());
5676 : : ////////
5677 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5678 : : }
5679 : :
5680 : 13274 : Sort TermManager::getRegExpSort(void)
5681 : : {
5682 : : CVC5_API_TRY_CATCH_BEGIN;
5683 : : //////// all checks before this line
5684 : 13274 : return Sort(d_nm, d_nm->regExpType());
5685 : : ////////
5686 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5687 : : }
5688 : :
5689 : 13935 : Sort TermManager::getStringSort(void)
5690 : : {
5691 : : CVC5_API_TRY_CATCH_BEGIN;
5692 : : //////// all checks before this line
5693 : 13935 : return Sort(d_nm, d_nm->stringType());
5694 : : ////////
5695 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5696 : : }
5697 : :
5698 : 11785 : Sort TermManager::getRoundingModeSort(void)
5699 : : {
5700 : : CVC5_API_TRY_CATCH_BEGIN;
5701 : : //////// all checks before this line
5702 : 11785 : return Sort(d_nm, d_nm->roundingModeType());
5703 : : ////////
5704 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5705 : : }
5706 : :
5707 : 6848 : Sort TermManager::mkArraySort(const Sort& indexSort, const Sort& elemSort)
5708 : : {
5709 : : CVC5_API_TRY_CATCH_BEGIN;
5710 : 6848 : CVC5_API_TM_CHECK_SORT(indexSort);
5711 : 6846 : CVC5_API_TM_CHECK_SORT(elemSort);
5712 : : //////// all checks before this line
5713 : 6846 : return Sort(d_nm, d_nm->mkArrayType(*indexSort.d_type, *elemSort.d_type));
5714 : : ////////
5715 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5716 [ - + ]: 2 : }
5717 : :
5718 : 33735 : Sort TermManager::mkBitVectorSort(uint32_t size)
5719 : : {
5720 : : CVC5_API_TRY_CATCH_BEGIN;
5721 [ + + ][ + + ]: 33735 : CVC5_API_ARG_CHECK_EXPECTED(size > 0, size) << "size > 0";
[ - - ]
5722 : : //////// all checks before this line
5723 : 33733 : return Sort(d_nm, d_nm->mkBitVectorType(size));
5724 : : ////////
5725 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5726 [ - + ]: 2 : }
5727 : :
5728 : 3215 : Sort TermManager::mkFiniteFieldSort(const std::string& modulus, uint32_t base)
5729 : : {
5730 : : CVC5_API_TRY_CATCH_BEGIN;
5731 : : //////// all checks before this line
5732 : 3215 : internal::Integer m(modulus, base);
5733 [ + + ][ + + ]: 3227 : CVC5_API_ARG_CHECK_EXPECTED(m.isProbablePrime(), modulus)
[ - - ]
5734 : 14 : << "modulus is prime";
5735 : 6398 : return Sort(d_nm, d_nm->mkFiniteFieldType(m));
5736 : : ////////
5737 [ + - ][ - - ]: 3229 : CVC5_API_TRY_CATCH_END;
[ + - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - ]
5738 [ - + ]: 16 : }
5739 : :
5740 : 47660 : Sort TermManager::mkFloatingPointSort(uint32_t exp, uint32_t sig)
5741 : : {
5742 : : CVC5_API_TRY_CATCH_BEGIN;
5743 [ + + ][ + + ]: 47660 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
5744 [ + + ][ + + ]: 47656 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
5745 : : //////// all checks before this line
5746 : 47652 : return Sort(d_nm, d_nm->mkFloatingPointType(exp, sig));
5747 : : ////////
5748 [ + - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5749 [ - + ]: 8 : }
5750 : :
5751 : 88 : Sort TermManager::mkDatatypeSort(const DatatypeDecl& dtypedecl)
5752 : : {
5753 : : CVC5_API_TRY_CATCH_BEGIN;
5754 : 88 : CVC5_API_TM_CHECK_DTDECL(dtypedecl);
5755 : : //////// all checks before this line
5756 : 162 : Sort res = Sort(d_nm, d_nm->mkDatatypeType(*dtypedecl.d_dtype));
5757 : 81 : const Datatype& dt = res.getDatatype();
5758 [ + + ][ + + ]: 83 : CVC5_API_CHECK(dt.d_dtype->isCodatatype() || dt.d_dtype->isWellFounded())
[ + + ][ - - ]
5759 : 82 : << "Datatype sort " << dt.d_dtype->getName() + " is not well-founded";
5760 : 160 : return res;
5761 : : ////////
5762 [ + - ][ - - ]: 90 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5763 [ - + ]: 8 : }
5764 : :
5765 : 3972 : std::vector<Sort> TermManager::mkDatatypeSorts(
5766 : : const std::vector<DatatypeDecl>& dtypedecls)
5767 : : {
5768 : 9352 : CVC5_API_TM_CHECK_DTDECLS(dtypedecls);
5769 : : CVC5_API_TRY_CATCH_BEGIN;
5770 : : //////// all checks before this line
5771 : 3960 : std::vector<internal::DType> datatypes;
5772 [ + + ]: 9340 : for (size_t i = 0, ndts = dtypedecls.size(); i < ndts; ++i)
5773 : : {
5774 : 5380 : datatypes.push_back(dtypedecls[i].getDatatype());
5775 : : }
5776 : : std::vector<internal::TypeNode> dtypes =
5777 : 3960 : d_nm->mkMutualDatatypeTypes(datatypes);
5778 : 3960 : std::vector<Sort> res = Sort::typeNodeVectorToSorts(d_nm, dtypes);
5779 [ + + ]: 9337 : for (size_t i = 0, ndts = datatypes.size(); i < ndts; ++i)
5780 : : {
5781 : 5380 : const Datatype& dt = res[i].getDatatype();
5782 [ + + ][ + + ]: 5386 : CVC5_API_CHECK(dt.d_dtype->isCodatatype() || dt.d_dtype->isWellFounded())
[ + + ][ - - ]
5783 : 5383 : << "Datatype sort " << dt.d_dtype->getName() + " is not well-founded";
5784 : 5380 : }
5785 : 7914 : return res;
5786 : : ////////
5787 [ + - ][ - - ]: 3969 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5788 [ - + ]: 15 : }
5789 : :
5790 : 21609 : Sort TermManager::mkFunctionSort(const std::vector<Sort>& sorts,
5791 : : const Sort& codomain)
5792 : : {
5793 : : CVC5_API_TRY_CATCH_BEGIN;
5794 [ - + ][ - + ]: 21609 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(sorts.size() >= 1, sorts)
[ - - ]
5795 : 0 : << "at least one parameter sort for function sort";
5796 : 46596 : CVC5_API_TM_CHECK_DOMAIN_SORTS(sorts);
5797 : 21606 : CVC5_API_TM_CHECK_CODOMAIN_SORT(codomain);
5798 : : //////// all checks before this line
5799 : 21600 : std::vector<internal::TypeNode> argTypes = Sort::sortVectorToTypeNodes(sorts);
5800 : 43200 : return Sort(d_nm, d_nm->mkFunctionType(argTypes, *codomain.d_type));
5801 : : ////////
5802 [ + - ][ - - ]: 21609 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5803 [ - + ]: 9 : }
5804 : :
5805 : 35 : Term TermManager::mkSkolem(SkolemId id, const std::vector<Term>& indices)
5806 : : {
5807 : : CVC5_API_TRY_CATCH_BEGIN;
5808 : 35 : cvc5::internal::SkolemManager* sm = d_nm->getSkolemManager();
5809 [ + + ][ + + ]: 37 : CVC5_API_CHECK(indices.size() == sm->getNumIndicesForSkolemId(id))
[ - - ]
5810 : 2 : << "invalid number of indices, expected "
5811 : 2 : << sm->getNumIndicesForSkolemId(id) << " got " << indices.size();
5812 : : //////// all checks before this line
5813 : : // iterate over indices and convert the Terms to Nodes
5814 : 33 : std::vector<internal::Node> nodeIndices = Term::termVectorToNodes(indices);
5815 : : // automatically sort if a commutative skolem
5816 [ + + ]: 33 : if (internal::SkolemManager::isCommutativeSkolemId(id))
5817 : : {
5818 : 18 : std::sort(nodeIndices.begin(), nodeIndices.end());
5819 : : }
5820 : : internal::Node res =
5821 : 33 : d_nm->getSkolemManager()->mkSkolemFunction(id, nodeIndices);
5822 : 66 : return Term(d_nm, res);
5823 : : ////////
5824 [ + - ][ - - ]: 35 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5825 [ - + ]: 2 : }
5826 : :
5827 : 41 : size_t TermManager::getNumIndicesForSkolemId(SkolemId id)
5828 : : {
5829 : : CVC5_API_TRY_CATCH_BEGIN;
5830 : : //////// all checks before this line
5831 : 41 : return d_nm->getSkolemManager()->getNumIndicesForSkolemId(id);
5832 : : ////////
5833 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5834 : : }
5835 : :
5836 : 64 : Sort TermManager::mkParamSort(const std::optional<std::string>& symbol)
5837 : : {
5838 : : CVC5_API_TRY_CATCH_BEGIN;
5839 : : //////// all checks before this line
5840 [ + - ]: 64 : internal::TypeNode tn = symbol ? d_nm->mkSort(*symbol) : d_nm->mkSort();
5841 : 128 : return Sort(d_nm, tn);
5842 : : ////////
5843 [ - - ][ - - ]: 64 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5844 : : }
5845 : :
5846 : 13 : Sort TermManager::mkPredicateSort(const std::vector<Sort>& sorts)
5847 : : {
5848 : : CVC5_API_TRY_CATCH_BEGIN;
5849 [ + + ][ + + ]: 15 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(sorts.size() >= 1, sorts)
[ - - ]
5850 : 2 : << "at least one parameter sort for predicate sort";
5851 : 22 : CVC5_API_TM_CHECK_DOMAIN_SORTS(sorts);
5852 : : //////// all checks before this line
5853 : 9 : return Sort(d_nm, d_nm->mkPredicateType(Sort::sortVectorToTypeNodes(sorts)));
5854 : : ////////
5855 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5856 [ - + ]: 4 : }
5857 : :
5858 : 15 : Sort TermManager::mkRecordSort(
5859 : : const std::vector<std::pair<std::string, Sort>>& fields)
5860 : : {
5861 : : CVC5_API_TRY_CATCH_BEGIN;
5862 : 15 : std::vector<std::pair<std::string, internal::TypeNode>> f;
5863 [ + + ]: 43 : for (size_t i = 0, size = fields.size(); i < size; ++i)
5864 : : {
5865 : 30 : const auto& p = fields[i];
5866 : 30 : CVC5_API_TM_CHECK_SORT_AT_INDEX(p.second, fields, i);
5867 : 28 : f.emplace_back(p.first, *p.second.d_type);
5868 : : }
5869 : : //////// all checks before this line
5870 : 26 : return Sort(d_nm, d_nm->mkRecordType(f));
5871 : : ////////
5872 [ + - ][ - - ]: 17 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5873 [ - + ]: 2 : }
5874 : :
5875 : 42517 : Sort TermManager::mkSetSort(const Sort& elemSort)
5876 : : {
5877 : : CVC5_API_TRY_CATCH_BEGIN;
5878 : 42517 : CVC5_API_TM_CHECK_SORT(elemSort);
5879 : : //////// all checks before this line
5880 : 42515 : return Sort(d_nm, d_nm->mkSetType(*elemSort.d_type));
5881 : : ////////
5882 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5883 [ - + ]: 2 : }
5884 : :
5885 : 37426 : Sort TermManager::mkBagSort(const Sort& elemSort)
5886 : : {
5887 : : CVC5_API_TRY_CATCH_BEGIN;
5888 : 37426 : CVC5_API_TM_CHECK_SORT(elemSort);
5889 : : //////// all checks before this line
5890 : 37424 : return Sort(d_nm, d_nm->mkBagType(*elemSort.d_type));
5891 : : ////////
5892 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5893 [ - + ]: 2 : }
5894 : :
5895 : 1382 : Sort TermManager::mkSequenceSort(const Sort& elemSort)
5896 : : {
5897 : : CVC5_API_TRY_CATCH_BEGIN;
5898 : 1382 : CVC5_API_TM_CHECK_SORT(elemSort);
5899 : : //////// all checks before this line
5900 : 1380 : return Sort(d_nm, d_nm->mkSequenceType(*elemSort.d_type));
5901 : : ////////
5902 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5903 [ - + ]: 2 : }
5904 : :
5905 : 27 : Sort TermManager::mkAbstractSort(SortKind k)
5906 : : {
5907 : : CVC5_API_TRY_CATCH_BEGIN;
5908 : 27 : internal::Kind ik = extToIntSortKind(k);
5909 [ + + ][ + + ]: 30 : CVC5_API_CHECK(d_nm->isSortKindAbstractable(ik))
[ - - ]
5910 : 3 : << "cannot construct abstract type for kind " << k;
5911 : : //////// all checks before this line
5912 : 24 : return Sort(d_nm, d_nm->mkAbstractType(ik));
5913 : : ////////
5914 [ + - ][ - - ]: 3 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5915 [ - + ]: 3 : }
5916 : :
5917 : 1081 : Sort TermManager::mkUninterpretedSort(const std::optional<std::string>& symbol)
5918 : : {
5919 : : CVC5_API_TRY_CATCH_BEGIN;
5920 : : //////// all checks before this line
5921 [ + + ]: 1081 : internal::TypeNode tn = symbol ? d_nm->mkSort(*symbol) : d_nm->mkSort();
5922 : 2162 : return Sort(d_nm, tn);
5923 : : ////////
5924 [ - - ][ - - ]: 1081 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5925 : : }
5926 : :
5927 : 5363 : Sort TermManager::mkUnresolvedDatatypeSort(const std::string& symbol,
5928 : : size_t arity)
5929 : : {
5930 : : CVC5_API_TRY_CATCH_BEGIN;
5931 : : //////// all checks before this line
5932 : 5363 : return Sort(d_nm, d_nm->mkUnresolvedDatatypeSort(symbol, arity));
5933 : : ////////
5934 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5935 : : }
5936 : :
5937 : 32 : Sort TermManager::mkUninterpretedSortConstructorSort(
5938 : : size_t arity, const std::optional<std::string>& symbol)
5939 : : {
5940 : : CVC5_API_TRY_CATCH_BEGIN;
5941 [ + + ][ + + ]: 32 : CVC5_API_ARG_CHECK_EXPECTED(arity > 0, arity) << "an arity > 0";
[ - - ]
5942 : : //////// all checks before this line
5943 [ + + ]: 30 : if (symbol)
5944 : : {
5945 : 25 : return Sort(d_nm, d_nm->mkSortConstructor(*symbol, arity));
5946 : : }
5947 : 5 : return Sort(d_nm, d_nm->mkSortConstructor("", arity));
5948 : : ////////
5949 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5950 [ - + ]: 2 : }
5951 : :
5952 : 43266 : Sort TermManager::mkTupleSort(const std::vector<Sort>& sorts)
5953 : : {
5954 : : CVC5_API_TRY_CATCH_BEGIN;
5955 : 58856 : CVC5_API_TM_CHECK_DOMAIN_SORTS(sorts);
5956 : : //////// all checks before this line
5957 : 43264 : return mkTupleSortHelper(sorts);
5958 : : ////////
5959 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5960 [ - + ]: 2 : }
5961 : :
5962 : 12683 : Sort TermManager::mkNullableSort(const Sort& sort)
5963 : : {
5964 : : CVC5_API_TRY_CATCH_BEGIN;
5965 : 12683 : CVC5_API_TM_CHECK_DOMAIN_SORT(sort);
5966 : : //////// all checks before this line
5967 : 12681 : return Sort(d_nm, d_nm->mkNullableType(sort.getTypeNode()));
5968 : : ////////
5969 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
5970 [ - + ]: 2 : }
5971 : :
5972 : : /* Terms -------------------------------------------------------------------- */
5973 : :
5974 : 6509355 : Term TermManager::mkTerm(Kind kind, const std::vector<Term>& children)
5975 : : {
5976 : : CVC5_API_TRY_CATCH_BEGIN;
5977 : 6509355 : CVC5_API_KIND_CHECK(kind);
5978 : 20606495 : CVC5_API_TM_CHECK_TERMS(children);
5979 : : //////// all checks before this line
5980 : 6509342 : Term res = mkTermHelper(kind, children);
5981 : 6509301 : increment_term_stats(kind);
5982 : 13018602 : return res;
5983 : : ////////
5984 [ + - ][ - + ]: 6509355 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
5985 [ - + ]: 54 : }
5986 : :
5987 : 197637 : Term TermManager::mkTerm(const Op& op, const std::vector<Term>& children)
5988 : : {
5989 : : CVC5_API_TRY_CATCH_BEGIN;
5990 : 197637 : CVC5_API_TM_CHECK_OP(op);
5991 : 395895 : CVC5_API_TM_CHECK_TERMS(children);
5992 : : //////// all checks before this line
5993 : 197629 : Term res = mkTermHelper(op, children);
5994 : 197608 : increment_term_stats(op.getKind());
5995 : 395216 : return res;
5996 : : ////////
5997 [ + - ][ - + ]: 197637 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
5998 [ - + ]: 29 : }
5999 : :
6000 : : /* Operators ---------------------------------------------------------------- */
6001 : :
6002 : 197688 : Op TermManager::mkOp(Kind kind, const std::vector<uint32_t>& args)
6003 : : {
6004 : : CVC5_API_TRY_CATCH_BEGIN;
6005 : 197688 : CVC5_API_KIND_CHECK(kind);
6006 : : //////// all checks before this line
6007 : 197688 : size_t nargs = args.size();
6008 : :
6009 : 197688 : Op res;
6010 [ + + ][ + + ]: 197688 : switch (kind)
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + ]
6011 : : {
6012 : 32148 : case Kind::BITVECTOR_EXTRACT:
6013 [ + + ][ + + ]: 32148 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6014 : 32144 : res = mkOpHelper(kind, internal::BitVectorExtract(args[0], args[1]));
6015 : 32144 : break;
6016 : 7652 : case Kind::BITVECTOR_REPEAT:
6017 [ - + ][ - + ]: 7652 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6018 : 7652 : res = mkOpHelper(kind, internal::BitVectorRepeat(args[0]));
6019 : 7652 : break;
6020 : 3617 : case Kind::BITVECTOR_ROTATE_LEFT:
6021 [ - + ][ - + ]: 3617 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6022 : 3617 : res = mkOpHelper(kind, internal::BitVectorRotateLeft(args[0]));
6023 : 3617 : break;
6024 : 4170 : case Kind::BITVECTOR_ROTATE_RIGHT:
6025 [ - + ][ - + ]: 4170 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6026 : 4170 : res = mkOpHelper(kind, internal::BitVectorRotateRight(args[0]));
6027 : 4170 : break;
6028 : 72681 : case Kind::BITVECTOR_SIGN_EXTEND:
6029 [ - + ][ - + ]: 72681 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6030 : 72681 : res = mkOpHelper(kind, internal::BitVectorSignExtend(args[0]));
6031 : 72681 : break;
6032 : 75600 : case Kind::BITVECTOR_ZERO_EXTEND:
6033 [ - + ][ - + ]: 75600 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6034 : 75600 : res = mkOpHelper(kind, internal::BitVectorZeroExtend(args[0]));
6035 : 75600 : break;
6036 : 2 : case Kind::BITVECTOR_BIT:
6037 [ - + ][ - + ]: 2 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6038 : 2 : res = mkOpHelper(kind, internal::BitVectorBit(args[0]));
6039 : 2 : break;
6040 : 66 : case Kind::DIVISIBLE:
6041 [ + + ][ + + ]: 66 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6042 [ + + ][ + + ]: 64 : CVC5_API_CHECK_OP_INDEX(args[0] != 0, args, 0) << "a value != 0";
[ - - ]
6043 : 63 : res = mkOpHelper(kind, internal::Divisible(args[0]));
6044 : 63 : break;
6045 : 20 : case Kind::FLOATINGPOINT_TO_SBV:
6046 [ - + ][ - + ]: 20 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6047 : 20 : res = mkOpHelper(kind, internal::FloatingPointToSBV(args[0]));
6048 : 20 : break;
6049 : 20 : case Kind::FLOATINGPOINT_TO_UBV:
6050 [ - + ][ - + ]: 20 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6051 : 20 : res = mkOpHelper(kind, internal::FloatingPointToUBV(args[0]));
6052 : 20 : break;
6053 : 111 : case Kind::FLOATINGPOINT_TO_FP_FROM_IEEE_BV:
6054 [ - + ][ - + ]: 111 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6055 [ + + ][ + + ]: 111 : CVC5_API_CHECK_OP_INDEX(args[0] > 1, args, 0) << "a value > 1";
[ - - ]
6056 [ - + ][ - + ]: 110 : CVC5_API_CHECK_OP_INDEX(args[1] > 1, args, 1) << "a value > 1";
[ - - ]
6057 : 220 : res = mkOpHelper(
6058 : 220 : kind, internal::FloatingPointToFPIEEEBitVector(args[0], args[1]));
6059 : 110 : break;
6060 : 32 : case Kind::FLOATINGPOINT_TO_FP_FROM_FP:
6061 [ - + ][ - + ]: 32 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6062 [ - + ][ - + ]: 32 : CVC5_API_CHECK_OP_INDEX(args[0] > 1, args, 0) << "a value > 1";
[ - - ]
6063 [ - + ][ - + ]: 32 : CVC5_API_CHECK_OP_INDEX(args[1] > 1, args, 1) << "a value > 1";
[ - - ]
6064 : 64 : res = mkOpHelper(
6065 : 64 : kind, internal::FloatingPointToFPFloatingPoint(args[0], args[1]));
6066 : 32 : break;
6067 : 111 : case Kind::FLOATINGPOINT_TO_FP_FROM_REAL:
6068 [ - + ][ - + ]: 111 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6069 [ - + ][ - + ]: 111 : CVC5_API_CHECK_OP_INDEX(args[0] > 1, args, 0) << "a value > 1";
[ - - ]
6070 [ - + ][ - + ]: 111 : CVC5_API_CHECK_OP_INDEX(args[1] > 1, args, 1) << "a value > 1";
[ - - ]
6071 : 111 : res = mkOpHelper(kind, internal::FloatingPointToFPReal(args[0], args[1]));
6072 : 111 : break;
6073 : 67 : case Kind::FLOATINGPOINT_TO_FP_FROM_SBV:
6074 [ - + ][ - + ]: 67 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6075 [ - + ][ - + ]: 67 : CVC5_API_CHECK_OP_INDEX(args[0] > 1, args, 0) << "a value > 1";
[ - - ]
6076 [ - + ][ - + ]: 67 : CVC5_API_CHECK_OP_INDEX(args[1] > 1, args, 1) << "a value > 1";
[ - - ]
6077 : 134 : res = mkOpHelper(
6078 : 134 : kind, internal::FloatingPointToFPSignedBitVector(args[0], args[1]));
6079 : 67 : break;
6080 : 40 : case Kind::FLOATINGPOINT_TO_FP_FROM_UBV:
6081 [ - + ][ - + ]: 40 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6082 [ - + ][ - + ]: 40 : CVC5_API_CHECK_OP_INDEX(args[0] > 1, args, 0) << "a value > 1";
[ - - ]
6083 [ - + ][ - + ]: 40 : CVC5_API_CHECK_OP_INDEX(args[1] > 1, args, 1) << "a value > 1";
[ - - ]
6084 : 80 : res = mkOpHelper(
6085 : 80 : kind, internal::FloatingPointToFPUnsignedBitVector(args[0], args[1]));
6086 : 40 : break;
6087 : 225 : case Kind::IAND:
6088 [ - + ][ - + ]: 225 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6089 : 225 : res = mkOpHelper(kind, internal::IntAnd(args[0]));
6090 : 225 : break;
6091 : 548 : case Kind::INT_TO_BITVECTOR:
6092 [ - + ][ - + ]: 548 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6093 : 548 : res = mkOpHelper(kind, internal::IntToBitVector(args[0]));
6094 : 547 : break;
6095 : 30 : case Kind::REGEXP_REPEAT:
6096 [ - + ][ - + ]: 30 : CVC5_API_OP_CHECK_ARITY(nargs, 1, kind);
[ - - ]
6097 : 30 : res = mkOpHelper(kind, internal::RegExpRepeat(args[0]));
6098 : 30 : break;
6099 : 149 : case Kind::REGEXP_LOOP:
6100 [ - + ][ - + ]: 149 : CVC5_API_OP_CHECK_ARITY(nargs, 2, kind);
[ - - ]
6101 : 149 : res = mkOpHelper(kind, internal::RegExpLoop(args[0], args[1]));
6102 : 149 : break;
6103 : 249 : case Kind::TUPLE_PROJECT:
6104 : : case Kind::RELATION_AGGREGATE:
6105 : : case Kind::RELATION_GROUP:
6106 : : case Kind::RELATION_PROJECT:
6107 : : case Kind::RELATION_TABLE_JOIN:
6108 : : case Kind::TABLE_AGGREGATE:
6109 : : case Kind::TABLE_GROUP:
6110 : : case Kind::TABLE_JOIN:
6111 : : case Kind::TABLE_PROJECT:
6112 : : {
6113 : 249 : res = mkOpHelper(kind, internal::ProjectOp(args));
6114 : 249 : break;
6115 : : }
6116 : 150 : default:
6117 [ + - ]: 150 : if (nargs == 0)
6118 : : {
6119 [ - + ][ - + ]: 150 : CVC5_API_CHECK(s_indexed_kinds.find(kind) == s_indexed_kinds.end())
[ - - ]
6120 : 0 : << "expected a kind for a non-indexed operator.";
6121 : 150 : return Op(d_nm, kind);
6122 : : }
6123 : : else
6124 : : {
6125 : 0 : CVC5_API_KIND_CHECK_EXPECTED(false, kind)
6126 : 0 : << "operator kind with " << nargs << " uint32_t arguments";
6127 : : }
6128 : : }
6129 [ - + ][ - + ]: 197529 : Assert(!res.isNull());
[ - - ]
6130 : 197529 : return res;
6131 : : ////////
6132 [ + - ][ - + ]: 197697 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
6133 [ - + ]: 9 : }
6134 : :
6135 : 140 : Op TermManager::mkOp(Kind kind, const std::initializer_list<uint32_t>& args)
6136 : : {
6137 : 280 : return mkOp(kind, std::vector<uint32_t>(args));
6138 : : }
6139 : :
6140 : 6 : Op TermManager::mkOp(Kind kind, const std::string& arg)
6141 : : {
6142 : : CVC5_API_TRY_CATCH_BEGIN;
6143 : 6 : CVC5_API_KIND_CHECK(kind);
6144 : 6 : CVC5_API_KIND_CHECK_EXPECTED((kind == Kind::DIVISIBLE), kind) << "DIVISIBLE";
6145 : : //////// all checks before this line
6146 : 4 : Op res;
6147 : : /* CLN and GMP handle this case differently, CLN interprets it as 0, GMP
6148 : : * throws an std::invalid_argument exception. For consistency, we treat it
6149 : : * as invalid. */
6150 [ - + ][ - + ]: 4 : CVC5_API_ARG_CHECK_EXPECTED(arg != ".", arg)
[ - - ]
6151 : 0 : << "a string representing an integer, real or rational value.";
6152 : 4 : res = mkOpHelper(kind, internal::Divisible(internal::Integer(arg)));
6153 : 8 : return res;
6154 : : ////////
6155 [ + - ][ - - ]: 6 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6156 [ - + ]: 2 : }
6157 : :
6158 : : /* Constants, Values and Special Terms -------------------------------------- */
6159 : :
6160 : 25108 : Term TermManager::mkTrue(void)
6161 : : {
6162 : : CVC5_API_TRY_CATCH_BEGIN;
6163 : : //////// all checks before this line
6164 : 25108 : return Term(d_nm, d_nm->mkConst<bool>(true));
6165 : : ////////
6166 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6167 : : }
6168 : :
6169 : 25026 : Term TermManager::mkFalse(void)
6170 : : {
6171 : : CVC5_API_TRY_CATCH_BEGIN;
6172 : : //////// all checks before this line
6173 : 25026 : return Term(d_nm, d_nm->mkConst<bool>(false));
6174 : : ////////
6175 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6176 : : }
6177 : :
6178 : 59 : Term TermManager::mkBoolean(bool val)
6179 : : {
6180 : : CVC5_API_TRY_CATCH_BEGIN;
6181 : : //////// all checks before this line
6182 : 59 : return Term(d_nm, d_nm->mkConst<bool>(val));
6183 : : ////////
6184 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6185 : : }
6186 : :
6187 : 11852 : Term TermManager::mkPi()
6188 : : {
6189 : : CVC5_API_TRY_CATCH_BEGIN;
6190 : : //////// all checks before this line
6191 : : internal::Node res =
6192 : 11852 : d_nm->mkNullaryOperator(d_nm->realType(), internal::Kind::PI);
6193 : 11852 : (void)res.getType(true); /* kick off type checking */
6194 : 23704 : return Term(d_nm, res);
6195 : : ////////
6196 [ - - ][ - - ]: 11852 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6197 : : }
6198 : :
6199 : 763800 : Term TermManager::mkInteger(const std::string& s)
6200 : : {
6201 : : CVC5_API_TRY_CATCH_BEGIN;
6202 [ + + ][ + + ]: 763800 : CVC5_API_ARG_CHECK_EXPECTED(isValidInteger(s), s) << "an integer ";
[ - - ]
6203 : 763757 : Term res = mkRealOrIntegerFromStrHelper(s);
6204 [ - + ][ - + ]: 2291271 : CVC5_API_ARG_CHECK_EXPECTED(CVC5_EQUAL(res.getSort(), getIntegerSort()), s)
[ - - ]
6205 : 0 : << "a string representing an integer";
6206 : : //////// all checks before this line
6207 : 1527514 : return res;
6208 : : ////////
6209 [ + - ][ - - ]: 763800 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6210 [ - + ]: 43 : }
6211 : :
6212 : 283 : Term TermManager::mkInteger(int64_t val)
6213 : : {
6214 : : CVC5_API_TRY_CATCH_BEGIN;
6215 : : //////// all checks before this line
6216 : : Term res =
6217 : 566 : TermManager::mkRationalValHelper(d_nm, internal::Rational(val), true);
6218 [ - + ][ - + ]: 849 : AssertEqual(res.getSort(), getIntegerSort());
[ - - ]
6219 : 566 : return res;
6220 : : ////////
6221 [ - - ][ - - ]: 283 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6222 : : }
6223 : :
6224 : 143550 : Term TermManager::mkReal(const std::string& s)
6225 : : {
6226 : : CVC5_API_TRY_CATCH_BEGIN;
6227 : : /* CLN and GMP handle this case differently, CLN interprets it as 0, GMP
6228 : : * throws an std::invalid_argument exception. For consistency, we treat it
6229 : : * as invalid. */
6230 [ + + ][ + + ]: 143552 : CVC5_API_ARG_CHECK_EXPECTED(s != ".", s)
[ - - ]
6231 : 2 : << "a string representing a real or rational value.";
6232 : : //////// all checks before this line
6233 : 143548 : return mkRealOrIntegerFromStrHelper(s, false);
6234 : : ////////
6235 [ + - ][ - - ]: 19 : CVC5_API_TRY_CATCH_END;
[ + - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - ]
6236 [ - + ]: 19 : }
6237 : :
6238 : 32 : Term TermManager::mkReal(int64_t val)
6239 : : {
6240 : : CVC5_API_TRY_CATCH_BEGIN;
6241 : : //////// all checks before this line
6242 : 32 : return TermManager::mkRationalValHelper(d_nm, internal::Rational(val), false);
6243 : : ////////
6244 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6245 : : }
6246 : :
6247 : 19 : Term TermManager::mkReal(int64_t num, int64_t den)
6248 : : {
6249 : : CVC5_API_TRY_CATCH_BEGIN;
6250 [ + + ][ + + ]: 19 : CVC5_API_CHECK(den != 0) << "invalid denominator '" << den << "'";
[ - - ]
6251 : : //////// all checks before this line
6252 : : return TermManager::mkRationalValHelper(
6253 : 17 : d_nm, internal::Rational(num, den), false);
6254 : : ////////
6255 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6256 [ - + ]: 2 : }
6257 : :
6258 : 13274 : Term TermManager::mkRegexpAll()
6259 : : {
6260 : : CVC5_API_TRY_CATCH_BEGIN;
6261 : : //////// all checks before this line
6262 : : internal::Node res =
6263 : 13274 : d_nm->mkNode(internal::Kind::REGEXP_ALL, std::vector<internal::Node>());
6264 : 13274 : (void)res.getType(true); /* kick off type checking */
6265 : 26548 : return Term(d_nm, res);
6266 : : ////////
6267 [ - - ][ - - ]: 13274 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6268 : : }
6269 : :
6270 : 13270 : Term TermManager::mkRegexpNone()
6271 : : {
6272 : : CVC5_API_TRY_CATCH_BEGIN;
6273 : : //////// all checks before this line
6274 : : internal::Node res =
6275 : 13270 : d_nm->mkNode(internal::Kind::REGEXP_NONE, std::vector<internal::Node>());
6276 : 13270 : (void)res.getType(true); /* kick off type checking */
6277 : 26540 : return Term(d_nm, res);
6278 : : ////////
6279 [ - - ][ - - ]: 13270 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6280 : : }
6281 : :
6282 : 13270 : Term TermManager::mkRegexpAllchar()
6283 : : {
6284 : : CVC5_API_TRY_CATCH_BEGIN;
6285 : : //////// all checks before this line
6286 : 13270 : internal::Node res = d_nm->mkNode(internal::Kind::REGEXP_ALLCHAR,
6287 : 13270 : std::vector<internal::Node>());
6288 : 13270 : (void)res.getType(true); /* kick off type checking */
6289 : 26540 : return Term(d_nm, res);
6290 : : ////////
6291 [ - - ][ - - ]: 13270 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6292 : : }
6293 : :
6294 : 12294 : Term TermManager::mkEmptySet(const Sort& sort)
6295 : : {
6296 : : CVC5_API_TRY_CATCH_BEGIN;
6297 : 12294 : CVC5_API_TM_CHECK_SORT(sort);
6298 [ + + ][ + + ]: 12291 : CVC5_API_ARG_CHECK_EXPECTED(sort.isSet(), sort) << "null sort or set sort";
[ - - ]
6299 : : //////// all checks before this line
6300 : 12289 : return mkValHelper(d_nm, internal::EmptySet(*sort.d_type));
6301 : : ////////
6302 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6303 [ - + ]: 5 : }
6304 : :
6305 : 11658 : Term TermManager::mkEmptyBag(const Sort& sort)
6306 : : {
6307 : : CVC5_API_TRY_CATCH_BEGIN;
6308 : 11658 : CVC5_API_TM_CHECK_SORT(sort);
6309 [ + + ][ + + ]: 11655 : CVC5_API_ARG_CHECK_EXPECTED(sort.isBag(), sort) << "null sort or bag sort";
[ - - ]
6310 : : //////// all checks before this line
6311 : 11653 : return mkValHelper(d_nm, internal::EmptyBag(*sort.d_type));
6312 : : ////////
6313 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6314 [ - + ]: 5 : }
6315 : :
6316 : 11551 : Term TermManager::mkSepEmp()
6317 : : {
6318 : : CVC5_API_TRY_CATCH_BEGIN;
6319 : : //////// all checks before this line
6320 : : internal::Node res =
6321 : 11551 : d_nm->mkNullaryOperator(d_nm->booleanType(), internal::Kind::SEP_EMP);
6322 : 11551 : (void)res.getType(true); /* kick off type checking */
6323 : 23102 : return Term(d_nm, res);
6324 : : ////////
6325 [ - - ][ - - ]: 11551 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6326 : : }
6327 : :
6328 : 11685 : Term TermManager::mkSepNil(const Sort& sort)
6329 : : {
6330 : : CVC5_API_TRY_CATCH_BEGIN;
6331 : 11685 : CVC5_API_TM_CHECK_SORT(sort);
6332 : : //////// all checks before this line
6333 : : internal::Node res =
6334 : 11681 : d_nm->mkNullaryOperator(*sort.d_type, internal::Kind::SEP_NIL);
6335 : 11681 : (void)res.getType(true); /* kick off type checking */
6336 : 23362 : return Term(d_nm, res);
6337 : : ////////
6338 [ + - ][ - - ]: 11685 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6339 [ - + ]: 4 : }
6340 : :
6341 : 29270 : Term TermManager::mkString(const std::string& s, bool useEscSequences)
6342 : : {
6343 : : CVC5_API_TRY_CATCH_BEGIN;
6344 : : //////// all checks before this line
6345 : 29270 : return mkValHelper(d_nm, internal::String(s, useEscSequences));
6346 : : ////////
6347 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6348 : : }
6349 : :
6350 : 2 : Term TermManager::mkString(const std::wstring& s)
6351 : : {
6352 : : CVC5_API_TRY_CATCH_BEGIN;
6353 [ - + ]: 2 : for (size_t i = 0, n = s.size(); i < n; ++i)
6354 : : {
6355 : 0 : CVC5_API_CHECK(static_cast<unsigned>(s[i]) < internal::String::num_codes())
6356 : 0 : << "Expected unicode string whose characters are less than code point "
6357 : 0 : << internal::String::num_codes();
6358 : : }
6359 : : //////// all checks before this line
6360 : 2 : return mkValHelper(d_nm, internal::String(s));
6361 : : ////////
6362 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6363 [ - - ]: 0 : }
6364 : :
6365 : 15 : Term TermManager::mkString(const std::u32string& s)
6366 : : {
6367 : : CVC5_API_TRY_CATCH_BEGIN;
6368 [ + + ]: 27 : for (size_t i = 0, n = s.size(); i < n; ++i)
6369 : : {
6370 [ + + ][ + + ]: 14 : CVC5_API_CHECK(static_cast<unsigned>(s[i]) < internal::String::num_codes())
[ - - ]
6371 : 1 : << "Expected unicode string whose characters are less than code point "
6372 : 1 : << internal::String::num_codes();
6373 : : }
6374 : : //////// all checks before this line
6375 : 14 : return mkValHelper(d_nm, internal::String(s));
6376 : : ////////
6377 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6378 [ - + ]: 1 : }
6379 : :
6380 : 13381 : Term TermManager::mkEmptySequence(const Sort& sort)
6381 : : {
6382 : : CVC5_API_TRY_CATCH_BEGIN;
6383 : 13381 : CVC5_API_TM_CHECK_SORT(sort);
6384 : : //////// all checks before this line
6385 : 13379 : std::vector<internal::Node> seq;
6386 : 13379 : internal::Node res = d_nm->mkConst(internal::Sequence(*sort.d_type, seq));
6387 : 26758 : return Term(d_nm, res);
6388 : : ////////
6389 [ + - ][ - - ]: 13381 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6390 [ - + ]: 2 : }
6391 : :
6392 : 11981 : Term TermManager::mkUniverseSet(const Sort& sort)
6393 : : {
6394 : : CVC5_API_TRY_CATCH_BEGIN;
6395 : 11981 : CVC5_API_TM_CHECK_SORT(sort);
6396 : : //////// all checks before this line
6397 : : internal::Node res =
6398 : 11978 : d_nm->mkNullaryOperator(*sort.d_type, internal::Kind::SET_UNIVERSE);
6399 : : // TODO(#2771): Reenable?
6400 : : // (void)res->getType(true); /* kick off type checking */
6401 : 23956 : return Term(d_nm, res);
6402 : : ////////
6403 [ + - ][ - - ]: 11981 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6404 [ - + ]: 3 : }
6405 : :
6406 : 155 : Term TermManager::mkBitVector(uint32_t size, uint64_t val)
6407 : : {
6408 : : CVC5_API_TRY_CATCH_BEGIN;
6409 : : //////// all checks before this line
6410 : 308 : return mkBVFromIntHelper(size, val);
6411 : : ////////
6412 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6413 : : }
6414 : :
6415 : 403940 : Term TermManager::mkBitVector(uint32_t size,
6416 : : const std::string& s,
6417 : : uint32_t base)
6418 : : {
6419 : : CVC5_API_TRY_CATCH_BEGIN;
6420 : : //////// all checks before this line
6421 : 807848 : return mkBVFromStrHelper(size, s, base);
6422 : : ////////
6423 [ - - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ + - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - ]
6424 : : }
6425 : :
6426 : 2698 : Term TermManager::mkFiniteFieldElem(const std::string& value,
6427 : : const Sort& sort,
6428 : : uint32_t base)
6429 : : {
6430 : : CVC5_API_TRY_CATCH_BEGIN;
6431 : 2698 : CVC5_API_TM_CHECK_SORT(sort);
6432 [ + + ][ + + ]: 2700 : CVC5_API_ARG_CHECK_EXPECTED(sort.isFiniteField(), sort)
[ - - ]
6433 : 2 : << "a finite field sort";
6434 : : //////// all checks before this line
6435 : 2696 : internal::Integer v(value, base);
6436 : 5388 : internal::FiniteFieldValue f(v, sort.d_type->getFfSize());
6437 : :
6438 : 5388 : return mkValHelper<internal::FiniteFieldValue>(d_nm, f);
6439 : : ////////
6440 [ + - ][ - - ]: 2698 : CVC5_API_TRY_CATCH_END;
[ + - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - ]
6441 [ - + ]: 4 : }
6442 : :
6443 : 248 : Term TermManager::mkConstArray(const Sort& sort, const Term& val)
6444 : : {
6445 : : CVC5_API_TRY_CATCH_BEGIN;
6446 : 248 : CVC5_API_TM_CHECK_SORT(sort);
6447 : 245 : CVC5_API_TM_CHECK_TERM(val);
6448 [ + + ][ + + ]: 242 : CVC5_API_ARG_CHECK_EXPECTED(sort.isArray(), sort) << "an array sort";
[ - - ]
6449 [ + + ][ + + ]: 252 : CVC5_API_CHECK(val.getSort() == sort.getArrayElementSort())
[ - - ]
6450 : 4 : << "value does not match element sort";
6451 : 236 : internal::Node n = *val.d_node;
6452 [ + + ][ + + ]: 236 : CVC5_API_ARG_CHECK_EXPECTED(n.isConst(), val) << "a value";
[ - - ]
6453 : : //////// all checks before this line
6454 : 468 : Term res = mkValHelper(d_nm, internal::ArrayStoreAll(*sort.d_type, n));
6455 : 468 : return res;
6456 : : ////////
6457 [ + - ][ - - ]: 250 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6458 [ - + ]: 14 : }
6459 : :
6460 : 24 : Term TermManager::mkFloatingPointPosInf(uint32_t exp, uint32_t sig)
6461 : : {
6462 : : CVC5_API_TRY_CATCH_BEGIN;
6463 [ - + ][ - + ]: 24 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6464 [ - + ][ - + ]: 24 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6465 : : //////// all checks before this line
6466 : 24 : return mkValHelper(d_nm,
6467 : 24 : internal::FloatingPoint::makeInf(
6468 : 48 : internal::FloatingPointSize(exp, sig), false));
6469 : : ////////
6470 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6471 [ - - ]: 0 : }
6472 : :
6473 : 30 : Term TermManager::mkFloatingPointNegInf(uint32_t exp, uint32_t sig)
6474 : : {
6475 : : CVC5_API_TRY_CATCH_BEGIN;
6476 [ - + ][ - + ]: 30 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6477 [ - + ][ - + ]: 30 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6478 : : //////// all checks before this line
6479 : 30 : return mkValHelper(d_nm,
6480 : 30 : internal::FloatingPoint::makeInf(
6481 : 60 : internal::FloatingPointSize(exp, sig), true));
6482 : : ////////
6483 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6484 [ - - ]: 0 : }
6485 : :
6486 : 21 : Term TermManager::mkFloatingPointNaN(uint32_t exp, uint32_t sig)
6487 : : {
6488 : : CVC5_API_TRY_CATCH_BEGIN;
6489 [ - + ][ - + ]: 21 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6490 [ - + ][ - + ]: 21 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6491 : : //////// all checks before this line
6492 : : return mkValHelper(
6493 : 21 : d_nm,
6494 : 21 : internal::FloatingPoint::makeNaN(internal::FloatingPointSize(exp, sig)));
6495 : : ////////
6496 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6497 [ - - ]: 0 : }
6498 : :
6499 : 39 : Term TermManager::mkFloatingPointPosZero(uint32_t exp, uint32_t sig)
6500 : : {
6501 : : CVC5_API_TRY_CATCH_BEGIN;
6502 [ - + ][ - + ]: 39 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6503 [ - + ][ - + ]: 39 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6504 : : //////// all checks before this line
6505 : 39 : return mkValHelper(d_nm,
6506 : 39 : internal::FloatingPoint::makeZero(
6507 : 78 : internal::FloatingPointSize(exp, sig), false));
6508 : : ////////
6509 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6510 [ - - ]: 0 : }
6511 : :
6512 : 36 : Term TermManager::mkFloatingPointNegZero(uint32_t exp, uint32_t sig)
6513 : : {
6514 : : CVC5_API_TRY_CATCH_BEGIN;
6515 [ - + ][ - + ]: 36 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6516 [ - + ][ - + ]: 36 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6517 : : //////// all checks before this line
6518 : 36 : return mkValHelper(d_nm,
6519 : 36 : internal::FloatingPoint::makeZero(
6520 : 72 : internal::FloatingPointSize(exp, sig), true));
6521 : : ////////
6522 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6523 [ - - ]: 0 : }
6524 : :
6525 : 117716 : Term TermManager::mkRoundingMode(RoundingMode rm)
6526 : : {
6527 : : CVC5_API_TRY_CATCH_BEGIN;
6528 : : //////// all checks before this line
6529 : 117716 : return mkValHelper(d_nm, s_rmodes.at(rm));
6530 : : ////////
6531 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6532 : : }
6533 : :
6534 : 23 : Term TermManager::mkFloatingPoint(uint32_t exp, uint32_t sig, const Term& val)
6535 : : {
6536 : : CVC5_API_TRY_CATCH_BEGIN;
6537 : 23 : CVC5_API_TM_CHECK_TERM(val);
6538 [ + + ][ + + ]: 20 : CVC5_API_ARG_CHECK_EXPECTED(exp > 1, exp) << "exponent size > 1";
[ - - ]
6539 [ + + ][ + + ]: 16 : CVC5_API_ARG_CHECK_EXPECTED(sig > 1, sig) << "significand size > 1";
[ - - ]
6540 : 12 : uint32_t bw = exp + sig;
6541 [ + + ][ + + ]: 16 : CVC5_API_ARG_CHECK_EXPECTED(bw == val.d_node->getType().getBitVectorSize(),
[ - - ]
6542 : : val)
6543 : 2 : << "a bit-vector value with bit-width '" << bw << "'";
6544 : 10 : CVC5_API_ARG_CHECK_EXPECTED(
6545 : : val.d_node->getType().isBitVector() && val.d_node->isConst(), val)
6546 : 0 : << "bit-vector value";
6547 : : //////// all checks before this line
6548 : : return mkValHelper(
6549 : 10 : d_nm,
6550 : 20 : internal::FloatingPoint(
6551 : 30 : exp, sig, val.d_node->getConst<internal::BitVector>()));
6552 : : ////////
6553 [ + - ][ - - ]: 13 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6554 [ - + ]: 13 : }
6555 : :
6556 : 237 : Term TermManager::mkFloatingPoint(const Term& sign,
6557 : : const Term& exp,
6558 : : const Term& sig)
6559 : : {
6560 : : CVC5_API_TRY_CATCH_BEGIN;
6561 : 237 : CVC5_API_TM_CHECK_TERM(sign);
6562 : 234 : CVC5_API_TM_CHECK_TERM(exp);
6563 : 231 : CVC5_API_TM_CHECK_TERM(sig);
6564 [ + - ][ + + ]: 232 : CVC5_API_ARG_CHECK_EXPECTED(
[ + + ][ + + ]
[ + - ][ - - ]
[ + - ]
6565 : : sign.d_node->getType().isBitVector() && sign.d_node->isConst(), sign)
6566 : 2 : << "bit-vector value";
6567 [ + - ][ + + ]: 230 : CVC5_API_ARG_CHECK_EXPECTED(
[ + + ][ + + ]
[ + - ][ - - ]
[ + - ]
6568 : : exp.d_node->getType().isBitVector() && exp.d_node->isConst(), exp)
6569 : 2 : << "bit-vector value";
6570 [ + - ][ + + ]: 228 : CVC5_API_ARG_CHECK_EXPECTED(
[ + + ][ + + ]
[ + - ][ - - ]
[ + - ]
6571 : : sig.d_node->getType().isBitVector() && sig.d_node->isConst(), sig)
6572 : 2 : << "bit-vector value";
6573 [ + + ][ + + ]: 226 : CVC5_API_ARG_CHECK_EXPECTED(sign.d_node->getType().getBitVectorSize() == 1,
[ - - ]
6574 : : sign)
6575 : 2 : << "a bit-vector value of size 1";
6576 [ + + ][ + + ]: 222 : CVC5_API_ARG_CHECK_EXPECTED(exp.d_node->getType().getBitVectorSize() > 1, exp)
[ - - ]
6577 : 1 : << "a bit-vector value of size > 1";
6578 : : //////// all checks before this line
6579 : 219 : uint32_t esize = exp.d_node->getType().getBitVectorSize();
6580 : 219 : uint32_t ssize = sig.d_node->getType().getBitVectorSize() + 1;
6581 : : return mkValHelper(
6582 : 219 : d_nm,
6583 : 219 : internal::FloatingPoint(
6584 : : esize,
6585 : : ssize,
6586 : 657 : sign.d_node->getConst<internal::BitVector>().concat(
6587 : 657 : exp.d_node->getConst<internal::BitVector>().concat(
6588 : 657 : sig.d_node->getConst<internal::BitVector>()))));
6589 : : ////////
6590 [ + - ][ - - ]: 18 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6591 [ - + ]: 18 : }
6592 : :
6593 : 131 : Term TermManager::mkCardinalityConstraint(const Sort& sort, uint32_t upperBound)
6594 : : {
6595 : : CVC5_API_TRY_CATCH_BEGIN;
6596 : 131 : CVC5_API_TM_CHECK_SORT(sort);
6597 [ + + ][ + + ]: 131 : CVC5_API_ARG_CHECK_EXPECTED(sort.isUninterpretedSort(), sort)
[ - - ]
6598 : 2 : << "an uninterpreted sort";
6599 [ + + ][ + + ]: 127 : CVC5_API_ARG_CHECK_EXPECTED(upperBound > 0, upperBound) << "a value > 0";
[ - - ]
6600 : : //////// all checks before this line
6601 : : internal::Node cco =
6602 : 250 : d_nm->mkConst(internal::CardinalityConstraint(*sort.d_type, upperBound));
6603 : : internal::Node res =
6604 : 125 : d_nm->mkNode(internal::Kind::CARDINALITY_CONSTRAINT, cco);
6605 : 250 : return Term(d_nm, res);
6606 : : ////////
6607 [ + - ][ - - ]: 131 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6608 [ - + ]: 6 : }
6609 : :
6610 : 9 : Term TermManager::mkNullableLift(Kind kind, const std::vector<Term>& args)
6611 : : {
6612 : : CVC5_API_TRY_CATCH_BEGIN;
6613 : : //////// all checks before this line
6614 : 9 : std::vector<internal::Node> vars;
6615 [ + + ]: 23 : for (size_t i = 0, size = args.size(); i < size; ++i)
6616 : : {
6617 : 16 : const Term& t = args[i];
6618 : 16 : CVC5_API_TM_CHECK_TERM_AT_INDEX(t, args, i);
6619 : 14 : internal::TypeNode type = t.d_node->getType();
6620 : 14 : internal::TypeNode elementType = type[0];
6621 : 14 : internal::Node var = mkVarHelper(elementType);
6622 : 14 : vars.push_back(var);
6623 : 14 : }
6624 : 7 : internal::Node varList = d_nm->mkNode(internal::Kind::BOUND_VAR_LIST, vars);
6625 : 7 : internal::Kind internalKind = extToIntKind(kind);
6626 : 7 : internal::Node body = d_nm->mkNode(internalKind, vars);
6627 : 14 : internal::Node lambda = d_nm->mkNode(internal::Kind::LAMBDA, varList, body);
6628 : 7 : std::vector<internal::Node> nodes;
6629 : 7 : nodes.push_back(lambda);
6630 : 7 : auto argNodes = Term::termVectorToNodes(args);
6631 : 7 : nodes.insert(nodes.end(), argNodes.begin(), argNodes.end());
6632 : :
6633 : 14 : return Term(d_nm, d_nm->mkNode(internal::Kind::NULLABLE_LIFT, nodes));
6634 : : ////////
6635 [ + - ][ - - ]: 11 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6636 [ - + ]: 2 : }
6637 : :
6638 : : /* Constants and Variables -------------------------------------------------- */
6639 : :
6640 : 9861 : Term TermManager::mkConst(const Sort& sort,
6641 : : const std::optional<std::string>& symbol)
6642 : : {
6643 : : CVC5_API_TRY_CATCH_BEGIN;
6644 : 9861 : CVC5_API_TM_CHECK_SORT(sort);
6645 : : //////// all checks before this line
6646 : 9857 : return Term(d_nm, mkConstHelper(*sort.d_type, symbol));
6647 : : ////////
6648 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6649 [ - + ]: 4 : }
6650 : :
6651 : 103948 : Term TermManager::mkVar(const Sort& sort,
6652 : : const std::optional<std::string>& symbol)
6653 : : {
6654 : : CVC5_API_TRY_CATCH_BEGIN;
6655 : 103948 : CVC5_API_TM_CHECK_SORT(sort);
6656 : : //////// all checks before this line
6657 : 103944 : return Term(d_nm, mkVarHelper(*sort.d_type, symbol));
6658 : : ////////
6659 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6660 [ - + ]: 4 : }
6661 : :
6662 : 17378 : Term TermManager::mkTuple(const std::vector<Term>& terms)
6663 : : {
6664 : : CVC5_API_TRY_CATCH_BEGIN;
6665 : 29264 : CVC5_API_TM_CHECK_TERMS(terms);
6666 : : //////// all checks before this line
6667 : 17376 : std::vector<internal::Node> args;
6668 : 17376 : std::vector<internal::TypeNode> typeNodes;
6669 [ + + ]: 29262 : for (size_t i = 0, size = terms.size(); i < size; i++)
6670 : : {
6671 : 11886 : internal::Node n = *terms[i].d_node;
6672 : 11886 : args.push_back(n);
6673 : 11886 : typeNodes.push_back(n.getType());
6674 : 11886 : }
6675 : 17376 : internal::TypeNode tn = d_nm->mkTupleType(typeNodes);
6676 : 17376 : const internal::DType& dt = tn.getDType();
6677 : 17376 : internal::NodeBuilder nb(d_nm.get(), extToIntKind(Kind::APPLY_CONSTRUCTOR));
6678 : 17376 : nb << dt[0].getConstructor();
6679 : 17376 : nb.append(args);
6680 : 17376 : internal::Node res = nb.constructNode();
6681 : 17376 : (void)res.getType(true); /* kick off type checking */
6682 : 34752 : return Term(d_nm, res);
6683 : : ////////
6684 [ + - ][ - - ]: 17378 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6685 [ - + ]: 2 : }
6686 : :
6687 : 219 : Term TermManager::mkNullableSome(const Term& term)
6688 : : {
6689 : : CVC5_API_TRY_CATCH_BEGIN;
6690 : 219 : CVC5_API_TM_CHECK_TERM(term);
6691 : : //////// all checks before this line
6692 : 217 : internal::Node arg = *term.d_node;
6693 : 217 : internal::TypeNode typeNode = arg.getType();
6694 : 217 : internal::TypeNode tn = d_nm->mkNullableType(typeNode);
6695 : 217 : const internal::DType& dt = tn.getDType();
6696 : 217 : internal::NodeBuilder nb(d_nm.get(), extToIntKind(Kind::APPLY_CONSTRUCTOR));
6697 : 217 : nb << dt[1].getConstructor();
6698 : 217 : nb.append(arg);
6699 : 217 : internal::Node res = nb.constructNode();
6700 : 217 : (void)res.getType(true); /* kick off type checking */
6701 : 434 : return Term(d_nm, res);
6702 : : ////////
6703 [ + - ][ - - ]: 219 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6704 [ - + ]: 2 : }
6705 : :
6706 : 12001 : Term TermManager::mkNullableNull(const Sort& sort)
6707 : : {
6708 : : CVC5_API_TRY_CATCH_BEGIN;
6709 : 12001 : CVC5_API_TM_CHECK_SORT(sort);
6710 [ - + ][ - + ]: 12000 : CVC5_API_ARG_CHECK_EXPECTED(sort.isNullable(), sort) << "nullable sort";
[ - - ]
6711 : : //////// all checks before this line
6712 : 12000 : internal::TypeNode tn = sort.getTypeNode();
6713 : 12000 : const internal::DType& dt = tn.getDType();
6714 : 12000 : internal::NodeBuilder nb(d_nm.get(), extToIntKind(Kind::APPLY_CONSTRUCTOR));
6715 : 12000 : nb << dt[0].getConstructor();
6716 : 12000 : internal::Node res = nb.constructNode();
6717 : 12000 : (void)res.getType(true); /* kick off type checking */
6718 : 24000 : return Term(d_nm, res);
6719 : : ////////
6720 [ + - ][ - - ]: 12001 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6721 [ - + ]: 1 : }
6722 : :
6723 : 71 : Term TermManager::mkNullableVal(const Term& term)
6724 : : {
6725 : : CVC5_API_TRY_CATCH_BEGIN;
6726 : 71 : CVC5_API_TM_CHECK_TERM(term);
6727 : 69 : Sort sort = term.getSort();
6728 [ - + ][ - + ]: 69 : CVC5_API_ARG_CHECK_EXPECTED(sort.isNullable(), sort) << "nullable sort";
[ - - ]
6729 : : //////// all checks before this line
6730 : 69 : internal::Node arg = (*term.d_node);
6731 : 69 : internal::TypeNode tn = arg.getType();
6732 : 69 : const internal::DType& dt = tn.getDType();
6733 : 69 : internal::Node sel = dt[1][0].getSelector();
6734 : : internal::Node applySel =
6735 : 138 : d_nm->mkNode(internal::Kind::APPLY_SELECTOR, sel, arg);
6736 : 69 : (void)applySel.getType(true); /* kick off type checking */
6737 : 138 : return Term(d_nm, applySel);
6738 : : ////////
6739 [ + - ][ - - ]: 71 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6740 [ - + ]: 2 : }
6741 : :
6742 : 62 : Term TermManager::mkNullableIsNull(const Term& term)
6743 : : {
6744 : : CVC5_API_TRY_CATCH_BEGIN;
6745 : 62 : CVC5_API_TM_CHECK_TERM(term);
6746 : 59 : Sort sort = term.getSort();
6747 [ - + ][ - + ]: 59 : CVC5_API_ARG_CHECK_EXPECTED(sort.isNullable(), sort) << "nullable sort";
[ - - ]
6748 : : //////// all checks before this line
6749 : 59 : internal::Node arg = (*term.d_node);
6750 : 59 : internal::TypeNode tn = arg.getType();
6751 : 59 : const internal::DType& dt = tn.getDType();
6752 : 59 : internal::Node tester = dt[0].getTester();
6753 : : internal::Node applyTester =
6754 : 118 : d_nm->mkNode(internal::Kind::APPLY_TESTER, tester, arg);
6755 : 59 : (void)applyTester.getType(true); /* kick off type checking */
6756 : 118 : return Term(d_nm, applyTester);
6757 : : ////////
6758 [ + - ][ - - ]: 62 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6759 [ - + ]: 3 : }
6760 : :
6761 : 20 : Term TermManager::mkNullableIsSome(const Term& term)
6762 : : {
6763 : : CVC5_API_TRY_CATCH_BEGIN;
6764 : 20 : CVC5_API_TM_CHECK_TERM(term);
6765 : 18 : Sort sort = term.getSort();
6766 [ - + ][ - + ]: 18 : CVC5_API_ARG_CHECK_EXPECTED(sort.isNullable(), sort) << "nullable sort";
[ - - ]
6767 : : //////// all checks before this line
6768 : 18 : internal::Node arg = (*term.d_node);
6769 : 18 : internal::TypeNode tn = arg.getType();
6770 : 18 : const internal::DType& dt = tn.getDType();
6771 : 18 : internal::Node tester = dt[1].getTester();
6772 : : internal::Node applyTester =
6773 : 36 : d_nm->mkNode(internal::Kind::APPLY_TESTER, tester, arg);
6774 : 18 : (void)applyTester.getType(true); /* kick off type checking */
6775 : 36 : return Term(d_nm, applyTester);
6776 : : ////////
6777 [ + - ][ - - ]: 20 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6778 [ - + ]: 2 : }
6779 : :
6780 : : /* Datatype Constructor Declaration ----------------------------------------- */
6781 : :
6782 : 9735 : DatatypeConstructorDecl TermManager::mkDatatypeConstructorDecl(
6783 : : const std::string& name)
6784 : : {
6785 : : CVC5_API_TRY_CATCH_BEGIN;
6786 : : //////// all checks before this line
6787 : 9735 : return DatatypeConstructorDecl(d_nm, name);
6788 : : ////////
6789 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6790 : : }
6791 : :
6792 : : /* Datatype Declaration ----------------------------------------------------- */
6793 : :
6794 : 122 : DatatypeDecl TermManager::mkDatatypeDecl(const std::string& name,
6795 : : bool isCoDatatype)
6796 : : {
6797 : : CVC5_API_TRY_CATCH_BEGIN;
6798 : : //////// all checks before this line
6799 : 122 : return DatatypeDecl(d_nm, name, isCoDatatype);
6800 : : ////////
6801 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6802 : : }
6803 : :
6804 : 5367 : DatatypeDecl TermManager::mkDatatypeDecl(const std::string& name,
6805 : : const std::vector<Sort>& params,
6806 : : bool isCoDatatype)
6807 : : {
6808 : : CVC5_API_TRY_CATCH_BEGIN;
6809 : 5673 : CVC5_API_TM_CHECK_SORTS(params);
6810 : : //////// all checks before this line
6811 : 5367 : return DatatypeDecl(d_nm, name, params, isCoDatatype);
6812 : : ////////
6813 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
6814 [ - - ]: 0 : }
6815 : :
6816 : : /* -------------------------------------------------------------------------- */
6817 : : /* Solver */
6818 : : /* -------------------------------------------------------------------------- */
6819 : :
6820 : 30028 : Solver::Solver(TermManager& tm, std::unique_ptr<internal::Options>&& original)
6821 : 30028 : : d_tm(tm)
6822 : : {
6823 : 30028 : d_originalOptions = std::move(original);
6824 : 30028 : resetInternal();
6825 : 30028 : }
6826 : :
6827 : 30111 : void Solver::resetInternal()
6828 : : {
6829 : : // Release the previous engine, if any, before constructing the new one so
6830 : : // that two engines are never alive at the same time.
6831 : 30111 : d_slv.reset();
6832 : 30111 : d_slv.reset(
6833 : 30111 : new internal::SolverEngine(d_tm.d_nm.get(), d_originalOptions.get()));
6834 : 30111 : d_slv->setSolver(this);
6835 : 30111 : d_rng.reset(new internal::Random(d_slv->getOptions().driver.seed));
6836 : 30111 : }
6837 : :
6838 : 30026 : Solver::Solver(TermManager& tm)
6839 : 30026 : : Solver(tm, std::make_unique<internal::Options>())
6840 : : {
6841 : 30026 : }
6842 : :
6843 : 2 : Solver::Solver()
6844 : 2 : : Solver(*TermManager::currentTM(), std::make_unique<internal::Options>())
6845 : : {
6846 : 2 : }
6847 : :
6848 : 25549 : Solver::~Solver() {}
6849 : :
6850 : : /* Helpers and private functions */
6851 : : /* -------------------------------------------------------------------------- */
6852 : :
6853 : 1642 : Term Solver::synthFunHelper(const std::string& symbol,
6854 : : const std::vector<Term>& boundVars,
6855 : : const Sort& sort,
6856 : : Grammar* grammar) const
6857 : : {
6858 : : // Note: boundVars, sort and grammar are checked in the caller to avoid
6859 : : // double checks.
6860 : 1642 : std::vector<internal::TypeNode> varTypes;
6861 [ + + ]: 5323 : for (const auto& bv : boundVars)
6862 : : {
6863 [ + + ]: 3683 : if (grammar)
6864 : : {
6865 [ + + ][ - - ]: 2566 : CVC5_API_CHECK(grammar->d_grammar->getNtSyms()[0].getType()
6866 : : == *sort.d_type)
6867 : 2 : << "invalid Start symbol for grammar, expected Start's sort to be "
6868 : 2 : << *sort.d_type << " but found "
6869 [ + + ][ + + ]: 1283 : << grammar->d_grammar->getNtSyms()[0].getType();
[ - - ]
6870 : : }
6871 : 3681 : varTypes.push_back(bv.d_node->getType());
6872 : : }
6873 [ + + ]: 1640 : if (grammar)
6874 : : {
6875 [ + + ]: 2455 : for (const auto& sym : grammar->d_grammar->getNtSyms())
6876 : : {
6877 [ + + ][ + + ]: 1695 : CVC5_API_CHECK(!grammar->d_grammar->getRulesFor(sym).empty())
[ - - ]
6878 : : << "invalid grammar, must have at least one rule for each "
6879 : 4 : "non-terminal symbol";
6880 : : }
6881 : : }
6882 : : //////// all checks before this line
6883 : :
6884 : : internal::TypeNode funType =
6885 : 1804 : varTypes.empty() ? *sort.d_type
6886 [ + + ]: 1804 : : d_tm.d_nm->mkFunctionType(varTypes, *sort.d_type);
6887 : :
6888 : 1636 : internal::Node fun = d_tm.mkVarHelper(funType, symbol);
6889 : :
6890 : 1636 : std::vector<internal::Node> bvns = Term::termVectorToNodes(boundVars);
6891 : :
6892 [ + + ]: 2404 : d_slv->declareSynthFun(
6893 [ + + ][ + - ]: 2402 : fun, grammar == nullptr ? funType : *grammar->resolve().d_type, bvns);
6894 : :
6895 : 3268 : return Term(d_tm.d_nm, fun);
6896 [ - + ]: 1656 : }
6897 : :
6898 : 135644 : void Solver::ensureWellFormedTerm(const Term& t) const
6899 : : {
6900 : : // only check if option is set
6901 [ + + ]: 135644 : if (d_slv->getOptions().expr.wellFormedChecking)
6902 : : {
6903 : : // Call isWellFormedTerm of the underlying solver, which checks if the
6904 : : // given node has free variables. We do not check for variable shadowing,
6905 : : // since this can be handled by our rewriter.
6906 [ + + ]: 600 : if (!d_slv->isWellFormedTerm(*t.d_node))
6907 : : {
6908 : 2 : std::stringstream se;
6909 : 4 : se << "cannot process term " << *t.d_node << " with free variables"
6910 : 2 : << std::endl;
6911 : 2 : throw CVC5ApiException(se.str().c_str());
6912 : 2 : }
6913 : : }
6914 : 135642 : }
6915 : :
6916 : 2988 : void Solver::ensureWellFormedTerms(const std::vector<Term>& ts) const
6917 : : {
6918 : : // only check if option is set
6919 [ + + ]: 2988 : if (d_slv->getOptions().expr.wellFormedChecking)
6920 : : {
6921 [ + + ]: 93 : for (const Term& t : ts)
6922 : : {
6923 : 60 : ensureWellFormedTerm(t);
6924 : : }
6925 : : }
6926 : 2986 : }
6927 : :
6928 : 2 : void Solver::printStatisticsSafe(int fd) const
6929 : : {
6930 : 2 : d_slv->printStatisticsSafe(fd);
6931 : 2 : }
6932 : :
6933 : : /* Deprecated Functions */
6934 : : /* -------------------------------------------------------------------------- */
6935 : :
6936 : 138461 : Sort Solver::getBooleanSort(void) const { return d_tm.getBooleanSort(); }
6937 : :
6938 : 36 : Sort Solver::getIntegerSort(void) const { return d_tm.getIntegerSort(); }
6939 : :
6940 : 2 : Sort Solver::getRealSort(void) const { return d_tm.getRealSort(); }
6941 : :
6942 : 2 : Sort Solver::getRegExpSort(void) const { return d_tm.getRegExpSort(); }
6943 : :
6944 : 4 : Sort Solver::getStringSort(void) const { return d_tm.getStringSort(); }
6945 : :
6946 : 2 : Sort Solver::getRoundingModeSort(void) const
6947 : : {
6948 : 2 : return d_tm.getRoundingModeSort();
6949 : : }
6950 : :
6951 : 4 : Sort Solver::mkArraySort(const Sort& indexSort, const Sort& elemSort) const
6952 : : {
6953 : 4 : return d_tm.mkArraySort(indexSort, elemSort);
6954 : : }
6955 : :
6956 : 4 : Sort Solver::mkBitVectorSort(uint32_t size) const
6957 : : {
6958 : 4 : return d_tm.mkBitVectorSort(size);
6959 : : }
6960 : :
6961 : 4 : Sort Solver::mkFiniteFieldSort(const std::string& modulus, uint32_t base) const
6962 : : {
6963 : 4 : return d_tm.mkFiniteFieldSort(modulus, base);
6964 : : }
6965 : :
6966 : 2 : Sort Solver::mkFloatingPointSort(uint32_t exp, uint32_t sig) const
6967 : : {
6968 : 2 : return d_tm.mkFloatingPointSort(exp, sig);
6969 : : }
6970 : :
6971 : 2 : Sort Solver::mkDatatypeSort(const DatatypeDecl& dtypedecl) const
6972 : : {
6973 : 2 : return d_tm.mkDatatypeSort(dtypedecl);
6974 : : }
6975 : :
6976 : 2 : std::vector<Sort> Solver::mkDatatypeSorts(
6977 : : const std::vector<DatatypeDecl>& dtypedecls) const
6978 : : {
6979 : 2 : return d_tm.mkDatatypeSorts(dtypedecls);
6980 : : }
6981 : :
6982 : 2 : Sort Solver::mkFunctionSort(const std::vector<Sort>& sorts,
6983 : : const Sort& codomain) const
6984 : : {
6985 : 2 : return d_tm.mkFunctionSort(sorts, codomain);
6986 : : }
6987 : :
6988 : 4 : Sort Solver::mkParamSort(const std::optional<std::string>& symbol) const
6989 : : {
6990 : 4 : return d_tm.mkParamSort(symbol);
6991 : : }
6992 : :
6993 : 2 : Sort Solver::mkPredicateSort(const std::vector<Sort>& sorts) const
6994 : : {
6995 : 2 : return d_tm.mkPredicateSort(sorts);
6996 : : }
6997 : :
6998 : 2 : Sort Solver::mkRecordSort(
6999 : : const std::vector<std::pair<std::string, Sort>>& fields) const
7000 : : {
7001 : 2 : return d_tm.mkRecordSort(fields);
7002 : : }
7003 : :
7004 : 4 : Sort Solver::mkSetSort(const Sort& elemSort) const
7005 : : {
7006 : 4 : return d_tm.mkSetSort(elemSort);
7007 : : }
7008 : :
7009 : 4 : Sort Solver::mkBagSort(const Sort& elemSort) const
7010 : : {
7011 : 4 : return d_tm.mkBagSort(elemSort);
7012 : : }
7013 : :
7014 : 2 : Sort Solver::mkSequenceSort(const Sort& elemSort) const
7015 : : {
7016 : 2 : return d_tm.mkSequenceSort(elemSort);
7017 : : }
7018 : :
7019 : 2 : Sort Solver::mkAbstractSort(SortKind k) const { return d_tm.mkAbstractSort(k); }
7020 : :
7021 : 6 : Sort Solver::mkUninterpretedSort(const std::optional<std::string>& symbol) const
7022 : : {
7023 : 6 : return d_tm.mkUninterpretedSort(symbol);
7024 : : }
7025 : :
7026 : 2 : Sort Solver::mkUnresolvedDatatypeSort(const std::string& symbol,
7027 : : size_t arity) const
7028 : : {
7029 : 2 : return d_tm.mkUnresolvedDatatypeSort(symbol, arity);
7030 : : }
7031 : :
7032 : 2 : Sort Solver::mkUninterpretedSortConstructorSort(
7033 : : size_t arity, const std::optional<std::string>& symbol) const
7034 : : {
7035 : 2 : return d_tm.mkUninterpretedSortConstructorSort(arity, symbol);
7036 : : }
7037 : :
7038 : 2 : Sort Solver::mkTupleSort(const std::vector<Sort>& sorts) const
7039 : : {
7040 : 2 : return d_tm.mkTupleSort(sorts);
7041 : : }
7042 : :
7043 : 6 : Sort Solver::mkNullableSort(const Sort& sort) const
7044 : : {
7045 : 6 : return d_tm.mkNullableSort(sort);
7046 : : }
7047 : :
7048 : 2 : Term Solver::mkTrue(void) const { return d_tm.mkTrue(); }
7049 : :
7050 : 2 : Term Solver::mkFalse(void) const { return d_tm.mkFalse(); }
7051 : :
7052 : 2 : Term Solver::mkBoolean(bool val) const { return d_tm.mkBoolean(val); }
7053 : :
7054 : 2 : Term Solver::mkPi() const { return d_tm.mkPi(); }
7055 : :
7056 : 2 : Term Solver::mkInteger(const std::string& s) const { return d_tm.mkInteger(s); }
7057 : :
7058 : 14 : Term Solver::mkInteger(int64_t val) const { return d_tm.mkInteger(val); }
7059 : :
7060 : 2 : Term Solver::mkReal(const std::string& s) const { return d_tm.mkReal(s); }
7061 : :
7062 : 2 : Term Solver::mkReal(int64_t val) const { return d_tm.mkReal(val); }
7063 : :
7064 : 2 : Term Solver::mkReal(int64_t num, int64_t den) const
7065 : : {
7066 : 2 : return d_tm.mkReal(num, den);
7067 : : }
7068 : :
7069 : 4 : Term Solver::mkRegexpAll() const { return d_tm.mkRegexpAll(); }
7070 : :
7071 : 2 : Term Solver::mkRegexpNone() const { return d_tm.mkRegexpNone(); }
7072 : :
7073 : 2 : Term Solver::mkRegexpAllchar() const { return d_tm.mkRegexpAllchar(); }
7074 : :
7075 : 2 : Term Solver::mkEmptySet(const Sort& sort) const
7076 : : {
7077 : 2 : return d_tm.mkEmptySet(sort);
7078 : : }
7079 : :
7080 : 2 : Term Solver::mkEmptyBag(const Sort& sort) const
7081 : : {
7082 : 2 : return d_tm.mkEmptyBag(sort);
7083 : : }
7084 : :
7085 : 2 : Term Solver::mkSepEmp() const { return d_tm.mkSepEmp(); }
7086 : :
7087 : 2 : Term Solver::mkSepNil(const Sort& sort) const { return d_tm.mkSepNil(sort); }
7088 : :
7089 : 2 : Term Solver::mkString(const std::string& s, bool useEscSequences) const
7090 : : {
7091 : 2 : return d_tm.mkString(s, useEscSequences);
7092 : : }
7093 : :
7094 : 2 : Term Solver::mkString(const std::wstring& s) const { return d_tm.mkString(s); }
7095 : :
7096 : 2 : Term Solver::mkEmptySequence(const Sort& sort) const
7097 : : {
7098 : 2 : return d_tm.mkEmptySequence(sort);
7099 : : }
7100 : :
7101 : 2 : Term Solver::mkUniverseSet(const Sort& sort) const
7102 : : {
7103 : 2 : return d_tm.mkUniverseSet(sort);
7104 : : }
7105 : :
7106 : 10 : Term Solver::mkBitVector(uint32_t size, uint64_t val) const
7107 : : {
7108 : 10 : return d_tm.mkBitVector(size, val);
7109 : : }
7110 : :
7111 : 6 : Term Solver::mkBitVector(uint32_t size,
7112 : : const std::string& s,
7113 : : uint32_t base) const
7114 : : {
7115 : 6 : return d_tm.mkBitVector(size, s, base);
7116 : : }
7117 : :
7118 : 2 : Term Solver::mkFiniteFieldElem(const std::string& value,
7119 : : const Sort& sort,
7120 : : uint32_t base) const
7121 : : {
7122 : 2 : return d_tm.mkFiniteFieldElem(value, sort, base);
7123 : : }
7124 : :
7125 : 2 : Term Solver::mkConstArray(const Sort& sort, const Term& val) const
7126 : : {
7127 : 2 : return d_tm.mkConstArray(sort, val);
7128 : : }
7129 : :
7130 : 2 : Term Solver::mkFloatingPointPosInf(uint32_t exp, uint32_t sig) const
7131 : : {
7132 : 2 : return d_tm.mkFloatingPointPosInf(exp, sig);
7133 : : }
7134 : :
7135 : 2 : Term Solver::mkFloatingPointNegInf(uint32_t exp, uint32_t sig) const
7136 : : {
7137 : 2 : return d_tm.mkFloatingPointNegInf(exp, sig);
7138 : : }
7139 : :
7140 : 2 : Term Solver::mkFloatingPointNaN(uint32_t exp, uint32_t sig) const
7141 : : {
7142 : 2 : return d_tm.mkFloatingPointNaN(exp, sig);
7143 : : }
7144 : :
7145 : 2 : Term Solver::mkFloatingPointPosZero(uint32_t exp, uint32_t sig) const
7146 : : {
7147 : 2 : return d_tm.mkFloatingPointPosZero(exp, sig);
7148 : : }
7149 : :
7150 : 2 : Term Solver::mkFloatingPointNegZero(uint32_t exp, uint32_t sig) const
7151 : : {
7152 : 2 : return d_tm.mkFloatingPointNegZero(exp, sig);
7153 : : }
7154 : :
7155 : 2 : Term Solver::mkRoundingMode(RoundingMode rm) const
7156 : : {
7157 : 2 : return d_tm.mkRoundingMode(rm);
7158 : : }
7159 : :
7160 : 2 : Term Solver::mkFloatingPoint(uint32_t exp, uint32_t sig, const Term& val) const
7161 : : {
7162 : 2 : return d_tm.mkFloatingPoint(exp, sig, val);
7163 : : }
7164 : :
7165 : 2 : Term Solver::mkFloatingPoint(const Term& sign,
7166 : : const Term& exp,
7167 : : const Term& sig) const
7168 : : {
7169 : 2 : return d_tm.mkFloatingPoint(sign, exp, sig);
7170 : : }
7171 : :
7172 : 2 : Term Solver::mkCardinalityConstraint(const Sort& sort,
7173 : : uint32_t upperBound) const
7174 : : {
7175 : 2 : return d_tm.mkCardinalityConstraint(sort, upperBound);
7176 : : }
7177 : :
7178 : 2 : Term Solver::mkNullableLift(Kind kind, const std::vector<Term>& args) const
7179 : : {
7180 : 2 : return d_tm.mkNullableLift(kind, args);
7181 : : }
7182 : :
7183 : 2 : Term Solver::mkConst(const Sort& sort,
7184 : : const std::optional<std::string>& symbol) const
7185 : : {
7186 : 2 : return d_tm.mkConst(sort, symbol);
7187 : : }
7188 : :
7189 : 2 : Term Solver::mkVar(const Sort& sort,
7190 : : const std::optional<std::string>& symbol) const
7191 : : {
7192 : 2 : return d_tm.mkVar(sort, symbol);
7193 : : }
7194 : :
7195 : 12 : DatatypeConstructorDecl Solver::mkDatatypeConstructorDecl(
7196 : : const std::string& name)
7197 : : {
7198 : 12 : return d_tm.mkDatatypeConstructorDecl(name);
7199 : : }
7200 : :
7201 : 6 : DatatypeDecl Solver::mkDatatypeDecl(const std::string& name, bool isCoDatatype)
7202 : : {
7203 : 6 : return d_tm.mkDatatypeDecl(name, isCoDatatype);
7204 : : }
7205 : :
7206 : 2 : DatatypeDecl Solver::mkDatatypeDecl(const std::string& name,
7207 : : const std::vector<Sort>& params,
7208 : : bool isCoDatatype)
7209 : : {
7210 : 2 : return d_tm.mkDatatypeDecl(name, params, isCoDatatype);
7211 : : }
7212 : :
7213 : 2 : Term Solver::mkTerm(Kind kind, const std::vector<Term>& children) const
7214 : : {
7215 : 2 : return d_tm.mkTerm(kind, children);
7216 : : }
7217 : :
7218 : 2 : Term Solver::mkTerm(const Op& op, const std::vector<Term>& children) const
7219 : : {
7220 : 2 : return d_tm.mkTerm(op, children);
7221 : : }
7222 : :
7223 : 2 : Term Solver::mkTuple(const std::vector<Term>& terms) const
7224 : : {
7225 : 2 : return d_tm.mkTuple(terms);
7226 : : }
7227 : :
7228 : 12 : Term Solver::mkNullableSome(const Term& term) const
7229 : : {
7230 : 12 : return d_tm.mkNullableSome(term);
7231 : : }
7232 : :
7233 : 2 : Term Solver::mkNullableNull(const Sort& sort) const
7234 : : {
7235 : 2 : return d_tm.mkNullableNull(sort);
7236 : : }
7237 : :
7238 : 2 : Term Solver::mkNullableVal(const Term& term) const
7239 : : {
7240 : 2 : return d_tm.mkNullableVal(term);
7241 : : }
7242 : :
7243 : 2 : Term Solver::mkNullableIsNull(const Term& term) const
7244 : : {
7245 : 2 : return d_tm.mkNullableIsNull(term);
7246 : : }
7247 : :
7248 : 2 : Term Solver::mkNullableIsSome(const Term& term) const
7249 : : {
7250 : 2 : return d_tm.mkNullableIsSome(term);
7251 : : }
7252 : :
7253 : 2 : Op Solver::mkOp(Kind kind, const std::vector<uint32_t>& args) const
7254 : : {
7255 : 2 : return d_tm.mkOp(kind, args);
7256 : : }
7257 : :
7258 : 2 : Op Solver::mkOp(Kind kind, const std::initializer_list<uint32_t>& args) const
7259 : : {
7260 : 2 : return d_tm.mkOp(kind, args);
7261 : : }
7262 : :
7263 : 2 : Op Solver::mkOp(Kind kind, const std::string& arg) const
7264 : : {
7265 : 2 : return d_tm.mkOp(kind, arg);
7266 : : }
7267 : :
7268 : : /* Non-SMT-LIB commands */
7269 : : /* -------------------------------------------------------------------------- */
7270 : :
7271 : 97 : Term Solver::simplify(const Term& term, bool applySubs)
7272 : : {
7273 : : CVC5_API_TRY_CATCH_BEGIN;
7274 : 97 : CVC5_API_SOLVER_CHECK_TERM(term);
7275 : : //////// all checks before this line
7276 : 186 : Term res = Term(d_tm.d_nm, d_slv->simplify(*term.d_node, applySubs));
7277 [ - + ][ - + ]: 460 : AssertEqual(*res.getSort().d_type, *term.getSort().d_type);
[ - - ]
7278 : 184 : return res;
7279 : : ////////
7280 [ + - ][ - + ]: 97 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7281 [ - + ]: 5 : }
7282 : :
7283 : : /* SMT-LIB commands */
7284 : : /* -------------------------------------------------------------------------- */
7285 : :
7286 : 135495 : void Solver::assertFormula(const Term& term) const
7287 : : {
7288 : : CVC5_API_TRY_CATCH_BEGIN;
7289 : 135495 : CVC5_API_SOLVER_CHECK_TERM(term);
7290 : 406476 : CVC5_API_SOLVER_CHECK_TERM_WITH_SORT(term, getBooleanSort());
7291 : 135492 : ensureWellFormedTerm(term);
7292 : : //////// all checks before this line
7293 : 135492 : d_slv->assertFormula(*term.d_node);
7294 : : ////////
7295 [ + - ][ - + ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7296 : 135490 : }
7297 : :
7298 : 17888 : Result Solver::checkSat(void) const
7299 : : {
7300 : : CVC5_API_TRY_CATCH_BEGIN;
7301 [ + + ][ + + ]: 17892 : CVC5_API_CHECK(!d_slv->isQueryMade()
[ + + ][ + + ]
[ - - ]
7302 : : || d_slv->getOptions().base.incrementalSolving)
7303 : : << "cannot make multiple queries unless incremental solving is enabled "
7304 : : "(try --"
7305 : 4 : << internal::options::base::longName::incrementalSolving << ")";
7306 : : //////// all checks before this line
7307 : 17884 : return d_slv->checkSat();
7308 : : ////////
7309 [ + - ][ - + ]: 47 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7310 [ - + ]: 47 : }
7311 : :
7312 : 35 : Result Solver::checkSatAssuming(const Term& assumption) const
7313 : : {
7314 : : CVC5_API_TRY_CATCH_BEGIN;
7315 [ + + ][ + + ]: 36 : CVC5_API_CHECK(!d_slv->isQueryMade()
[ + + ][ + + ]
[ - - ]
7316 : : || d_slv->getOptions().base.incrementalSolving)
7317 : : << "cannot make multiple queries unless incremental solving is enabled "
7318 : : "(try --"
7319 : 1 : << internal::options::base::longName::incrementalSolving << ")";
7320 : 96 : CVC5_API_SOLVER_CHECK_TERM_WITH_SORT(assumption, getBooleanSort());
7321 : 31 : ensureWellFormedTerm(assumption);
7322 : : //////// all checks before this line
7323 : 31 : return d_slv->checkSat(*assumption.d_node);
7324 : : ////////
7325 [ + - ][ - + ]: 7 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7326 [ - + ]: 7 : }
7327 : :
7328 : 2852 : Result Solver::checkSatAssuming(const std::vector<Term>& assumptions) const
7329 : : {
7330 : : CVC5_API_TRY_CATCH_BEGIN;
7331 [ + + ][ - + ]: 2853 : CVC5_API_CHECK(!d_slv->isQueryMade() || assumptions.size() == 0
[ + + ][ + + ]
[ + + ][ + + ]
[ - - ]
7332 : : || d_slv->getOptions().base.incrementalSolving)
7333 : : << "cannot make multiple queries unless incremental solving is enabled "
7334 : : "(try --"
7335 : 1 : << internal::options::base::longName::incrementalSolving << ")";
7336 : 11617 : CVC5_API_SOLVER_CHECK_TERMS_WITH_SORT(assumptions, getBooleanSort());
7337 : 2849 : ensureWellFormedTerms(assumptions);
7338 : : //////// all checks before this line
7339 [ + + ]: 5768 : for (const Term& term : assumptions)
7340 : : {
7341 : 2920 : CVC5_API_SOLVER_CHECK_TERM(term);
7342 : : }
7343 : : std::vector<internal::Node> eassumptions =
7344 : 2848 : Term::termVectorToNodes(assumptions);
7345 : 5690 : return d_slv->checkSat(eassumptions);
7346 : : ////////
7347 [ + - ][ - + ]: 2858 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7348 [ - + ]: 10 : }
7349 : :
7350 : 23 : Sort Solver::declareDatatype(
7351 : : const std::string& symbol,
7352 : : const std::vector<DatatypeConstructorDecl>& ctors) const
7353 : : {
7354 : : CVC5_API_TRY_CATCH_BEGIN;
7355 [ + + ][ + + ]: 25 : CVC5_API_ARG_CHECK_EXPECTED(ctors.size() > 0, ctors)
[ - - ]
7356 : 2 : << "a datatype declaration with at least one constructor";
7357 [ + + ]: 51 : for (size_t i = 0, size = ctors.size(); i < size; i++)
7358 : : {
7359 : 34 : CVC5_API_SOLVER_CHECK_DTCTORDECL_AT_INDEX(ctors[i], ctorsr, i);
7360 [ + + ][ + + ]: 34 : CVC5_API_CHECK(!ctors[i].isResolved())
[ - - ]
7361 : 2 : << "cannot use a constructor for multiple datatypes";
7362 : : }
7363 : : //////// all checks before this line
7364 : 17 : DatatypeDecl dtdecl(d_tm.d_nm, symbol);
7365 [ + + ]: 47 : for (size_t i = 0, size = ctors.size(); i < size; i++)
7366 : : {
7367 : 30 : dtdecl.addConstructor(ctors[i]);
7368 : : }
7369 : 34 : return Sort(d_tm.d_nm, d_tm.d_nm->mkDatatypeType(*dtdecl.d_dtype));
7370 : : ////////
7371 [ + - ][ - - ]: 23 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7372 [ - + ]: 6 : }
7373 : :
7374 : 344543 : Term Solver::declareFun(const std::string& symbol,
7375 : : const std::vector<Sort>& sorts,
7376 : : const Sort& sort,
7377 : : bool fresh) const
7378 : : {
7379 : : CVC5_API_TRY_CATCH_BEGIN;
7380 : 421166 : CVC5_API_SOLVER_CHECK_DOMAIN_SORTS(sorts);
7381 : 344543 : CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(sort);
7382 : : //////// all checks before this line
7383 : :
7384 : 344535 : internal::TypeNode type = *sort.d_type;
7385 [ + + ]: 344535 : if (!sorts.empty())
7386 : : {
7387 : 42392 : std::vector<internal::TypeNode> types = Sort::sortVectorToTypeNodes(sorts);
7388 : 42392 : type = d_tm.d_nm->mkFunctionType(types, type);
7389 : 42392 : }
7390 : 344535 : internal::Node res = d_tm.mkConstHelper(type, symbol, fresh);
7391 : : // notify the solver engine of the declaration
7392 : 344535 : d_slv->declareConst(res);
7393 : 689070 : return Term(d_tm.d_nm, res);
7394 : : ////////
7395 [ + - ][ - - ]: 344543 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7396 [ - + ]: 8 : }
7397 : :
7398 : 11696 : Sort Solver::declareSort(const std::string& symbol,
7399 : : uint32_t arity,
7400 : : bool fresh) const
7401 : : {
7402 : : CVC5_API_TRY_CATCH_BEGIN;
7403 : : //////// all checks before this line
7404 : 11696 : internal::TypeNode type = d_tm.d_nm->mkSortConstructor(symbol, arity, fresh);
7405 : : // notify the solver engine of the declaration
7406 : 11696 : d_slv->declareSort(type);
7407 : 23392 : return Sort(d_tm.d_nm, type);
7408 : : ////////
7409 [ - - ][ - - ]: 11696 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7410 : : }
7411 : :
7412 : 7434 : Term Solver::defineFun(const std::string& symbol,
7413 : : const std::vector<Term>& bound_vars,
7414 : : const Sort& sort,
7415 : : const Term& term,
7416 : : bool global) const
7417 : : {
7418 : : CVC5_API_TRY_CATCH_BEGIN;
7419 : 7434 : CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(sort);
7420 : 7427 : CVC5_API_SOLVER_CHECK_TERM(term);
7421 : : // the sort of the body must match the return sort
7422 [ + + ][ - - ]: 14850 : CVC5_API_CHECK(term.d_node->getType() == *sort.d_type)
7423 : 2 : << "invalid sort of function body '" << term << "', expected '" << sort
7424 [ + + ][ + + ]: 7425 : << "', found '" << term.getSort() << "'";
[ - - ]
7425 : :
7426 : 7421 : std::vector<Sort> domain_sorts;
7427 [ + + ]: 19602 : for (size_t i = 0, n = bound_vars.size(); i < n; ++i)
7428 : : {
7429 : 12187 : CVC5_API_SOLVER_CHECK_BOUND_VAR_AT_INDEX(bound_vars[i], bound_vars, i);
7430 : 12181 : domain_sorts.push_back(bound_vars[i].getSort());
7431 : : }
7432 : : Sort fun_sort =
7433 : 7415 : domain_sorts.empty()
7434 : : ? sort
7435 : 4529 : : Sort(d_tm.d_nm,
7436 [ - - ]: 9058 : d_tm.d_nm->mkFunctionType(
7437 : 25531 : Sort::sortVectorToTypeNodes(domain_sorts), *sort.d_type));
7438 : 7415 : Term fun = d_tm.mkConst(fun_sort, symbol);
7439 : 19594 : CVC5_API_SOLVER_CHECK_BOUND_VARS_DEF_FUN_SORTS(bound_vars, domain_sorts);
7440 : : //////// all checks before this line
7441 : :
7442 : 22254 : d_slv->defineFunction(
7443 : 22248 : *fun.d_node, Term::termVectorToNodes(bound_vars), *term.d_node, global);
7444 : 14824 : return fun;
7445 : : ////////
7446 [ + - ][ - + ]: 7449 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7447 [ - + ]: 22 : }
7448 : :
7449 : 30 : Term Solver::defineFunRec(const std::string& symbol,
7450 : : const std::vector<Term>& bound_vars,
7451 : : const Sort& sort,
7452 : : const Term& term,
7453 : : bool global) const
7454 : : {
7455 : : CVC5_API_TRY_CATCH_BEGIN;
7456 : :
7457 [ + + ][ + + ]: 34 : CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
[ - - ]
7458 : 2 : << "recursive function definitions require a logic with quantifiers";
7459 [ - + ][ - + ]: 28 : CVC5_API_CHECK(
[ - - ]
7460 : : d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
7461 : : << "recursive function definitions require a logic with uninterpreted "
7462 : 0 : "functions";
7463 : :
7464 : 28 : CVC5_API_SOLVER_CHECK_TERM(term);
7465 : 24 : CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(sort);
7466 [ + + ][ + + ]: 23 : CVC5_API_CHECK(term.d_node->getType() == *sort.d_type)
[ - - ]
7467 : 2 : << "invalid sort of function body '" << term << "', expected '" << sort
7468 : 2 : << "'";
7469 : :
7470 : 17 : std::vector<Sort> domain_sorts;
7471 [ + + ]: 33 : for (size_t i = 0, n = bound_vars.size(); i < n; ++i)
7472 : : {
7473 : 22 : CVC5_API_SOLVER_CHECK_BOUND_VAR_AT_INDEX(bound_vars[i], bound_vars, i);
7474 : 16 : domain_sorts.push_back(bound_vars[i].getSort());
7475 : : }
7476 : : Sort fun_sort =
7477 : 11 : domain_sorts.empty()
7478 : : ? sort
7479 : 6 : : Sort(d_tm.d_nm,
7480 [ - - ]: 12 : d_tm.d_nm->mkFunctionType(
7481 : 35 : Sort::sortVectorToTypeNodes(domain_sorts), *sort.d_type));
7482 : 11 : Term fun = d_tm.mkConst(fun_sort, symbol);
7483 : 23 : CVC5_API_SOLVER_CHECK_BOUND_VARS_DEF_FUN_SORTS(bound_vars, domain_sorts);
7484 : : //////// all checks before this line
7485 : :
7486 : 33 : d_slv->defineFunctionRec(
7487 : 33 : *fun.d_node, Term::termVectorToNodes(bound_vars), *term.d_node, global);
7488 : :
7489 : 22 : return fun;
7490 : : ////////
7491 [ + - ][ - - ]: 36 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7492 [ - + ]: 19 : }
7493 : :
7494 : 19 : Term Solver::defineFunRec(const Term& fun,
7495 : : const std::vector<Term>& bound_vars,
7496 : : const Term& term,
7497 : : bool global) const
7498 : : {
7499 : : CVC5_API_TRY_CATCH_BEGIN;
7500 : :
7501 [ + + ][ + + ]: 23 : CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
[ - - ]
7502 : 2 : << "recursive function definitions require a logic with quantifiers";
7503 [ - + ][ - + ]: 17 : CVC5_API_CHECK(
[ - - ]
7504 : : d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
7505 : : << "recursive function definitions require a logic with uninterpreted "
7506 : 0 : "functions";
7507 : :
7508 : 17 : CVC5_API_SOLVER_CHECK_TERM(fun);
7509 : 15 : CVC5_API_SOLVER_CHECK_TERM(term);
7510 [ + + ]: 15 : if (fun.getSort().isFunction())
7511 : : {
7512 : 13 : std::vector<Sort> domain_sorts = fun.getSort().getFunctionDomainSorts();
7513 : 30 : CVC5_API_SOLVER_CHECK_BOUND_VARS_DEF_FUN_SORTS(bound_vars, domain_sorts);
7514 : 8 : Sort codomain = fun.getSort().getFunctionCodomainSort();
7515 : 16 : CVC5_API_CHECK(*codomain.d_type == term.d_node->getType())
7516 : 4 : << "invalid sort of function body '" << term << "', expected '"
7517 : 4 : << codomain << "'";
7518 : 17 : }
7519 : : else
7520 : : {
7521 : 4 : CVC5_API_SOLVER_CHECK_BOUND_VARS(bound_vars);
7522 [ + - ][ + - ]: 4 : CVC5_API_ARG_CHECK_EXPECTED(bound_vars.size() == 0, fun)
[ - - ]
7523 : 2 : << "function or nullary symbol";
7524 : : }
7525 : : //////// all checks before this line
7526 : :
7527 : 4 : std::vector<internal::Node> ebound_vars = Term::termVectorToNodes(bound_vars);
7528 : 4 : d_slv->defineFunctionRec(*fun.d_node, ebound_vars, *term.d_node, global);
7529 : 8 : return fun;
7530 : : ////////
7531 [ + - ][ - - ]: 19 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7532 [ - + ]: 15 : }
7533 : :
7534 : 679 : void Solver::defineFunsRec(const std::vector<Term>& funs,
7535 : : const std::vector<std::vector<Term>>& bound_vars,
7536 : : const std::vector<Term>& terms,
7537 : : bool global) const
7538 : : {
7539 : : CVC5_API_TRY_CATCH_BEGIN;
7540 : :
7541 [ + + ][ + + ]: 689 : CVC5_API_CHECK(d_slv->getUserLogicInfo().isQuantified())
[ - - ]
7542 : 5 : << "recursive function definitions require a logic with quantifiers";
7543 [ - + ][ - + ]: 674 : CVC5_API_CHECK(
[ - - ]
7544 : : d_slv->getUserLogicInfo().isTheoryEnabled(internal::theory::THEORY_UF))
7545 : : << "recursive function definitions require a logic with uninterpreted "
7546 : 0 : "functions";
7547 : 1487 : CVC5_API_SOLVER_CHECK_TERMS(funs);
7548 : 1477 : CVC5_API_SOLVER_CHECK_TERMS(terms);
7549 : :
7550 : 667 : size_t funs_size = funs.size();
7551 [ - + ][ - + ]: 667 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(funs_size == bound_vars.size(), bound_vars)
[ - - ]
7552 : 0 : << "'" << funs_size << "'";
7553 [ - + ][ - + ]: 667 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(funs_size == terms.size(), terms)
[ - - ]
7554 : 0 : << "'" << funs_size << "'";
7555 : :
7556 [ + + ]: 1446 : for (size_t j = 0; j < funs_size; ++j)
7557 : : {
7558 : 794 : const Term& fun = funs[j];
7559 : 794 : const std::vector<Term>& bvars = bound_vars[j];
7560 : 794 : const Term& term = terms[j];
7561 : :
7562 [ - + ][ - + ]: 794 : CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED(
[ - - ]
7563 : : d_tm.d_nm == fun.d_nm, "function", funs, j)
7564 : 0 : << "function associated with the node manager of this solver object";
7565 [ - + ][ - + ]: 794 : CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED(
[ - - ]
7566 : : d_tm.d_nm == term.d_nm, "term", terms, j)
7567 : 0 : << "term associated with the node manager of this solver object";
7568 : :
7569 [ + + ]: 794 : if (fun.getSort().isFunction())
7570 : : {
7571 : 752 : std::vector<Sort> domain_sorts = fun.getSort().getFunctionDomainSorts();
7572 : 2218 : CVC5_API_SOLVER_CHECK_BOUND_VARS(bvars);
7573 : 2207 : CVC5_API_SOLVER_CHECK_BOUND_VARS_DEF_FUN_SORTS(bvars, domain_sorts);
7574 : 741 : Sort codomain = fun.getSort().getFunctionCodomainSort();
7575 [ + + ][ + + ]: 745 : CVC5_API_ARG_AT_INDEX_CHECK_EXPECTED(
[ - - ]
7576 : : codomain == term.getSort(), "sort of function body", terms, j)
7577 : 2 : << "'" << codomain << "'";
7578 : 754 : }
7579 : : else
7580 : : {
7581 : 44 : CVC5_API_SOLVER_CHECK_BOUND_VARS(bvars);
7582 [ + + ][ + + ]: 44 : CVC5_API_ARG_CHECK_EXPECTED(bvars.size() == 0, fun)
[ - - ]
7583 : 2 : << "function or nullary symbol";
7584 : : }
7585 : : }
7586 : : //////// all checks before this line
7587 : 652 : std::vector<internal::Node> efuns = Term::termVectorToNodes(funs);
7588 : 652 : std::vector<std::vector<internal::Node>> ebound_vars;
7589 [ + + ]: 1426 : for (const auto& v : bound_vars)
7590 : : {
7591 : 774 : ebound_vars.push_back(Term::termVectorToNodes(v));
7592 : : }
7593 : 652 : std::vector<internal::Node> nodes = Term::termVectorToNodes(terms);
7594 : 652 : d_slv->defineFunctionsRec(efuns, ebound_vars, nodes, global);
7595 : : ////////
7596 [ + - ][ - + ]: 682 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
7597 : 651 : }
7598 : :
7599 : 4 : std::vector<Term> Solver::getAssertions(void) const
7600 : : {
7601 : : CVC5_API_TRY_CATCH_BEGIN;
7602 : : //////// all checks before this line
7603 : 4 : std::vector<internal::Node> assertions = d_slv->getAssertions();
7604 : : /* Can not use
7605 : : * return std::vector<Term>(assertions.begin(), assertions.end());
7606 : : * here since constructor is private */
7607 : 8 : return Term::nodeVectorToTerms(d_tm.d_nm, assertions);
7608 : : ////////
7609 [ - - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7610 : : }
7611 : :
7612 : 38 : std::string Solver::getInfo(const std::string& flag) const
7613 : : {
7614 : : CVC5_API_TRY_CATCH_BEGIN;
7615 [ + + ][ + + ]: 47 : CVC5_API_UNSUPPORTED_CHECK(d_slv->isValidGetInfoFlag(flag))
[ - - ]
7616 : 9 : << "unrecognized flag: " << flag << ".";
7617 : : //////// all checks before this line
7618 : 29 : return d_slv->getInfo(flag);
7619 : : ////////
7620 [ + - ][ + - ]: 13 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7621 [ - + ]: 13 : }
7622 : :
7623 : 1283954 : std::string Solver::getOption(const std::string& option) const
7624 : : {
7625 : : try
7626 : : {
7627 : 2567905 : return d_slv->getOption(option);
7628 : : }
7629 [ - + ]: 3 : catch (internal::OptionException& e)
7630 : : {
7631 : 3 : throw CVC5ApiUnsupportedException(e.getMessage());
7632 : 3 : }
7633 : : }
7634 : :
7635 : : // Supports a visitor from a list of lambdas
7636 : : // Taken from https://en.cppreference.com/w/cpp/utility/variant/visit
7637 : : template <class... Ts>
7638 : : struct overloaded : Ts...
7639 : : {
7640 : : using Ts::operator()...;
7641 : : };
7642 : : template <class... Ts>
7643 : : overloaded(Ts...) -> overloaded<Ts...>;
7644 : :
7645 : 74579 : OptionInfo& OptionInfo::operator=(OptionInfo&& info)
7646 : : {
7647 : 74579 : name = std::move(info.name);
7648 : 74579 : aliases = std::move(info.aliases);
7649 : 74579 : noSupports = std::move(info.noSupports);
7650 : 74579 : setByUser = std::move(info.setByUser);
7651 : 74579 : category = std::move(info.category);
7652 : 74579 : valueInfo = std::move(info.valueInfo);
7653 : 74579 : return *this;
7654 : : }
7655 : :
7656 : 562663 : bool OptionInfo::boolValue() const
7657 : : {
7658 : : CVC5_API_TRY_CATCH_BEGIN;
7659 [ - + ][ - + ]: 562663 : CVC5_API_RECOVERABLE_CHECK(std::holds_alternative<ValueInfo<bool>>(valueInfo))
[ - - ]
7660 : 0 : << name << " is not a bool option";
7661 : : //////// all checks before this line
7662 : 562663 : return std::get<ValueInfo<bool>>(valueInfo).currentValue;
7663 : : ////////
7664 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7665 : : }
7666 : 23 : std::string OptionInfo::stringValue() const
7667 : : {
7668 : : CVC5_API_TRY_CATCH_BEGIN;
7669 [ - + ][ - + ]: 23 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
7670 : : std::holds_alternative<ValueInfo<std::string>>(valueInfo))
7671 : 0 : << name << " is not a string option";
7672 : : //////// all checks before this line
7673 : 23 : return std::get<ValueInfo<std::string>>(valueInfo).currentValue;
7674 : : ////////
7675 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7676 [ - - ]: 0 : }
7677 : 2 : int64_t OptionInfo::intValue() const
7678 : : {
7679 : : CVC5_API_TRY_CATCH_BEGIN;
7680 [ - + ][ - + ]: 2 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
7681 : : std::holds_alternative<NumberInfo<int64_t>>(valueInfo))
7682 : 0 : << name << " is not an int option";
7683 : : //////// all checks before this line
7684 : 2 : return std::get<NumberInfo<int64_t>>(valueInfo).currentValue;
7685 : : ////////
7686 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7687 : : }
7688 : 24693 : uint64_t OptionInfo::uintValue() const
7689 : : {
7690 : : CVC5_API_TRY_CATCH_BEGIN;
7691 [ - + ][ - + ]: 24693 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
7692 : : std::holds_alternative<NumberInfo<uint64_t>>(valueInfo))
7693 : 0 : << name << " is not a uint option";
7694 : : //////// all checks before this line
7695 : 24693 : return std::get<NumberInfo<uint64_t>>(valueInfo).currentValue;
7696 : : ////////
7697 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7698 : : }
7699 : 2 : double OptionInfo::doubleValue() const
7700 : : {
7701 : : CVC5_API_TRY_CATCH_BEGIN;
7702 [ - + ][ - + ]: 2 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
7703 : : std::holds_alternative<NumberInfo<double>>(valueInfo))
7704 : 0 : << name << " is not a double option";
7705 : : //////// all checks before this line
7706 : 2 : return std::get<NumberInfo<double>>(valueInfo).currentValue;
7707 : : ////////
7708 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7709 : : }
7710 : :
7711 : 15 : std::string OptionInfo::toString() const
7712 : : {
7713 : 15 : std::stringstream os;
7714 : 15 : os << "OptionInfo{ " << name;
7715 [ + + ]: 15 : if (setByUser)
7716 : : {
7717 : 2 : os << " | set by user";
7718 : : }
7719 [ + + ]: 15 : if (!aliases.empty())
7720 : : {
7721 : 4 : internal::container_to_stream(os, aliases, ", ", "", ", ");
7722 : : }
7723 [ - + ]: 15 : if (!noSupports.empty())
7724 : : {
7725 : 0 : internal::container_to_stream(os, noSupports, ", ", "", ", ");
7726 : : }
7727 : 14 : auto printNum = [&os](const std::string& type, const auto& vi) {
7728 : 6 : os << " | " << type << " | " << vi.currentValue << " | default "
7729 : 6 : << vi.defaultValue;
7730 [ + + ][ - + ]: 6 : if (vi.minimum || vi.maximum)
[ + + ]
7731 : : {
7732 : 2 : os << " |";
7733 [ + - ]: 2 : if (vi.minimum)
7734 : : {
7735 : 2 : os << " " << *vi.minimum << " <=";
7736 : : }
7737 : 2 : os << " x";
7738 [ + - ]: 2 : if (vi.maximum)
7739 : : {
7740 : 2 : os << " <= " << *vi.maximum;
7741 : : }
7742 : : }
7743 : 21 : };
7744 : 0 : std::visit(overloaded{
7745 : 3 : [&os](const OptionInfo::VoidInfo&) { os << " | void"; },
7746 : 2 : [&os](const OptionInfo::ValueInfo<bool>& vi) {
7747 : 2 : os << std::boolalpha << " | bool | " << vi.currentValue
7748 : 2 : << " | default " << vi.defaultValue << std::noboolalpha;
7749 : 2 : },
7750 : 2 : [&os](const OptionInfo::ValueInfo<std::string>& vi) {
7751 : 2 : os << " | string | \"" << vi.currentValue
7752 : 2 : << "\" | default \"" << vi.defaultValue << "\"";
7753 : 2 : },
7754 : 2 : [&printNum](const OptionInfo::NumberInfo<int64_t>& vi) {
7755 : 2 : printNum("int64_t", vi);
7756 : 2 : },
7757 : 2 : [&printNum](const OptionInfo::NumberInfo<uint64_t>& vi) {
7758 : 2 : printNum("uint64_t", vi);
7759 : 2 : },
7760 : 2 : [&printNum](const OptionInfo::NumberInfo<double>& vi) {
7761 : 2 : printNum("double", vi);
7762 : 2 : },
7763 : 4 : [&os](const OptionInfo::ModeInfo& vi) {
7764 : 2 : os << " | mode | " << vi.currentValue << " | default "
7765 : 2 : << vi.defaultValue << " | modes: ";
7766 : 2 : internal::container_to_stream(os, vi.modes, "", "", ", ");
7767 : 2 : },
7768 : : },
7769 : 15 : valueInfo);
7770 : 15 : os << " }";
7771 : 30 : return os.str();
7772 : 15 : }
7773 : :
7774 : 8 : std::ostream& operator<<(std::ostream& os, const OptionInfo& oi)
7775 : : {
7776 : 8 : os << oi.toString();
7777 : 8 : return os;
7778 : : }
7779 : :
7780 : 2 : std::vector<std::string> Solver::getOptionNames() const
7781 : : {
7782 : : CVC5_API_TRY_CATCH_BEGIN;
7783 : : //////// all checks before this line
7784 : 4 : return internal::options::getNames();
7785 : : ////////
7786 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7787 : : }
7788 : :
7789 : : // Helper function to convert internal category to external enum
7790 : 1578284 : modes::OptionCategory convertOptionCategory(
7791 : : internal::options::OptionInfo::Category internalCategory)
7792 : : {
7793 [ + + ][ + + ]: 1578284 : switch (internalCategory)
7794 : : {
7795 : 300572 : case internal::options::OptionInfo::Category::REGULAR:
7796 : 300572 : return modes::OptionCategory::REGULAR;
7797 : 306664 : case internal::options::OptionInfo::Category::EXPERT:
7798 : 306664 : return modes::OptionCategory::EXPERT;
7799 : 970896 : case internal::options::OptionInfo::Category::COMMON:
7800 : 970896 : return modes::OptionCategory::COMMON;
7801 : 152 : default:
7802 [ - + ][ - + ]: 152 : Assert(internalCategory
[ - - ]
7803 : : == internal::options::OptionInfo::Category::UNDOCUMENTED);
7804 : 152 : return modes::OptionCategory::UNDOCUMENTED;
7805 : : }
7806 : : }
7807 : :
7808 : 789144 : OptionInfo Solver::getOptionInfo(const std::string& option) const
7809 : : {
7810 : : CVC5_API_TRY_CATCH_BEGIN;
7811 : : //////// all checks before this line
7812 : 789144 : auto info = internal::options::getInfo(d_slv->getOptions(), option);
7813 [ - + ][ - + ]: 789142 : CVC5_API_CHECK(info.name != "")
[ - - ]
7814 : 0 : << "Querying invalid or unknown option " << option;
7815 : : return std::visit(
7816 : 0 : overloaded{
7817 : 3835 : [&info](const internal::options::OptionInfo::VoidInfo&) {
7818 : 767 : auto cat = convertOptionCategory(info.category);
7819 : 767 : return OptionInfo{info.name,
7820 : 767 : info.aliases,
7821 : 767 : info.noSupports,
7822 : 767 : info.setByUser,
7823 : 767 : cat == modes::OptionCategory::EXPERT,
7824 : 767 : cat == modes::OptionCategory::REGULAR,
7825 : 1534 : convertOptionCategory(info.category),
7826 : 767 : OptionInfo::VoidInfo{}};
7827 : : },
7828 : 3651775 : [&info](const internal::options::OptionInfo::ValueInfo<bool>& vi) {
7829 : 730355 : auto cat = convertOptionCategory(info.category);
7830 : : return OptionInfo{
7831 : 730355 : info.name,
7832 : 730355 : info.aliases,
7833 : 730355 : info.noSupports,
7834 : 730355 : info.setByUser,
7835 : 730355 : cat == modes::OptionCategory::EXPERT,
7836 : 730355 : cat == modes::OptionCategory::REGULAR,
7837 : 1460710 : convertOptionCategory(info.category),
7838 : 730355 : OptionInfo::ValueInfo<bool>{vi.defaultValue, vi.currentValue}};
7839 : : },
7840 : 25010 : [&info](
7841 : 125050 : const internal::options::OptionInfo::ValueInfo<std::string>& vi) {
7842 : 25010 : auto cat = convertOptionCategory(info.category);
7843 : 25010 : return OptionInfo{info.name,
7844 : 25010 : info.aliases,
7845 : 25010 : info.noSupports,
7846 : 25010 : info.setByUser,
7847 : 25010 : cat == modes::OptionCategory::EXPERT,
7848 : 25010 : cat == modes::OptionCategory::REGULAR,
7849 : 50020 : convertOptionCategory(info.category),
7850 : 25010 : OptionInfo::ValueInfo<std::string>{
7851 : 25010 : vi.defaultValue, vi.currentValue}};
7852 : : },
7853 : 1435 : [&info](
7854 : 7175 : const internal::options::OptionInfo::NumberInfo<int64_t>& vi) {
7855 : 1435 : auto cat = convertOptionCategory(info.category);
7856 : : return OptionInfo{
7857 : 1435 : info.name,
7858 : 1435 : info.aliases,
7859 : 1435 : info.noSupports,
7860 : 1435 : info.setByUser,
7861 : 1435 : cat == modes::OptionCategory::EXPERT,
7862 : 1435 : cat == modes::OptionCategory::REGULAR,
7863 : 2870 : convertOptionCategory(info.category),
7864 : 1435 : OptionInfo::NumberInfo<int64_t>{
7865 : 1435 : vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
7866 : : },
7867 : 26722 : [&info](
7868 : 133610 : const internal::options::OptionInfo::NumberInfo<uint64_t>& vi) {
7869 : 26722 : auto cat = convertOptionCategory(info.category);
7870 : : return OptionInfo{
7871 : 26722 : info.name,
7872 : 26722 : info.aliases,
7873 : 26722 : info.noSupports,
7874 : 26722 : info.setByUser,
7875 : 26722 : cat == modes::OptionCategory::EXPERT,
7876 : 26722 : cat == modes::OptionCategory::REGULAR,
7877 : 53444 : convertOptionCategory(info.category),
7878 : 26722 : OptionInfo::NumberInfo<uint64_t>{
7879 : 26722 : vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
7880 : : },
7881 : 1445 : [&info](const internal::options::OptionInfo::NumberInfo<double>& vi) {
7882 : 289 : auto cat = convertOptionCategory(info.category);
7883 : : return OptionInfo{
7884 : 289 : info.name,
7885 : 289 : info.aliases,
7886 : 289 : info.noSupports,
7887 : 289 : info.setByUser,
7888 : 289 : cat == modes::OptionCategory::EXPERT,
7889 : 289 : cat == modes::OptionCategory::REGULAR,
7890 : 578 : convertOptionCategory(info.category),
7891 : 289 : OptionInfo::NumberInfo<double>{
7892 : 289 : vi.defaultValue, vi.currentValue, vi.minimum, vi.maximum}};
7893 : : },
7894 : 22820 : [&info](const internal::options::OptionInfo::ModeInfo& vi) {
7895 : 4564 : auto cat = convertOptionCategory(info.category);
7896 : 4564 : return OptionInfo{info.name,
7897 : 4564 : info.aliases,
7898 : 4564 : info.noSupports,
7899 : 4564 : info.setByUser,
7900 : 4564 : cat == modes::OptionCategory::EXPERT,
7901 : 4564 : cat == modes::OptionCategory::REGULAR,
7902 : 9128 : convertOptionCategory(info.category),
7903 : 4564 : OptionInfo::ModeInfo{
7904 : 4564 : vi.defaultValue, vi.currentValue, vi.modes}};
7905 : : },
7906 : : },
7907 : 1578284 : info.valueInfo);
7908 : : ////////
7909 [ - + ][ - - ]: 789144 : CVC5_API_TRY_CATCH_END;
[ - + ][ - + ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7910 [ - + ]: 2 : }
7911 : :
7912 : 688959 : DriverOptions Solver::getDriverOptions() const { return DriverOptions(*this); }
7913 : :
7914 : 28 : std::vector<Term> Solver::getUnsatAssumptions(void) const
7915 : : {
7916 : : CVC5_API_TRY_CATCH_BEGIN;
7917 [ + + ][ + + ]: 32 : CVC5_API_CHECK(d_slv->getOptions().smt.unsatAssumptions)
[ - - ]
7918 : : << "cannot get unsat assumptions unless explicitly enabled "
7919 : : "(try --"
7920 : 4 : << internal::options::smt::longName::unsatAssumptions << ")";
7921 [ + + ][ + + ]: 26 : CVC5_API_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
[ - - ]
7922 : 2 : << "cannot get unsat assumptions unless in unsat mode.";
7923 : : //////// all checks before this line
7924 : :
7925 : 22 : std::vector<internal::Node> uassumptions = d_slv->getUnsatAssumptions();
7926 : : /* Cannot use
7927 : : * return std::vector<Term>(uassumptions.begin(), uassumptions.end());
7928 : : * here since constructor is private */
7929 : 22 : std::vector<Term> res;
7930 [ + + ]: 41 : for (const internal::Node& n : uassumptions)
7931 : : {
7932 : 19 : res.push_back(Term(d_tm.d_nm, n));
7933 : : }
7934 : 44 : return res;
7935 : : ////////
7936 [ + - ][ - - ]: 28 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7937 [ - + ]: 6 : }
7938 : :
7939 : 42 : std::vector<Term> Solver::getUnsatCore(void) const
7940 : : {
7941 : : CVC5_API_TRY_CATCH_BEGIN;
7942 [ + + ][ + + ]: 47 : CVC5_API_CHECK(d_slv->getOptions().smt.produceUnsatCores)
[ - - ]
7943 : : << "cannot get unsat core unless explicitly enabled "
7944 : : "(try --"
7945 : 5 : << internal::options::smt::longName::produceUnsatCores << ")";
7946 [ + + ][ + + ]: 43 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
[ - - ]
7947 : 6 : << "cannot get unsat core unless in unsat mode.";
7948 : : //////// all checks before this line
7949 : 31 : internal::UnsatCore core = d_slv->getUnsatCore();
7950 : : /* Can not use
7951 : : * return std::vector<Term>(core.begin(), core.end());
7952 : : * here since constructor is private */
7953 : 31 : std::vector<Term> res;
7954 [ + + ]: 90 : for (const internal::Node& e : core)
7955 : : {
7956 : 59 : res.push_back(Term(d_tm.d_nm, e));
7957 : : }
7958 : 62 : return res;
7959 : : ////////
7960 [ + - ][ - - ]: 42 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7961 [ - + ]: 11 : }
7962 : :
7963 : 12 : std::vector<Term> Solver::getUnsatCoreLemmas(void) const
7964 : : {
7965 : : CVC5_API_TRY_CATCH_BEGIN;
7966 [ - + ][ - + ]: 12 : CVC5_API_CHECK(d_slv->getOptions().smt.produceUnsatCores)
[ - - ]
7967 : : << "cannot get unsat core lemmas unless explicitly enabled "
7968 : : "(try --"
7969 : 0 : << internal::options::smt::longName::produceUnsatCores << ")";
7970 [ - + ][ - + ]: 12 : CVC5_API_CHECK(d_slv->getOptions().smt.unsatCoresMode
[ - - ]
7971 : : == internal::options::UnsatCoresMode::SAT_PROOF)
7972 : 0 : << "cannot get unsat core lemmas unless SAT proofs are enabled";
7973 [ + + ][ + + ]: 14 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
[ - - ]
7974 : 2 : << "cannot get unsat core unless in unsat mode.";
7975 : : //////// all checks before this line
7976 : 10 : std::vector<internal::Node> lemmas = d_slv->getUnsatCoreLemmas();
7977 : : /* Can not use
7978 : : * return std::vector<Term>(assertions.begin(), assertions.end());
7979 : : * here since constructor is private */
7980 : 20 : return Term::nodeVectorToTerms(d_tm.d_nm, lemmas);
7981 : : ////////
7982 [ + - ][ - - ]: 12 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
7983 [ - + ]: 2 : }
7984 : :
7985 : 23 : std::map<Term, Term> Solver::getDifficulty() const
7986 : : {
7987 : : CVC5_API_TRY_CATCH_BEGIN;
7988 [ + + ][ + + ]: 25 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT
[ + + ][ - + ]
[ + + ][ + + ]
[ - - ]
7989 : : || d_slv->getSmtMode() == internal::SmtMode::SAT
7990 : : || d_slv->getSmtMode()
7991 : : == internal::SmtMode::SAT_UNKNOWN)
7992 : 2 : << "cannot get difficulty unless after a UNSAT, SAT or UNKNOWN response.";
7993 : : //////// all checks before this line
7994 : 21 : std::map<Term, Term> res;
7995 : 21 : std::map<internal::Node, internal::Node> dmap;
7996 : 21 : d_slv->getDifficultyMap(dmap);
7997 [ + + ]: 48 : for (const std::pair<const internal::Node, internal::Node>& d : dmap)
7998 : : {
7999 : 29 : res[Term(d_tm.d_nm, d.first)] = Term(d_tm.d_nm, d.second);
8000 : : }
8001 : 38 : return res;
8002 : : ////////
8003 [ + - ][ - + ]: 27 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8004 [ - + ]: 4 : }
8005 : :
8006 : 19 : std::pair<Result, std::vector<Term>> Solver::getTimeoutCore() const
8007 : : {
8008 : : CVC5_API_TRY_CATCH_BEGIN;
8009 [ - + ][ - + ]: 19 : CVC5_API_CHECK(d_slv->getOptions().smt.produceUnsatCores)
[ - - ]
8010 : : << "cannot get timeout core unless unsat cores are enabled "
8011 : : "(try --"
8012 : 0 : << internal::options::smt::longName::produceUnsatCores << ")";
8013 : : //////// all checks before this line
8014 : 19 : return getTimeoutCoreHelper({});
8015 : : ////////
8016 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8017 [ - - ]: 0 : }
8018 : :
8019 : 13 : std::pair<Result, std::vector<Term>> Solver::getTimeoutCoreAssuming(
8020 : : const std::vector<Term>& assumptions) const
8021 : : {
8022 : : CVC5_API_TRY_CATCH_BEGIN;
8023 [ + + ][ + + ]: 14 : CVC5_API_CHECK(!assumptions.empty())
[ - - ]
8024 : 1 : << "cannot get timeout core assuming an empty set of assumptions";
8025 [ - + ][ - + ]: 12 : CVC5_API_CHECK(d_slv->getOptions().smt.produceUnsatCores)
[ - - ]
8026 : : << "cannot get timeout core unless unsat cores are enabled "
8027 : : "(try --"
8028 : 0 : << internal::options::smt::longName::produceUnsatCores << ")";
8029 : : //////// all checks before this line
8030 : 12 : return getTimeoutCoreHelper(assumptions);
8031 : : ////////
8032 [ + - ][ - - ]: 1 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8033 [ - + ]: 1 : }
8034 : :
8035 : 31 : std::pair<Result, std::vector<Term>> Solver::getTimeoutCoreHelper(
8036 : : const std::vector<Term>& assumptions) const
8037 : : {
8038 : 31 : std::vector<Term> res;
8039 : : std::pair<internal::Result, std::vector<internal::Node>> resi =
8040 : 31 : d_slv->getTimeoutCore(Term::termVectorToNodes(assumptions));
8041 [ + + ]: 60 : for (internal::Node& c : resi.second)
8042 : : {
8043 : 29 : res.push_back(Term(d_tm.d_nm, c));
8044 : : }
8045 : 93 : return std::pair<Result, std::vector<Term>>(Result(resi.first), res);
8046 : 31 : }
8047 : :
8048 : 5365 : std::vector<Proof> Solver::getProof(modes::ProofComponent c) const
8049 : : {
8050 : : CVC5_API_TRY_CATCH_BEGIN;
8051 [ - + ][ - + ]: 5365 : CVC5_API_CHECK(d_slv->getOptions().smt.produceProofs)
[ - - ]
8052 : : << "cannot get proof unless proofs are enabled (try --"
8053 : 0 : << internal::options::smt::longName::produceProofs << ")";
8054 [ - + ][ - + ]: 5365 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT)
[ - - ]
8055 : 0 : << "cannot get proof unless in unsat mode.";
8056 : : //////// all checks before this line
8057 : : std::vector<std::shared_ptr<internal::ProofNode>> proof_nodes =
8058 : 5365 : d_slv->getProof(c);
8059 : 5364 : std::vector<Proof> proofs;
8060 [ + + ]: 10755 : for (auto& p : proof_nodes)
8061 : : {
8062 : 5391 : proofs.push_back(Proof(d_tm.d_nm, p));
8063 : : }
8064 : 10728 : return proofs;
8065 : : ////////
8066 [ - - ][ - + ]: 5365 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8067 [ - + ]: 1 : }
8068 : :
8069 : 5373 : std::string Solver::proofToString(
8070 : : Proof proof,
8071 : : modes::ProofFormat format,
8072 : : const std::map<cvc5::Term, std::string>& assertionNames) const
8073 : : {
8074 : : CVC5_API_TRY_CATCH_BEGIN;
8075 : : //////// all checks before this line
8076 : 5373 : std::ostringstream ss;
8077 : : // convert the map's domain to use nodes rather than terms
8078 : 5373 : std::map<internal::Node, std::string> nodeAssertionNames;
8079 [ + + ]: 9041 : for (const auto& p : assertionNames)
8080 : : {
8081 : 3668 : nodeAssertionNames[p.first.getNode()] = p.second;
8082 : : }
8083 : 5373 : this->d_slv->printProof(ss, proof.d_proofNode, format, nodeAssertionNames);
8084 : 10746 : return ss.str();
8085 : : ////////
8086 [ - - ][ - - ]: 5373 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8087 : : }
8088 : :
8089 : 22 : std::vector<Term> Solver::getLearnedLiterals(modes::LearnedLitType t) const
8090 : : {
8091 : : CVC5_API_TRY_CATCH_BEGIN;
8092 [ - + ][ - + ]: 22 : CVC5_API_CHECK(d_slv->getOptions().smt.produceLearnedLiterals)
[ - - ]
8093 : : << "cannot get learned literals unless enabled (try "
8094 : : "--"
8095 : 0 : << internal::options::smt::longName::produceLearnedLiterals << ")";
8096 [ + - ][ + + ]: 24 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT
[ + + ][ - + ]
[ + + ][ + + ]
[ - - ]
8097 : : || d_slv->getSmtMode() == internal::SmtMode::SAT
8098 : : || d_slv->getSmtMode()
8099 : : == internal::SmtMode::SAT_UNKNOWN)
8100 : : << "cannot get learned literals unless after a UNSAT, SAT or UNKNOWN "
8101 : 2 : "response.";
8102 : : //////// all checks before this line
8103 : 20 : std::vector<internal::Node> lits = d_slv->getLearnedLiterals(t);
8104 : 40 : return Term::nodeVectorToTerms(d_tm.d_nm, lits);
8105 : : ////////
8106 [ + - ][ - - ]: 22 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8107 [ - + ]: 2 : }
8108 : :
8109 : 217 : Term Solver::getValueHelper(const Term& term) const
8110 : : {
8111 : : // Note: Term is checked in the caller to avoid double checks
8112 : 217 : bool wasShadow = false;
8113 : : bool freeOrShadowedVar =
8114 : 217 : internal::expr::hasFreeOrShadowedVar(term.getNode(), wasShadow);
8115 [ - + ][ - + ]: 217 : CVC5_API_RECOVERABLE_CHECK(!freeOrShadowedVar)
[ - - ]
8116 : : << "cannot get value of term containing "
8117 [ - - ]: 0 : << (wasShadow ? "shadowed" : "free") << " variables";
8118 : : //////// all checks before this line
8119 : 217 : internal::Node value = d_slv->getValue(*term.d_node, true);
8120 : 217 : Term res = Term(d_tm.d_nm, value);
8121 [ - + ][ - + ]: 651 : AssertEqual(res.getSort(), term.getSort());
[ - - ]
8122 : 434 : return res;
8123 [ - - ]: 217 : }
8124 : :
8125 : 73 : Term Solver::getValue(const Term& term) const
8126 : : {
8127 : : CVC5_API_TRY_CATCH_BEGIN;
8128 [ + + ][ + + ]: 77 : CVC5_API_RECOVERABLE_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8129 : : << "cannot get value unless model generation is enabled "
8130 : : "(try --"
8131 : 4 : << internal::options::smt::longName::produceModels << ")";
8132 [ + + ][ + + ]: 75 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8133 : 6 : << "cannot get value unless after a SAT or UNKNOWN response.";
8134 : 63 : CVC5_API_SOLVER_CHECK_TERM(term);
8135 [ - + ][ - + ]: 61 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
8136 : : d_slv->getEnv().isFirstClassType(term.getSort().getTypeNode()))
8137 : 0 : << "cannot get value of a term that is not first class.";
8138 : 61 : CVC5_API_RECOVERABLE_CHECK(!term.getSort().isDatatype()
8139 : : || term.getSort().getDatatype().isWellFounded())
8140 : 0 : << "cannot get value of a term of non-well-founded datatype sort.";
8141 : 61 : ensureWellFormedTerm(term);
8142 : : //////// all checks before this line
8143 : 61 : return getValueHelper(term);
8144 : : ////////
8145 [ + - ][ - - ]: 12 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8146 [ - + ]: 12 : }
8147 : :
8148 : 126 : std::vector<Term> Solver::getValue(const std::vector<Term>& terms) const
8149 : : {
8150 : : CVC5_API_TRY_CATCH_BEGIN;
8151 [ - + ][ - + ]: 126 : CVC5_API_RECOVERABLE_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8152 : : << "cannot get value unless model generation is enabled "
8153 : : "(try --"
8154 : 0 : << internal::options::smt::longName::produceModels << ")";
8155 [ + + ][ + + ]: 134 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8156 : 8 : << "cannot get value unless after a SAT or UNKNOWN response.";
8157 [ + + ]: 274 : for (const Term& t : terms)
8158 : : {
8159 [ + + ][ + + ]: 164 : CVC5_API_RECOVERABLE_CHECK(
[ - - ]
8160 : : d_slv->getEnv().isFirstClassType(t.getSort().getTypeNode()))
8161 : 2 : << "cannot get value of a term that is not first class.";
8162 : 156 : CVC5_API_RECOVERABLE_CHECK(!t.getSort().isDatatype()
8163 : : || t.getSort().getDatatype().isWellFounded())
8164 : 0 : << "cannot get value of a term of non-well-founded datatype sort.";
8165 : : }
8166 : 272 : CVC5_API_SOLVER_CHECK_TERMS(terms);
8167 : 116 : ensureWellFormedTerms(terms);
8168 : : //////// all checks before this line
8169 : :
8170 : 116 : std::vector<Term> res;
8171 [ + + ]: 272 : for (size_t i = 0, n = terms.size(); i < n; ++i)
8172 : : {
8173 : : /* Can not use emplace_back here since constructor is private. */
8174 : 156 : res.push_back(getValueHelper(terms[i]));
8175 : : }
8176 : 232 : return res;
8177 : : ////////
8178 [ + - ][ - - ]: 126 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8179 [ - + ]: 10 : }
8180 : :
8181 : 36 : std::vector<Term> Solver::getModelDomainElements(const Sort& s) const
8182 : : {
8183 : : CVC5_API_TRY_CATCH_BEGIN;
8184 [ - + ][ - + ]: 36 : CVC5_API_RECOVERABLE_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8185 : : << "cannot get domain elements unless model generation is enabled "
8186 : : "(try --"
8187 : 0 : << internal::options::smt::longName::produceModels << ")";
8188 [ + + ][ + + ]: 40 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8189 : 4 : << "cannot get domain elements unless after a SAT or UNKNOWN response.";
8190 : 32 : CVC5_API_SOLVER_CHECK_SORT(s);
8191 [ + + ][ + + ]: 32 : CVC5_API_RECOVERABLE_CHECK(s.isUninterpretedSort())
[ - - ]
8192 : : << "expected an uninterpreted sort as argument to "
8193 : 2 : "getModelDomainElements.";
8194 : : //////// all checks before this line
8195 : 28 : std::vector<Term> res;
8196 : : std::vector<internal::Node> elements =
8197 : 28 : d_slv->getModelDomainElements(s.getTypeNode());
8198 [ + + ]: 64 : for (const internal::Node& n : elements)
8199 : : {
8200 : 36 : res.push_back(Term(d_tm.d_nm, n));
8201 : : }
8202 : 56 : return res;
8203 : : ////////
8204 [ + - ][ - - ]: 36 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8205 [ - + ]: 8 : }
8206 : :
8207 : 10 : bool Solver::isModelCoreSymbol(const Term& v) const
8208 : : {
8209 : : CVC5_API_TRY_CATCH_BEGIN;
8210 [ - + ][ - + ]: 10 : CVC5_API_RECOVERABLE_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8211 : : << "cannot check if model core symbol unless model generation is enabled "
8212 : : "(try --"
8213 : 0 : << internal::options::smt::longName::produceModels << ")";
8214 [ - + ][ - + ]: 10 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8215 : : << "cannot check if model core symbol unless after a SAT or UNKNOWN "
8216 : 0 : "response.";
8217 : 10 : CVC5_API_SOLVER_CHECK_TERM(v);
8218 [ + + ][ + + ]: 10 : CVC5_API_RECOVERABLE_CHECK(v.getKind() == Kind::CONSTANT)
[ - - ]
8219 : 2 : << "expected a free constant as argument to isModelCoreSymbol.";
8220 : : //////// all checks before this line
8221 : 6 : return d_slv->isModelCoreSymbol(v.getNode());
8222 : : ////////
8223 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8224 : : }
8225 : :
8226 : 63 : std::string Solver::getModel(const std::vector<Sort>& sorts,
8227 : : const std::vector<Term>& vars) const
8228 : : {
8229 : : CVC5_API_TRY_CATCH_BEGIN;
8230 [ + + ][ + + ]: 65 : CVC5_API_RECOVERABLE_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8231 : : << "cannot get model unless model generation is enabled "
8232 : : "(try --"
8233 : 2 : << internal::options::smt::longName::produceModels << ")";
8234 [ + + ][ + + ]: 69 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8235 : 8 : << "cannot get model unless after a SAT or UNKNOWN response.";
8236 : 65 : CVC5_API_SOLVER_CHECK_SORTS(sorts);
8237 [ + + ]: 64 : for (const Sort& s : sorts)
8238 : : {
8239 [ + + ][ + + ]: 13 : CVC5_API_RECOVERABLE_CHECK(s.isUninterpretedSort())
[ - - ]
8240 : : << "expected an uninterpreted sort as argument to "
8241 : 1 : "getModel.";
8242 : : }
8243 : 135 : CVC5_API_SOLVER_CHECK_TERMS(vars);
8244 [ + + ]: 132 : for (const Term& v : vars)
8245 : : {
8246 [ - + ][ - + ]: 81 : CVC5_API_RECOVERABLE_CHECK(v.getKind() == Kind::CONSTANT)
[ - - ]
8247 : 0 : << "expected a free constant as argument to getModel.";
8248 : : }
8249 : : //////// all checks before this line
8250 : 51 : return d_slv->getModel(Sort::sortVectorToTypeNodes(sorts),
8251 : 102 : Term::termVectorToNodes(vars));
8252 : : ////////
8253 [ + - ][ - - ]: 12 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8254 [ - + ]: 12 : }
8255 : :
8256 : 26 : Term Solver::getQuantifierElimination(const Term& q) const
8257 : : {
8258 : : CVC5_API_TRY_CATCH_BEGIN;
8259 : 26 : CVC5_API_SOLVER_CHECK_TERM(q);
8260 : : //////// all checks before this line
8261 : 24 : return Term(d_tm.d_nm, d_slv->getQuantifierElimination(q.getNode(), true));
8262 : : ////////
8263 [ + - ][ - + ]: 6 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8264 [ - + ]: 6 : }
8265 : :
8266 : 7 : Term Solver::getQuantifierEliminationDisjunct(const Term& q) const
8267 : : {
8268 : : CVC5_API_TRY_CATCH_BEGIN;
8269 : 7 : CVC5_API_SOLVER_CHECK_TERM(q);
8270 : : //////// all checks before this line
8271 : 7 : return Term(d_tm.d_nm, d_slv->getQuantifierElimination(q.getNode(), false));
8272 : : ////////
8273 [ + - ][ - + ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8274 [ - + ]: 4 : }
8275 : :
8276 : 180 : void Solver::declareSepHeap(const Sort& locSort, const Sort& dataSort) const
8277 : : {
8278 : : CVC5_API_TRY_CATCH_BEGIN;
8279 : 180 : CVC5_API_SOLVER_CHECK_SORT(locSort);
8280 : 178 : CVC5_API_SOLVER_CHECK_SORT(dataSort);
8281 [ + + ][ + + ]: 177 : CVC5_API_CHECK(d_slv->isLogicSet())
[ - - ]
8282 : 1 : << "cannot call 'declareSepHeap()' if logic is not set";
8283 [ - + ][ - + ]: 175 : CVC5_API_CHECK(
[ - - ]
8284 : : d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
8285 : : << "cannot obtain separation logic expressions if not using the "
8286 : 0 : "separation logic theory.";
8287 : : //////// all checks before this line
8288 : 181 : d_slv->declareSepHeap(locSort.getTypeNode(), dataSort.getTypeNode());
8289 : : ////////
8290 [ + - ][ - + ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8291 : 172 : }
8292 : :
8293 : 13 : Term Solver::getValueSepHeap() const
8294 : : {
8295 : : CVC5_API_TRY_CATCH_BEGIN;
8296 [ + + ][ + + ]: 16 : CVC5_API_CHECK(
[ - - ]
8297 : : d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
8298 : : << "cannot obtain separation logic expressions if not using the "
8299 : 3 : "separation logic theory.";
8300 [ + + ][ + + ]: 12 : CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8301 : : << "cannot get separation heap term unless model generation is enabled "
8302 : : "(try --"
8303 : 2 : << internal::options::smt::longName::produceModels << ")";
8304 [ + + ][ + + ]: 10 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8305 : 2 : << "can only get separtion heap term after SAT or UNKNOWN response.";
8306 : : //////// all checks before this line
8307 : 6 : return Term(d_tm.d_nm, d_slv->getSepHeapExpr());
8308 : : ////////
8309 [ + - ][ + - ]: 9 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8310 [ - + ]: 9 : }
8311 : :
8312 : 13 : Term Solver::getValueSepNil() const
8313 : : {
8314 : : CVC5_API_TRY_CATCH_BEGIN;
8315 [ + + ][ + + ]: 16 : CVC5_API_CHECK(
[ - - ]
8316 : : d_slv->getLogicInfo().isTheoryEnabled(internal::theory::THEORY_SEP))
8317 : : << "cannot obtain separation logic expressions if not using the "
8318 : 3 : "separation logic theory.";
8319 [ + + ][ + + ]: 12 : CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8320 : : << "cannot get separation nil term unless model generation is enabled "
8321 : : "(try --"
8322 : 2 : << internal::options::smt::longName::produceModels << ")";
8323 [ + + ][ + + ]: 10 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8324 : 2 : << "can only get separtion nil term after SAT or UNKNOWN response.";
8325 : : //////// all checks before this line
8326 : 6 : return Term(d_tm.d_nm, d_slv->getSepNilExpr());
8327 : : ////////
8328 [ + - ][ + - ]: 9 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8329 [ - + ]: 9 : }
8330 : :
8331 : 40 : Term Solver::declarePool(const std::string& symbol,
8332 : : const Sort& sort,
8333 : : const std::vector<Term>& initValue) const
8334 : : {
8335 : : CVC5_API_TRY_CATCH_BEGIN;
8336 : 40 : CVC5_API_SOLVER_CHECK_SORT(sort);
8337 : 82 : CVC5_API_SOLVER_CHECK_TERMS(initValue);
8338 : : //////// all checks before this line
8339 : 32 : internal::TypeNode setType = d_tm.d_nm->mkSetType(*sort.d_type);
8340 : 32 : internal::Node pool = d_tm.mkVarHelper(setType, symbol);
8341 : 32 : std::vector<internal::Node> initv = Term::termVectorToNodes(initValue);
8342 : 32 : d_slv->declarePool(pool, initv);
8343 : 32 : d_tm.increment_vars_consts_stats(setType, true);
8344 : 64 : return Term(d_tm.d_nm, pool);
8345 : : ////////
8346 [ + - ][ - - ]: 40 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8347 [ - + ]: 8 : }
8348 : :
8349 : 16 : Term Solver::declareOracleFun(
8350 : : const std::string& symbol,
8351 : : const std::vector<Sort>& sorts,
8352 : : const Sort& sort,
8353 : : std::function<Term(const std::vector<Term>&)> fn) const
8354 : : {
8355 : : CVC5_API_TRY_CATCH_BEGIN;
8356 : 32 : CVC5_API_SOLVER_CHECK_DOMAIN_SORTS(sorts);
8357 : 13 : CVC5_API_SOLVER_CHECK_CODOMAIN_SORT(sort);
8358 [ + + ][ + + ]: 13 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.oracles)
[ - - ]
8359 : : << "cannot call declareOracleFun unless oracles is enabled (use "
8360 : : "--"
8361 : 2 : << internal::options::quantifiers::longName::oracles << ")";
8362 : : //////// all checks before this line
8363 : 9 : internal::TypeNode type = *sort.d_type;
8364 [ + - ]: 9 : if (!sorts.empty())
8365 : : {
8366 : 9 : std::vector<internal::TypeNode> types = Sort::sortVectorToTypeNodes(sorts);
8367 : 9 : type = d_tm.d_nm->mkFunctionType(types, type);
8368 : 9 : }
8369 : 9 : internal::Node fun = d_tm.mkConstHelper(type, symbol);
8370 : : // Wrap the terms-to-term function so that it is nodes-to-nodes. Note we
8371 : : // make the method return a vector of size one to conform to the interface
8372 : : // at the SolverEngine level.
8373 : 9 : d_slv->declareOracleFun(
8374 : 24 : fun, [&, fn](const std::vector<internal::Node> nodes) {
8375 : 24 : std::vector<Term> terms = Term::nodeVectorToTerms(d_tm.d_nm, nodes);
8376 : 24 : Term output = fn(terms);
8377 : 72 : return Term::termVectorToNodes({output});
8378 : 24 : });
8379 : 18 : return Term(d_tm.d_nm, fun);
8380 : : ////////
8381 [ + - ][ - - ]: 16 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8382 [ - + ]: 7 : }
8383 : :
8384 : 6 : void Solver::addPlugin(Plugin& p)
8385 : : {
8386 : : CVC5_API_TRY_CATCH_BEGIN;
8387 : 6 : d_slv->addPlugin(p.d_pExtToInt.get());
8388 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8389 : 6 : }
8390 : :
8391 : 2990 : void Solver::pop(uint32_t nscopes) const
8392 : : {
8393 : : CVC5_API_TRY_CATCH_BEGIN;
8394 [ + + ][ + + ]: 2992 : CVC5_API_CHECK(d_slv->getOptions().base.incrementalSolving)
[ - - ]
8395 : : << "cannot pop when not solving incrementally (use --"
8396 : 2 : << internal::options::base::longName::incrementalSolving << ")";
8397 [ + + ][ + + ]: 2992 : CVC5_API_CHECK(nscopes <= d_slv->getNumUserLevels())
[ - - ]
8398 : 4 : << "cannot pop beyond first pushed context";
8399 : : //////// all checks before this line
8400 [ + + ]: 6065 : for (uint32_t n = 0; n < nscopes; ++n)
8401 : : {
8402 : 3081 : d_slv->pop();
8403 : : }
8404 : : ////////
8405 [ + - ][ - - ]: 6 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8406 : 2984 : }
8407 : :
8408 : 32 : Term Solver::getInterpolant(const Term& conj) const
8409 : : {
8410 : : CVC5_API_TRY_CATCH_BEGIN;
8411 : 32 : CVC5_API_SOLVER_CHECK_TERM(conj);
8412 [ - + ][ - + ]: 30 : CVC5_API_CHECK(d_slv->getOptions().smt.produceInterpolants)
[ - - ]
8413 : : << "cannot get interpolant unless interpolants are enabled (try "
8414 : : "--"
8415 : 0 : << internal::options::smt::longName::produceInterpolants << ")";
8416 : : //////// all checks before this line
8417 : 30 : internal::TypeNode nullType;
8418 : 30 : internal::Node result = d_slv->getInterpolant(*conj.d_node, nullType);
8419 : 58 : return Term(d_tm.d_nm, result);
8420 : : ////////
8421 [ + - ][ - + ]: 33 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8422 [ - + ]: 3 : }
8423 : :
8424 : 15 : Term Solver::getInterpolant(const Term& conj, Grammar& grammar) const
8425 : : {
8426 : : CVC5_API_TRY_CATCH_BEGIN;
8427 : 15 : CVC5_API_SOLVER_CHECK_TERM(conj);
8428 : 13 : CVC5_API_SOLVER_CHECK_GRAMMAR(grammar);
8429 [ - + ][ - + ]: 11 : CVC5_API_CHECK(d_slv->getOptions().smt.produceInterpolants)
[ - - ]
8430 : : << "cannot get interpolant unless interpolants are enabled (try "
8431 : : "--"
8432 : 0 : << internal::options::smt::longName::produceInterpolants << ")";
8433 [ + + ]: 25 : for (const auto& sym : grammar.d_grammar->getNtSyms())
8434 : : {
8435 [ + + ][ + + ]: 18 : CVC5_API_CHECK(!grammar.d_grammar->getRulesFor(sym).empty())
[ - - ]
8436 : : << "invalid grammar, must have at least one rule for each "
8437 : 2 : "non-terminal symbol";
8438 : : }
8439 : : //////// all checks before this line
8440 : : internal::Node result =
8441 : 9 : d_slv->getInterpolant(*conj.d_node, *grammar.resolve().d_type);
8442 : 18 : return Term(d_tm.d_nm, result);
8443 : : ////////
8444 [ + - ][ - - ]: 15 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8445 [ - + ]: 6 : }
8446 : :
8447 : 3 : Term Solver::getInterpolantNext() const
8448 : : {
8449 : : CVC5_API_TRY_CATCH_BEGIN;
8450 [ - + ][ - + ]: 3 : CVC5_API_CHECK(d_slv->getOptions().smt.produceInterpolants)
[ - - ]
8451 : : << "cannot get interpolant unless interpolants are enabled (try "
8452 : : "--"
8453 : 0 : << internal::options::smt::longName::produceInterpolants << ")";
8454 [ - + ][ - + ]: 3 : CVC5_API_CHECK(d_slv->getOptions().base.incrementalSolving)
[ - - ]
8455 : : << "cannot get next interpolant when not solving incrementally (try "
8456 : : "--"
8457 : 0 : << internal::options::base::longName::incrementalSolving << ")";
8458 : : //////// all checks before this line
8459 : 3 : internal::Node result = d_slv->getInterpolantNext();
8460 : 6 : return Term(d_tm.d_nm, result);
8461 : : ////////
8462 [ - - ][ - - ]: 3 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8463 [ - - ]: 0 : }
8464 : :
8465 : 72 : Term Solver::getAbduct(const Term& conj) const
8466 : : {
8467 : : CVC5_API_TRY_CATCH_BEGIN;
8468 : 72 : CVC5_API_SOLVER_CHECK_TERM(conj);
8469 [ + + ][ + + ]: 72 : CVC5_API_CHECK(d_slv->getOptions().smt.produceAbducts)
[ - - ]
8470 : : << "cannot get abduct unless abducts are enabled (try --"
8471 : 2 : << internal::options::smt::longName::produceAbducts << ")";
8472 : : //////// all checks before this line
8473 : 68 : internal::TypeNode nullType;
8474 : 68 : internal::Node result = d_slv->getAbduct(*conj.d_node, nullType);
8475 : 130 : return Term(d_tm.d_nm, result);
8476 : : ////////
8477 [ + - ][ - + ]: 75 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8478 [ - + ]: 7 : }
8479 : :
8480 : 22 : Term Solver::getAbduct(const Term& conj, Grammar& grammar) const
8481 : : {
8482 : : CVC5_API_TRY_CATCH_BEGIN;
8483 : 22 : CVC5_API_SOLVER_CHECK_TERM(conj);
8484 : 20 : CVC5_API_SOLVER_CHECK_GRAMMAR(grammar);
8485 [ - + ][ - + ]: 18 : CVC5_API_CHECK(d_slv->getOptions().smt.produceAbducts)
[ - - ]
8486 : : << "cannot get abduct unless abducts are enabled (try --"
8487 : 0 : << internal::options::smt::longName::produceAbducts << ")";
8488 [ + + ]: 50 : for (const auto& sym : grammar.d_grammar->getNtSyms())
8489 : : {
8490 [ + + ][ + + ]: 36 : CVC5_API_CHECK(!grammar.d_grammar->getRulesFor(sym).empty())
[ - - ]
8491 : : << "invalid grammar, must have at least one rule for each "
8492 : 2 : "non-terminal symbol";
8493 : : }
8494 : : //////// all checks before this line
8495 : : internal::Node result =
8496 : 18 : d_slv->getAbduct(*conj.d_node, *grammar.resolve().d_type);
8497 : 28 : return Term(d_tm.d_nm, result);
8498 : : ////////
8499 [ + - ][ - + ]: 22 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8500 [ - + ]: 8 : }
8501 : :
8502 : 14 : Term Solver::getAbductNext() const
8503 : : {
8504 : : CVC5_API_TRY_CATCH_BEGIN;
8505 [ - + ][ - + ]: 14 : CVC5_API_CHECK(d_slv->getOptions().smt.produceAbducts)
[ - - ]
8506 : : << "cannot get next abduct unless abducts are enabled (try "
8507 : : "--"
8508 : 0 : << internal::options::smt::longName::produceAbducts << ")";
8509 [ - + ][ - + ]: 14 : CVC5_API_CHECK(d_slv->getOptions().base.incrementalSolving)
[ - - ]
8510 : : << "cannot get next abduct when not solving incrementally (try "
8511 : : "--"
8512 : 0 : << internal::options::base::longName::incrementalSolving << ")";
8513 : : //////// all checks before this line
8514 : 14 : internal::Node result = d_slv->getAbductNext();
8515 : 28 : return Term(d_tm.d_nm, result);
8516 : : ////////
8517 [ - - ][ - - ]: 14 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8518 [ - - ]: 0 : }
8519 : :
8520 : 34 : void Solver::blockModel(modes::BlockModelsMode mode) const
8521 : : {
8522 : : CVC5_API_TRY_CATCH_BEGIN;
8523 [ + + ][ + + ]: 36 : CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8524 : : << "cannot get value unless model generation is enabled "
8525 : : "(try --"
8526 : 2 : << internal::options::smt::longName::produceModels << ")";
8527 [ + + ][ + + ]: 34 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8528 : 2 : << "can only block model after SAT or UNKNOWN response.";
8529 : : //////// all checks before this line
8530 : 30 : d_slv->blockModel(mode);
8531 : : ////////
8532 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8533 : 30 : }
8534 : :
8535 : 31 : void Solver::blockModelValues(const std::vector<Term>& terms) const
8536 : : {
8537 : : CVC5_API_TRY_CATCH_BEGIN;
8538 [ + + ][ + + ]: 33 : CVC5_API_CHECK(d_slv->getOptions().smt.produceModels)
[ - - ]
8539 : : << "cannot get value unless model generation is enabled "
8540 : : "(try --"
8541 : 2 : << internal::options::smt::longName::produceModels << ")";
8542 [ + + ][ + + ]: 31 : CVC5_API_RECOVERABLE_CHECK(d_slv->isSmtModeSat())
[ - - ]
8543 : 2 : << "can only block model values after SAT or UNKNOWN response.";
8544 [ + + ][ + + ]: 28 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(!terms.empty(), terms)
[ - - ]
8545 : 1 : << "a non-empty set of terms";
8546 : 71 : CVC5_API_SOLVER_CHECK_TERMS(terms);
8547 : 23 : ensureWellFormedTerms(terms);
8548 : : //////// all checks before this line
8549 : 22 : d_slv->blockModelValues(Term::termVectorToNodes(terms));
8550 : : ////////
8551 [ + - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8552 : 22 : }
8553 : :
8554 : 16 : std::string Solver::getInstantiations() const
8555 : : {
8556 : : CVC5_API_TRY_CATCH_BEGIN;
8557 [ + + ][ - + ]: 18 : CVC5_API_RECOVERABLE_CHECK(d_slv->getSmtMode() == internal::SmtMode::UNSAT
[ + + ][ - + ]
[ + + ][ + + ]
[ - - ]
8558 : : || d_slv->getSmtMode() == internal::SmtMode::SAT
8559 : : || d_slv->getSmtMode()
8560 : : == internal::SmtMode::SAT_UNKNOWN)
8561 : : << "cannot get instantiations unless after a UNSAT, SAT or UNKNOWN "
8562 : 2 : "response.";
8563 : : //////// all checks before this line
8564 : 14 : std::stringstream ss;
8565 : 14 : d_slv->printInstantiations(ss);
8566 : 28 : return ss.str();
8567 : : ////////
8568 [ + - ][ - - ]: 16 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8569 [ - + ]: 2 : }
8570 : :
8571 : 3691 : void Solver::push(uint32_t nscopes) const
8572 : : {
8573 : : CVC5_API_TRY_CATCH_BEGIN;
8574 [ + + ][ + + ]: 3693 : CVC5_API_CHECK(d_slv->getOptions().base.incrementalSolving)
[ - - ]
8575 : : << "cannot push when not solving incrementally (use --"
8576 : 2 : << internal::options::base::longName::incrementalSolving << ")";
8577 : : //////// all checks before this line
8578 [ + + ]: 7395 : for (uint32_t n = 0; n < nscopes; ++n)
8579 : : {
8580 : 3706 : d_slv->push();
8581 : : }
8582 : : ////////
8583 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8584 : 3689 : }
8585 : :
8586 : 47 : void Solver::resetAssertions(void) const
8587 : : {
8588 : : CVC5_API_TRY_CATCH_BEGIN;
8589 : : //////// all checks before this line
8590 : 47 : d_slv->resetAssertions();
8591 : : ////////
8592 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8593 : 47 : }
8594 : :
8595 : 37549 : void Solver::setInfo(const std::string& keyword, const std::string& value) const
8596 : : {
8597 : : CVC5_API_TRY_CATCH_BEGIN;
8598 [ + + ][ + + ]: 37596 : CVC5_API_UNSUPPORTED_CHECK(
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - - ]
8599 : : keyword == "source" || keyword == "category" || keyword == "difficulty"
8600 : : || keyword == "filename" || keyword == "license" || keyword == "name"
8601 : : || keyword == "notes" || keyword == "smt-lib-version"
8602 : : || keyword == "status")
8603 : : << "unrecognized keyword: " << keyword
8604 : : << ", expected 'source', 'category', 'difficulty', "
8605 : : "'filename', 'license', 'name', "
8606 : 47 : "'notes', 'smt-lib-version' or 'status'";
8607 [ + + ][ + + ]: 37504 : CVC5_API_RECOVERABLE_ARG_CHECK_EXPECTED(
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - - ]
8608 : : keyword != "smt-lib-version" || value == "2" || value == "2.0"
8609 : : || value == "2.5" || value == "2.6" || value == "2.7",
8610 : : value)
8611 : 2 : << "'2.0', '2.5', '2.6', '2.7'";
8612 [ + + ][ + + ]: 37502 : CVC5_API_ARG_CHECK_EXPECTED(keyword != "status" || value == "sat"
[ + + ][ + + ]
[ + + ][ + + ]
[ + + ][ + + ]
[ - - ]
8613 : : || value == "unsat" || value == "unknown",
8614 : : value)
8615 : 2 : << "'sat', 'unsat' or 'unknown'";
8616 : : //////// all checks before this line
8617 [ + + ]: 37498 : if (keyword == "filename")
8618 : : {
8619 : : // only the Solver object has non-const access to the original options
8620 : 24951 : d_originalOptions->write_driver().filename = value;
8621 : : }
8622 : 37498 : d_slv->setInfo(keyword, value);
8623 : : ////////
8624 [ + - ][ - - ]: 51 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8625 : 37498 : }
8626 : :
8627 : 24914 : void Solver::setLogic(const std::string& logic) const
8628 : : {
8629 : : CVC5_API_TRY_CATCH_BEGIN;
8630 [ + + ][ + + ]: 24920 : CVC5_API_CHECK(!d_slv->isLogicSet())
[ - - ]
8631 : 6 : << "invalid call to 'setLogic', logic is already set";
8632 [ - + ][ - + ]: 24908 : CVC5_API_CHECK(!d_slv->isFullyInited())
[ - - ]
8633 : 0 : << "invalid call to 'setLogic', solver is already fully initialized";
8634 : : //////// all checks before this line
8635 : 24908 : internal::LogicInfo linfo(logic);
8636 : 24908 : d_slv->setLogic(linfo);
8637 : : ////////
8638 [ + - ][ - - ]: 24914 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8639 : 24908 : }
8640 : :
8641 : 24995 : bool Solver::isLogicSet() const
8642 : : {
8643 : : CVC5_API_TRY_CATCH_BEGIN;
8644 : : //////// all checks before this line
8645 : 24995 : return d_slv->isLogicSet();
8646 : : ////////
8647 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8648 : : }
8649 : :
8650 : 160 : std::string Solver::getLogic() const
8651 : : {
8652 : : CVC5_API_TRY_CATCH_BEGIN;
8653 [ + + ][ + + ]: 162 : CVC5_API_CHECK(d_slv->isLogicSet())
[ - - ]
8654 : 2 : << "invalid call to 'getLogic', logic has not yet been set";
8655 : : //////// all checks before this line
8656 : 158 : return d_slv->getUserLogicInfo().getLogicString();
8657 : : ////////
8658 [ + - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8659 [ - + ]: 2 : }
8660 : :
8661 : 142027 : void Solver::setOption(const std::string& option,
8662 : : const std::string& value) const
8663 : : {
8664 : : CVC5_API_TRY_CATCH_BEGIN;
8665 : 142027 : std::vector<std::string> options = internal::options::getNames();
8666 [ + - ][ + + ]: 142028 : CVC5_API_UNSUPPORTED_CHECK(
[ + + ][ + + ]
[ - - ]
8667 : : option.find("command-verbosity") != std::string::npos
8668 : : || std::find(options.cbegin(), options.cend(), option) != options.cend())
8669 : 1 : << "unrecognized option: " << option << '.';
8670 : : // this list includes options that are prescribed to be changable in any
8671 : : // context based on the SMT-LIB standard, as well as options (e.g. tlimit-per)
8672 : : // that have no impact on solver initialization or imply other options.
8673 : : static constexpr auto mutableOpts = {"diagnostic-output-channel",
8674 : : "print-success",
8675 : : "regular-output-channel",
8676 : : "reproducible-resource-limit",
8677 : : "verbosity",
8678 : : "tlimit-per"};
8679 : 142026 : if (std::find(mutableOpts.begin(), mutableOpts.end(), option)
8680 [ + + ]: 142026 : == mutableOpts.end())
8681 : : {
8682 [ + + ][ + + ]: 141585 : CVC5_API_CHECK(!d_slv->isFullyInited())
[ - - ]
8683 : : << "invalid call to 'setOption' for option '" << option
8684 : 8 : << "', solver is already fully initialized";
8685 : : }
8686 : : //////// all checks before this line
8687 : : // mark that the option originated from the user here
8688 : 142018 : d_slv->setOption(option, value, true);
8689 : : ////////
8690 [ + + ][ - + ]: 153996 : CVC5_API_TRY_CATCH_END;
[ - + ][ - + ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8691 : 129874 : }
8692 : :
8693 : 1445 : Term Solver::declareSygusVar(const std::string& symbol, const Sort& sort) const
8694 : : {
8695 : : CVC5_API_TRY_CATCH_BEGIN;
8696 : 1445 : CVC5_API_SOLVER_CHECK_SORT(sort);
8697 [ + + ][ + + ]: 1443 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8698 : : << "cannot call declareSygusVar unless sygus is enabled (use --"
8699 : 2 : << internal::options::quantifiers::longName::sygus << ")";
8700 : : //////// all checks before this line
8701 : 1439 : internal::Node res = d_tm.mkVarHelper(*sort.d_type, symbol);
8702 : 1439 : d_slv->declareSygusVar(res);
8703 : 2878 : return Term(d_tm.d_nm, res);
8704 : : ////////
8705 [ + - ][ - - ]: 1445 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8706 [ - + ]: 6 : }
8707 : :
8708 : 868 : Grammar Solver::mkGrammar(const std::vector<Term>& boundVars,
8709 : : const std::vector<Term>& ntSymbols) const
8710 : : {
8711 : : CVC5_API_TRY_CATCH_BEGIN;
8712 [ + + ][ + + ]: 869 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(!ntSymbols.empty(), ntSymbols)
[ - - ]
8713 : 1 : << "a non-empty vector";
8714 : 2180 : CVC5_API_SOLVER_CHECK_BOUND_VARS(boundVars);
8715 : 2699 : CVC5_API_SOLVER_CHECK_BOUND_VARS(ntSymbols);
8716 : : //////// all checks before this line
8717 : 860 : return Grammar(d_tm.d_nm, boundVars, ntSymbols);
8718 : : ////////
8719 [ + - ][ - - ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8720 [ - + ]: 8 : }
8721 : :
8722 : 877 : Term Solver::synthFun(const std::string& symbol,
8723 : : const std::vector<Term>& boundVars,
8724 : : const Sort& sort) const
8725 : : {
8726 : : CVC5_API_TRY_CATCH_BEGIN;
8727 : 3280 : CVC5_API_SOLVER_CHECK_BOUND_VARS(boundVars);
8728 : 875 : CVC5_API_SOLVER_CHECK_SORT(sort);
8729 [ - + ][ - + ]: 872 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8730 : : << "cannot call synthFun unless sygus is enabled (use --"
8731 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8732 : : //////// all checks before this line
8733 : 872 : return synthFunHelper(symbol, boundVars, sort);
8734 : : ////////
8735 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8736 [ - + ]: 5 : }
8737 : :
8738 : 771 : Term Solver::synthFun(const std::string& symbol,
8739 : : const std::vector<Term>& boundVars,
8740 : : Sort sort,
8741 : : Grammar& grammar) const
8742 : : {
8743 : : CVC5_API_TRY_CATCH_BEGIN;
8744 : 2052 : CVC5_API_SOLVER_CHECK_BOUND_VARS(boundVars);
8745 : 770 : CVC5_API_SOLVER_CHECK_SORT(sort);
8746 : 770 : CVC5_API_SOLVER_CHECK_GRAMMAR(grammar);
8747 [ - + ][ - + ]: 770 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8748 : : << "cannot call synthFun unless sygus is enabled (use --"
8749 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8750 : : //////// all checks before this line
8751 : 770 : return synthFunHelper(symbol, boundVars, sort, &grammar);
8752 : : ////////
8753 [ + - ][ - + ]: 9 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8754 [ - + ]: 9 : }
8755 : :
8756 : 1405 : void Solver::addSygusConstraint(const Term& term) const
8757 : : {
8758 : : CVC5_API_TRY_CATCH_BEGIN;
8759 : 1405 : CVC5_API_SOLVER_CHECK_TERM(term);
8760 [ + + ][ + + ]: 4207 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
8761 : : CVC5_EQUAL(term.d_node->getType(), d_tm.d_nm->booleanType()), term)
8762 : 1 : << "boolean term";
8763 [ - + ][ - + ]: 1401 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8764 : : << "cannot addSygusConstraint unless sygus is enabled (use --"
8765 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8766 : : //////// all checks before this line
8767 : 1401 : d_slv->assertSygusConstraint(*term.d_node, false);
8768 : : ////////
8769 [ + - ][ - - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8770 : 1401 : }
8771 : :
8772 : 2 : std::vector<Term> Solver::getSygusConstraints() const
8773 : : {
8774 : : CVC5_API_TRY_CATCH_BEGIN;
8775 : : //////// all checks before this line
8776 : 2 : std::vector<internal::Node> constraints = d_slv->getSygusConstraints();
8777 : 4 : return Term::nodeVectorToTerms(d_tm.d_nm, constraints);
8778 : : ////////
8779 [ - - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8780 : : }
8781 : :
8782 : 21 : void Solver::addSygusAssume(const Term& term) const
8783 : : {
8784 : : CVC5_API_TRY_CATCH_BEGIN;
8785 : 21 : CVC5_API_SOLVER_CHECK_TERM(term);
8786 [ + + ][ + + ]: 56 : CVC5_API_ARG_CHECK_EXPECTED(
[ - - ]
8787 : : CVC5_EQUAL(term.d_node->getType(), d_tm.d_nm->booleanType()), term)
8788 : 2 : << "boolean term";
8789 [ - + ][ - + ]: 16 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8790 : : << "cannot addSygusAssume unless sygus is enabled (use --"
8791 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8792 : : //////// all checks before this line
8793 : 16 : d_slv->assertSygusConstraint(*term.d_node, true);
8794 : : ////////
8795 [ + - ][ - - ]: 5 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8796 : 16 : }
8797 : :
8798 : 2 : std::vector<Term> Solver::getSygusAssumptions() const
8799 : : {
8800 : : CVC5_API_TRY_CATCH_BEGIN;
8801 : : //////// all checks before this line
8802 : 2 : std::vector<internal::Node> assumptions = d_slv->getSygusAssumptions();
8803 : 4 : return Term::nodeVectorToTerms(d_tm.d_nm, assumptions);
8804 : : ////////
8805 [ - - ][ - - ]: 2 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8806 : : }
8807 : :
8808 : 61 : void Solver::addSygusInvConstraint(const Term& inv,
8809 : : const Term& pre,
8810 : : const Term& trans,
8811 : : const Term& post) const
8812 : : {
8813 : : CVC5_API_TRY_CATCH_BEGIN;
8814 : 61 : CVC5_API_SOLVER_CHECK_TERM(inv);
8815 : 58 : CVC5_API_SOLVER_CHECK_TERM(pre);
8816 : 55 : CVC5_API_SOLVER_CHECK_TERM(trans);
8817 : 52 : CVC5_API_SOLVER_CHECK_TERM(post);
8818 : :
8819 [ + + ][ + + ]: 53 : CVC5_API_ARG_CHECK_EXPECTED(inv.d_node->getType().isFunction(), inv)
[ - - ]
8820 : 2 : << "a function";
8821 : :
8822 : 47 : internal::TypeNode invType = inv.d_node->getType();
8823 : :
8824 [ + + ][ + + ]: 51 : CVC5_API_ARG_CHECK_EXPECTED(invType.getRangeType().isBoolean(), inv)
[ - - ]
8825 : 2 : << "boolean range";
8826 : :
8827 [ + + ][ + + ]: 49 : CVC5_API_CHECK(pre.d_node->getType() == invType)
[ - - ]
8828 : 2 : << "expected inv and pre to have the same sort";
8829 : :
8830 [ + + ][ + + ]: 47 : CVC5_API_CHECK(post.d_node->getType() == invType)
[ - - ]
8831 : 2 : << "expected inv and post to have the same sort";
8832 [ - + ][ - + ]: 41 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8833 : : << "cannot addSygusInvConstraint unless sygus is enabled (use --"
8834 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8835 : : //////// all checks before this line
8836 : :
8837 : 41 : const std::vector<internal::TypeNode>& invArgTypes = invType.getArgTypes();
8838 : :
8839 : 41 : std::vector<internal::TypeNode> expectedTypes;
8840 : 41 : expectedTypes.reserve(2 * invArgTypes.size() + 1);
8841 : :
8842 [ + + ]: 240 : for (size_t i = 0, n = invArgTypes.size(); i < 2 * n; i += 2)
8843 : : {
8844 : 199 : expectedTypes.push_back(invArgTypes[i % n]);
8845 : 199 : expectedTypes.push_back(invArgTypes[(i + 1) % n]);
8846 : : }
8847 : :
8848 : 41 : expectedTypes.push_back(invType.getRangeType());
8849 : : internal::TypeNode expectedTransType =
8850 : 41 : d_tm.d_nm->mkFunctionType(expectedTypes);
8851 : :
8852 [ + + ][ + + ]: 61 : CVC5_API_CHECK(trans.d_node->getType() == expectedTransType)
[ - - ]
8853 : 10 : << "expected the sort of trans sort to be " << invType;
8854 : :
8855 : 155 : d_slv->assertSygusInvConstraint(
8856 : 124 : *inv.d_node, *pre.d_node, *trans.d_node, *post.d_node);
8857 : : ////////
8858 [ + - ][ - - ]: 107 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8859 : 31 : }
8860 : :
8861 : 484 : SynthResult Solver::checkSynth() const
8862 : : {
8863 : : CVC5_API_TRY_CATCH_BEGIN;
8864 [ + + ][ + + ]: 486 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8865 : : << "cannot check for a synthesis solution unless sygus is enabled (use --"
8866 : 2 : << internal::options::quantifiers::longName::sygus << ")";
8867 [ + + ][ + + ]: 484 : CVC5_API_CHECK(!d_slv->isQueryMade()
[ + + ][ + + ]
[ - - ]
8868 : : || d_slv->getOptions().base.incrementalSolving)
8869 : : << "cannot make multiple check synthesis solution calls unless "
8870 : : "incremental solving is "
8871 : : "enabled (try --"
8872 : 2 : << internal::options::base::longName::incrementalSolving << ")";
8873 : : //////// all checks before this line
8874 : 480 : return d_slv->checkSynth();
8875 : : ////////
8876 [ + - ][ - + ]: 8 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8877 [ - + ]: 8 : }
8878 : :
8879 : 18 : SynthResult Solver::checkSynthNext() const
8880 : : {
8881 : : CVC5_API_TRY_CATCH_BEGIN;
8882 [ - + ][ - + ]: 18 : CVC5_API_CHECK(d_slv->getOptions().quantifiers.sygus)
[ - - ]
8883 : : << "cannot check for a next synth solution unless sygus is enabled (use "
8884 : : "--"
8885 : 0 : << internal::options::quantifiers::longName::sygus << ")";
8886 [ + + ][ + + ]: 20 : CVC5_API_CHECK(d_slv->getOptions().base.incrementalSolving)
[ - - ]
8887 : : << "cannot check for a next synthesis solution when not solving "
8888 : : "incrementally (use "
8889 : : "--"
8890 : 2 : << internal::options::base::longName::incrementalSolving << ")";
8891 : : //////// all checks before this line
8892 : 16 : return d_slv->checkSynth(true);
8893 : : ////////
8894 [ + - ][ + - ]: 4 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8895 [ - + ]: 4 : }
8896 : :
8897 : 33 : Term Solver::getSynthSolution(const Term& term) const
8898 : : {
8899 : : CVC5_API_TRY_CATCH_BEGIN;
8900 : 33 : CVC5_API_SOLVER_CHECK_TERM(term);
8901 : :
8902 : 31 : std::map<internal::Node, internal::Node> map;
8903 [ + + ][ + + ]: 34 : CVC5_API_CHECK(d_slv->getSynthSolutions(map))
[ - - ]
8904 : : << "solver is not in a state immediately preceded by a "
8905 : 3 : "successful call to checkSynth";
8906 : :
8907 : : std::map<internal::Node, internal::Node>::const_iterator it =
8908 : 28 : map.find(*term.d_node);
8909 : :
8910 [ + + ][ + + ]: 30 : CVC5_API_CHECK(it != map.cend())
[ - - ]
8911 : 2 : << "synthesis solution not found for given term";
8912 : : //////// all checks before this line
8913 : 52 : return Term(d_tm.d_nm, it->second);
8914 : : ////////
8915 [ + - ][ - - ]: 38 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8916 [ - + ]: 7 : }
8917 : :
8918 : 17 : std::vector<Term> Solver::getSynthSolutions(
8919 : : const std::vector<Term>& terms) const
8920 : : {
8921 : : CVC5_API_TRY_CATCH_BEGIN;
8922 [ + + ][ + + ]: 17 : CVC5_API_ARG_SIZE_CHECK_EXPECTED(!terms.empty(), terms) << "non-empty vector";
[ - - ]
8923 : 30 : CVC5_API_SOLVER_CHECK_TERMS(terms);
8924 : :
8925 : 13 : std::map<internal::Node, internal::Node> map;
8926 [ + + ][ + + ]: 16 : CVC5_API_CHECK(d_slv->getSynthSolutions(map))
[ - - ]
8927 : : << "solver is not in a state immediately preceded by a "
8928 : 3 : "successful call to checkSynth";
8929 : : //////// all checks before this line
8930 : :
8931 : 10 : std::vector<Term> synthSolution;
8932 : 10 : synthSolution.reserve(terms.size());
8933 : :
8934 [ + + ]: 20 : for (size_t i = 0, n = terms.size(); i < n; ++i)
8935 : : {
8936 : : std::map<internal::Node, internal::Node>::const_iterator it =
8937 : 12 : map.find(*terms[i].d_node);
8938 : :
8939 [ + + ][ + + ]: 14 : CVC5_API_CHECK(it != map.cend())
[ - - ]
8940 : 2 : << "synthesis solution not found for term at index " << i;
8941 : :
8942 : 10 : synthSolution.push_back(Term(d_tm.d_nm, it->second));
8943 : : }
8944 : :
8945 : 16 : return synthSolution;
8946 : : ////////
8947 [ + - ][ - - ]: 24 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8948 [ - + ]: 9 : }
8949 : :
8950 : 43 : Term Solver::findSynth(modes::FindSynthTarget fst) const
8951 : : {
8952 : : CVC5_API_TRY_CATCH_BEGIN;
8953 : : //////// all checks before this line
8954 : 50 : return Term(d_tm.d_nm, d_slv->findSynth(fst, internal::TypeNode::null()));
8955 : : ////////
8956 [ - - ][ - + ]: 7 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - + ][ - + ]
[ - - ][ - - ]
[ - ]
8957 : : }
8958 : :
8959 : 3 : Term Solver::findSynth(modes::FindSynthTarget fst, Grammar& grammar) const
8960 : : {
8961 : : CVC5_API_TRY_CATCH_BEGIN;
8962 : 3 : CVC5_API_SOLVER_CHECK_GRAMMAR(grammar);
8963 [ + + ]: 6 : for (const auto& sym : grammar.d_grammar->getNtSyms())
8964 : : {
8965 [ - + ][ - + ]: 3 : CVC5_API_CHECK(!grammar.d_grammar->getRulesFor(sym).empty())
[ - - ]
8966 : : << "invalid grammar, must have at least one rule for each "
8967 : 0 : "non-terminal symbol";
8968 : : }
8969 : : //////// all checks before this line
8970 : 3 : return Term(d_tm.d_nm, d_slv->findSynth(fst, *grammar.resolve().d_type));
8971 : : ////////
8972 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8973 [ - - ]: 0 : }
8974 : :
8975 : 3 : Term Solver::findSynthNext() const
8976 : : {
8977 : : CVC5_API_TRY_CATCH_BEGIN;
8978 : : //////// all checks before this line
8979 : 3 : return Term(d_tm.d_nm, d_slv->findSynthNext());
8980 : : ////////
8981 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
8982 : : }
8983 : :
8984 : 22 : Statistics Solver::getStatistics() const
8985 : : {
8986 : 22 : return Statistics(d_slv->getStatisticsRegistry());
8987 : : }
8988 : :
8989 : 688830 : bool Solver::isOutputOn(const std::string& tag) const
8990 : : {
8991 : : // `isOutputOn(tag)` may raise an `OptionException`, which we do not want to
8992 : : // forward as such. We thus do not use the standard exception handling macros
8993 : : // here but roll our own.
8994 : : try
8995 : : {
8996 : 688830 : return d_slv->getEnv().isOutputOn(tag);
8997 : : }
8998 [ - + ]: 3 : catch (const internal::Exception& e)
8999 : : {
9000 : 3 : throw CVC5ApiException("invalid output tag " + tag);
9001 : 3 : }
9002 : : }
9003 : :
9004 : 140395 : std::ostream& Solver::getOutput(const std::string& tag) const
9005 : : {
9006 : : // `output(tag)` may raise an `OptionException`, which we do not want to
9007 : : // forward as such. We thus do not use the standard exception handling macros
9008 : : // here but roll our own.
9009 : : try
9010 : : {
9011 : 140395 : return d_slv->getEnv().output(tag);
9012 : : }
9013 [ - + ]: 1 : catch (const internal::Exception& e)
9014 : : {
9015 : 1 : throw CVC5ApiException("invalid output tag " + tag);
9016 : 1 : }
9017 : : }
9018 : :
9019 : 2 : std::string Solver::getVersion() const
9020 : : {
9021 : : CVC5_API_TRY_CATCH_BEGIN;
9022 : 4 : return internal::Configuration::getVersionString();
9023 [ - - ][ - - ]: 0 : CVC5_API_TRY_CATCH_END;
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - - ][ - - ]
[ - ]
9024 : : }
9025 : :
9026 : 324930 : TermManager& Solver::getTermManager() const { return d_tm; }
9027 : :
9028 : : } // namespace cvc5
9029 : :
9030 : : namespace std {
9031 : :
9032 : 68619540 : size_t hash<cvc5::Kind>::operator()(cvc5::Kind k) const
9033 : : {
9034 : 68619540 : return static_cast<size_t>(k);
9035 : : }
9036 : :
9037 : 955 : std::string to_string(cvc5::Kind k)
9038 : : {
9039 : 955 : auto it = cvc5::s_kinds.find(k);
9040 [ - + ]: 955 : if (it == cvc5::s_kinds.end())
9041 : : {
9042 : 0 : return "UNDEFINED_KIND";
9043 : : }
9044 : 955 : return it->second.second;
9045 : : }
9046 : :
9047 : 674506 : size_t hash<cvc5::SortKind>::operator()(cvc5::SortKind k) const
9048 : : {
9049 : 674506 : return static_cast<size_t>(k);
9050 : : }
9051 : :
9052 : 96 : std::string to_string(cvc5::SortKind k)
9053 : : {
9054 : 96 : auto it = cvc5::s_sort_kinds.find(k);
9055 [ - + ]: 96 : if (it == cvc5::s_sort_kinds.end())
9056 : : {
9057 : 0 : return "UNDEFINED_SORT_KIND";
9058 : : }
9059 : 96 : return it->second.second;
9060 : : }
9061 : :
9062 : 115 : size_t hash<cvc5::Op>::operator()(const cvc5::Op& t) const
9063 : : {
9064 [ + + ]: 115 : if (t.isIndexedHelper())
9065 : : {
9066 : 85 : return std::hash<cvc5::internal::Node>()(*t.d_node);
9067 : : }
9068 : : else
9069 : : {
9070 : 30 : return std::hash<cvc5::Kind>()(t.d_kind);
9071 : : }
9072 : : }
9073 : :
9074 : 2072 : size_t std::hash<cvc5::Sort>::operator()(const cvc5::Sort& s) const
9075 : : {
9076 : 2072 : return std::hash<cvc5::internal::TypeNode>()(*s.d_type);
9077 : : }
9078 : :
9079 : 6702332 : size_t std::hash<cvc5::Term>::operator()(const cvc5::Term& t) const
9080 : : {
9081 : 6702332 : return std::hash<cvc5::internal::Node>()(*t.d_node);
9082 : : }
9083 : :
9084 : 165 : size_t std::hash<cvc5::DatatypeConstructorDecl>::operator()(
9085 : : const cvc5::DatatypeConstructorDecl& decl) const
9086 : : {
9087 [ + + ]: 165 : if (decl.isNull())
9088 : : {
9089 : 1 : return 0;
9090 : : }
9091 : 164 : return std::hash<cvc5::internal::DTypeConstructor>()(*decl.d_ctor);
9092 : : }
9093 : :
9094 : 87 : size_t std::hash<cvc5::DatatypeDecl>::operator()(
9095 : : const cvc5::DatatypeDecl& decl) const
9096 : : {
9097 [ + + ]: 87 : if (decl.isNull())
9098 : : {
9099 : 1 : return 0;
9100 : : }
9101 : 86 : return std::hash<cvc5::internal::DType>()(*decl.d_dtype);
9102 : : }
9103 : :
9104 : 41 : size_t std::hash<cvc5::DatatypeSelector>::operator()(
9105 : : const cvc5::DatatypeSelector& sel) const
9106 : : {
9107 [ + + ]: 41 : if (sel.isNull())
9108 : : {
9109 : 1 : return 0;
9110 : : }
9111 : 40 : return std::hash<cvc5::internal::DTypeSelector>()(*sel.d_stor);
9112 : : }
9113 : :
9114 : 47 : size_t std::hash<cvc5::DatatypeConstructor>::operator()(
9115 : : const cvc5::DatatypeConstructor& cons) const
9116 : : {
9117 [ + + ]: 47 : if (cons.isNull())
9118 : : {
9119 : 1 : return 0;
9120 : : }
9121 : 46 : return std::hash<cvc5::internal::DTypeConstructor>()(*cons.d_ctor);
9122 : : }
9123 : :
9124 : 70 : size_t hash<cvc5::Datatype>::operator()(const cvc5::Datatype& dt) const
9125 : : {
9126 [ + + ]: 70 : if (dt.isNull())
9127 : : {
9128 : 1 : return 0;
9129 : : }
9130 : 69 : return std::hash<cvc5::internal::DType>()(*dt.d_dtype);
9131 : : }
9132 : :
9133 : 38 : size_t hash<cvc5::Proof>::operator()(const cvc5::Proof& proof) const
9134 : : {
9135 [ + + ]: 38 : if (proof.isNull())
9136 : : {
9137 : 1 : return 0;
9138 : : }
9139 : 37 : return std::hash<cvc5::internal::ProofNode>{}(*proof.d_proofNode);
9140 : : }
9141 : :
9142 : 70 : size_t hash<cvc5::Grammar>::operator()(const cvc5::Grammar& grammar) const
9143 : : {
9144 [ + + ]: 70 : if (grammar.isNull())
9145 : : {
9146 : 1 : return 0;
9147 : : }
9148 : 69 : return std::hash<cvc5::internal::SygusGrammar>{}(*grammar.d_grammar);
9149 : : }
9150 : :
9151 : : } // namespace std
|
