1 |
|
/****************************************************************************** |
2 |
|
* Top contributors (to current version): |
3 |
|
* Morgan Deters, Tim King, Andrew Reynolds |
4 |
|
* |
5 |
|
* This file is part of the cvc5 project. |
6 |
|
* |
7 |
|
* Copyright (c) 2009-2021 by the authors listed in the file AUTHORS |
8 |
|
* in the top-level source directory and their institutional affiliations. |
9 |
|
* All rights reserved. See the file COPYING in the top-level source |
10 |
|
* directory for licensing information. |
11 |
|
* **************************************************************************** |
12 |
|
* |
13 |
|
* Contains code for handling command-line options. |
14 |
|
*/ |
15 |
|
|
16 |
|
#if !defined(_BSD_SOURCE) && defined(__MINGW32__) && !defined(__MINGW64__) |
17 |
|
// force use of optreset; mingw32 croaks on argv-switching otherwise |
18 |
|
#include "base/cvc5config.h" |
19 |
|
#define _BSD_SOURCE |
20 |
|
#undef HAVE_DECL_OPTRESET |
21 |
|
#define HAVE_DECL_OPTRESET 1 |
22 |
|
#define CVC5_IS_NOT_REALLY_BSD |
23 |
|
#endif /* !_BSD_SOURCE && __MINGW32__ && !__MINGW64__ */ |
24 |
|
|
25 |
|
#ifdef __MINGW64__ |
26 |
|
extern int optreset; |
27 |
|
#endif /* __MINGW64__ */ |
28 |
|
|
29 |
|
#include <getopt.h> |
30 |
|
|
31 |
|
// clean up |
32 |
|
#ifdef CVC5_IS_NOT_REALLY_BSD |
33 |
|
# undef _BSD_SOURCE |
34 |
|
#endif /* CVC5_IS_NOT_REALLY_BSD */ |
35 |
|
|
36 |
|
#include <unistd.h> |
37 |
|
#include <string.h> |
38 |
|
#include <time.h> |
39 |
|
|
40 |
|
#include <cstdio> |
41 |
|
#include <cstdlib> |
42 |
|
#include <cstring> |
43 |
|
#include <iomanip> |
44 |
|
#include <new> |
45 |
|
#include <string> |
46 |
|
#include <sstream> |
47 |
|
#include <limits> |
48 |
|
|
49 |
|
#include "base/check.h" |
50 |
|
#include "base/exception.h" |
51 |
|
#include "base/output.h" |
52 |
|
#include "options/didyoumean.h" |
53 |
|
#include "options/language.h" |
54 |
|
#include "options/options_handler.h" |
55 |
|
#include "options/options_listener.h" |
56 |
|
|
57 |
|
// clang-format off |
58 |
|
#include "options/arith_options.h" |
59 |
|
#include "options/arrays_options.h" |
60 |
|
#include "options/base_options.h" |
61 |
|
#include "options/booleans_options.h" |
62 |
|
#include "options/builtin_options.h" |
63 |
|
#include "options/bv_options.h" |
64 |
|
#include "options/datatypes_options.h" |
65 |
|
#include "options/decision_options.h" |
66 |
|
#include "options/expr_options.h" |
67 |
|
#include "options/fp_options.h" |
68 |
|
#include "options/main_options.h" |
69 |
|
#include "options/parser_options.h" |
70 |
|
#include "options/printer_options.h" |
71 |
|
#include "options/proof_options.h" |
72 |
|
#include "options/prop_options.h" |
73 |
|
#include "options/quantifiers_options.h" |
74 |
|
#include "options/resource_manager_options.h" |
75 |
|
#include "options/sep_options.h" |
76 |
|
#include "options/sets_options.h" |
77 |
|
#include "options/smt_options.h" |
78 |
|
#include "options/strings_options.h" |
79 |
|
#include "options/theory_options.h" |
80 |
|
#include "options/uf_options.h" |
81 |
|
|
82 |
|
#include "base/cvc5config.h" |
83 |
|
#include "options/base_handlers.h" |
84 |
|
|
85 |
|
|
86 |
|
|
87 |
|
using namespace cvc5; |
88 |
|
using namespace cvc5::options; |
89 |
|
// clang-format on |
90 |
|
|
91 |
|
namespace cvc5 { |
92 |
|
|
93 |
|
thread_local Options* Options::s_current = NULL; |
94 |
|
|
95 |
|
/** |
96 |
|
* This is a default handler for options of built-in C++ type. This |
97 |
|
* template is really just a helper for the handleOption() template, |
98 |
|
* below. Variants of this template handle numeric and non-numeric, |
99 |
|
* integral and non-integral, signed and unsigned C++ types. |
100 |
|
* handleOption() makes sure to instantiate the right one. |
101 |
|
* |
102 |
|
* This implements default behavior when e.g. an option is |
103 |
|
* unsigned but the user specifies a negative argument; etc. |
104 |
|
*/ |
105 |
|
template <class T, bool is_numeric, bool is_integer> |
106 |
|
struct OptionHandler { |
107 |
|
static T handle(std::string option, std::string optionarg); |
108 |
|
};/* struct OptionHandler<> */ |
109 |
|
|
110 |
|
/** Variant for integral C++ types */ |
111 |
|
template <class T> |
112 |
|
struct OptionHandler<T, true, true> { |
113 |
121 |
static bool stringToInt(T& t, const std::string& str) { |
114 |
242 |
std::istringstream ss(str); |
115 |
121 |
ss >> t; |
116 |
|
char tmp; |
117 |
242 |
return !(ss.fail() || ss.get(tmp)); |
118 |
|
} |
119 |
|
|
120 |
94 |
static bool containsMinus(const std::string& str) { |
121 |
94 |
return str.find('-') != std::string::npos; |
122 |
|
} |
123 |
|
|
124 |
121 |
static T handle(const std::string& option, const std::string& optionarg) { |
125 |
|
try { |
126 |
|
T i; |
127 |
121 |
bool success = stringToInt(i, optionarg); |
128 |
|
|
129 |
121 |
if(!success){ |
130 |
|
throw OptionException(option + ": failed to parse "+ optionarg + |
131 |
|
" as an integer of the appropriate type."); |
132 |
|
} |
133 |
|
|
134 |
|
// Depending in the platform unsigned numbers with '-' signs may parse. |
135 |
|
// Reject these by looking for any minus if it is not signed. |
136 |
94 |
if( (! std::numeric_limits<T>::is_signed) && containsMinus(optionarg) ) { |
137 |
|
// unsigned type but user gave negative argument |
138 |
|
throw OptionException(option + " requires a nonnegative argument"); |
139 |
121 |
} else if(i < std::numeric_limits<T>::min()) { |
140 |
|
// negative overflow for type |
141 |
|
std::stringstream ss; |
142 |
|
ss << option << " requires an argument >= " |
143 |
|
<< std::numeric_limits<T>::min(); |
144 |
|
throw OptionException(ss.str()); |
145 |
121 |
} else if(i > std::numeric_limits<T>::max()) { |
146 |
|
// positive overflow for type |
147 |
|
std::stringstream ss; |
148 |
|
ss << option << " requires an argument <= " |
149 |
|
<< std::numeric_limits<T>::max(); |
150 |
|
throw OptionException(ss.str()); |
151 |
|
} |
152 |
|
|
153 |
121 |
return i; |
154 |
|
|
155 |
|
// if(std::numeric_limits<T>::is_signed) { |
156 |
|
// return T(i.getLong()); |
157 |
|
// } else { |
158 |
|
// return T(i.getUnsignedLong()); |
159 |
|
// } |
160 |
|
} catch(std::invalid_argument&) { |
161 |
|
// user gave something other than an integer |
162 |
|
throw OptionException(option + " requires an integer argument"); |
163 |
|
} |
164 |
|
} |
165 |
|
};/* struct OptionHandler<T, true, true> */ |
166 |
|
|
167 |
|
/** Variant for numeric but non-integral C++ types */ |
168 |
|
template <class T> |
169 |
|
struct OptionHandler<T, true, false> { |
170 |
|
static T handle(std::string option, std::string optionarg) { |
171 |
|
std::stringstream in(optionarg); |
172 |
|
long double r; |
173 |
|
in >> r; |
174 |
|
if(! in.eof()) { |
175 |
|
// we didn't consume the whole string (junk at end) |
176 |
|
throw OptionException(option + " requires a numeric argument"); |
177 |
|
} |
178 |
|
|
179 |
|
if(! std::numeric_limits<T>::is_signed && r < 0.0) { |
180 |
|
// unsigned type but user gave negative value |
181 |
|
throw OptionException(option + " requires a nonnegative argument"); |
182 |
|
} else if(r < -std::numeric_limits<T>::max()) { |
183 |
|
// negative overflow for type |
184 |
|
std::stringstream ss; |
185 |
|
ss << option << " requires an argument >= " |
186 |
|
<< -std::numeric_limits<T>::max(); |
187 |
|
throw OptionException(ss.str()); |
188 |
|
} else if(r > std::numeric_limits<T>::max()) { |
189 |
|
// positive overflow for type |
190 |
|
std::stringstream ss; |
191 |
|
ss << option << " requires an argument <= " |
192 |
|
<< std::numeric_limits<T>::max(); |
193 |
|
throw OptionException(ss.str()); |
194 |
|
} |
195 |
|
|
196 |
|
return T(r); |
197 |
|
} |
198 |
|
};/* struct OptionHandler<T, true, false> */ |
199 |
|
|
200 |
|
/** Variant for non-numeric C++ types */ |
201 |
|
template <class T> |
202 |
|
struct OptionHandler<T, false, false> { |
203 |
|
static T handle(std::string option, std::string optionarg) { |
204 |
|
T::unsupported_handleOption_call___please_write_me; |
205 |
|
// The above line causes a compiler error if this version of the template |
206 |
|
// is ever instantiated (meaning that a specialization is missing). So |
207 |
|
// don't worry about the segfault in the next line, the "return" is only |
208 |
|
// there to keep the compiler from giving additional, distracting errors |
209 |
|
// and warnings. |
210 |
|
return *(T*)0; |
211 |
|
} |
212 |
|
};/* struct OptionHandler<T, false, false> */ |
213 |
|
|
214 |
|
/** Handle an option of type T in the default way. */ |
215 |
|
template <class T> |
216 |
121 |
T handleOption(std::string option, std::string optionarg) { |
217 |
121 |
return OptionHandler<T, std::numeric_limits<T>::is_specialized, std::numeric_limits<T>::is_integer>::handle(option, optionarg); |
218 |
|
} |
219 |
|
|
220 |
|
/** Handle an option of type std::string in the default way. */ |
221 |
|
template <> |
222 |
12 |
std::string handleOption<std::string>(std::string option, std::string optionarg) { |
223 |
12 |
return optionarg; |
224 |
|
} |
225 |
|
|
226 |
|
/** |
227 |
|
* Run handler, and any user-given predicates, for option T. |
228 |
|
* If a user specifies a :handler or :predicates, it overrides this. |
229 |
|
*/ |
230 |
|
template <class T> |
231 |
|
typename T::type runHandlerAndPredicates(T, std::string option, std::string optionarg, options::OptionsHandler* handler) { |
232 |
|
// By default, parse the option argument in a way appropriate for its type. |
233 |
|
// E.g., for "unsigned int" options, ensure that the provided argument is |
234 |
|
// a nonnegative integer that fits in the unsigned int type. |
235 |
|
|
236 |
|
return handleOption<typename T::type>(option, optionarg); |
237 |
|
} |
238 |
|
|
239 |
|
template <class T> |
240 |
|
void runBoolPredicates(T, std::string option, bool b, options::OptionsHandler* handler) { |
241 |
|
// By default, nothing to do for bool. Users add things with |
242 |
|
// :predicate in options files to provide custom checking routines |
243 |
|
// that can throw exceptions. |
244 |
|
} |
245 |
|
|
246 |
25268 |
Options::Options(OptionsListener* ol) |
247 |
25268 |
: d_handler(new options::OptionsHandler(this)), |
248 |
|
// clang-format off |
249 |
|
d_arith(std::make_unique<options::HolderARITH>()), |
250 |
|
d_arrays(std::make_unique<options::HolderARRAYS>()), |
251 |
|
d_base(std::make_unique<options::HolderBASE>()), |
252 |
|
d_booleans(std::make_unique<options::HolderBOOLEANS>()), |
253 |
|
d_builtin(std::make_unique<options::HolderBUILTIN>()), |
254 |
|
d_bv(std::make_unique<options::HolderBV>()), |
255 |
|
d_datatypes(std::make_unique<options::HolderDATATYPES>()), |
256 |
|
d_decision(std::make_unique<options::HolderDECISION>()), |
257 |
|
d_expr(std::make_unique<options::HolderEXPR>()), |
258 |
|
d_fp(std::make_unique<options::HolderFP>()), |
259 |
|
d_driver(std::make_unique<options::HolderDRIVER>()), |
260 |
|
d_parser(std::make_unique<options::HolderPARSER>()), |
261 |
|
d_printer(std::make_unique<options::HolderPRINTER>()), |
262 |
|
d_proof(std::make_unique<options::HolderPROOF>()), |
263 |
|
d_prop(std::make_unique<options::HolderPROP>()), |
264 |
|
d_quantifiers(std::make_unique<options::HolderQUANTIFIERS>()), |
265 |
|
d_resman(std::make_unique<options::HolderRESMAN>()), |
266 |
|
d_sep(std::make_unique<options::HolderSEP>()), |
267 |
|
d_sets(std::make_unique<options::HolderSETS>()), |
268 |
|
d_smt(std::make_unique<options::HolderSMT>()), |
269 |
|
d_strings(std::make_unique<options::HolderSTRINGS>()), |
270 |
|
d_theory(std::make_unique<options::HolderTHEORY>()), |
271 |
|
d_uf(std::make_unique<options::HolderUF>()), |
272 |
|
// clang-format on |
273 |
25268 |
d_olisten(ol) |
274 |
25268 |
{} |
275 |
|
|
276 |
45486 |
Options::~Options() { |
277 |
22743 |
delete d_handler; |
278 |
22743 |
} |
279 |
|
|
280 |
15260 |
void Options::copyValues(const Options& options){ |
281 |
15260 |
if(this != &options) { |
282 |
|
// clang-format off |
283 |
15260 |
*d_arith = *options.d_arith; |
284 |
15260 |
*d_arrays = *options.d_arrays; |
285 |
15260 |
*d_base = *options.d_base; |
286 |
15260 |
*d_booleans = *options.d_booleans; |
287 |
15260 |
*d_builtin = *options.d_builtin; |
288 |
15260 |
*d_bv = *options.d_bv; |
289 |
15260 |
*d_datatypes = *options.d_datatypes; |
290 |
15260 |
*d_decision = *options.d_decision; |
291 |
15260 |
*d_expr = *options.d_expr; |
292 |
15260 |
*d_fp = *options.d_fp; |
293 |
15260 |
*d_driver = *options.d_driver; |
294 |
15260 |
*d_parser = *options.d_parser; |
295 |
15260 |
*d_printer = *options.d_printer; |
296 |
15260 |
*d_proof = *options.d_proof; |
297 |
15260 |
*d_prop = *options.d_prop; |
298 |
15260 |
*d_quantifiers = *options.d_quantifiers; |
299 |
15260 |
*d_resman = *options.d_resman; |
300 |
15260 |
*d_sep = *options.d_sep; |
301 |
15260 |
*d_sets = *options.d_sets; |
302 |
15260 |
*d_smt = *options.d_smt; |
303 |
15260 |
*d_strings = *options.d_strings; |
304 |
15260 |
*d_theory = *options.d_theory; |
305 |
15260 |
*d_uf = *options.d_uf; |
306 |
|
// clang-format on |
307 |
|
} |
308 |
15260 |
} |
309 |
|
|
310 |
26876226 |
const options::HolderARITH& Options::arith() const { return *d_arith; } |
311 |
41966 |
options::HolderARITH& Options::arith() { return *d_arith; } |
312 |
413150 |
const options::HolderARRAYS& Options::arrays() const { return *d_arrays; } |
313 |
3615 |
options::HolderARRAYS& Options::arrays() { return *d_arrays; } |
314 |
2299851 |
const options::HolderBASE& Options::base() const { return *d_base; } |
315 |
22149 |
options::HolderBASE& Options::base() { return *d_base; } |
316 |
|
const options::HolderBOOLEANS& Options::booleans() const { return *d_booleans; } |
317 |
|
options::HolderBOOLEANS& Options::booleans() { return *d_booleans; } |
318 |
|
const options::HolderBUILTIN& Options::builtin() const { return *d_builtin; } |
319 |
|
options::HolderBUILTIN& Options::builtin() { return *d_builtin; } |
320 |
6711087 |
const options::HolderBV& Options::bv() const { return *d_bv; } |
321 |
6718 |
options::HolderBV& Options::bv() { return *d_bv; } |
322 |
1910110 |
const options::HolderDATATYPES& Options::datatypes() const { return *d_datatypes; } |
323 |
893 |
options::HolderDATATYPES& Options::datatypes() { return *d_datatypes; } |
324 |
15733295 |
const options::HolderDECISION& Options::decision() const { return *d_decision; } |
325 |
18908 |
options::HolderDECISION& Options::decision() { return *d_decision; } |
326 |
184038 |
const options::HolderEXPR& Options::expr() const { return *d_expr; } |
327 |
4 |
options::HolderEXPR& Options::expr() { return *d_expr; } |
328 |
2488 |
const options::HolderFP& Options::fp() const { return *d_fp; } |
329 |
44 |
options::HolderFP& Options::fp() { return *d_fp; } |
330 |
63093 |
const options::HolderDRIVER& Options::driver() const { return *d_driver; } |
331 |
5879 |
options::HolderDRIVER& Options::driver() { return *d_driver; } |
332 |
30335 |
const options::HolderPARSER& Options::parser() const { return *d_parser; } |
333 |
70 |
options::HolderPARSER& Options::parser() { return *d_parser; } |
334 |
251 |
const options::HolderPRINTER& Options::printer() const { return *d_printer; } |
335 |
30 |
options::HolderPRINTER& Options::printer() { return *d_printer; } |
336 |
14237647 |
const options::HolderPROOF& Options::proof() const { return *d_proof; } |
337 |
3731 |
options::HolderPROOF& Options::proof() { return *d_proof; } |
338 |
193262 |
const options::HolderPROP& Options::prop() const { return *d_prop; } |
339 |
7450 |
options::HolderPROP& Options::prop() { return *d_prop; } |
340 |
28384631 |
const options::HolderQUANTIFIERS& Options::quantifiers() const { return *d_quantifiers; } |
341 |
38747 |
options::HolderQUANTIFIERS& Options::quantifiers() { return *d_quantifiers; } |
342 |
312475276 |
const options::HolderRESMAN& Options::resman() const { return *d_resman; } |
343 |
12 |
options::HolderRESMAN& Options::resman() { return *d_resman; } |
344 |
13540 |
const options::HolderSEP& Options::sep() const { return *d_sep; } |
345 |
2 |
options::HolderSEP& Options::sep() { return *d_sep; } |
346 |
142741 |
const options::HolderSETS& Options::sets() const { return *d_sets; } |
347 |
236 |
options::HolderSETS& Options::sets() { return *d_sets; } |
348 |
51510344 |
const options::HolderSMT& Options::smt() const { return *d_smt; } |
349 |
80842 |
options::HolderSMT& Options::smt() { return *d_smt; } |
350 |
602415 |
const options::HolderSTRINGS& Options::strings() const { return *d_strings; } |
351 |
1926 |
options::HolderSTRINGS& Options::strings() { return *d_strings; } |
352 |
160324833 |
const options::HolderTHEORY& Options::theory() const { return *d_theory; } |
353 |
1773 |
options::HolderTHEORY& Options::theory() { return *d_theory; } |
354 |
16604764 |
const options::HolderUF& Options::uf() const { return *d_uf; } |
355 |
11833 |
options::HolderUF& Options::uf() { return *d_uf; } |
356 |
|
|
357 |
|
std::string Options::formatThreadOptionException(const std::string& option) { |
358 |
|
std::stringstream ss; |
359 |
|
ss << "can't understand option `" << option |
360 |
|
<< "': expected something like --threadN=\"--option1 --option2\"," |
361 |
|
<< " where N is a nonnegative integer"; |
362 |
|
return ss.str(); |
363 |
|
} |
364 |
|
|
365 |
10093 |
void Options::setListener(OptionsListener* ol) { d_olisten = ol; } |
366 |
|
|
367 |
|
// clang-format off |
368 |
|
template <> void Options::assign( |
369 |
|
options::maxApproxDepth__option_t, |
370 |
|
std::string option, |
371 |
|
std::string optionarg) |
372 |
|
{ |
373 |
|
auto parsedval = handleOption<int16_t>(option, optionarg); |
374 |
|
|
375 |
|
arith().maxApproxDepth = parsedval; |
376 |
|
arith().maxApproxDepth__setByUser__ = true; |
377 |
|
Trace("options") << "user assigned option maxApproxDepth" << std::endl; |
378 |
|
} |
379 |
4 |
template <> void Options::assignBool( |
380 |
|
options::brabTest__option_t, |
381 |
|
std::string option, |
382 |
|
bool value) |
383 |
|
{ |
384 |
|
|
385 |
4 |
arith().brabTest = value; |
386 |
4 |
arith().brabTest__setByUser__ = true; |
387 |
4 |
Trace("options") << "user assigned option brabTest" << std::endl; |
388 |
4 |
} |
389 |
3 |
template <> void Options::assignBool( |
390 |
|
options::arithNoPartialFun__option_t, |
391 |
|
std::string option, |
392 |
|
bool value) |
393 |
|
{ |
394 |
|
|
395 |
3 |
arith().arithNoPartialFun = value; |
396 |
3 |
arith().arithNoPartialFun__setByUser__ = true; |
397 |
3 |
Trace("options") << "user assigned option arithNoPartialFun" << std::endl; |
398 |
3 |
} |
399 |
|
template <> void Options::assign( |
400 |
|
options::arithPropAsLemmaLength__option_t, |
401 |
|
std::string option, |
402 |
|
std::string optionarg) |
403 |
|
{ |
404 |
|
auto parsedval = handleOption<uint16_t>(option, optionarg); |
405 |
|
|
406 |
|
arith().arithPropAsLemmaLength = parsedval; |
407 |
|
arith().arithPropAsLemmaLength__setByUser__ = true; |
408 |
|
Trace("options") << "user assigned option arithPropAsLemmaLength" << std::endl; |
409 |
|
} |
410 |
|
template <> void Options::assign( |
411 |
|
options::arithPropagationMode__option_t, |
412 |
|
std::string option, |
413 |
|
std::string optionarg) |
414 |
|
{ |
415 |
|
auto parsedval = stringToArithPropagationMode(optionarg); |
416 |
|
|
417 |
|
arith().arithPropagationMode = parsedval; |
418 |
|
arith().arithPropagationMode__setByUser__ = true; |
419 |
|
Trace("options") << "user assigned option arithPropagationMode" << std::endl; |
420 |
|
} |
421 |
9 |
template <> void Options::assignBool( |
422 |
|
options::arithRewriteEq__option_t, |
423 |
|
std::string option, |
424 |
|
bool value) |
425 |
|
{ |
426 |
|
|
427 |
9 |
arith().arithRewriteEq = value; |
428 |
9 |
arith().arithRewriteEq__setByUser__ = true; |
429 |
9 |
Trace("options") << "user assigned option arithRewriteEq" << std::endl; |
430 |
9 |
} |
431 |
|
template <> void Options::assignBool( |
432 |
|
options::collectPivots__option_t, |
433 |
|
std::string option, |
434 |
|
bool value) |
435 |
|
{ |
436 |
|
|
437 |
|
arith().collectPivots = value; |
438 |
|
arith().collectPivots__setByUser__ = true; |
439 |
|
Trace("options") << "user assigned option collectPivots" << std::endl; |
440 |
|
} |
441 |
|
template <> void Options::assignBool( |
442 |
|
options::doCutAllBounded__option_t, |
443 |
|
std::string option, |
444 |
|
bool value) |
445 |
|
{ |
446 |
|
|
447 |
|
arith().doCutAllBounded = value; |
448 |
|
arith().doCutAllBounded__setByUser__ = true; |
449 |
|
Trace("options") << "user assigned option doCutAllBounded" << std::endl; |
450 |
|
} |
451 |
|
template <> void Options::assignBool( |
452 |
|
options::exportDioDecompositions__option_t, |
453 |
|
std::string option, |
454 |
|
bool value) |
455 |
|
{ |
456 |
|
|
457 |
|
arith().exportDioDecompositions = value; |
458 |
|
arith().exportDioDecompositions__setByUser__ = true; |
459 |
|
Trace("options") << "user assigned option exportDioDecompositions" << std::endl; |
460 |
|
} |
461 |
|
template <> void Options::assignBool( |
462 |
|
options::dioRepeat__option_t, |
463 |
|
std::string option, |
464 |
|
bool value) |
465 |
|
{ |
466 |
|
|
467 |
|
arith().dioRepeat = value; |
468 |
|
arith().dioRepeat__setByUser__ = true; |
469 |
|
Trace("options") << "user assigned option dioRepeat" << std::endl; |
470 |
|
} |
471 |
|
template <> void Options::assignBool( |
472 |
|
options::arithDioSolver__option_t, |
473 |
|
std::string option, |
474 |
|
bool value) |
475 |
|
{ |
476 |
|
|
477 |
|
arith().arithDioSolver = value; |
478 |
|
arith().arithDioSolver__setByUser__ = true; |
479 |
|
Trace("options") << "user assigned option arithDioSolver" << std::endl; |
480 |
|
} |
481 |
|
template <> void Options::assign( |
482 |
|
options::dioSolverTurns__option_t, |
483 |
|
std::string option, |
484 |
|
std::string optionarg) |
485 |
|
{ |
486 |
|
auto parsedval = handleOption<int>(option, optionarg); |
487 |
|
|
488 |
|
arith().dioSolverTurns = parsedval; |
489 |
|
arith().dioSolverTurns__setByUser__ = true; |
490 |
|
Trace("options") << "user assigned option dioSolverTurns" << std::endl; |
491 |
|
} |
492 |
|
template <> void Options::assign( |
493 |
|
options::arithErrorSelectionRule__option_t, |
494 |
|
std::string option, |
495 |
|
std::string optionarg) |
496 |
|
{ |
497 |
|
auto parsedval = stringToErrorSelectionRule(optionarg); |
498 |
|
|
499 |
|
arith().arithErrorSelectionRule = parsedval; |
500 |
|
arith().arithErrorSelectionRule__setByUser__ = true; |
501 |
|
Trace("options") << "user assigned option arithErrorSelectionRule" << std::endl; |
502 |
|
} |
503 |
|
template <> void Options::assignBool( |
504 |
|
options::havePenalties__option_t, |
505 |
|
std::string option, |
506 |
|
bool value) |
507 |
|
{ |
508 |
|
|
509 |
|
arith().havePenalties = value; |
510 |
|
arith().havePenalties__setByUser__ = true; |
511 |
|
Trace("options") << "user assigned option havePenalties" << std::endl; |
512 |
|
} |
513 |
|
template <> void Options::assign( |
514 |
|
options::arithHeuristicPivots__option_t, |
515 |
|
std::string option, |
516 |
|
std::string optionarg) |
517 |
|
{ |
518 |
|
auto parsedval = handleOption<int16_t>(option, optionarg); |
519 |
|
|
520 |
|
arith().arithHeuristicPivots = parsedval; |
521 |
|
arith().arithHeuristicPivots__setByUser__ = true; |
522 |
|
Trace("options") << "user assigned option arithHeuristicPivots" << std::endl; |
523 |
|
} |
524 |
|
template <> void Options::assignBool( |
525 |
|
options::replayFailureLemma__option_t, |
526 |
|
std::string option, |
527 |
|
bool value) |
528 |
|
{ |
529 |
|
|
530 |
|
arith().replayFailureLemma = value; |
531 |
|
arith().replayFailureLemma__setByUser__ = true; |
532 |
|
Trace("options") << "user assigned option replayFailureLemma" << std::endl; |
533 |
|
} |
534 |
|
template <> void Options::assign( |
535 |
|
options::maxCutsInContext__option_t, |
536 |
|
std::string option, |
537 |
|
std::string optionarg) |
538 |
|
{ |
539 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
540 |
|
|
541 |
|
arith().maxCutsInContext = parsedval; |
542 |
|
arith().maxCutsInContext__setByUser__ = true; |
543 |
|
Trace("options") << "user assigned option maxCutsInContext" << std::endl; |
544 |
|
} |
545 |
8 |
template <> void Options::assignBool( |
546 |
|
options::arithMLTrick__option_t, |
547 |
|
std::string option, |
548 |
|
bool value) |
549 |
|
{ |
550 |
|
|
551 |
8 |
arith().arithMLTrick = value; |
552 |
8 |
arith().arithMLTrick__setByUser__ = true; |
553 |
8 |
Trace("options") << "user assigned option arithMLTrick" << std::endl; |
554 |
8 |
} |
555 |
|
template <> void Options::assign( |
556 |
|
options::arithMLTrickSubstitutions__option_t, |
557 |
|
std::string option, |
558 |
|
std::string optionarg) |
559 |
|
{ |
560 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
561 |
|
|
562 |
|
arith().arithMLTrickSubstitutions = parsedval; |
563 |
|
arith().arithMLTrickSubstitutions__setByUser__ = true; |
564 |
|
Trace("options") << "user assigned option arithMLTrickSubstitutions" << std::endl; |
565 |
|
} |
566 |
8 |
template <> void Options::assignBool( |
567 |
|
options::newProp__option_t, |
568 |
|
std::string option, |
569 |
|
bool value) |
570 |
|
{ |
571 |
|
|
572 |
8 |
arith().newProp = value; |
573 |
8 |
arith().newProp__setByUser__ = true; |
574 |
8 |
Trace("options") << "user assigned option newProp" << std::endl; |
575 |
8 |
} |
576 |
5 |
template <> void Options::assignBool( |
577 |
|
options::nlCad__option_t, |
578 |
|
std::string option, |
579 |
|
bool value) |
580 |
|
{ |
581 |
|
|
582 |
5 |
arith().nlCad = value; |
583 |
5 |
arith().nlCad__setByUser__ = true; |
584 |
5 |
Trace("options") << "user assigned option nlCad" << std::endl; |
585 |
5 |
} |
586 |
|
template <> void Options::assignBool( |
587 |
|
options::nlCadUseInitial__option_t, |
588 |
|
std::string option, |
589 |
|
bool value) |
590 |
|
{ |
591 |
|
|
592 |
|
arith().nlCadUseInitial = value; |
593 |
|
arith().nlCadUseInitial__setByUser__ = true; |
594 |
|
Trace("options") << "user assigned option nlCadUseInitial" << std::endl; |
595 |
|
} |
596 |
|
template <> void Options::assignBool( |
597 |
|
options::nlExtEntailConflicts__option_t, |
598 |
|
std::string option, |
599 |
|
bool value) |
600 |
|
{ |
601 |
|
|
602 |
|
arith().nlExtEntailConflicts = value; |
603 |
|
arith().nlExtEntailConflicts__setByUser__ = true; |
604 |
|
Trace("options") << "user assigned option nlExtEntailConflicts" << std::endl; |
605 |
|
} |
606 |
|
template <> void Options::assignBool( |
607 |
|
options::nlExtFactor__option_t, |
608 |
|
std::string option, |
609 |
|
bool value) |
610 |
|
{ |
611 |
|
|
612 |
|
arith().nlExtFactor = value; |
613 |
|
arith().nlExtFactor__setByUser__ = true; |
614 |
|
Trace("options") << "user assigned option nlExtFactor" << std::endl; |
615 |
|
} |
616 |
2 |
template <> void Options::assignBool( |
617 |
|
options::nlExtIncPrecision__option_t, |
618 |
|
std::string option, |
619 |
|
bool value) |
620 |
|
{ |
621 |
|
|
622 |
2 |
arith().nlExtIncPrecision = value; |
623 |
2 |
arith().nlExtIncPrecision__setByUser__ = true; |
624 |
2 |
Trace("options") << "user assigned option nlExtIncPrecision" << std::endl; |
625 |
2 |
} |
626 |
4 |
template <> void Options::assignBool( |
627 |
|
options::nlExtPurify__option_t, |
628 |
|
std::string option, |
629 |
|
bool value) |
630 |
|
{ |
631 |
|
|
632 |
4 |
arith().nlExtPurify = value; |
633 |
4 |
arith().nlExtPurify__setByUser__ = true; |
634 |
4 |
Trace("options") << "user assigned option nlExtPurify" << std::endl; |
635 |
4 |
} |
636 |
|
template <> void Options::assignBool( |
637 |
|
options::nlExtResBound__option_t, |
638 |
|
std::string option, |
639 |
|
bool value) |
640 |
|
{ |
641 |
|
|
642 |
|
arith().nlExtResBound = value; |
643 |
|
arith().nlExtResBound__setByUser__ = true; |
644 |
|
Trace("options") << "user assigned option nlExtResBound" << std::endl; |
645 |
|
} |
646 |
|
template <> void Options::assignBool( |
647 |
|
options::nlExtRewrites__option_t, |
648 |
|
std::string option, |
649 |
|
bool value) |
650 |
|
{ |
651 |
|
|
652 |
|
arith().nlExtRewrites = value; |
653 |
|
arith().nlExtRewrites__setByUser__ = true; |
654 |
|
Trace("options") << "user assigned option nlExtRewrites" << std::endl; |
655 |
|
} |
656 |
|
template <> void Options::assignBool( |
657 |
|
options::nlExtSplitZero__option_t, |
658 |
|
std::string option, |
659 |
|
bool value) |
660 |
|
{ |
661 |
|
|
662 |
|
arith().nlExtSplitZero = value; |
663 |
|
arith().nlExtSplitZero__setByUser__ = true; |
664 |
|
Trace("options") << "user assigned option nlExtSplitZero" << std::endl; |
665 |
|
} |
666 |
|
template <> void Options::assign( |
667 |
|
options::nlExtTfTaylorDegree__option_t, |
668 |
|
std::string option, |
669 |
|
std::string optionarg) |
670 |
|
{ |
671 |
|
auto parsedval = handleOption<int16_t>(option, optionarg); |
672 |
|
|
673 |
|
arith().nlExtTfTaylorDegree = parsedval; |
674 |
|
arith().nlExtTfTaylorDegree__setByUser__ = true; |
675 |
|
Trace("options") << "user assigned option nlExtTfTaylorDegree" << std::endl; |
676 |
|
} |
677 |
41 |
template <> void Options::assignBool( |
678 |
|
options::nlExtTfTangentPlanes__option_t, |
679 |
|
std::string option, |
680 |
|
bool value) |
681 |
|
{ |
682 |
|
|
683 |
41 |
arith().nlExtTfTangentPlanes = value; |
684 |
41 |
arith().nlExtTfTangentPlanes__setByUser__ = true; |
685 |
41 |
Trace("options") << "user assigned option nlExtTfTangentPlanes" << std::endl; |
686 |
41 |
} |
687 |
41 |
template <> void Options::assignBool( |
688 |
|
options::nlExtTangentPlanes__option_t, |
689 |
|
std::string option, |
690 |
|
bool value) |
691 |
|
{ |
692 |
|
|
693 |
41 |
arith().nlExtTangentPlanes = value; |
694 |
41 |
arith().nlExtTangentPlanes__setByUser__ = true; |
695 |
41 |
Trace("options") << "user assigned option nlExtTangentPlanes" << std::endl; |
696 |
41 |
} |
697 |
|
template <> void Options::assignBool( |
698 |
|
options::nlExtTangentPlanesInterleave__option_t, |
699 |
|
std::string option, |
700 |
|
bool value) |
701 |
|
{ |
702 |
|
|
703 |
|
arith().nlExtTangentPlanesInterleave = value; |
704 |
|
arith().nlExtTangentPlanesInterleave__setByUser__ = true; |
705 |
|
Trace("options") << "user assigned option nlExtTangentPlanesInterleave" << std::endl; |
706 |
|
} |
707 |
128 |
template <> void Options::assign( |
708 |
|
options::nlExt__option_t, |
709 |
|
std::string option, |
710 |
|
std::string optionarg) |
711 |
|
{ |
712 |
128 |
auto parsedval = stringToNlExtMode(optionarg); |
713 |
|
|
714 |
128 |
arith().nlExt = parsedval; |
715 |
128 |
arith().nlExt__setByUser__ = true; |
716 |
128 |
Trace("options") << "user assigned option nlExt" << std::endl; |
717 |
128 |
} |
718 |
2 |
template <> void Options::assignBool( |
719 |
|
options::nlICP__option_t, |
720 |
|
std::string option, |
721 |
|
bool value) |
722 |
|
{ |
723 |
|
|
724 |
2 |
arith().nlICP = value; |
725 |
2 |
arith().nlICP__setByUser__ = true; |
726 |
2 |
Trace("options") << "user assigned option nlICP" << std::endl; |
727 |
2 |
} |
728 |
10 |
template <> void Options::assign( |
729 |
|
options::nlRlvMode__option_t, |
730 |
|
std::string option, |
731 |
|
std::string optionarg) |
732 |
|
{ |
733 |
10 |
auto parsedval = stringToNlRlvMode(optionarg); |
734 |
|
|
735 |
10 |
arith().nlRlvMode = parsedval; |
736 |
10 |
arith().nlRlvMode__setByUser__ = true; |
737 |
10 |
Trace("options") << "user assigned option nlRlvMode" << std::endl; |
738 |
10 |
} |
739 |
2 |
template <> void Options::assignBool( |
740 |
|
options::pbRewrites__option_t, |
741 |
|
std::string option, |
742 |
|
bool value) |
743 |
|
{ |
744 |
|
|
745 |
2 |
arith().pbRewrites = value; |
746 |
2 |
arith().pbRewrites__setByUser__ = true; |
747 |
2 |
Trace("options") << "user assigned option pbRewrites" << std::endl; |
748 |
2 |
} |
749 |
|
template <> void Options::assign( |
750 |
|
options::arithPivotThreshold__option_t, |
751 |
|
std::string option, |
752 |
|
std::string optionarg) |
753 |
|
{ |
754 |
|
auto parsedval = handleOption<uint16_t>(option, optionarg); |
755 |
|
|
756 |
|
arith().arithPivotThreshold = parsedval; |
757 |
|
arith().arithPivotThreshold__setByUser__ = true; |
758 |
|
Trace("options") << "user assigned option arithPivotThreshold" << std::endl; |
759 |
|
} |
760 |
|
template <> void Options::assign( |
761 |
|
options::ppAssertMaxSubSize__option_t, |
762 |
|
std::string option, |
763 |
|
std::string optionarg) |
764 |
|
{ |
765 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
766 |
|
|
767 |
|
arith().ppAssertMaxSubSize = parsedval; |
768 |
|
arith().ppAssertMaxSubSize__setByUser__ = true; |
769 |
|
Trace("options") << "user assigned option ppAssertMaxSubSize" << std::endl; |
770 |
|
} |
771 |
|
template <> void Options::assign( |
772 |
|
options::arithPropagateMaxLength__option_t, |
773 |
|
std::string option, |
774 |
|
std::string optionarg) |
775 |
|
{ |
776 |
|
auto parsedval = handleOption<uint16_t>(option, optionarg); |
777 |
|
|
778 |
|
arith().arithPropagateMaxLength = parsedval; |
779 |
|
arith().arithPropagateMaxLength__setByUser__ = true; |
780 |
|
Trace("options") << "user assigned option arithPropagateMaxLength" << std::endl; |
781 |
|
} |
782 |
|
template <> void Options::assign( |
783 |
|
options::replayEarlyCloseDepths__option_t, |
784 |
|
std::string option, |
785 |
|
std::string optionarg) |
786 |
|
{ |
787 |
|
auto parsedval = handleOption<int>(option, optionarg); |
788 |
|
|
789 |
|
arith().replayEarlyCloseDepths = parsedval; |
790 |
|
arith().replayEarlyCloseDepths__setByUser__ = true; |
791 |
|
Trace("options") << "user assigned option replayEarlyCloseDepths" << std::endl; |
792 |
|
} |
793 |
|
template <> void Options::assign( |
794 |
|
options::replayFailurePenalty__option_t, |
795 |
|
std::string option, |
796 |
|
std::string optionarg) |
797 |
|
{ |
798 |
|
auto parsedval = handleOption<int>(option, optionarg); |
799 |
|
|
800 |
|
arith().replayFailurePenalty = parsedval; |
801 |
|
arith().replayFailurePenalty__setByUser__ = true; |
802 |
|
Trace("options") << "user assigned option replayFailurePenalty" << std::endl; |
803 |
|
} |
804 |
|
template <> void Options::assign( |
805 |
|
options::lemmaRejectCutSize__option_t, |
806 |
|
std::string option, |
807 |
|
std::string optionarg) |
808 |
|
{ |
809 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
810 |
|
|
811 |
|
arith().lemmaRejectCutSize = parsedval; |
812 |
|
arith().lemmaRejectCutSize__setByUser__ = true; |
813 |
|
Trace("options") << "user assigned option lemmaRejectCutSize" << std::endl; |
814 |
|
} |
815 |
|
template <> void Options::assign( |
816 |
|
options::replayNumericFailurePenalty__option_t, |
817 |
|
std::string option, |
818 |
|
std::string optionarg) |
819 |
|
{ |
820 |
|
auto parsedval = handleOption<int>(option, optionarg); |
821 |
|
|
822 |
|
arith().replayNumericFailurePenalty = parsedval; |
823 |
|
arith().replayNumericFailurePenalty__setByUser__ = true; |
824 |
|
Trace("options") << "user assigned option replayNumericFailurePenalty" << std::endl; |
825 |
|
} |
826 |
|
template <> void Options::assign( |
827 |
|
options::replayRejectCutSize__option_t, |
828 |
|
std::string option, |
829 |
|
std::string optionarg) |
830 |
|
{ |
831 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
832 |
|
|
833 |
|
arith().replayRejectCutSize = parsedval; |
834 |
|
arith().replayRejectCutSize__setByUser__ = true; |
835 |
|
Trace("options") << "user assigned option replayRejectCutSize" << std::endl; |
836 |
|
} |
837 |
|
template <> void Options::assign( |
838 |
|
options::soiApproxMajorFailurePen__option_t, |
839 |
|
std::string option, |
840 |
|
std::string optionarg) |
841 |
|
{ |
842 |
|
auto parsedval = handleOption<int>(option, optionarg); |
843 |
|
|
844 |
|
arith().soiApproxMajorFailurePen = parsedval; |
845 |
|
arith().soiApproxMajorFailurePen__setByUser__ = true; |
846 |
|
Trace("options") << "user assigned option soiApproxMajorFailurePen" << std::endl; |
847 |
|
} |
848 |
|
template <> void Options::assign( |
849 |
|
options::soiApproxMajorFailure__option_t, |
850 |
|
std::string option, |
851 |
|
std::string optionarg) |
852 |
|
{ |
853 |
|
auto parsedval = handleOption<double>(option, optionarg); |
854 |
|
|
855 |
|
arith().soiApproxMajorFailure = parsedval; |
856 |
|
arith().soiApproxMajorFailure__setByUser__ = true; |
857 |
|
Trace("options") << "user assigned option soiApproxMajorFailure" << std::endl; |
858 |
|
} |
859 |
|
template <> void Options::assign( |
860 |
|
options::soiApproxMinorFailurePen__option_t, |
861 |
|
std::string option, |
862 |
|
std::string optionarg) |
863 |
|
{ |
864 |
|
auto parsedval = handleOption<int>(option, optionarg); |
865 |
|
|
866 |
|
arith().soiApproxMinorFailurePen = parsedval; |
867 |
|
arith().soiApproxMinorFailurePen__setByUser__ = true; |
868 |
|
Trace("options") << "user assigned option soiApproxMinorFailurePen" << std::endl; |
869 |
|
} |
870 |
|
template <> void Options::assign( |
871 |
|
options::soiApproxMinorFailure__option_t, |
872 |
|
std::string option, |
873 |
|
std::string optionarg) |
874 |
|
{ |
875 |
|
auto parsedval = handleOption<double>(option, optionarg); |
876 |
|
|
877 |
|
arith().soiApproxMinorFailure = parsedval; |
878 |
|
arith().soiApproxMinorFailure__setByUser__ = true; |
879 |
|
Trace("options") << "user assigned option soiApproxMinorFailure" << std::endl; |
880 |
|
} |
881 |
|
template <> void Options::assignBool( |
882 |
|
options::restrictedPivots__option_t, |
883 |
|
std::string option, |
884 |
|
bool value) |
885 |
|
{ |
886 |
|
|
887 |
|
arith().restrictedPivots = value; |
888 |
|
arith().restrictedPivots__setByUser__ = true; |
889 |
|
Trace("options") << "user assigned option restrictedPivots" << std::endl; |
890 |
|
} |
891 |
|
template <> void Options::assignBool( |
892 |
|
options::revertArithModels__option_t, |
893 |
|
std::string option, |
894 |
|
bool value) |
895 |
|
{ |
896 |
|
|
897 |
|
arith().revertArithModels = value; |
898 |
|
arith().revertArithModels__setByUser__ = true; |
899 |
|
Trace("options") << "user assigned option revertArithModels" << std::endl; |
900 |
|
} |
901 |
|
template <> void Options::assign( |
902 |
|
options::rrTurns__option_t, |
903 |
|
std::string option, |
904 |
|
std::string optionarg) |
905 |
|
{ |
906 |
|
auto parsedval = handleOption<int>(option, optionarg); |
907 |
|
|
908 |
|
arith().rrTurns = parsedval; |
909 |
|
arith().rrTurns__setByUser__ = true; |
910 |
|
Trace("options") << "user assigned option rrTurns" << std::endl; |
911 |
|
} |
912 |
|
template <> void Options::assignBool( |
913 |
|
options::trySolveIntStandardEffort__option_t, |
914 |
|
std::string option, |
915 |
|
bool value) |
916 |
|
{ |
917 |
|
|
918 |
|
arith().trySolveIntStandardEffort = value; |
919 |
|
arith().trySolveIntStandardEffort__setByUser__ = true; |
920 |
|
Trace("options") << "user assigned option trySolveIntStandardEffort" << std::endl; |
921 |
|
} |
922 |
|
template <> void Options::assign( |
923 |
|
options::arithSimplexCheckPeriod__option_t, |
924 |
|
std::string option, |
925 |
|
std::string optionarg) |
926 |
|
{ |
927 |
|
auto parsedval = handleOption<uint16_t>(option, optionarg); |
928 |
|
|
929 |
|
arith().arithSimplexCheckPeriod = parsedval; |
930 |
|
arith().arithSimplexCheckPeriod__setByUser__ = true; |
931 |
|
Trace("options") << "user assigned option arithSimplexCheckPeriod" << std::endl; |
932 |
|
} |
933 |
|
template <> void Options::assignBool( |
934 |
|
options::soiQuickExplain__option_t, |
935 |
|
std::string option, |
936 |
|
bool value) |
937 |
|
{ |
938 |
|
|
939 |
|
arith().soiQuickExplain = value; |
940 |
|
arith().soiQuickExplain__setByUser__ = true; |
941 |
|
Trace("options") << "user assigned option soiQuickExplain" << std::endl; |
942 |
|
} |
943 |
|
template <> void Options::assign( |
944 |
|
options::arithStandardCheckVarOrderPivots__option_t, |
945 |
|
std::string option, |
946 |
|
std::string optionarg) |
947 |
|
{ |
948 |
|
auto parsedval = handleOption<int16_t>(option, optionarg); |
949 |
|
|
950 |
|
arith().arithStandardCheckVarOrderPivots = parsedval; |
951 |
|
arith().arithStandardCheckVarOrderPivots__setByUser__ = true; |
952 |
|
Trace("options") << "user assigned option arithStandardCheckVarOrderPivots" << std::endl; |
953 |
|
} |
954 |
|
template <> void Options::assign( |
955 |
|
options::arithUnateLemmaMode__option_t, |
956 |
|
std::string option, |
957 |
|
std::string optionarg) |
958 |
|
{ |
959 |
|
auto parsedval = stringToArithUnateLemmaMode(optionarg); |
960 |
|
|
961 |
|
arith().arithUnateLemmaMode = parsedval; |
962 |
|
arith().arithUnateLemmaMode__setByUser__ = true; |
963 |
|
Trace("options") << "user assigned option arithUnateLemmaMode" << std::endl; |
964 |
|
} |
965 |
|
template <> void Options::assignBool( |
966 |
|
options::useApprox__option_t, |
967 |
|
std::string option, |
968 |
|
bool value) |
969 |
|
{ |
970 |
|
|
971 |
|
arith().useApprox = value; |
972 |
|
arith().useApprox__setByUser__ = true; |
973 |
|
Trace("options") << "user assigned option useApprox" << std::endl; |
974 |
|
} |
975 |
|
template <> void Options::assignBool( |
976 |
|
options::useFC__option_t, |
977 |
|
std::string option, |
978 |
|
bool value) |
979 |
|
{ |
980 |
|
|
981 |
|
arith().useFC = value; |
982 |
|
arith().useFC__setByUser__ = true; |
983 |
|
Trace("options") << "user assigned option useFC" << std::endl; |
984 |
|
} |
985 |
|
template <> void Options::assignBool( |
986 |
|
options::useSOI__option_t, |
987 |
|
std::string option, |
988 |
|
bool value) |
989 |
|
{ |
990 |
|
|
991 |
|
arith().useSOI = value; |
992 |
|
arith().useSOI__setByUser__ = true; |
993 |
|
Trace("options") << "user assigned option useSOI" << std::endl; |
994 |
|
} |
995 |
|
template <> void Options::assign( |
996 |
|
options::arraysConfig__option_t, |
997 |
|
std::string option, |
998 |
|
std::string optionarg) |
999 |
|
{ |
1000 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1001 |
|
|
1002 |
|
arrays().arraysConfig = parsedval; |
1003 |
|
arrays().arraysConfig__setByUser__ = true; |
1004 |
|
Trace("options") << "user assigned option arraysConfig" << std::endl; |
1005 |
|
} |
1006 |
|
template <> void Options::assignBool( |
1007 |
|
options::arraysEagerIndexSplitting__option_t, |
1008 |
|
std::string option, |
1009 |
|
bool value) |
1010 |
|
{ |
1011 |
|
|
1012 |
|
arrays().arraysEagerIndexSplitting = value; |
1013 |
|
arrays().arraysEagerIndexSplitting__setByUser__ = true; |
1014 |
|
Trace("options") << "user assigned option arraysEagerIndexSplitting" << std::endl; |
1015 |
|
} |
1016 |
|
template <> void Options::assignBool( |
1017 |
|
options::arraysEagerLemmas__option_t, |
1018 |
|
std::string option, |
1019 |
|
bool value) |
1020 |
|
{ |
1021 |
|
|
1022 |
|
arrays().arraysEagerLemmas = value; |
1023 |
|
arrays().arraysEagerLemmas__setByUser__ = true; |
1024 |
|
Trace("options") << "user assigned option arraysEagerLemmas" << std::endl; |
1025 |
|
} |
1026 |
10 |
template <> void Options::assignBool( |
1027 |
|
options::arraysExp__option_t, |
1028 |
|
std::string option, |
1029 |
|
bool value) |
1030 |
|
{ |
1031 |
|
|
1032 |
10 |
arrays().arraysExp = value; |
1033 |
10 |
arrays().arraysExp__setByUser__ = true; |
1034 |
10 |
Trace("options") << "user assigned option arraysExp" << std::endl; |
1035 |
10 |
} |
1036 |
|
template <> void Options::assignBool( |
1037 |
|
options::arraysModelBased__option_t, |
1038 |
|
std::string option, |
1039 |
|
bool value) |
1040 |
|
{ |
1041 |
|
|
1042 |
|
arrays().arraysModelBased = value; |
1043 |
|
arrays().arraysModelBased__setByUser__ = true; |
1044 |
|
Trace("options") << "user assigned option arraysModelBased" << std::endl; |
1045 |
|
} |
1046 |
|
template <> void Options::assignBool( |
1047 |
|
options::arraysOptimizeLinear__option_t, |
1048 |
|
std::string option, |
1049 |
|
bool value) |
1050 |
|
{ |
1051 |
|
|
1052 |
|
arrays().arraysOptimizeLinear = value; |
1053 |
|
arrays().arraysOptimizeLinear__setByUser__ = true; |
1054 |
|
Trace("options") << "user assigned option arraysOptimizeLinear" << std::endl; |
1055 |
|
} |
1056 |
|
template <> void Options::assign( |
1057 |
|
options::arraysPropagate__option_t, |
1058 |
|
std::string option, |
1059 |
|
std::string optionarg) |
1060 |
|
{ |
1061 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1062 |
|
|
1063 |
|
arrays().arraysPropagate = parsedval; |
1064 |
|
arrays().arraysPropagate__setByUser__ = true; |
1065 |
|
Trace("options") << "user assigned option arraysPropagate" << std::endl; |
1066 |
|
} |
1067 |
|
template <> void Options::assignBool( |
1068 |
|
options::arraysReduceSharing__option_t, |
1069 |
|
std::string option, |
1070 |
|
bool value) |
1071 |
|
{ |
1072 |
|
|
1073 |
|
arrays().arraysReduceSharing = value; |
1074 |
|
arrays().arraysReduceSharing__setByUser__ = true; |
1075 |
|
Trace("options") << "user assigned option arraysReduceSharing" << std::endl; |
1076 |
|
} |
1077 |
|
template <> void Options::assignBool( |
1078 |
|
options::arraysWeakEquivalence__option_t, |
1079 |
|
std::string option, |
1080 |
|
bool value) |
1081 |
|
{ |
1082 |
|
|
1083 |
|
arrays().arraysWeakEquivalence = value; |
1084 |
|
arrays().arraysWeakEquivalence__setByUser__ = true; |
1085 |
|
Trace("options") << "user assigned option arraysWeakEquivalence" << std::endl; |
1086 |
|
} |
1087 |
500 |
template <> void Options::assign( |
1088 |
|
options::inputLanguage__option_t, |
1089 |
|
std::string option, |
1090 |
|
std::string optionarg) |
1091 |
|
{ |
1092 |
500 |
auto parsedval = d_handler->stringToInputLanguage(option, optionarg); |
1093 |
|
|
1094 |
500 |
base().inputLanguage = parsedval; |
1095 |
500 |
base().inputLanguage__setByUser__ = true; |
1096 |
500 |
Trace("options") << "user assigned option inputLanguage" << std::endl; |
1097 |
500 |
} |
1098 |
|
template <> void Options::assignBool( |
1099 |
|
options::languageHelp__option_t, |
1100 |
|
std::string option, |
1101 |
|
bool value) |
1102 |
|
{ |
1103 |
|
|
1104 |
|
base().languageHelp = value; |
1105 |
|
base().languageHelp__setByUser__ = true; |
1106 |
|
Trace("options") << "user assigned option languageHelp" << std::endl; |
1107 |
|
} |
1108 |
87 |
template <> void Options::assign( |
1109 |
|
options::outputLanguage__option_t, |
1110 |
|
std::string option, |
1111 |
|
std::string optionarg) |
1112 |
|
{ |
1113 |
87 |
auto parsedval = d_handler->stringToOutputLanguage(option, optionarg); |
1114 |
|
|
1115 |
87 |
base().outputLanguage = parsedval; |
1116 |
87 |
base().outputLanguage__setByUser__ = true; |
1117 |
87 |
Trace("options") << "user assigned option outputLanguage" << std::endl; |
1118 |
87 |
} |
1119 |
|
template <> void Options::assignBool( |
1120 |
|
options::parseOnly__option_t, |
1121 |
|
std::string option, |
1122 |
|
bool value) |
1123 |
|
{ |
1124 |
|
|
1125 |
|
base().parseOnly = value; |
1126 |
|
base().parseOnly__setByUser__ = true; |
1127 |
|
Trace("options") << "user assigned option parseOnly" << std::endl; |
1128 |
|
} |
1129 |
3 |
template <> void Options::assignBool( |
1130 |
|
options::preprocessOnly__option_t, |
1131 |
|
std::string option, |
1132 |
|
bool value) |
1133 |
|
{ |
1134 |
|
|
1135 |
3 |
base().preprocessOnly = value; |
1136 |
3 |
base().preprocessOnly__setByUser__ = true; |
1137 |
3 |
Trace("options") << "user assigned option preprocessOnly" << std::endl; |
1138 |
3 |
} |
1139 |
29 |
template <> void Options::assignBool( |
1140 |
|
options::printSuccess__option_t, |
1141 |
|
std::string option, |
1142 |
|
bool value) |
1143 |
|
{ |
1144 |
|
|
1145 |
29 |
base().printSuccess = value; |
1146 |
29 |
base().printSuccess__setByUser__ = true; |
1147 |
29 |
Trace("options") << "user assigned option printSuccess" << std::endl; |
1148 |
29 |
} |
1149 |
|
template <> void Options::assignBool( |
1150 |
|
options::statistics__option_t, |
1151 |
|
std::string option, |
1152 |
|
bool value) |
1153 |
|
{ |
1154 |
|
d_handler->setStats(option, value); |
1155 |
|
base().statistics = value; |
1156 |
|
base().statistics__setByUser__ = true; |
1157 |
|
Trace("options") << "user assigned option statistics" << std::endl; |
1158 |
|
} |
1159 |
|
template <> void Options::assignBool( |
1160 |
|
options::statisticsAll__option_t, |
1161 |
|
std::string option, |
1162 |
|
bool value) |
1163 |
|
{ |
1164 |
|
d_handler->setStats(option, value); |
1165 |
|
base().statisticsAll = value; |
1166 |
|
base().statisticsAll__setByUser__ = true; |
1167 |
|
Trace("options") << "user assigned option statisticsAll" << std::endl; |
1168 |
|
} |
1169 |
|
template <> void Options::assignBool( |
1170 |
|
options::statisticsEveryQuery__option_t, |
1171 |
|
std::string option, |
1172 |
|
bool value) |
1173 |
|
{ |
1174 |
|
d_handler->setStats(option, value); |
1175 |
|
base().statisticsEveryQuery = value; |
1176 |
|
base().statisticsEveryQuery__setByUser__ = true; |
1177 |
|
Trace("options") << "user assigned option statisticsEveryQuery" << std::endl; |
1178 |
|
} |
1179 |
|
template <> void Options::assignBool( |
1180 |
|
options::statisticsExpert__option_t, |
1181 |
|
std::string option, |
1182 |
|
bool value) |
1183 |
|
{ |
1184 |
|
d_handler->setStats(option, value); |
1185 |
|
base().statisticsExpert = value; |
1186 |
|
base().statisticsExpert__setByUser__ = true; |
1187 |
|
Trace("options") << "user assigned option statisticsExpert" << std::endl; |
1188 |
|
} |
1189 |
|
template <> void Options::assign( |
1190 |
|
options::verbosity__option_t, |
1191 |
|
std::string option, |
1192 |
|
std::string optionarg) |
1193 |
|
{ |
1194 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1195 |
|
d_handler->setVerbosity(option, parsedval); |
1196 |
|
base().verbosity = parsedval; |
1197 |
|
base().verbosity__setByUser__ = true; |
1198 |
|
Trace("options") << "user assigned option verbosity" << std::endl; |
1199 |
|
} |
1200 |
|
template <> void Options::assignBool( |
1201 |
|
options::bitvectorAig__option_t, |
1202 |
|
std::string option, |
1203 |
|
bool value) |
1204 |
|
{ |
1205 |
|
d_handler->abcEnabledBuild(option, value); |
1206 |
|
d_handler->setBitblastAig(option, value); |
1207 |
|
bv().bitvectorAig = value; |
1208 |
|
bv().bitvectorAig__setByUser__ = true; |
1209 |
|
Trace("options") << "user assigned option bitvectorAig" << std::endl; |
1210 |
|
} |
1211 |
38 |
template <> void Options::assign( |
1212 |
|
options::bitblastMode__option_t, |
1213 |
|
std::string option, |
1214 |
|
std::string optionarg) |
1215 |
|
{ |
1216 |
38 |
auto parsedval = stringToBitblastMode(optionarg); |
1217 |
|
|
1218 |
38 |
bv().bitblastMode = parsedval; |
1219 |
38 |
bv().bitblastMode__setByUser__ = true; |
1220 |
38 |
Trace("options") << "user assigned option bitblastMode" << std::endl; |
1221 |
38 |
} |
1222 |
|
template <> void Options::assignBool( |
1223 |
|
options::bitwiseEq__option_t, |
1224 |
|
std::string option, |
1225 |
|
bool value) |
1226 |
|
{ |
1227 |
|
|
1228 |
|
bv().bitwiseEq = value; |
1229 |
|
bv().bitwiseEq__setByUser__ = true; |
1230 |
|
Trace("options") << "user assigned option bitwiseEq" << std::endl; |
1231 |
|
} |
1232 |
12 |
template <> void Options::assign( |
1233 |
|
options::boolToBitvector__option_t, |
1234 |
|
std::string option, |
1235 |
|
std::string optionarg) |
1236 |
|
{ |
1237 |
12 |
auto parsedval = stringToBoolToBVMode(optionarg); |
1238 |
|
|
1239 |
12 |
bv().boolToBitvector = parsedval; |
1240 |
12 |
bv().boolToBitvector__setByUser__ = true; |
1241 |
12 |
Trace("options") << "user assigned option boolToBitvector" << std::endl; |
1242 |
12 |
} |
1243 |
4 |
template <> void Options::assignBool( |
1244 |
|
options::bvAbstraction__option_t, |
1245 |
|
std::string option, |
1246 |
|
bool value) |
1247 |
|
{ |
1248 |
|
|
1249 |
4 |
bv().bvAbstraction = value; |
1250 |
4 |
bv().bvAbstraction__setByUser__ = true; |
1251 |
4 |
Trace("options") << "user assigned option bvAbstraction" << std::endl; |
1252 |
4 |
} |
1253 |
|
template <> void Options::assign( |
1254 |
|
options::bitvectorAigSimplifications__option_t, |
1255 |
|
std::string option, |
1256 |
|
std::string optionarg) |
1257 |
|
{ |
1258 |
|
auto parsedval = handleOption<std::string>(option, optionarg); |
1259 |
|
d_handler->abcEnabledBuild(option, parsedval); |
1260 |
|
bv().bitvectorAigSimplifications = parsedval; |
1261 |
|
bv().bitvectorAigSimplifications__setByUser__ = true; |
1262 |
|
Trace("options") << "user assigned option bitvectorAigSimplifications" << std::endl; |
1263 |
|
} |
1264 |
|
template <> void Options::assignBool( |
1265 |
|
options::bvAlgExtf__option_t, |
1266 |
|
std::string option, |
1267 |
|
bool value) |
1268 |
|
{ |
1269 |
|
|
1270 |
|
bv().bvAlgExtf = value; |
1271 |
|
bv().bvAlgExtf__setByUser__ = true; |
1272 |
|
Trace("options") << "user assigned option bvAlgExtf" << std::endl; |
1273 |
|
} |
1274 |
|
template <> void Options::assign( |
1275 |
|
options::bitvectorAlgebraicBudget__option_t, |
1276 |
|
std::string option, |
1277 |
|
std::string optionarg) |
1278 |
|
{ |
1279 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
1280 |
|
|
1281 |
|
bv().bitvectorAlgebraicBudget = parsedval; |
1282 |
|
bv().bitvectorAlgebraicBudget__setByUser__ = true; |
1283 |
|
Trace("options") << "user assigned option bitvectorAlgebraicBudget" << std::endl; |
1284 |
|
} |
1285 |
|
template <> void Options::assignBool( |
1286 |
|
options::bitvectorAlgebraicSolver__option_t, |
1287 |
|
std::string option, |
1288 |
|
bool value) |
1289 |
|
{ |
1290 |
|
|
1291 |
|
bv().bitvectorAlgebraicSolver = value; |
1292 |
|
bv().bitvectorAlgebraicSolver__setByUser__ = true; |
1293 |
|
Trace("options") << "user assigned option bitvectorAlgebraicSolver" << std::endl; |
1294 |
|
} |
1295 |
|
template <> void Options::assignBool( |
1296 |
|
options::bvAssertInput__option_t, |
1297 |
|
std::string option, |
1298 |
|
bool value) |
1299 |
|
{ |
1300 |
|
|
1301 |
|
bv().bvAssertInput = value; |
1302 |
|
bv().bvAssertInput__setByUser__ = true; |
1303 |
|
Trace("options") << "user assigned option bvAssertInput" << std::endl; |
1304 |
|
} |
1305 |
|
template <> void Options::assignBool( |
1306 |
|
options::bvEagerExplanations__option_t, |
1307 |
|
std::string option, |
1308 |
|
bool value) |
1309 |
|
{ |
1310 |
|
|
1311 |
|
bv().bvEagerExplanations = value; |
1312 |
|
bv().bvEagerExplanations__setByUser__ = true; |
1313 |
|
Trace("options") << "user assigned option bvEagerExplanations" << std::endl; |
1314 |
|
} |
1315 |
2 |
template <> void Options::assignBool( |
1316 |
|
options::bitvectorEqualitySolver__option_t, |
1317 |
|
std::string option, |
1318 |
|
bool value) |
1319 |
|
{ |
1320 |
|
|
1321 |
2 |
bv().bitvectorEqualitySolver = value; |
1322 |
2 |
bv().bitvectorEqualitySolver__setByUser__ = true; |
1323 |
2 |
Trace("options") << "user assigned option bitvectorEqualitySolver" << std::endl; |
1324 |
2 |
} |
1325 |
|
template <> void Options::assignBool( |
1326 |
|
options::bvExtractArithRewrite__option_t, |
1327 |
|
std::string option, |
1328 |
|
bool value) |
1329 |
|
{ |
1330 |
|
|
1331 |
|
bv().bvExtractArithRewrite = value; |
1332 |
|
bv().bvExtractArithRewrite__setByUser__ = true; |
1333 |
|
Trace("options") << "user assigned option bvExtractArithRewrite" << std::endl; |
1334 |
|
} |
1335 |
|
template <> void Options::assignBool( |
1336 |
|
options::bvGaussElim__option_t, |
1337 |
|
std::string option, |
1338 |
|
bool value) |
1339 |
|
{ |
1340 |
|
|
1341 |
|
bv().bvGaussElim = value; |
1342 |
|
bv().bvGaussElim__setByUser__ = true; |
1343 |
|
Trace("options") << "user assigned option bvGaussElim" << std::endl; |
1344 |
|
} |
1345 |
|
template <> void Options::assignBool( |
1346 |
|
options::bitvectorInequalitySolver__option_t, |
1347 |
|
std::string option, |
1348 |
|
bool value) |
1349 |
|
{ |
1350 |
|
|
1351 |
|
bv().bitvectorInequalitySolver = value; |
1352 |
|
bv().bitvectorInequalitySolver__setByUser__ = true; |
1353 |
|
Trace("options") << "user assigned option bitvectorInequalitySolver" << std::endl; |
1354 |
|
} |
1355 |
2 |
template <> void Options::assignBool( |
1356 |
|
options::bvIntroducePow2__option_t, |
1357 |
|
std::string option, |
1358 |
|
bool value) |
1359 |
|
{ |
1360 |
|
|
1361 |
2 |
bv().bvIntroducePow2 = value; |
1362 |
2 |
bv().bvIntroducePow2__setByUser__ = true; |
1363 |
2 |
Trace("options") << "user assigned option bvIntroducePow2" << std::endl; |
1364 |
2 |
} |
1365 |
|
template <> void Options::assignBool( |
1366 |
|
options::bvLazyReduceExtf__option_t, |
1367 |
|
std::string option, |
1368 |
|
bool value) |
1369 |
|
{ |
1370 |
|
|
1371 |
|
bv().bvLazyReduceExtf = value; |
1372 |
|
bv().bvLazyReduceExtf__setByUser__ = true; |
1373 |
|
Trace("options") << "user assigned option bvLazyReduceExtf" << std::endl; |
1374 |
|
} |
1375 |
|
template <> void Options::assignBool( |
1376 |
|
options::bvLazyRewriteExtf__option_t, |
1377 |
|
std::string option, |
1378 |
|
bool value) |
1379 |
|
{ |
1380 |
|
|
1381 |
|
bv().bvLazyRewriteExtf = value; |
1382 |
|
bv().bvLazyRewriteExtf__setByUser__ = true; |
1383 |
|
Trace("options") << "user assigned option bvLazyRewriteExtf" << std::endl; |
1384 |
|
} |
1385 |
|
template <> void Options::assign( |
1386 |
|
options::bvNumFunc__option_t, |
1387 |
|
std::string option, |
1388 |
|
std::string optionarg) |
1389 |
|
{ |
1390 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
1391 |
|
|
1392 |
|
bv().bvNumFunc = parsedval; |
1393 |
|
bv().bvNumFunc__setByUser__ = true; |
1394 |
|
Trace("options") << "user assigned option bvNumFunc" << std::endl; |
1395 |
|
} |
1396 |
2 |
template <> void Options::assignBool( |
1397 |
|
options::bvPrintConstsAsIndexedSymbols__option_t, |
1398 |
|
std::string option, |
1399 |
|
bool value) |
1400 |
|
{ |
1401 |
|
|
1402 |
2 |
bv().bvPrintConstsAsIndexedSymbols = value; |
1403 |
2 |
bv().bvPrintConstsAsIndexedSymbols__setByUser__ = true; |
1404 |
2 |
Trace("options") << "user assigned option bvPrintConstsAsIndexedSymbols" << std::endl; |
1405 |
2 |
} |
1406 |
|
template <> void Options::assignBool( |
1407 |
|
options::bitvectorPropagate__option_t, |
1408 |
|
std::string option, |
1409 |
|
bool value) |
1410 |
|
{ |
1411 |
|
|
1412 |
|
bv().bitvectorPropagate = value; |
1413 |
|
bv().bitvectorPropagate__setByUser__ = true; |
1414 |
|
Trace("options") << "user assigned option bitvectorPropagate" << std::endl; |
1415 |
|
} |
1416 |
|
template <> void Options::assignBool( |
1417 |
|
options::bitvectorQuickXplain__option_t, |
1418 |
|
std::string option, |
1419 |
|
bool value) |
1420 |
|
{ |
1421 |
|
|
1422 |
|
bv().bitvectorQuickXplain = value; |
1423 |
|
bv().bitvectorQuickXplain__setByUser__ = true; |
1424 |
|
Trace("options") << "user assigned option bitvectorQuickXplain" << std::endl; |
1425 |
|
} |
1426 |
18 |
template <> void Options::assign( |
1427 |
|
options::bvSatSolver__option_t, |
1428 |
|
std::string option, |
1429 |
|
std::string optionarg) |
1430 |
|
{ |
1431 |
18 |
auto parsedval = stringToSatSolverMode(optionarg); |
1432 |
16 |
d_handler->checkBvSatSolver(option, parsedval); |
1433 |
16 |
bv().bvSatSolver = parsedval; |
1434 |
16 |
bv().bvSatSolver__setByUser__ = true; |
1435 |
16 |
Trace("options") << "user assigned option bvSatSolver" << std::endl; |
1436 |
16 |
} |
1437 |
|
template <> void Options::assignBool( |
1438 |
|
options::skolemizeArguments__option_t, |
1439 |
|
std::string option, |
1440 |
|
bool value) |
1441 |
|
{ |
1442 |
|
|
1443 |
|
bv().skolemizeArguments = value; |
1444 |
|
bv().skolemizeArguments__setByUser__ = true; |
1445 |
|
Trace("options") << "user assigned option skolemizeArguments" << std::endl; |
1446 |
|
} |
1447 |
14 |
template <> void Options::assign( |
1448 |
|
options::bvSolver__option_t, |
1449 |
|
std::string option, |
1450 |
|
std::string optionarg) |
1451 |
|
{ |
1452 |
14 |
auto parsedval = stringToBVSolver(optionarg); |
1453 |
|
|
1454 |
14 |
bv().bvSolver = parsedval; |
1455 |
14 |
bv().bvSolver__setByUser__ = true; |
1456 |
14 |
Trace("options") << "user assigned option bvSolver" << std::endl; |
1457 |
14 |
} |
1458 |
10 |
template <> void Options::assignBool( |
1459 |
|
options::bitvectorToBool__option_t, |
1460 |
|
std::string option, |
1461 |
|
bool value) |
1462 |
|
{ |
1463 |
|
|
1464 |
10 |
bv().bitvectorToBool = value; |
1465 |
10 |
bv().bitvectorToBool__setByUser__ = true; |
1466 |
10 |
Trace("options") << "user assigned option bitvectorToBool" << std::endl; |
1467 |
10 |
} |
1468 |
|
template <> void Options::assignBool( |
1469 |
|
options::cdtBisimilar__option_t, |
1470 |
|
std::string option, |
1471 |
|
bool value) |
1472 |
|
{ |
1473 |
|
|
1474 |
|
datatypes().cdtBisimilar = value; |
1475 |
|
datatypes().cdtBisimilar__setByUser__ = true; |
1476 |
|
Trace("options") << "user assigned option cdtBisimilar" << std::endl; |
1477 |
|
} |
1478 |
|
template <> void Options::assignBool( |
1479 |
|
options::dtBinarySplit__option_t, |
1480 |
|
std::string option, |
1481 |
|
bool value) |
1482 |
|
{ |
1483 |
|
|
1484 |
|
datatypes().dtBinarySplit = value; |
1485 |
|
datatypes().dtBinarySplit__setByUser__ = true; |
1486 |
|
Trace("options") << "user assigned option dtBinarySplit" << std::endl; |
1487 |
|
} |
1488 |
|
template <> void Options::assignBool( |
1489 |
|
options::dtBlastSplits__option_t, |
1490 |
|
std::string option, |
1491 |
|
bool value) |
1492 |
|
{ |
1493 |
|
|
1494 |
|
datatypes().dtBlastSplits = value; |
1495 |
|
datatypes().dtBlastSplits__setByUser__ = true; |
1496 |
|
Trace("options") << "user assigned option dtBlastSplits" << std::endl; |
1497 |
|
} |
1498 |
|
template <> void Options::assignBool( |
1499 |
|
options::dtCyclic__option_t, |
1500 |
|
std::string option, |
1501 |
|
bool value) |
1502 |
|
{ |
1503 |
|
|
1504 |
|
datatypes().dtCyclic = value; |
1505 |
|
datatypes().dtCyclic__setByUser__ = true; |
1506 |
|
Trace("options") << "user assigned option dtCyclic" << std::endl; |
1507 |
|
} |
1508 |
|
template <> void Options::assignBool( |
1509 |
|
options::dtForceAssignment__option_t, |
1510 |
|
std::string option, |
1511 |
|
bool value) |
1512 |
|
{ |
1513 |
|
|
1514 |
|
datatypes().dtForceAssignment = value; |
1515 |
|
datatypes().dtForceAssignment__setByUser__ = true; |
1516 |
|
Trace("options") << "user assigned option dtForceAssignment" << std::endl; |
1517 |
|
} |
1518 |
|
template <> void Options::assignBool( |
1519 |
|
options::dtInferAsLemmas__option_t, |
1520 |
|
std::string option, |
1521 |
|
bool value) |
1522 |
|
{ |
1523 |
|
|
1524 |
|
datatypes().dtInferAsLemmas = value; |
1525 |
|
datatypes().dtInferAsLemmas__setByUser__ = true; |
1526 |
|
Trace("options") << "user assigned option dtInferAsLemmas" << std::endl; |
1527 |
|
} |
1528 |
10 |
template <> void Options::assignBool( |
1529 |
|
options::dtNestedRec__option_t, |
1530 |
|
std::string option, |
1531 |
|
bool value) |
1532 |
|
{ |
1533 |
|
|
1534 |
10 |
datatypes().dtNestedRec = value; |
1535 |
10 |
datatypes().dtNestedRec__setByUser__ = true; |
1536 |
10 |
Trace("options") << "user assigned option dtNestedRec" << std::endl; |
1537 |
10 |
} |
1538 |
|
template <> void Options::assignBool( |
1539 |
|
options::dtPoliteOptimize__option_t, |
1540 |
|
std::string option, |
1541 |
|
bool value) |
1542 |
|
{ |
1543 |
|
|
1544 |
|
datatypes().dtPoliteOptimize = value; |
1545 |
|
datatypes().dtPoliteOptimize__setByUser__ = true; |
1546 |
|
Trace("options") << "user assigned option dtPoliteOptimize" << std::endl; |
1547 |
|
} |
1548 |
5 |
template <> void Options::assignBool( |
1549 |
|
options::dtRewriteErrorSel__option_t, |
1550 |
|
std::string option, |
1551 |
|
bool value) |
1552 |
|
{ |
1553 |
|
|
1554 |
5 |
datatypes().dtRewriteErrorSel = value; |
1555 |
5 |
datatypes().dtRewriteErrorSel__setByUser__ = true; |
1556 |
5 |
Trace("options") << "user assigned option dtRewriteErrorSel" << std::endl; |
1557 |
5 |
} |
1558 |
|
template <> void Options::assignBool( |
1559 |
|
options::dtSharedSelectors__option_t, |
1560 |
|
std::string option, |
1561 |
|
bool value) |
1562 |
|
{ |
1563 |
|
|
1564 |
|
datatypes().dtSharedSelectors = value; |
1565 |
|
datatypes().dtSharedSelectors__setByUser__ = true; |
1566 |
|
Trace("options") << "user assigned option dtSharedSelectors" << std::endl; |
1567 |
|
} |
1568 |
11 |
template <> void Options::assign( |
1569 |
|
options::sygusAbortSize__option_t, |
1570 |
|
std::string option, |
1571 |
|
std::string optionarg) |
1572 |
|
{ |
1573 |
11 |
auto parsedval = handleOption<int>(option, optionarg); |
1574 |
|
|
1575 |
11 |
datatypes().sygusAbortSize = parsedval; |
1576 |
11 |
datatypes().sygusAbortSize__setByUser__ = true; |
1577 |
11 |
Trace("options") << "user assigned option sygusAbortSize" << std::endl; |
1578 |
11 |
} |
1579 |
|
template <> void Options::assignBool( |
1580 |
|
options::sygusFairMax__option_t, |
1581 |
|
std::string option, |
1582 |
|
bool value) |
1583 |
|
{ |
1584 |
|
|
1585 |
|
datatypes().sygusFairMax = value; |
1586 |
|
datatypes().sygusFairMax__setByUser__ = true; |
1587 |
|
Trace("options") << "user assigned option sygusFairMax" << std::endl; |
1588 |
|
} |
1589 |
2 |
template <> void Options::assign( |
1590 |
|
options::sygusFair__option_t, |
1591 |
|
std::string option, |
1592 |
|
std::string optionarg) |
1593 |
|
{ |
1594 |
2 |
auto parsedval = stringToSygusFairMode(optionarg); |
1595 |
|
|
1596 |
2 |
datatypes().sygusFair = parsedval; |
1597 |
2 |
datatypes().sygusFair__setByUser__ = true; |
1598 |
2 |
Trace("options") << "user assigned option sygusFair" << std::endl; |
1599 |
2 |
} |
1600 |
8 |
template <> void Options::assignBool( |
1601 |
|
options::sygusSymBreak__option_t, |
1602 |
|
std::string option, |
1603 |
|
bool value) |
1604 |
|
{ |
1605 |
|
|
1606 |
8 |
datatypes().sygusSymBreak = value; |
1607 |
8 |
datatypes().sygusSymBreak__setByUser__ = true; |
1608 |
8 |
Trace("options") << "user assigned option sygusSymBreak" << std::endl; |
1609 |
8 |
} |
1610 |
|
template <> void Options::assignBool( |
1611 |
|
options::sygusSymBreakAgg__option_t, |
1612 |
|
std::string option, |
1613 |
|
bool value) |
1614 |
|
{ |
1615 |
|
|
1616 |
|
datatypes().sygusSymBreakAgg = value; |
1617 |
|
datatypes().sygusSymBreakAgg__setByUser__ = true; |
1618 |
|
Trace("options") << "user assigned option sygusSymBreakAgg" << std::endl; |
1619 |
|
} |
1620 |
|
template <> void Options::assignBool( |
1621 |
|
options::sygusSymBreakDynamic__option_t, |
1622 |
|
std::string option, |
1623 |
|
bool value) |
1624 |
|
{ |
1625 |
|
|
1626 |
|
datatypes().sygusSymBreakDynamic = value; |
1627 |
|
datatypes().sygusSymBreakDynamic__setByUser__ = true; |
1628 |
|
Trace("options") << "user assigned option sygusSymBreakDynamic" << std::endl; |
1629 |
|
} |
1630 |
2 |
template <> void Options::assignBool( |
1631 |
|
options::sygusSymBreakLazy__option_t, |
1632 |
|
std::string option, |
1633 |
|
bool value) |
1634 |
|
{ |
1635 |
|
|
1636 |
2 |
datatypes().sygusSymBreakLazy = value; |
1637 |
2 |
datatypes().sygusSymBreakLazy__setByUser__ = true; |
1638 |
2 |
Trace("options") << "user assigned option sygusSymBreakLazy" << std::endl; |
1639 |
2 |
} |
1640 |
|
template <> void Options::assignBool( |
1641 |
|
options::sygusSymBreakPbe__option_t, |
1642 |
|
std::string option, |
1643 |
|
bool value) |
1644 |
|
{ |
1645 |
|
|
1646 |
|
datatypes().sygusSymBreakPbe = value; |
1647 |
|
datatypes().sygusSymBreakPbe__setByUser__ = true; |
1648 |
|
Trace("options") << "user assigned option sygusSymBreakPbe" << std::endl; |
1649 |
|
} |
1650 |
2 |
template <> void Options::assignBool( |
1651 |
|
options::sygusSymBreakRlv__option_t, |
1652 |
|
std::string option, |
1653 |
|
bool value) |
1654 |
|
{ |
1655 |
|
|
1656 |
2 |
datatypes().sygusSymBreakRlv = value; |
1657 |
2 |
datatypes().sygusSymBreakRlv__setByUser__ = true; |
1658 |
2 |
Trace("options") << "user assigned option sygusSymBreakRlv" << std::endl; |
1659 |
2 |
} |
1660 |
|
template <> void Options::assign( |
1661 |
|
options::decisionRandomWeight__option_t, |
1662 |
|
std::string option, |
1663 |
|
std::string optionarg) |
1664 |
|
{ |
1665 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1666 |
|
|
1667 |
|
decision().decisionRandomWeight = parsedval; |
1668 |
|
decision().decisionRandomWeight__setByUser__ = true; |
1669 |
|
Trace("options") << "user assigned option decisionRandomWeight" << std::endl; |
1670 |
|
} |
1671 |
|
template <> void Options::assign( |
1672 |
|
options::decisionThreshold__option_t, |
1673 |
|
std::string option, |
1674 |
|
std::string optionarg) |
1675 |
|
{ |
1676 |
|
auto parsedval = handleOption<decision::DecisionWeight>(option, optionarg); |
1677 |
|
|
1678 |
|
decision().decisionThreshold = parsedval; |
1679 |
|
decision().decisionThreshold__setByUser__ = true; |
1680 |
|
Trace("options") << "user assigned option decisionThreshold" << std::endl; |
1681 |
|
} |
1682 |
|
template <> void Options::assignBool( |
1683 |
|
options::decisionUseWeight__option_t, |
1684 |
|
std::string option, |
1685 |
|
bool value) |
1686 |
|
{ |
1687 |
|
|
1688 |
|
decision().decisionUseWeight = value; |
1689 |
|
decision().decisionUseWeight__setByUser__ = true; |
1690 |
|
Trace("options") << "user assigned option decisionUseWeight" << std::endl; |
1691 |
|
} |
1692 |
|
template <> void Options::assign( |
1693 |
|
options::decisionWeightInternal__option_t, |
1694 |
|
std::string option, |
1695 |
|
std::string optionarg) |
1696 |
|
{ |
1697 |
|
auto parsedval = stringToDecisionWeightInternal(optionarg); |
1698 |
|
|
1699 |
|
decision().decisionWeightInternal = parsedval; |
1700 |
|
decision().decisionWeightInternal__setByUser__ = true; |
1701 |
|
Trace("options") << "user assigned option decisionWeightInternal" << std::endl; |
1702 |
|
} |
1703 |
68 |
template <> void Options::assign( |
1704 |
|
options::decisionMode__option_t, |
1705 |
|
std::string option, |
1706 |
|
std::string optionarg) |
1707 |
|
{ |
1708 |
68 |
auto parsedval = stringToDecisionMode(optionarg); |
1709 |
68 |
d_handler->setDecisionModeStopOnly(option, parsedval); |
1710 |
68 |
decision().decisionMode = parsedval; |
1711 |
68 |
decision().decisionMode__setByUser__ = true; |
1712 |
68 |
Trace("options") << "user assigned option decisionMode" << std::endl; |
1713 |
68 |
} |
1714 |
|
template <> void Options::assignBool( |
1715 |
|
options::decisionStopOnly__option_t, |
1716 |
|
std::string option, |
1717 |
|
bool value) |
1718 |
|
{ |
1719 |
|
|
1720 |
|
decision().decisionStopOnly = value; |
1721 |
|
decision().decisionStopOnly__setByUser__ = true; |
1722 |
|
Trace("options") << "user assigned option decisionStopOnly" << std::endl; |
1723 |
|
} |
1724 |
2 |
template <> void Options::assign( |
1725 |
|
options::defaultDagThresh__option_t, |
1726 |
|
std::string option, |
1727 |
|
std::string optionarg) |
1728 |
|
{ |
1729 |
2 |
auto parsedval = handleOption<int>(option, optionarg); |
1730 |
2 |
d_handler->setDefaultDagThreshPredicate(option, parsedval); |
1731 |
2 |
expr().defaultDagThresh = parsedval; |
1732 |
2 |
expr().defaultDagThresh__setByUser__ = true; |
1733 |
2 |
Trace("options") << "user assigned option defaultDagThresh" << std::endl; |
1734 |
2 |
} |
1735 |
|
template <> void Options::assign( |
1736 |
|
options::defaultExprDepth__option_t, |
1737 |
|
std::string option, |
1738 |
|
std::string optionarg) |
1739 |
|
{ |
1740 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1741 |
|
d_handler->setDefaultExprDepthPredicate(option, parsedval); |
1742 |
|
expr().defaultExprDepth = parsedval; |
1743 |
|
expr().defaultExprDepth__setByUser__ = true; |
1744 |
|
Trace("options") << "user assigned option defaultExprDepth" << std::endl; |
1745 |
|
} |
1746 |
|
template <> void Options::assignBool( |
1747 |
|
options::typeChecking__option_t, |
1748 |
|
std::string option, |
1749 |
|
bool value) |
1750 |
|
{ |
1751 |
|
|
1752 |
|
expr().typeChecking = value; |
1753 |
|
expr().typeChecking__setByUser__ = true; |
1754 |
|
Trace("options") << "user assigned option typeChecking" << std::endl; |
1755 |
|
} |
1756 |
22 |
template <> void Options::assignBool( |
1757 |
|
options::fpExp__option_t, |
1758 |
|
std::string option, |
1759 |
|
bool value) |
1760 |
|
{ |
1761 |
|
|
1762 |
22 |
fp().fpExp = value; |
1763 |
22 |
fp().fpExp__setByUser__ = true; |
1764 |
22 |
Trace("options") << "user assigned option fpExp" << std::endl; |
1765 |
22 |
} |
1766 |
|
template <> void Options::assignBool( |
1767 |
|
options::earlyExit__option_t, |
1768 |
|
std::string option, |
1769 |
|
bool value) |
1770 |
|
{ |
1771 |
|
|
1772 |
|
driver().earlyExit = value; |
1773 |
|
driver().earlyExit__setByUser__ = true; |
1774 |
|
Trace("options") << "user assigned option earlyExit" << std::endl; |
1775 |
|
} |
1776 |
|
template <> void Options::assignBool( |
1777 |
|
options::help__option_t, |
1778 |
|
std::string option, |
1779 |
|
bool value) |
1780 |
|
{ |
1781 |
|
|
1782 |
|
driver().help = value; |
1783 |
|
driver().help__setByUser__ = true; |
1784 |
|
Trace("options") << "user assigned option help" << std::endl; |
1785 |
|
} |
1786 |
|
template <> void Options::assignBool( |
1787 |
|
options::interactive__option_t, |
1788 |
|
std::string option, |
1789 |
|
bool value) |
1790 |
|
{ |
1791 |
|
|
1792 |
|
driver().interactive = value; |
1793 |
|
driver().interactive__setByUser__ = true; |
1794 |
|
Trace("options") << "user assigned option interactive" << std::endl; |
1795 |
|
} |
1796 |
|
template <> void Options::assignBool( |
1797 |
|
options::interactivePrompt__option_t, |
1798 |
|
std::string option, |
1799 |
|
bool value) |
1800 |
|
{ |
1801 |
|
|
1802 |
|
driver().interactivePrompt = value; |
1803 |
|
driver().interactivePrompt__setByUser__ = true; |
1804 |
|
Trace("options") << "user assigned option interactivePrompt" << std::endl; |
1805 |
|
} |
1806 |
|
template <> void Options::assign( |
1807 |
|
options::seed__option_t, |
1808 |
|
std::string option, |
1809 |
|
std::string optionarg) |
1810 |
|
{ |
1811 |
|
auto parsedval = handleOption<uint64_t>(option, optionarg); |
1812 |
|
|
1813 |
|
driver().seed = parsedval; |
1814 |
|
driver().seed__setByUser__ = true; |
1815 |
|
Trace("options") << "user assigned option seed" << std::endl; |
1816 |
|
} |
1817 |
|
template <> void Options::assignBool( |
1818 |
|
options::segvSpin__option_t, |
1819 |
|
std::string option, |
1820 |
|
bool value) |
1821 |
|
{ |
1822 |
|
|
1823 |
|
driver().segvSpin = value; |
1824 |
|
driver().segvSpin__setByUser__ = true; |
1825 |
|
Trace("options") << "user assigned option segvSpin" << std::endl; |
1826 |
|
} |
1827 |
|
template <> void Options::assign( |
1828 |
|
options::tearDownIncremental__option_t, |
1829 |
|
std::string option, |
1830 |
|
std::string optionarg) |
1831 |
|
{ |
1832 |
|
auto parsedval = handleOption<int>(option, optionarg); |
1833 |
|
|
1834 |
|
driver().tearDownIncremental = parsedval; |
1835 |
|
driver().tearDownIncremental__setByUser__ = true; |
1836 |
|
Trace("options") << "user assigned option tearDownIncremental" << std::endl; |
1837 |
|
} |
1838 |
|
template <> void Options::assignBool( |
1839 |
|
options::version__option_t, |
1840 |
|
std::string option, |
1841 |
|
bool value) |
1842 |
|
{ |
1843 |
|
|
1844 |
|
driver().version = value; |
1845 |
|
driver().version__setByUser__ = true; |
1846 |
|
Trace("options") << "user assigned option version" << std::endl; |
1847 |
|
} |
1848 |
|
template <> void Options::assignBool( |
1849 |
|
options::filesystemAccess__option_t, |
1850 |
|
std::string option, |
1851 |
|
bool value) |
1852 |
|
{ |
1853 |
|
|
1854 |
|
parser().filesystemAccess = value; |
1855 |
|
parser().filesystemAccess__setByUser__ = true; |
1856 |
|
Trace("options") << "user assigned option filesystemAccess" << std::endl; |
1857 |
|
} |
1858 |
9 |
template <> void Options::assign( |
1859 |
|
options::forceLogicString__option_t, |
1860 |
|
std::string option, |
1861 |
|
std::string optionarg) |
1862 |
|
{ |
1863 |
18 |
auto parsedval = handleOption<std::string>(option, optionarg); |
1864 |
|
|
1865 |
9 |
parser().forceLogicString = parsedval; |
1866 |
9 |
parser().forceLogicString__setByUser__ = true; |
1867 |
9 |
Trace("options") << "user assigned option forceLogicString" << std::endl; |
1868 |
9 |
} |
1869 |
17 |
template <> void Options::assignBool( |
1870 |
|
options::globalDeclarations__option_t, |
1871 |
|
std::string option, |
1872 |
|
bool value) |
1873 |
|
{ |
1874 |
|
|
1875 |
17 |
parser().globalDeclarations = value; |
1876 |
17 |
parser().globalDeclarations__setByUser__ = true; |
1877 |
17 |
Trace("options") << "user assigned option globalDeclarations" << std::endl; |
1878 |
17 |
} |
1879 |
|
template <> void Options::assignBool( |
1880 |
|
options::memoryMap__option_t, |
1881 |
|
std::string option, |
1882 |
|
bool value) |
1883 |
|
{ |
1884 |
|
|
1885 |
|
parser().memoryMap = value; |
1886 |
|
parser().memoryMap__setByUser__ = true; |
1887 |
|
Trace("options") << "user assigned option memoryMap" << std::endl; |
1888 |
|
} |
1889 |
|
template <> void Options::assignBool( |
1890 |
|
options::semanticChecks__option_t, |
1891 |
|
std::string option, |
1892 |
|
bool value) |
1893 |
|
{ |
1894 |
|
|
1895 |
|
parser().semanticChecks = value; |
1896 |
|
parser().semanticChecks__setByUser__ = true; |
1897 |
|
Trace("options") << "user assigned option semanticChecks" << std::endl; |
1898 |
|
} |
1899 |
9 |
template <> void Options::assignBool( |
1900 |
|
options::strictParsing__option_t, |
1901 |
|
std::string option, |
1902 |
|
bool value) |
1903 |
|
{ |
1904 |
|
|
1905 |
9 |
parser().strictParsing = value; |
1906 |
9 |
parser().strictParsing__setByUser__ = true; |
1907 |
9 |
Trace("options") << "user assigned option strictParsing" << std::endl; |
1908 |
9 |
} |
1909 |
|
template <> void Options::assignBool( |
1910 |
|
options::flattenHOChains__option_t, |
1911 |
|
std::string option, |
1912 |
|
bool value) |
1913 |
|
{ |
1914 |
|
|
1915 |
|
printer().flattenHOChains = value; |
1916 |
|
printer().flattenHOChains__setByUser__ = true; |
1917 |
|
Trace("options") << "user assigned option flattenHOChains" << std::endl; |
1918 |
|
} |
1919 |
|
template <> void Options::assign( |
1920 |
|
options::instFormatMode__option_t, |
1921 |
|
std::string option, |
1922 |
|
std::string optionarg) |
1923 |
|
{ |
1924 |
|
auto parsedval = d_handler->stringToInstFormatMode(option, optionarg); |
1925 |
|
|
1926 |
|
printer().instFormatMode = parsedval; |
1927 |
|
printer().instFormatMode__setByUser__ = true; |
1928 |
|
Trace("options") << "user assigned option instFormatMode" << std::endl; |
1929 |
|
} |
1930 |
|
template <> void Options::assign( |
1931 |
|
options::modelFormatMode__option_t, |
1932 |
|
std::string option, |
1933 |
|
std::string optionarg) |
1934 |
|
{ |
1935 |
|
auto parsedval = stringToModelFormatMode(optionarg); |
1936 |
|
|
1937 |
|
printer().modelFormatMode = parsedval; |
1938 |
|
printer().modelFormatMode__setByUser__ = true; |
1939 |
|
Trace("options") << "user assigned option modelFormatMode" << std::endl; |
1940 |
|
} |
1941 |
12 |
template <> void Options::assignBool( |
1942 |
|
options::printInstFull__option_t, |
1943 |
|
std::string option, |
1944 |
|
bool value) |
1945 |
|
{ |
1946 |
|
|
1947 |
12 |
printer().printInstFull = value; |
1948 |
12 |
printer().printInstFull__setByUser__ = true; |
1949 |
12 |
Trace("options") << "user assigned option printInstFull" << std::endl; |
1950 |
12 |
} |
1951 |
3 |
template <> void Options::assign( |
1952 |
|
options::printInstMode__option_t, |
1953 |
|
std::string option, |
1954 |
|
std::string optionarg) |
1955 |
|
{ |
1956 |
3 |
auto parsedval = stringToPrintInstMode(optionarg); |
1957 |
|
|
1958 |
3 |
printer().printInstMode = parsedval; |
1959 |
3 |
printer().printInstMode__setByUser__ = true; |
1960 |
3 |
Trace("options") << "user assigned option printInstMode" << std::endl; |
1961 |
3 |
} |
1962 |
2 |
template <> void Options::assignBool( |
1963 |
|
options::proofEagerChecking__option_t, |
1964 |
|
std::string option, |
1965 |
|
bool value) |
1966 |
|
{ |
1967 |
|
|
1968 |
2 |
proof().proofEagerChecking = value; |
1969 |
2 |
proof().proofEagerChecking__setByUser__ = true; |
1970 |
2 |
Trace("options") << "user assigned option proofEagerChecking" << std::endl; |
1971 |
2 |
} |
1972 |
|
template <> void Options::assign( |
1973 |
|
options::proofFormatMode__option_t, |
1974 |
|
std::string option, |
1975 |
|
std::string optionarg) |
1976 |
|
{ |
1977 |
|
auto parsedval = stringToProofFormatMode(optionarg); |
1978 |
|
|
1979 |
|
proof().proofFormatMode = parsedval; |
1980 |
|
proof().proofFormatMode__setByUser__ = true; |
1981 |
|
Trace("options") << "user assigned option proofFormatMode" << std::endl; |
1982 |
|
} |
1983 |
|
template <> void Options::assign( |
1984 |
|
options::proofGranularityMode__option_t, |
1985 |
|
std::string option, |
1986 |
|
std::string optionarg) |
1987 |
|
{ |
1988 |
|
auto parsedval = stringToProofGranularityMode(optionarg); |
1989 |
|
|
1990 |
|
proof().proofGranularityMode = parsedval; |
1991 |
|
proof().proofGranularityMode__setByUser__ = true; |
1992 |
|
Trace("options") << "user assigned option proofGranularityMode" << std::endl; |
1993 |
|
} |
1994 |
|
template <> void Options::assign( |
1995 |
|
options::proofPedantic__option_t, |
1996 |
|
std::string option, |
1997 |
|
std::string optionarg) |
1998 |
|
{ |
1999 |
|
auto parsedval = handleOption<uint32_t>(option, optionarg); |
2000 |
|
|
2001 |
|
proof().proofPedantic = parsedval; |
2002 |
|
proof().proofPedantic__setByUser__ = true; |
2003 |
|
Trace("options") << "user assigned option proofPedantic" << std::endl; |
2004 |
|
} |
2005 |
|
template <> void Options::assignBool( |
2006 |
|
options::proofPrintConclusion__option_t, |
2007 |
|
std::string option, |
2008 |
|
bool value) |
2009 |
|
{ |
2010 |
|
|
2011 |
|
proof().proofPrintConclusion = value; |
2012 |
|
proof().proofPrintConclusion__setByUser__ = true; |
2013 |
|
Trace("options") << "user assigned option proofPrintConclusion" << std::endl; |
2014 |
|
} |
2015 |
|
template <> void Options::assignBool( |
2016 |
|
options::minisatDumpDimacs__option_t, |
2017 |
|
std::string option, |
2018 |
|
bool value) |
2019 |
|
{ |
2020 |
|
|
2021 |
|
prop().minisatDumpDimacs = value; |
2022 |
|
prop().minisatDumpDimacs__setByUser__ = true; |
2023 |
|
Trace("options") << "user assigned option minisatDumpDimacs" << std::endl; |
2024 |
|
} |
2025 |
|
template <> void Options::assignBool( |
2026 |
|
options::minisatUseElim__option_t, |
2027 |
|
std::string option, |
2028 |
|
bool value) |
2029 |
|
{ |
2030 |
|
|
2031 |
|
prop().minisatUseElim = value; |
2032 |
|
prop().minisatUseElim__setByUser__ = true; |
2033 |
|
Trace("options") << "user assigned option minisatUseElim" << std::endl; |
2034 |
|
} |
2035 |
|
template <> void Options::assign( |
2036 |
|
options::satRandomFreq__option_t, |
2037 |
|
std::string option, |
2038 |
|
std::string optionarg) |
2039 |
|
{ |
2040 |
|
auto parsedval = handleOption<double>(option, optionarg); |
2041 |
|
d_handler->doubleGreaterOrEqual0(option, parsedval); |
2042 |
|
d_handler->doubleLessOrEqual1(option, parsedval); |
2043 |
|
prop().satRandomFreq = parsedval; |
2044 |
|
prop().satRandomFreq__setByUser__ = true; |
2045 |
|
Trace("options") << "user assigned option satRandomFreq" << std::endl; |
2046 |
|
} |
2047 |
|
template <> void Options::assign( |
2048 |
|
options::satRandomSeed__option_t, |
2049 |
|
std::string option, |
2050 |
|
std::string optionarg) |
2051 |
|
{ |
2052 |
|
auto parsedval = handleOption<uint32_t>(option, optionarg); |
2053 |
|
|
2054 |
|
prop().satRandomSeed = parsedval; |
2055 |
|
prop().satRandomSeed__setByUser__ = true; |
2056 |
|
Trace("options") << "user assigned option satRandomSeed" << std::endl; |
2057 |
|
} |
2058 |
|
template <> void Options::assignBool( |
2059 |
|
options::sat_refine_conflicts__option_t, |
2060 |
|
std::string option, |
2061 |
|
bool value) |
2062 |
|
{ |
2063 |
|
|
2064 |
|
prop().sat_refine_conflicts = value; |
2065 |
|
prop().sat_refine_conflicts__setByUser__ = true; |
2066 |
|
Trace("options") << "user assigned option sat_refine_conflicts" << std::endl; |
2067 |
|
} |
2068 |
|
template <> void Options::assign( |
2069 |
|
options::satRestartFirst__option_t, |
2070 |
|
std::string option, |
2071 |
|
std::string optionarg) |
2072 |
|
{ |
2073 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
2074 |
|
|
2075 |
|
prop().satRestartFirst = parsedval; |
2076 |
|
prop().satRestartFirst__setByUser__ = true; |
2077 |
|
Trace("options") << "user assigned option satRestartFirst" << std::endl; |
2078 |
|
} |
2079 |
|
template <> void Options::assign( |
2080 |
|
options::satRestartInc__option_t, |
2081 |
|
std::string option, |
2082 |
|
std::string optionarg) |
2083 |
|
{ |
2084 |
|
auto parsedval = handleOption<double>(option, optionarg); |
2085 |
|
d_handler->doubleGreaterOrEqual0(option, parsedval); |
2086 |
|
prop().satRestartInc = parsedval; |
2087 |
|
prop().satRestartInc__setByUser__ = true; |
2088 |
|
Trace("options") << "user assigned option satRestartInc" << std::endl; |
2089 |
|
} |
2090 |
4 |
template <> void Options::assignBool( |
2091 |
|
options::aggressiveMiniscopeQuant__option_t, |
2092 |
|
std::string option, |
2093 |
|
bool value) |
2094 |
|
{ |
2095 |
|
|
2096 |
4 |
quantifiers().aggressiveMiniscopeQuant = value; |
2097 |
4 |
quantifiers().aggressiveMiniscopeQuant__setByUser__ = true; |
2098 |
4 |
Trace("options") << "user assigned option aggressiveMiniscopeQuant" << std::endl; |
2099 |
4 |
} |
2100 |
2 |
template <> void Options::assign( |
2101 |
|
options::cegisSample__option_t, |
2102 |
|
std::string option, |
2103 |
|
std::string optionarg) |
2104 |
|
{ |
2105 |
2 |
auto parsedval = stringToCegisSampleMode(optionarg); |
2106 |
|
|
2107 |
2 |
quantifiers().cegisSample = parsedval; |
2108 |
2 |
quantifiers().cegisSample__setByUser__ = true; |
2109 |
2 |
Trace("options") << "user assigned option cegisSample" << std::endl; |
2110 |
2 |
} |
2111 |
19 |
template <> void Options::assignBool( |
2112 |
|
options::cegqi__option_t, |
2113 |
|
std::string option, |
2114 |
|
bool value) |
2115 |
|
{ |
2116 |
|
|
2117 |
19 |
quantifiers().cegqi = value; |
2118 |
19 |
quantifiers().cegqi__setByUser__ = true; |
2119 |
19 |
Trace("options") << "user assigned option cegqi" << std::endl; |
2120 |
19 |
} |
2121 |
18 |
template <> void Options::assignBool( |
2122 |
|
options::cegqiAll__option_t, |
2123 |
|
std::string option, |
2124 |
|
bool value) |
2125 |
|
{ |
2126 |
|
|
2127 |
18 |
quantifiers().cegqiAll = value; |
2128 |
18 |
quantifiers().cegqiAll__setByUser__ = true; |
2129 |
18 |
Trace("options") << "user assigned option cegqiAll" << std::endl; |
2130 |
18 |
} |
2131 |
106 |
template <> void Options::assignBool( |
2132 |
|
options::cegqiBv__option_t, |
2133 |
|
std::string option, |
2134 |
|
bool value) |
2135 |
|
{ |
2136 |
|
|
2137 |
106 |
quantifiers().cegqiBv = value; |
2138 |
106 |
quantifiers().cegqiBv__setByUser__ = true; |
2139 |
106 |
Trace("options") << "user assigned option cegqiBv" << std::endl; |
2140 |
106 |
} |
2141 |
|
template <> void Options::assignBool( |
2142 |
|
options::cegqiBvConcInv__option_t, |
2143 |
|
std::string option, |
2144 |
|
bool value) |
2145 |
|
{ |
2146 |
|
|
2147 |
|
quantifiers().cegqiBvConcInv = value; |
2148 |
|
quantifiers().cegqiBvConcInv__setByUser__ = true; |
2149 |
|
Trace("options") << "user assigned option cegqiBvConcInv" << std::endl; |
2150 |
|
} |
2151 |
82 |
template <> void Options::assign( |
2152 |
|
options::cegqiBvIneqMode__option_t, |
2153 |
|
std::string option, |
2154 |
|
std::string optionarg) |
2155 |
|
{ |
2156 |
82 |
auto parsedval = stringToCegqiBvIneqMode(optionarg); |
2157 |
|
|
2158 |
82 |
quantifiers().cegqiBvIneqMode = parsedval; |
2159 |
82 |
quantifiers().cegqiBvIneqMode__setByUser__ = true; |
2160 |
82 |
Trace("options") << "user assigned option cegqiBvIneqMode" << std::endl; |
2161 |
82 |
} |
2162 |
|
template <> void Options::assignBool( |
2163 |
|
options::cegqiBvInterleaveValue__option_t, |
2164 |
|
std::string option, |
2165 |
|
bool value) |
2166 |
|
{ |
2167 |
|
|
2168 |
|
quantifiers().cegqiBvInterleaveValue = value; |
2169 |
|
quantifiers().cegqiBvInterleaveValue__setByUser__ = true; |
2170 |
|
Trace("options") << "user assigned option cegqiBvInterleaveValue" << std::endl; |
2171 |
|
} |
2172 |
|
template <> void Options::assignBool( |
2173 |
|
options::cegqiBvLinearize__option_t, |
2174 |
|
std::string option, |
2175 |
|
bool value) |
2176 |
|
{ |
2177 |
|
|
2178 |
|
quantifiers().cegqiBvLinearize = value; |
2179 |
|
quantifiers().cegqiBvLinearize__setByUser__ = true; |
2180 |
|
Trace("options") << "user assigned option cegqiBvLinearize" << std::endl; |
2181 |
|
} |
2182 |
2 |
template <> void Options::assignBool( |
2183 |
|
options::cegqiBvRmExtract__option_t, |
2184 |
|
std::string option, |
2185 |
|
bool value) |
2186 |
|
{ |
2187 |
|
|
2188 |
2 |
quantifiers().cegqiBvRmExtract = value; |
2189 |
2 |
quantifiers().cegqiBvRmExtract__setByUser__ = true; |
2190 |
2 |
Trace("options") << "user assigned option cegqiBvRmExtract" << std::endl; |
2191 |
2 |
} |
2192 |
|
template <> void Options::assignBool( |
2193 |
|
options::cegqiBvSolveNl__option_t, |
2194 |
|
std::string option, |
2195 |
|
bool value) |
2196 |
|
{ |
2197 |
|
|
2198 |
|
quantifiers().cegqiBvSolveNl = value; |
2199 |
|
quantifiers().cegqiBvSolveNl__setByUser__ = true; |
2200 |
|
Trace("options") << "user assigned option cegqiBvSolveNl" << std::endl; |
2201 |
|
} |
2202 |
597 |
template <> void Options::assignBool( |
2203 |
|
options::cegqiFullEffort__option_t, |
2204 |
|
std::string option, |
2205 |
|
bool value) |
2206 |
|
{ |
2207 |
|
|
2208 |
597 |
quantifiers().cegqiFullEffort = value; |
2209 |
597 |
quantifiers().cegqiFullEffort__setByUser__ = true; |
2210 |
597 |
Trace("options") << "user assigned option cegqiFullEffort" << std::endl; |
2211 |
597 |
} |
2212 |
|
template <> void Options::assignBool( |
2213 |
|
options::cegqiInnermost__option_t, |
2214 |
|
std::string option, |
2215 |
|
bool value) |
2216 |
|
{ |
2217 |
|
|
2218 |
|
quantifiers().cegqiInnermost = value; |
2219 |
|
quantifiers().cegqiInnermost__setByUser__ = true; |
2220 |
|
Trace("options") << "user assigned option cegqiInnermost" << std::endl; |
2221 |
|
} |
2222 |
|
template <> void Options::assignBool( |
2223 |
|
options::cegqiMidpoint__option_t, |
2224 |
|
std::string option, |
2225 |
|
bool value) |
2226 |
|
{ |
2227 |
|
|
2228 |
|
quantifiers().cegqiMidpoint = value; |
2229 |
|
quantifiers().cegqiMidpoint__setByUser__ = true; |
2230 |
|
Trace("options") << "user assigned option cegqiMidpoint" << std::endl; |
2231 |
|
} |
2232 |
|
template <> void Options::assignBool( |
2233 |
|
options::cegqiMinBounds__option_t, |
2234 |
|
std::string option, |
2235 |
|
bool value) |
2236 |
|
{ |
2237 |
|
|
2238 |
|
quantifiers().cegqiMinBounds = value; |
2239 |
|
quantifiers().cegqiMinBounds__setByUser__ = true; |
2240 |
|
Trace("options") << "user assigned option cegqiMinBounds" << std::endl; |
2241 |
|
} |
2242 |
|
template <> void Options::assignBool( |
2243 |
|
options::cegqiModel__option_t, |
2244 |
|
std::string option, |
2245 |
|
bool value) |
2246 |
|
{ |
2247 |
|
|
2248 |
|
quantifiers().cegqiModel = value; |
2249 |
|
quantifiers().cegqiModel__setByUser__ = true; |
2250 |
|
Trace("options") << "user assigned option cegqiModel" << std::endl; |
2251 |
|
} |
2252 |
3 |
template <> void Options::assignBool( |
2253 |
|
options::cegqiMultiInst__option_t, |
2254 |
|
std::string option, |
2255 |
|
bool value) |
2256 |
|
{ |
2257 |
|
|
2258 |
3 |
quantifiers().cegqiMultiInst = value; |
2259 |
3 |
quantifiers().cegqiMultiInst__setByUser__ = true; |
2260 |
3 |
Trace("options") << "user assigned option cegqiMultiInst" << std::endl; |
2261 |
3 |
} |
2262 |
19 |
template <> void Options::assignBool( |
2263 |
|
options::cegqiNestedQE__option_t, |
2264 |
|
std::string option, |
2265 |
|
bool value) |
2266 |
|
{ |
2267 |
|
|
2268 |
19 |
quantifiers().cegqiNestedQE = value; |
2269 |
19 |
quantifiers().cegqiNestedQE__setByUser__ = true; |
2270 |
19 |
Trace("options") << "user assigned option cegqiNestedQE" << std::endl; |
2271 |
19 |
} |
2272 |
|
template <> void Options::assignBool( |
2273 |
|
options::cegqiNopt__option_t, |
2274 |
|
std::string option, |
2275 |
|
bool value) |
2276 |
|
{ |
2277 |
|
|
2278 |
|
quantifiers().cegqiNopt = value; |
2279 |
|
quantifiers().cegqiNopt__setByUser__ = true; |
2280 |
|
Trace("options") << "user assigned option cegqiNopt" << std::endl; |
2281 |
|
} |
2282 |
|
template <> void Options::assignBool( |
2283 |
|
options::cegqiRepeatLit__option_t, |
2284 |
|
std::string option, |
2285 |
|
bool value) |
2286 |
|
{ |
2287 |
|
|
2288 |
|
quantifiers().cegqiRepeatLit = value; |
2289 |
|
quantifiers().cegqiRepeatLit__setByUser__ = true; |
2290 |
|
Trace("options") << "user assigned option cegqiRepeatLit" << std::endl; |
2291 |
|
} |
2292 |
|
template <> void Options::assignBool( |
2293 |
|
options::cegqiRoundUpLowerLia__option_t, |
2294 |
|
std::string option, |
2295 |
|
bool value) |
2296 |
|
{ |
2297 |
|
|
2298 |
|
quantifiers().cegqiRoundUpLowerLia = value; |
2299 |
|
quantifiers().cegqiRoundUpLowerLia__setByUser__ = true; |
2300 |
|
Trace("options") << "user assigned option cegqiRoundUpLowerLia" << std::endl; |
2301 |
|
} |
2302 |
|
template <> void Options::assignBool( |
2303 |
|
options::cegqiSat__option_t, |
2304 |
|
std::string option, |
2305 |
|
bool value) |
2306 |
|
{ |
2307 |
|
|
2308 |
|
quantifiers().cegqiSat = value; |
2309 |
|
quantifiers().cegqiSat__setByUser__ = true; |
2310 |
|
Trace("options") << "user assigned option cegqiSat" << std::endl; |
2311 |
|
} |
2312 |
6 |
template <> void Options::assignBool( |
2313 |
|
options::cegqiUseInfInt__option_t, |
2314 |
|
std::string option, |
2315 |
|
bool value) |
2316 |
|
{ |
2317 |
|
|
2318 |
6 |
quantifiers().cegqiUseInfInt = value; |
2319 |
6 |
quantifiers().cegqiUseInfInt__setByUser__ = true; |
2320 |
6 |
Trace("options") << "user assigned option cegqiUseInfInt" << std::endl; |
2321 |
6 |
} |
2322 |
6 |
template <> void Options::assignBool( |
2323 |
|
options::cegqiUseInfReal__option_t, |
2324 |
|
std::string option, |
2325 |
|
bool value) |
2326 |
|
{ |
2327 |
|
|
2328 |
6 |
quantifiers().cegqiUseInfReal = value; |
2329 |
6 |
quantifiers().cegqiUseInfReal__setByUser__ = true; |
2330 |
6 |
Trace("options") << "user assigned option cegqiUseInfReal" << std::endl; |
2331 |
6 |
} |
2332 |
|
template <> void Options::assignBool( |
2333 |
|
options::condVarSplitQuantAgg__option_t, |
2334 |
|
std::string option, |
2335 |
|
bool value) |
2336 |
|
{ |
2337 |
|
|
2338 |
|
quantifiers().condVarSplitQuantAgg = value; |
2339 |
|
quantifiers().condVarSplitQuantAgg__setByUser__ = true; |
2340 |
|
Trace("options") << "user assigned option condVarSplitQuantAgg" << std::endl; |
2341 |
|
} |
2342 |
|
template <> void Options::assignBool( |
2343 |
|
options::condVarSplitQuant__option_t, |
2344 |
|
std::string option, |
2345 |
|
bool value) |
2346 |
|
{ |
2347 |
|
|
2348 |
|
quantifiers().condVarSplitQuant = value; |
2349 |
|
quantifiers().condVarSplitQuant__setByUser__ = true; |
2350 |
|
Trace("options") << "user assigned option condVarSplitQuant" << std::endl; |
2351 |
|
} |
2352 |
|
template <> void Options::assignBool( |
2353 |
|
options::conjectureFilterActiveTerms__option_t, |
2354 |
|
std::string option, |
2355 |
|
bool value) |
2356 |
|
{ |
2357 |
|
|
2358 |
|
quantifiers().conjectureFilterActiveTerms = value; |
2359 |
|
quantifiers().conjectureFilterActiveTerms__setByUser__ = true; |
2360 |
|
Trace("options") << "user assigned option conjectureFilterActiveTerms" << std::endl; |
2361 |
|
} |
2362 |
|
template <> void Options::assignBool( |
2363 |
|
options::conjectureFilterCanonical__option_t, |
2364 |
|
std::string option, |
2365 |
|
bool value) |
2366 |
|
{ |
2367 |
|
|
2368 |
|
quantifiers().conjectureFilterCanonical = value; |
2369 |
|
quantifiers().conjectureFilterCanonical__setByUser__ = true; |
2370 |
|
Trace("options") << "user assigned option conjectureFilterCanonical" << std::endl; |
2371 |
|
} |
2372 |
2 |
template <> void Options::assignBool( |
2373 |
|
options::conjectureFilterModel__option_t, |
2374 |
|
std::string option, |
2375 |
|
bool value) |
2376 |
|
{ |
2377 |
|
|
2378 |
2 |
quantifiers().conjectureFilterModel = value; |
2379 |
2 |
quantifiers().conjectureFilterModel__setByUser__ = true; |
2380 |
2 |
Trace("options") << "user assigned option conjectureFilterModel" << std::endl; |
2381 |
2 |
} |
2382 |
7 |
template <> void Options::assignBool( |
2383 |
|
options::conjectureGen__option_t, |
2384 |
|
std::string option, |
2385 |
|
bool value) |
2386 |
|
{ |
2387 |
|
|
2388 |
7 |
quantifiers().conjectureGen = value; |
2389 |
7 |
quantifiers().conjectureGen__setByUser__ = true; |
2390 |
7 |
Trace("options") << "user assigned option conjectureGen" << std::endl; |
2391 |
7 |
} |
2392 |
|
template <> void Options::assign( |
2393 |
|
options::conjectureGenGtEnum__option_t, |
2394 |
|
std::string option, |
2395 |
|
std::string optionarg) |
2396 |
|
{ |
2397 |
|
auto parsedval = handleOption<int>(option, optionarg); |
2398 |
|
|
2399 |
|
quantifiers().conjectureGenGtEnum = parsedval; |
2400 |
|
quantifiers().conjectureGenGtEnum__setByUser__ = true; |
2401 |
|
Trace("options") << "user assigned option conjectureGenGtEnum" << std::endl; |
2402 |
|
} |
2403 |
|
template <> void Options::assign( |
2404 |
|
options::conjectureGenMaxDepth__option_t, |
2405 |
|
std::string option, |
2406 |
|
std::string optionarg) |
2407 |
|
{ |
2408 |
|
auto parsedval = handleOption<int>(option, optionarg); |
2409 |
|
|
2410 |
|
quantifiers().conjectureGenMaxDepth = parsedval; |
2411 |
|
quantifiers().conjectureGenMaxDepth__setByUser__ = true; |
2412 |
|
Trace("options") << "user assigned option conjectureGenMaxDepth" << std::endl; |
2413 |
|
} |
2414 |
|
template <> void Options::assign( |
2415 |
|
options::conjectureGenPerRound__option_t, |
2416 |
|
std::string option, |
2417 |
|
std::string optionarg) |
2418 |
|
{ |
2419 |
|
auto parsedval = handleOption<int>(option, optionarg); |
2420 |
|
|
2421 |
|
quantifiers().conjectureGenPerRound = parsedval; |
2422 |
|
quantifiers().conjectureGenPerRound__setByUser__ = true; |
2423 |
|
Trace("options") << "user assigned option conjectureGenPerRound" << std::endl; |
2424 |
|
} |
2425 |
|
template <> void Options::assignBool( |
2426 |
|
options::conjectureUeeIntro__option_t, |
2427 |
|
std::string option, |
2428 |
|
bool value) |
2429 |
|
{ |
2430 |
|
|
2431 |
|
quantifiers().conjectureUeeIntro = value; |
2432 |
|
quantifiers().conjectureUeeIntro__setByUser__ = true; |
2433 |
|
Trace("options") << "user assigned option conjectureUeeIntro" << std::endl; |
2434 |
|
} |
2435 |
2 |
template <> void Options::assignBool( |
2436 |
|
options::conjectureNoFilter__option_t, |
2437 |
|
std::string option, |
2438 |
|
bool value) |
2439 |
|
{ |
2440 |
|
|
2441 |
2 |
quantifiers().conjectureNoFilter = value; |
2442 |
2 |
quantifiers().conjectureNoFilter__setByUser__ = true; |
2443 |
2 |
Trace("options") << "user assigned option conjectureNoFilter" << std::endl; |
2444 |
2 |
} |
2445 |
2 |
template <> void Options::assignBool( |
2446 |
|
options::debugInst__option_t, |
2447 |
|
std::string option, |
2448 |
|
bool value) |
2449 |
|
{ |
2450 |
|
|
2451 |
2 |
quantifiers().debugInst = value; |
2452 |
2 |
quantifiers().debugInst__setByUser__ = true; |
2453 |
2 |
Trace("options") << "user assigned option debugInst" << std::endl; |
2454 |
2 |
} |
2455 |
1 |
template <> void Options::assignBool( |
2456 |
|
options::debugSygus__option_t, |
2457 |
|
std::string option, |
2458 |
|
bool value) |
2459 |
|
{ |
2460 |
|
|
2461 |
1 |
quantifiers().debugSygus = value; |
2462 |
1 |
quantifiers().debugSygus__setByUser__ = true; |
2463 |
1 |
Trace("options") << "user assigned option debugSygus" << std::endl; |
2464 |
1 |
} |
2465 |
|
template <> void Options::assignBool( |
2466 |
|
options::dtStcInduction__option_t, |
2467 |
|
std::string option, |
2468 |
|
bool value) |
2469 |
|
{ |
2470 |
|
|
2471 |
|
quantifiers().dtStcInduction = value; |
2472 |
|
quantifiers().dtStcInduction__setByUser__ = true; |
2473 |
|
Trace("options") << "user assigned option dtStcInduction" << std::endl; |
2474 |
|
} |
2475 |
|
template <> void Options::assignBool( |
2476 |
|
options::dtVarExpandQuant__option_t, |
2477 |
|
std::string option, |
2478 |
|
bool value) |
2479 |
|
{ |
2480 |
|
|
2481 |
|
quantifiers().dtVarExpandQuant = value; |
2482 |
|
quantifiers().dtVarExpandQuant__setByUser__ = true; |
2483 |
|
Trace("options") << "user assigned option dtVarExpandQuant" << std::endl; |
2484 |
|
} |
2485 |
1 |
template <> void Options::assignBool( |
2486 |
|
options::eMatching__option_t, |
2487 |
|
std::string option, |
2488 |
|
bool value) |
2489 |
|
{ |
2490 |
|
|
2491 |
1 |
quantifiers().eMatching = value; |
2492 |
1 |
quantifiers().eMatching__setByUser__ = true; |
2493 |
1 |
Trace("options") << "user assigned option eMatching" << std::endl; |
2494 |
1 |
} |
2495 |
|
template <> void Options::assignBool( |
2496 |
|
options::elimTautQuant__option_t, |
2497 |
|
std::string option, |
2498 |
|
bool value) |
2499 |
|
{ |
2500 |
|
|
2501 |
|
quantifiers().elimTautQuant = value; |
2502 |
|
quantifiers().elimTautQuant__setByUser__ = true; |
2503 |
|
Trace("options") << "user assigned option elimTautQuant" << std::endl; |
2504 |
|
} |
2505 |
11 |
template <> void Options::assignBool( |
2506 |
|
options::extRewriteQuant__option_t, |
2507 |
|
std::string option, |
2508 |
|
bool value) |
2509 |
|
{ |
2510 |
|
|
2511 |
11 |
quantifiers().extRewriteQuant = value; |
2512 |
11 |
quantifiers().extRewriteQuant__setByUser__ = true; |
2513 |
11 |
Trace("options") << "user assigned option extRewriteQuant" << std::endl; |
2514 |
11 |
} |
2515 |
175 |
template <> void Options::assignBool( |
2516 |
|
options::finiteModelFind__option_t, |
2517 |
|
std::string option, |
2518 |
|
bool value) |
2519 |
|
{ |
2520 |
|
|
2521 |
175 |
quantifiers().finiteModelFind = value; |
2522 |
175 |
quantifiers().finiteModelFind__setByUser__ = true; |
2523 |
175 |
Trace("options") << "user assigned option finiteModelFind" << std::endl; |
2524 |
175 |
} |
2525 |
35 |
template <> void Options::assignBool( |
2526 |
|
options::fmfBound__option_t, |
2527 |
|
std::string option, |
2528 |
|
bool value) |
2529 |
|
{ |
2530 |
|
|
2531 |
35 |
quantifiers().fmfBound = value; |
2532 |
35 |
quantifiers().fmfBound__setByUser__ = true; |
2533 |
35 |
Trace("options") << "user assigned option fmfBound" << std::endl; |
2534 |
35 |
} |
2535 |
12 |
template <> void Options::assignBool( |
2536 |
|
options::fmfBoundInt__option_t, |
2537 |
|
std::string option, |
2538 |
|
bool value) |
2539 |
|
{ |
2540 |
|
|
2541 |
12 |
quantifiers().fmfBoundInt = value; |
2542 |
12 |
quantifiers().fmfBoundInt__setByUser__ = true; |
2543 |
12 |
Trace("options") << "user assigned option fmfBoundInt" << std::endl; |
2544 |
12 |
} |
2545 |
3 |
template <> void Options::assignBool( |
2546 |
|
options::fmfBoundLazy__option_t, |
2547 |
|
std::string option, |
2548 |
|
bool value) |
2549 |
|
{ |
2550 |
|
|
2551 |
3 |
quantifiers().fmfBoundLazy = value; |
2552 |
3 |
quantifiers().fmfBoundLazy__setByUser__ = true; |
2553 |
3 |
Trace("options") << "user assigned option fmfBoundLazy" << std::endl; |
2554 |
3 |
} |
2555 |
|
template <> void Options::assignBool( |
2556 |
|
options::fmfFmcSimple__option_t, |
2557 |
|
std::string option, |
2558 |
|
bool value) |
2559 |
|
{ |
2560 |
|
|
2561 |
|
quantifiers().fmfFmcSimple = value; |
2562 |
|
quantifiers().fmfFmcSimple__setByUser__ = true; |
2563 |
|
Trace("options") << "user assigned option fmfFmcSimple" << std::endl; |
2564 |
|
} |
2565 |
|
template <> void Options::assignBool( |
2566 |
|
options::fmfFreshDistConst__option_t, |
2567 |
|
std::string option, |
2568 |
|
bool value) |
2569 |
|
{ |
2570 |
|
|
2571 |
|
quantifiers().fmfFreshDistConst = value; |
2572 |
|
quantifiers().fmfFreshDistConst__setByUser__ = true; |
2573 |
|
Trace("options") << "user assigned option fmfFreshDistConst" << std::endl; |
2574 |
|
} |
2575 |
47 |
template <> void Options::assignBool( |
2576 |
|
options::fmfFunWellDefined__option_t, |
2577 |
|
std::string option, |
2578 |
|
bool value) |
2579 |
|
{ |
2580 |
|
|
2581 |
47 |
quantifiers().fmfFunWellDefined = value; |
2582 |
47 |
quantifiers().fmfFunWellDefined__setByUser__ = true; |
2583 |
47 |
Trace("options") << "user assigned option fmfFunWellDefined" << std::endl; |
2584 |
47 |
} |
2585 |
10 |
template <> void Options::assignBool( |
2586 |
|
options::fmfFunWellDefinedRelevant__option_t, |
2587 |
|
std::string option, |
2588 |
|
bool value) |
2589 |
|
{ |
2590 |
|
|
2591 |
10 |
quantifiers().fmfFunWellDefinedRelevant = value; |
2592 |
10 |
quantifiers().fmfFunWellDefinedRelevant__setByUser__ = true; |
2593 |
10 |
Trace("options") << "user assigned option fmfFunWellDefinedRelevant" << std::endl; |
2594 |
10 |
} |
2595 |
7 |
template <> void Options::assignBool( |
2596 |
|
options::fmfInstEngine__option_t, |
2597 |
|
std::string option, |
2598 |
|
bool value) |
2599 |
|
{ |
2600 |
|
|
2601 |
7 |
quantifiers().fmfInstEngine = value; |
2602 |
7 |
quantifiers().fmfInstEngine__setByUser__ = true; |
2603 |
7 |
Trace("options") << "user assigned option fmfInstEngine" << std::endl; |
2604 |
7 |
} |
2605 |
|
template <> void Options::assign( |
2606 |
|
options::fmfTypeCompletionThresh__option_t, |
2607 |
|
std::string option, |
2608 |
|
std::string optionarg) |
2609 |
|
{ |
2610 |
|
auto parsedval = handleOption<int>(option, optionarg); |
2611 |
|
|
2612 |
|
quantifiers().fmfTypeCompletionThresh = parsedval; |
2613 |
|
quantifiers().fmfTypeCompletionThresh__setByUser__ = true; |
2614 |
|
Trace("options") << "user assigned option fmfTypeCompletionThresh" << std::endl; |
2615 |
|
} |
2616 |
|
template <> void Options::assignBool( |
2617 |
|
options::fullSaturateInterleave__option_t, |
2618 |
|
std::string option, |
2619 |
|
bool value) |
2620 |
|
{ |
2621 |
|
|
2622 |
|
quantifiers().fullSaturateInterleave = value; |
2623 |
|
quantifiers().fullSaturateInterleave__setByUser__ = true; |
2624 |
|
Trace("options") << "user assigned option fullSaturateInterleave" << std::endl; |
2625 |
|
} |
2626 |
3 |
template <> void Options::assignBool( |
2627 |
|
options::fullSaturateStratify__option_t, |
2628 |
|
std::string option, |
2629 |
|
bool value) |
2630 |
|
{ |
2631 |
|
|
2632 |
3 |
quantifiers().fullSaturateStratify = value; |
2633 |
3 |
quantifiers().fullSaturateStratify__setByUser__ = true; |
2634 |
3 |
Trace("options") << "user assigned option fullSaturateStratify" << std::endl; |
2635 |
3 |
} |
2636 |
|
template <> void Options::assignBool( |
2637 |
|
options::fullSaturateSum__option_t, |
2638 |
|
std::string option, |
2639 |
|
bool value) |
2640 |
|
{ |
2641 |
|
|
2642 |
|
quantifiers().fullSaturateSum = value; |
2643 |
|
quantifiers().fullSaturateSum__setByUser__ = true; |
2644 |
|
Trace("options") << "user assigned option fullSaturateSum" << std::endl; |
2645 |
|
} |
2646 |
65 |
template <> void Options::assignBool( |
2647 |
|
options::fullSaturateQuant__option_t, |
2648 |
|
std::string option, |
2649 |
|
bool value) |
2650 |
|
{ |
2651 |
|
|
2652 |
65 |
quantifiers().fullSaturateQuant = value; |
2653 |
65 |
quantifiers().fullSaturateQuant__setByUser__ = true; |
2654 |
65 |
Trace("options") << "user assigned option fullSaturateQuant" << std::endl; |
2655 |
65 |
} |
2656 |
3 |
template <> void Options::assign( |
2657 |
|
options::fullSaturateLimit__option_t, |
2658 |
|
std::string option, |
2659 |
|
std::string optionarg) |
2660 |
|
{ |
2661 |
3 |
auto parsedval = handleOption<int>(option, optionarg); |
2662 |
|
|
2663 |
3 |
quantifiers().fullSaturateLimit = parsedval; |
2664 |
3 |
quantifiers().fullSaturateLimit__setByUser__ = true; |
2665 |
3 |
Trace("options") << "user assigned option fullSaturateLimit" << std::endl; |
2666 |
3 |
} |
2667 |
|
template <> void Options::assignBool( |
2668 |
|
options::fullSaturateQuantRd__option_t, |
2669 |
|
std::string option, |
2670 |
|
bool value) |
2671 |
|
{ |
2672 |
|
|
2673 |
|
quantifiers().fullSaturateQuantRd = value; |
2674 |
|
quantifiers().fullSaturateQuantRd__setByUser__ = true; |
2675 |
|
Trace("options") << "user assigned option fullSaturateQuantRd" << std::endl; |
2676 |
|
} |
2677 |
8 |
template <> void Options::assignBool( |
2678 |
|
options::globalNegate__option_t, |
2679 |
|
std::string option, |
2680 |
|
bool value) |
2681 |
|
{ |
2682 |
|
|
2683 |
8 |
quantifiers().globalNegate = value; |
2684 |
8 |
quantifiers().globalNegate__setByUser__ = true; |
2685 |
8 |
Trace("options") << "user assigned option globalNegate" << std::endl; |
2686 |
8 |
} |
2687 |
11 |
template <> void Options::assignBool( |
2688 |
|
options::hoElim__option_t, |
2689 |
|
std::string option, |
2690 |
|
bool value) |
2691 |
|
{ |
2692 |
|
|
2693 |
11 |
quantifiers().hoElim = value; |
2694 |
11 |
quantifiers().hoElim__setByUser__ = true; |
2695 |
11 |
Trace("options") << "user assigned option hoElim" << std::endl; |
2696 |
11 |
} |
2697 |
1 |
template <> void Options::assignBool( |
2698 |
|
options::hoElimStoreAx__option_t, |
2699 |
|
std::string option, |
2700 |
|
bool value) |
2701 |
|
{ |
2702 |
|
|
2703 |
1 |
quantifiers().hoElimStoreAx = value; |
2704 |
1 |
quantifiers().hoElimStoreAx__setByUser__ = true; |
2705 |
1 |
Trace("options") << "user assigned option hoElimStoreAx" << std::endl; |
2706 |
1 |
} |
2707 |
|
template <> void Options::assignBool( |
2708 |
|
options::hoMatching__option_t, |
2709 |
|
std::string option, |
2710 |
|
bool value) |
2711 |
|
{ |
2712 |
|
|
2713 |
|
quantifiers().hoMatching = value; |
2714 |
|
quantifiers().hoMatching__setByUser__ = true; |
2715 |
|
Trace("options") << "user assigned option hoMatching" << std::endl; |
2716 |
|
} |
2717 |
|
template <> void Options::assignBool( |
2718 |
|
options::hoMatchingVarArgPriority__option_t, |
2719 |
|
std::string option, |
2720 |
|
bool value) |
2721 |
|
{ |
2722 |
|
|
2723 |
|
quantifiers().hoMatchingVarArgPriority = value; |
2724 |
|
quantifiers().hoMatchingVarArgPriority__setByUser__ = true; |
2725 |
|
Trace("options") << "user assigned option hoMatchingVarArgPriority" << std::endl; |
2726 |
|
} |
2727 |
|
template <> void Options::assignBool( |
2728 |
|
options::hoMergeTermDb__option_t, |
2729 |
|
std::string option, |
2730 |
|
bool value) |
2731 |
|
{ |
2732 |
|
|
2733 |
|
quantifiers().hoMergeTermDb = value; |
2734 |
|
quantifiers().hoMergeTermDb__setByUser__ = true; |
2735 |
|
Trace("options") << "user assigned option hoMergeTermDb" << std::endl; |
2736 |
|
} |
2737 |
|
template <> void Options::assignBool( |
2738 |
|
options::incrementTriggers__option_t, |
2739 |
|
std::string option, |
2740 |
|
bool value) |
2741 |
|
{ |
2742 |
|
|
2743 |
|
quantifiers().incrementTriggers = value; |
2744 |
|
quantifiers().incrementTriggers__setByUser__ = true; |
2745 |
|
Trace("options") << "user assigned option incrementTriggers" << std::endl; |
2746 |
|
} |
2747 |
|
template <> void Options::assignBool( |
2748 |
|
options::instLevelInputOnly__option_t, |
2749 |
|
std::string option, |
2750 |
|
bool value) |
2751 |
|
{ |
2752 |
|
|
2753 |
|
quantifiers().instLevelInputOnly = value; |
2754 |
|
quantifiers().instLevelInputOnly__setByUser__ = true; |
2755 |
|
Trace("options") << "user assigned option instLevelInputOnly" << std::endl; |
2756 |
|
} |
2757 |
3 |
template <> void Options::assign( |
2758 |
|
options::instMaxLevel__option_t, |
2759 |
|
std::string option, |
2760 |
|
std::string optionarg) |
2761 |
|
{ |
2762 |
3 |
auto parsedval = handleOption<int>(option, optionarg); |
2763 |
|
|
2764 |
3 |
quantifiers().instMaxLevel = parsedval; |
2765 |
3 |
quantifiers().instMaxLevel__setByUser__ = true; |
2766 |
3 |
Trace("options") << "user assigned option instMaxLevel" << std::endl; |
2767 |
3 |
} |
2768 |
|
template <> void Options::assignBool( |
2769 |
|
options::instNoEntail__option_t, |
2770 |
|
std::string option, |
2771 |
|
bool value) |
2772 |
|
{ |
2773 |
|
|
2774 |
|
quantifiers().instNoEntail = value; |
2775 |
|
quantifiers().instNoEntail__setByUser__ = true; |
2776 |
|
Trace("options") << "user assigned option instNoEntail" << std::endl; |
2777 |
|
} |
2778 |
|
template <> void Options::assign( |
2779 |
|
options::instWhenPhase__option_t, |
2780 |
|
std::string option, |
2781 |
|
std::string optionarg) |
2782 |
|
{ |
2783 |
|
auto parsedval = handleOption<int>(option, optionarg); |
2784 |
|
|
2785 |
|
quantifiers().instWhenPhase = parsedval; |
2786 |
|
quantifiers().instWhenPhase__setByUser__ = true; |
2787 |
|
Trace("options") << "user assigned option instWhenPhase" << std::endl; |
2788 |
|
} |
2789 |
|
template <> void Options::assignBool( |
2790 |
|
options::instWhenStrictInterleave__option_t, |
2791 |
|
std::string option, |
2792 |
|
bool value) |
2793 |
|
{ |
2794 |
|
|
2795 |
|
quantifiers().instWhenStrictInterleave = value; |
2796 |
|
quantifiers().instWhenStrictInterleave__setByUser__ = true; |
2797 |
|
Trace("options") << "user assigned option instWhenStrictInterleave" << std::endl; |
2798 |
|
} |
2799 |
|
template <> void Options::assignBool( |
2800 |
|
options::instWhenTcFirst__option_t, |
2801 |
|
std::string option, |
2802 |
|
bool value) |
2803 |
|
{ |
2804 |
|
|
2805 |
|
quantifiers().instWhenTcFirst = value; |
2806 |
|
quantifiers().instWhenTcFirst__setByUser__ = true; |
2807 |
|
Trace("options") << "user assigned option instWhenTcFirst" << std::endl; |
2808 |
|
} |
2809 |
3 |
template <> void Options::assign( |
2810 |
|
options::instWhenMode__option_t, |
2811 |
|
std::string option, |
2812 |
|
std::string optionarg) |
2813 |
|
{ |
2814 |
3 |
auto parsedval = stringToInstWhenMode(optionarg); |
2815 |
3 |
d_handler->checkInstWhenMode(option, parsedval); |
2816 |
3 |
quantifiers().instWhenMode = parsedval; |
2817 |
3 |
quantifiers().instWhenMode__setByUser__ = true; |
2818 |
3 |
Trace("options") << "user assigned option instWhenMode" << std::endl; |
2819 |
3 |
} |
2820 |
5 |
template <> void Options::assignBool( |
2821 |
|
options::intWfInduction__option_t, |
2822 |
|
std::string option, |
2823 |
|
bool value) |
2824 |
|
{ |
2825 |
|
|
2826 |
5 |
quantifiers().intWfInduction = value; |
2827 |
5 |
quantifiers().intWfInduction__setByUser__ = true; |
2828 |
5 |
Trace("options") << "user assigned option intWfInduction" << std::endl; |
2829 |
5 |
} |
2830 |
|
template <> void Options::assignBool( |
2831 |
|
options::iteDtTesterSplitQuant__option_t, |
2832 |
|
std::string option, |
2833 |
|
bool value) |
2834 |
|
{ |
2835 |
|
|
2836 |
|
quantifiers().iteDtTesterSplitQuant = value; |
2837 |
|
quantifiers().iteDtTesterSplitQuant__setByUser__ = true; |
2838 |
|
Trace("options") << "user assigned option iteDtTesterSplitQuant" << std::endl; |
2839 |
|
} |
2840 |
|
template <> void Options::assign( |
2841 |
|
options::iteLiftQuant__option_t, |
2842 |
|
std::string option, |
2843 |
|
std::string optionarg) |
2844 |
|
{ |
2845 |
|
auto parsedval = stringToIteLiftQuantMode(optionarg); |
2846 |
|
|
2847 |
|
quantifiers().iteLiftQuant = parsedval; |
2848 |
|
quantifiers().iteLiftQuant__setByUser__ = true; |
2849 |
|
Trace("options") << "user assigned option iteLiftQuant" << std::endl; |
2850 |
|
} |
2851 |
|
template <> void Options::assign( |
2852 |
|
options::literalMatchMode__option_t, |
2853 |
|
std::string option, |
2854 |
|
std::string optionarg) |
2855 |
|
{ |
2856 |
|
auto parsedval = stringToLiteralMatchMode(optionarg); |
2857 |
|
|
2858 |
|
quantifiers().literalMatchMode = parsedval; |
2859 |
|
quantifiers().literalMatchMode__setByUser__ = true; |
2860 |
|
Trace("options") << "user assigned option literalMatchMode" << std::endl; |
2861 |
|
} |
2862 |
17 |
template <> void Options::assignBool( |
2863 |
|
options::macrosQuant__option_t, |
2864 |
|
std::string option, |
2865 |
|
bool value) |
2866 |
|
{ |
2867 |
|
|
2868 |
17 |
quantifiers().macrosQuant = value; |
2869 |
17 |
quantifiers().macrosQuant__setByUser__ = true; |
2870 |
17 |
Trace("options") << "user assigned option macrosQuant" << std::endl; |
2871 |
17 |
} |
2872 |
2 |
template <> void Options::assign( |
2873 |
|
options::macrosQuantMode__option_t, |
2874 |
|
std::string option, |
2875 |
|
std::string optionarg) |
2876 |
|
{ |
2877 |
2 |
auto parsedval = stringToMacrosQuantMode(optionarg); |
2878 |
|
|
2879 |
2 |
quantifiers().macrosQuantMode = parsedval; |
2880 |
2 |
quantifiers().macrosQuantMode__setByUser__ = true; |
2881 |
2 |
Trace("options") << "user assigned option macrosQuantMode" << std::endl; |
2882 |
2 |
} |
2883 |
|
template <> void Options::assignBool( |
2884 |
|
options::mbqiInterleave__option_t, |
2885 |
|
std::string option, |
2886 |
|
bool value) |
2887 |
|
{ |
2888 |
|
|
2889 |
|
quantifiers().mbqiInterleave = value; |
2890 |
|
quantifiers().mbqiInterleave__setByUser__ = true; |
2891 |
|
Trace("options") << "user assigned option mbqiInterleave" << std::endl; |
2892 |
|
} |
2893 |
|
template <> void Options::assignBool( |
2894 |
|
options::fmfOneInstPerRound__option_t, |
2895 |
|
std::string option, |
2896 |
|
bool value) |
2897 |
|
{ |
2898 |
|
|
2899 |
|
quantifiers().fmfOneInstPerRound = value; |
2900 |
|
quantifiers().fmfOneInstPerRound__setByUser__ = true; |
2901 |
|
Trace("options") << "user assigned option fmfOneInstPerRound" << std::endl; |
2902 |
|
} |
2903 |
|
template <> void Options::assign( |
2904 |
|
options::mbqiMode__option_t, |
2905 |
|
std::string option, |
2906 |
|
std::string optionarg) |
2907 |
|
{ |
2908 |
|
auto parsedval = stringToMbqiMode(optionarg); |
2909 |
|
|
2910 |
|
quantifiers().mbqiMode = parsedval; |
2911 |
|
quantifiers().mbqiMode__setByUser__ = true; |
2912 |
|
Trace("options") << "user assigned option mbqiMode" << std::endl; |
2913 |
|
} |
2914 |
128 |
template <> void Options::assignBool( |
2915 |
|
options::miniscopeQuant__option_t, |
2916 |
|
std::string option, |
2917 |
|
bool value) |
2918 |
|
{ |
2919 |
|
|
2920 |
128 |
quantifiers().miniscopeQuant = value; |
2921 |
128 |
quantifiers().miniscopeQuant__setByUser__ = true; |
2922 |
128 |
Trace("options") << "user assigned option miniscopeQuant" << std::endl; |
2923 |
128 |
} |
2924 |
126 |
template <> void Options::assignBool( |
2925 |
|
options::miniscopeQuantFreeVar__option_t, |
2926 |
|
std::string option, |
2927 |
|
bool value) |
2928 |
|
{ |
2929 |
|
|
2930 |
126 |
quantifiers().miniscopeQuantFreeVar = value; |
2931 |
126 |
quantifiers().miniscopeQuantFreeVar__setByUser__ = true; |
2932 |
126 |
Trace("options") << "user assigned option miniscopeQuantFreeVar" << std::endl; |
2933 |
126 |
} |
2934 |
3 |
template <> void Options::assignBool( |
2935 |
|
options::multiTriggerCache__option_t, |
2936 |
|
std::string option, |
2937 |
|
bool value) |
2938 |
|
{ |
2939 |
|
|
2940 |
3 |
quantifiers().multiTriggerCache = value; |
2941 |
3 |
quantifiers().multiTriggerCache__setByUser__ = true; |
2942 |
3 |
Trace("options") << "user assigned option multiTriggerCache" << std::endl; |
2943 |
3 |
} |
2944 |
|
template <> void Options::assignBool( |
2945 |
|
options::multiTriggerLinear__option_t, |
2946 |
|
std::string option, |
2947 |
|
bool value) |
2948 |
|
{ |
2949 |
|
|
2950 |
|
quantifiers().multiTriggerLinear = value; |
2951 |
|
quantifiers().multiTriggerLinear__setByUser__ = true; |
2952 |
|
Trace("options") << "user assigned option multiTriggerLinear" << std::endl; |
2953 |
|
} |
2954 |
|
template <> void Options::assignBool( |
2955 |
|
options::multiTriggerPriority__option_t, |
2956 |
|
std::string option, |
2957 |
|
bool value) |
2958 |
|
{ |
2959 |
|
|
2960 |
|
quantifiers().multiTriggerPriority = value; |
2961 |
|
quantifiers().multiTriggerPriority__setByUser__ = true; |
2962 |
|
Trace("options") << "user assigned option multiTriggerPriority" << std::endl; |
2963 |
|
} |
2964 |
|
template <> void Options::assignBool( |
2965 |
|
options::multiTriggerWhenSingle__option_t, |
2966 |
|
std::string option, |
2967 |
|
bool value) |
2968 |
|
{ |
2969 |
|
|
2970 |
|
quantifiers().multiTriggerWhenSingle = value; |
2971 |
|
quantifiers().multiTriggerWhenSingle__setByUser__ = true; |
2972 |
|
Trace("options") << "user assigned option multiTriggerWhenSingle" << std::endl; |
2973 |
|
} |
2974 |
3 |
template <> void Options::assignBool( |
2975 |
|
options::partialTriggers__option_t, |
2976 |
|
std::string option, |
2977 |
|
bool value) |
2978 |
|
{ |
2979 |
|
|
2980 |
3 |
quantifiers().partialTriggers = value; |
2981 |
3 |
quantifiers().partialTriggers__setByUser__ = true; |
2982 |
3 |
Trace("options") << "user assigned option partialTriggers" << std::endl; |
2983 |
3 |
} |
2984 |
3 |
template <> void Options::assignBool( |
2985 |
|
options::poolInst__option_t, |
2986 |
|
std::string option, |
2987 |
|
bool value) |
2988 |
|
{ |
2989 |
|
|
2990 |
3 |
quantifiers().poolInst = value; |
2991 |
3 |
quantifiers().poolInst__setByUser__ = true; |
2992 |
3 |
Trace("options") << "user assigned option poolInst" << std::endl; |
2993 |
3 |
} |
2994 |
2 |
template <> void Options::assignBool( |
2995 |
|
options::preSkolemQuant__option_t, |
2996 |
|
std::string option, |
2997 |
|
bool value) |
2998 |
|
{ |
2999 |
|
|
3000 |
2 |
quantifiers().preSkolemQuant = value; |
3001 |
2 |
quantifiers().preSkolemQuant__setByUser__ = true; |
3002 |
2 |
Trace("options") << "user assigned option preSkolemQuant" << std::endl; |
3003 |
2 |
} |
3004 |
|
template <> void Options::assignBool( |
3005 |
|
options::preSkolemQuantAgg__option_t, |
3006 |
|
std::string option, |
3007 |
|
bool value) |
3008 |
|
{ |
3009 |
|
|
3010 |
|
quantifiers().preSkolemQuantAgg = value; |
3011 |
|
quantifiers().preSkolemQuantAgg__setByUser__ = true; |
3012 |
|
Trace("options") << "user assigned option preSkolemQuantAgg" << std::endl; |
3013 |
|
} |
3014 |
2 |
template <> void Options::assignBool( |
3015 |
|
options::preSkolemQuantNested__option_t, |
3016 |
|
std::string option, |
3017 |
|
bool value) |
3018 |
|
{ |
3019 |
|
|
3020 |
2 |
quantifiers().preSkolemQuantNested = value; |
3021 |
2 |
quantifiers().preSkolemQuantNested__setByUser__ = true; |
3022 |
2 |
Trace("options") << "user assigned option preSkolemQuantNested" << std::endl; |
3023 |
2 |
} |
3024 |
|
template <> void Options::assignBool( |
3025 |
|
options::prenexQuantUser__option_t, |
3026 |
|
std::string option, |
3027 |
|
bool value) |
3028 |
|
{ |
3029 |
|
|
3030 |
|
quantifiers().prenexQuantUser = value; |
3031 |
|
quantifiers().prenexQuantUser__setByUser__ = true; |
3032 |
|
Trace("options") << "user assigned option prenexQuantUser" << std::endl; |
3033 |
|
} |
3034 |
|
template <> void Options::assign( |
3035 |
|
options::prenexQuant__option_t, |
3036 |
|
std::string option, |
3037 |
|
std::string optionarg) |
3038 |
|
{ |
3039 |
|
auto parsedval = stringToPrenexQuantMode(optionarg); |
3040 |
|
|
3041 |
|
quantifiers().prenexQuant = parsedval; |
3042 |
|
quantifiers().prenexQuant__setByUser__ = true; |
3043 |
|
Trace("options") << "user assigned option prenexQuant" << std::endl; |
3044 |
|
} |
3045 |
3 |
template <> void Options::assignBool( |
3046 |
|
options::purifyTriggers__option_t, |
3047 |
|
std::string option, |
3048 |
|
bool value) |
3049 |
|
{ |
3050 |
|
|
3051 |
3 |
quantifiers().purifyTriggers = value; |
3052 |
3 |
quantifiers().purifyTriggers__setByUser__ = true; |
3053 |
3 |
Trace("options") << "user assigned option purifyTriggers" << std::endl; |
3054 |
3 |
} |
3055 |
|
template <> void Options::assignBool( |
3056 |
|
options::qcfAllConflict__option_t, |
3057 |
|
std::string option, |
3058 |
|
bool value) |
3059 |
|
{ |
3060 |
|
|
3061 |
|
quantifiers().qcfAllConflict = value; |
3062 |
|
quantifiers().qcfAllConflict__setByUser__ = true; |
3063 |
|
Trace("options") << "user assigned option qcfAllConflict" << std::endl; |
3064 |
|
} |
3065 |
|
template <> void Options::assignBool( |
3066 |
|
options::qcfEagerCheckRd__option_t, |
3067 |
|
std::string option, |
3068 |
|
bool value) |
3069 |
|
{ |
3070 |
|
|
3071 |
|
quantifiers().qcfEagerCheckRd = value; |
3072 |
|
quantifiers().qcfEagerCheckRd__setByUser__ = true; |
3073 |
|
Trace("options") << "user assigned option qcfEagerCheckRd" << std::endl; |
3074 |
|
} |
3075 |
|
template <> void Options::assignBool( |
3076 |
|
options::qcfEagerTest__option_t, |
3077 |
|
std::string option, |
3078 |
|
bool value) |
3079 |
|
{ |
3080 |
|
|
3081 |
|
quantifiers().qcfEagerTest = value; |
3082 |
|
quantifiers().qcfEagerTest__setByUser__ = true; |
3083 |
|
Trace("options") << "user assigned option qcfEagerTest" << std::endl; |
3084 |
|
} |
3085 |
|
template <> void Options::assignBool( |
3086 |
|
options::qcfNestedConflict__option_t, |
3087 |
|
std::string option, |
3088 |
|
bool value) |
3089 |
|
{ |
3090 |
|
|
3091 |
|
quantifiers().qcfNestedConflict = value; |
3092 |
|
quantifiers().qcfNestedConflict__setByUser__ = true; |
3093 |
|
Trace("options") << "user assigned option qcfNestedConflict" << std::endl; |
3094 |
|
} |
3095 |
|
template <> void Options::assignBool( |
3096 |
|
options::qcfSkipRd__option_t, |
3097 |
|
std::string option, |
3098 |
|
bool value) |
3099 |
|
{ |
3100 |
|
|
3101 |
|
quantifiers().qcfSkipRd = value; |
3102 |
|
quantifiers().qcfSkipRd__setByUser__ = true; |
3103 |
|
Trace("options") << "user assigned option qcfSkipRd" << std::endl; |
3104 |
|
} |
3105 |
6 |
template <> void Options::assignBool( |
3106 |
|
options::qcfTConstraint__option_t, |
3107 |
|
std::string option, |
3108 |
|
bool value) |
3109 |
|
{ |
3110 |
|
|
3111 |
6 |
quantifiers().qcfTConstraint = value; |
3112 |
6 |
quantifiers().qcfTConstraint__setByUser__ = true; |
3113 |
6 |
Trace("options") << "user assigned option qcfTConstraint" << std::endl; |
3114 |
6 |
} |
3115 |
|
template <> void Options::assignBool( |
3116 |
|
options::qcfVoExp__option_t, |
3117 |
|
std::string option, |
3118 |
|
bool value) |
3119 |
|
{ |
3120 |
|
|
3121 |
|
quantifiers().qcfVoExp = value; |
3122 |
|
quantifiers().qcfVoExp__setByUser__ = true; |
3123 |
|
Trace("options") << "user assigned option qcfVoExp" << std::endl; |
3124 |
|
} |
3125 |
|
template <> void Options::assignBool( |
3126 |
|
options::quantAlphaEquiv__option_t, |
3127 |
|
std::string option, |
3128 |
|
bool value) |
3129 |
|
{ |
3130 |
|
|
3131 |
|
quantifiers().quantAlphaEquiv = value; |
3132 |
|
quantifiers().quantAlphaEquiv__setByUser__ = true; |
3133 |
|
Trace("options") << "user assigned option quantAlphaEquiv" << std::endl; |
3134 |
|
} |
3135 |
|
template <> void Options::assignBool( |
3136 |
|
options::quantConflictFind__option_t, |
3137 |
|
std::string option, |
3138 |
|
bool value) |
3139 |
|
{ |
3140 |
|
|
3141 |
|
quantifiers().quantConflictFind = value; |
3142 |
|
quantifiers().quantConflictFind__setByUser__ = true; |
3143 |
|
Trace("options") << "user assigned option quantConflictFind" << std::endl; |
3144 |
|
} |
3145 |
|
template <> void Options::assign( |
3146 |
|
options::qcfMode__option_t, |
3147 |
|
std::string option, |
3148 |
|
std::string optionarg) |
3149 |
|
{ |
3150 |
|
auto parsedval = stringToQcfMode(optionarg); |
3151 |
|
|
3152 |
|
quantifiers().qcfMode = parsedval; |
3153 |
|
quantifiers().qcfMode__setByUser__ = true; |
3154 |
|
Trace("options") << "user assigned option qcfMode" << std::endl; |
3155 |
|
} |
3156 |
|
template <> void Options::assign( |
3157 |
|
options::qcfWhenMode__option_t, |
3158 |
|
std::string option, |
3159 |
|
std::string optionarg) |
3160 |
|
{ |
3161 |
|
auto parsedval = stringToQcfWhenMode(optionarg); |
3162 |
|
|
3163 |
|
quantifiers().qcfWhenMode = parsedval; |
3164 |
|
quantifiers().qcfWhenMode__setByUser__ = true; |
3165 |
|
Trace("options") << "user assigned option qcfWhenMode" << std::endl; |
3166 |
|
} |
3167 |
|
template <> void Options::assign( |
3168 |
|
options::quantDynamicSplit__option_t, |
3169 |
|
std::string option, |
3170 |
|
std::string optionarg) |
3171 |
|
{ |
3172 |
|
auto parsedval = stringToQuantDSplitMode(optionarg); |
3173 |
|
|
3174 |
|
quantifiers().quantDynamicSplit = parsedval; |
3175 |
|
quantifiers().quantDynamicSplit__setByUser__ = true; |
3176 |
|
Trace("options") << "user assigned option quantDynamicSplit" << std::endl; |
3177 |
|
} |
3178 |
|
template <> void Options::assignBool( |
3179 |
|
options::quantFunWellDefined__option_t, |
3180 |
|
std::string option, |
3181 |
|
bool value) |
3182 |
|
{ |
3183 |
|
|
3184 |
|
quantifiers().quantFunWellDefined = value; |
3185 |
|
quantifiers().quantFunWellDefined__setByUser__ = true; |
3186 |
|
Trace("options") << "user assigned option quantFunWellDefined" << std::endl; |
3187 |
|
} |
3188 |
8 |
template <> void Options::assignBool( |
3189 |
|
options::quantInduction__option_t, |
3190 |
|
std::string option, |
3191 |
|
bool value) |
3192 |
|
{ |
3193 |
|
|
3194 |
8 |
quantifiers().quantInduction = value; |
3195 |
8 |
quantifiers().quantInduction__setByUser__ = true; |
3196 |
8 |
Trace("options") << "user assigned option quantInduction" << std::endl; |
3197 |
8 |
} |
3198 |
|
template <> void Options::assign( |
3199 |
|
options::quantRepMode__option_t, |
3200 |
|
std::string option, |
3201 |
|
std::string optionarg) |
3202 |
|
{ |
3203 |
|
auto parsedval = stringToQuantRepMode(optionarg); |
3204 |
|
|
3205 |
|
quantifiers().quantRepMode = parsedval; |
3206 |
|
quantifiers().quantRepMode__setByUser__ = true; |
3207 |
|
Trace("options") << "user assigned option quantRepMode" << std::endl; |
3208 |
|
} |
3209 |
126 |
template <> void Options::assignBool( |
3210 |
|
options::quantSplit__option_t, |
3211 |
|
std::string option, |
3212 |
|
bool value) |
3213 |
|
{ |
3214 |
|
|
3215 |
126 |
quantifiers().quantSplit = value; |
3216 |
126 |
quantifiers().quantSplit__setByUser__ = true; |
3217 |
126 |
Trace("options") << "user assigned option quantSplit" << std::endl; |
3218 |
126 |
} |
3219 |
|
template <> void Options::assignBool( |
3220 |
|
options::registerQuantBodyTerms__option_t, |
3221 |
|
std::string option, |
3222 |
|
bool value) |
3223 |
|
{ |
3224 |
|
|
3225 |
|
quantifiers().registerQuantBodyTerms = value; |
3226 |
|
quantifiers().registerQuantBodyTerms__setByUser__ = true; |
3227 |
|
Trace("options") << "user assigned option registerQuantBodyTerms" << std::endl; |
3228 |
|
} |
3229 |
15 |
template <> void Options::assignBool( |
3230 |
|
options::relationalTriggers__option_t, |
3231 |
|
std::string option, |
3232 |
|
bool value) |
3233 |
|
{ |
3234 |
|
|
3235 |
15 |
quantifiers().relationalTriggers = value; |
3236 |
15 |
quantifiers().relationalTriggers__setByUser__ = true; |
3237 |
15 |
Trace("options") << "user assigned option relationalTriggers" << std::endl; |
3238 |
15 |
} |
3239 |
3 |
template <> void Options::assignBool( |
3240 |
|
options::relevantTriggers__option_t, |
3241 |
|
std::string option, |
3242 |
|
bool value) |
3243 |
|
{ |
3244 |
|
|
3245 |
3 |
quantifiers().relevantTriggers = value; |
3246 |
3 |
quantifiers().relevantTriggers__setByUser__ = true; |
3247 |
3 |
Trace("options") << "user assigned option relevantTriggers" << std::endl; |
3248 |
3 |
} |
3249 |
|
template <> void Options::assignBool( |
3250 |
|
options::strictTriggers__option_t, |
3251 |
|
std::string option, |
3252 |
|
bool value) |
3253 |
|
{ |
3254 |
|
|
3255 |
|
quantifiers().strictTriggers = value; |
3256 |
|
quantifiers().strictTriggers__setByUser__ = true; |
3257 |
|
Trace("options") << "user assigned option strictTriggers" << std::endl; |
3258 |
|
} |
3259 |
|
template <> void Options::assignBool( |
3260 |
|
options::sygus__option_t, |
3261 |
|
std::string option, |
3262 |
|
bool value) |
3263 |
|
{ |
3264 |
|
|
3265 |
|
quantifiers().sygus = value; |
3266 |
|
quantifiers().sygus__setByUser__ = true; |
3267 |
|
Trace("options") << "user assigned option sygus" << std::endl; |
3268 |
|
} |
3269 |
|
template <> void Options::assign( |
3270 |
|
options::sygusActiveGenEnumConsts__option_t, |
3271 |
|
std::string option, |
3272 |
|
std::string optionarg) |
3273 |
|
{ |
3274 |
|
auto parsedval = handleOption<unsigned long>(option, optionarg); |
3275 |
|
|
3276 |
|
quantifiers().sygusActiveGenEnumConsts = parsedval; |
3277 |
|
quantifiers().sygusActiveGenEnumConsts__setByUser__ = true; |
3278 |
|
Trace("options") << "user assigned option sygusActiveGenEnumConsts" << std::endl; |
3279 |
|
} |
3280 |
14 |
template <> void Options::assign( |
3281 |
|
options::sygusActiveGenMode__option_t, |
3282 |
|
std::string option, |
3283 |
|
std::string optionarg) |
3284 |
|
{ |
3285 |
14 |
auto parsedval = stringToSygusActiveGenMode(optionarg); |
3286 |
|
|
3287 |
14 |
quantifiers().sygusActiveGenMode = parsedval; |
3288 |
14 |
quantifiers().sygusActiveGenMode__setByUser__ = true; |
3289 |
14 |
Trace("options") << "user assigned option sygusActiveGenMode" << std::endl; |
3290 |
14 |
} |
3291 |
2 |
template <> void Options::assignBool( |
3292 |
|
options::sygusAddConstGrammar__option_t, |
3293 |
|
std::string option, |
3294 |
|
bool value) |
3295 |
|
{ |
3296 |
|
|
3297 |
2 |
quantifiers().sygusAddConstGrammar = value; |
3298 |
2 |
quantifiers().sygusAddConstGrammar__setByUser__ = true; |
3299 |
2 |
Trace("options") << "user assigned option sygusAddConstGrammar" << std::endl; |
3300 |
2 |
} |
3301 |
3 |
template <> void Options::assignBool( |
3302 |
|
options::sygusArgRelevant__option_t, |
3303 |
|
std::string option, |
3304 |
|
bool value) |
3305 |
|
{ |
3306 |
|
|
3307 |
3 |
quantifiers().sygusArgRelevant = value; |
3308 |
3 |
quantifiers().sygusArgRelevant__setByUser__ = true; |
3309 |
3 |
Trace("options") << "user assigned option sygusArgRelevant" << std::endl; |
3310 |
3 |
} |
3311 |
|
template <> void Options::assignBool( |
3312 |
|
options::sygusInvAutoUnfold__option_t, |
3313 |
|
std::string option, |
3314 |
|
bool value) |
3315 |
|
{ |
3316 |
|
|
3317 |
|
quantifiers().sygusInvAutoUnfold = value; |
3318 |
|
quantifiers().sygusInvAutoUnfold__setByUser__ = true; |
3319 |
|
Trace("options") << "user assigned option sygusInvAutoUnfold" << std::endl; |
3320 |
|
} |
3321 |
1 |
template <> void Options::assignBool( |
3322 |
|
options::sygusBoolIteReturnConst__option_t, |
3323 |
|
std::string option, |
3324 |
|
bool value) |
3325 |
|
{ |
3326 |
|
|
3327 |
1 |
quantifiers().sygusBoolIteReturnConst = value; |
3328 |
1 |
quantifiers().sygusBoolIteReturnConst__setByUser__ = true; |
3329 |
1 |
Trace("options") << "user assigned option sygusBoolIteReturnConst" << std::endl; |
3330 |
1 |
} |
3331 |
5 |
template <> void Options::assignBool( |
3332 |
|
options::sygusCoreConnective__option_t, |
3333 |
|
std::string option, |
3334 |
|
bool value) |
3335 |
|
{ |
3336 |
|
|
3337 |
5 |
quantifiers().sygusCoreConnective = value; |
3338 |
5 |
quantifiers().sygusCoreConnective__setByUser__ = true; |
3339 |
5 |
Trace("options") << "user assigned option sygusCoreConnective" << std::endl; |
3340 |
5 |
} |
3341 |
|
template <> void Options::assignBool( |
3342 |
|
options::sygusConstRepairAbort__option_t, |
3343 |
|
std::string option, |
3344 |
|
bool value) |
3345 |
|
{ |
3346 |
|
|
3347 |
|
quantifiers().sygusConstRepairAbort = value; |
3348 |
|
quantifiers().sygusConstRepairAbort__setByUser__ = true; |
3349 |
|
Trace("options") << "user assigned option sygusConstRepairAbort" << std::endl; |
3350 |
|
} |
3351 |
|
template <> void Options::assignBool( |
3352 |
|
options::sygusEvalOpt__option_t, |
3353 |
|
std::string option, |
3354 |
|
bool value) |
3355 |
|
{ |
3356 |
|
|
3357 |
|
quantifiers().sygusEvalOpt = value; |
3358 |
|
quantifiers().sygusEvalOpt__setByUser__ = true; |
3359 |
|
Trace("options") << "user assigned option sygusEvalOpt" << std::endl; |
3360 |
|
} |
3361 |
|
template <> void Options::assignBool( |
3362 |
|
options::sygusEvalUnfold__option_t, |
3363 |
|
std::string option, |
3364 |
|
bool value) |
3365 |
|
{ |
3366 |
|
|
3367 |
|
quantifiers().sygusEvalUnfold = value; |
3368 |
|
quantifiers().sygusEvalUnfold__setByUser__ = true; |
3369 |
|
Trace("options") << "user assigned option sygusEvalUnfold" << std::endl; |
3370 |
|
} |
3371 |
|
template <> void Options::assignBool( |
3372 |
|
options::sygusEvalUnfoldBool__option_t, |
3373 |
|
std::string option, |
3374 |
|
bool value) |
3375 |
|
{ |
3376 |
|
|
3377 |
|
quantifiers().sygusEvalUnfoldBool = value; |
3378 |
|
quantifiers().sygusEvalUnfoldBool__setByUser__ = true; |
3379 |
|
Trace("options") << "user assigned option sygusEvalUnfoldBool" << std::endl; |
3380 |
|
} |
3381 |
|
template <> void Options::assign( |
3382 |
|
options::sygusExprMinerCheckTimeout__option_t, |
3383 |
|
std::string option, |
3384 |
|
std::string optionarg) |
3385 |
|
{ |
3386 |
|
auto parsedval = handleOption<unsigned long>(option, optionarg); |
3387 |
|
|
3388 |
|
quantifiers().sygusExprMinerCheckTimeout = parsedval; |
3389 |
|
quantifiers().sygusExprMinerCheckTimeout__setByUser__ = true; |
3390 |
|
Trace("options") << "user assigned option sygusExprMinerCheckTimeout" << std::endl; |
3391 |
|
} |
3392 |
2 |
template <> void Options::assignBool( |
3393 |
|
options::sygusExtRew__option_t, |
3394 |
|
std::string option, |
3395 |
|
bool value) |
3396 |
|
{ |
3397 |
|
|
3398 |
2 |
quantifiers().sygusExtRew = value; |
3399 |
2 |
quantifiers().sygusExtRew__setByUser__ = true; |
3400 |
2 |
Trace("options") << "user assigned option sygusExtRew" << std::endl; |
3401 |
2 |
} |
3402 |
|
template <> void Options::assignBool( |
3403 |
|
options::sygusFilterSolRevSubsume__option_t, |
3404 |
|
std::string option, |
3405 |
|
bool value) |
3406 |
|
{ |
3407 |
|
|
3408 |
|
quantifiers().sygusFilterSolRevSubsume = value; |
3409 |
|
quantifiers().sygusFilterSolRevSubsume__setByUser__ = true; |
3410 |
|
Trace("options") << "user assigned option sygusFilterSolRevSubsume" << std::endl; |
3411 |
|
} |
3412 |
|
template <> void Options::assign( |
3413 |
|
options::sygusFilterSolMode__option_t, |
3414 |
|
std::string option, |
3415 |
|
std::string optionarg) |
3416 |
|
{ |
3417 |
|
auto parsedval = stringToSygusFilterSolMode(optionarg); |
3418 |
|
|
3419 |
|
quantifiers().sygusFilterSolMode = parsedval; |
3420 |
|
quantifiers().sygusFilterSolMode__setByUser__ = true; |
3421 |
|
Trace("options") << "user assigned option sygusFilterSolMode" << std::endl; |
3422 |
|
} |
3423 |
6 |
template <> void Options::assign( |
3424 |
|
options::sygusGrammarConsMode__option_t, |
3425 |
|
std::string option, |
3426 |
|
std::string optionarg) |
3427 |
|
{ |
3428 |
6 |
auto parsedval = stringToSygusGrammarConsMode(optionarg); |
3429 |
|
|
3430 |
6 |
quantifiers().sygusGrammarConsMode = parsedval; |
3431 |
6 |
quantifiers().sygusGrammarConsMode__setByUser__ = true; |
3432 |
6 |
Trace("options") << "user assigned option sygusGrammarConsMode" << std::endl; |
3433 |
6 |
} |
3434 |
|
template <> void Options::assignBool( |
3435 |
|
options::sygusGrammarNorm__option_t, |
3436 |
|
std::string option, |
3437 |
|
bool value) |
3438 |
|
{ |
3439 |
|
|
3440 |
|
quantifiers().sygusGrammarNorm = value; |
3441 |
|
quantifiers().sygusGrammarNorm__setByUser__ = true; |
3442 |
|
Trace("options") << "user assigned option sygusGrammarNorm" << std::endl; |
3443 |
|
} |
3444 |
60 |
template <> void Options::assignBool( |
3445 |
|
options::sygusInference__option_t, |
3446 |
|
std::string option, |
3447 |
|
bool value) |
3448 |
|
{ |
3449 |
|
|
3450 |
60 |
quantifiers().sygusInference = value; |
3451 |
60 |
quantifiers().sygusInference__setByUser__ = true; |
3452 |
60 |
Trace("options") << "user assigned option sygusInference" << std::endl; |
3453 |
60 |
} |
3454 |
18 |
template <> void Options::assignBool( |
3455 |
|
options::sygusInst__option_t, |
3456 |
|
std::string option, |
3457 |
|
bool value) |
3458 |
|
{ |
3459 |
|
|
3460 |
18 |
quantifiers().sygusInst = value; |
3461 |
18 |
quantifiers().sygusInst__setByUser__ = true; |
3462 |
18 |
Trace("options") << "user assigned option sygusInst" << std::endl; |
3463 |
18 |
} |
3464 |
|
template <> void Options::assign( |
3465 |
|
options::sygusInstMode__option_t, |
3466 |
|
std::string option, |
3467 |
|
std::string optionarg) |
3468 |
|
{ |
3469 |
|
auto parsedval = stringToSygusInstMode(optionarg); |
3470 |
|
|
3471 |
|
quantifiers().sygusInstMode = parsedval; |
3472 |
|
quantifiers().sygusInstMode__setByUser__ = true; |
3473 |
|
Trace("options") << "user assigned option sygusInstMode" << std::endl; |
3474 |
|
} |
3475 |
|
template <> void Options::assign( |
3476 |
|
options::sygusInstScope__option_t, |
3477 |
|
std::string option, |
3478 |
|
std::string optionarg) |
3479 |
|
{ |
3480 |
|
auto parsedval = stringToSygusInstScope(optionarg); |
3481 |
|
|
3482 |
|
quantifiers().sygusInstScope = parsedval; |
3483 |
|
quantifiers().sygusInstScope__setByUser__ = true; |
3484 |
|
Trace("options") << "user assigned option sygusInstScope" << std::endl; |
3485 |
|
} |
3486 |
|
template <> void Options::assign( |
3487 |
|
options::sygusInstTermSel__option_t, |
3488 |
|
std::string option, |
3489 |
|
std::string optionarg) |
3490 |
|
{ |
3491 |
|
auto parsedval = stringToSygusInstTermSelMode(optionarg); |
3492 |
|
|
3493 |
|
quantifiers().sygusInstTermSel = parsedval; |
3494 |
|
quantifiers().sygusInstTermSel__setByUser__ = true; |
3495 |
|
Trace("options") << "user assigned option sygusInstTermSel" << std::endl; |
3496 |
|
} |
3497 |
|
template <> void Options::assignBool( |
3498 |
|
options::sygusInvTemplWhenSyntax__option_t, |
3499 |
|
std::string option, |
3500 |
|
bool value) |
3501 |
|
{ |
3502 |
|
|
3503 |
|
quantifiers().sygusInvTemplWhenSyntax = value; |
3504 |
|
quantifiers().sygusInvTemplWhenSyntax__setByUser__ = true; |
3505 |
|
Trace("options") << "user assigned option sygusInvTemplWhenSyntax" << std::endl; |
3506 |
|
} |
3507 |
3 |
template <> void Options::assign( |
3508 |
|
options::sygusInvTemplMode__option_t, |
3509 |
|
std::string option, |
3510 |
|
std::string optionarg) |
3511 |
|
{ |
3512 |
3 |
auto parsedval = stringToSygusInvTemplMode(optionarg); |
3513 |
|
|
3514 |
3 |
quantifiers().sygusInvTemplMode = parsedval; |
3515 |
3 |
quantifiers().sygusInvTemplMode__setByUser__ = true; |
3516 |
3 |
Trace("options") << "user assigned option sygusInvTemplMode" << std::endl; |
3517 |
3 |
} |
3518 |
|
template <> void Options::assignBool( |
3519 |
|
options::sygusMinGrammar__option_t, |
3520 |
|
std::string option, |
3521 |
|
bool value) |
3522 |
|
{ |
3523 |
|
|
3524 |
|
quantifiers().sygusMinGrammar = value; |
3525 |
|
quantifiers().sygusMinGrammar__setByUser__ = true; |
3526 |
|
Trace("options") << "user assigned option sygusMinGrammar" << std::endl; |
3527 |
|
} |
3528 |
6 |
template <> void Options::assignBool( |
3529 |
|
options::sygusUnifPbe__option_t, |
3530 |
|
std::string option, |
3531 |
|
bool value) |
3532 |
|
{ |
3533 |
|
|
3534 |
6 |
quantifiers().sygusUnifPbe = value; |
3535 |
6 |
quantifiers().sygusUnifPbe__setByUser__ = true; |
3536 |
6 |
Trace("options") << "user assigned option sygusUnifPbe" << std::endl; |
3537 |
6 |
} |
3538 |
|
template <> void Options::assignBool( |
3539 |
|
options::sygusPbeMultiFair__option_t, |
3540 |
|
std::string option, |
3541 |
|
bool value) |
3542 |
|
{ |
3543 |
|
|
3544 |
|
quantifiers().sygusPbeMultiFair = value; |
3545 |
|
quantifiers().sygusPbeMultiFair__setByUser__ = true; |
3546 |
|
Trace("options") << "user assigned option sygusPbeMultiFair" << std::endl; |
3547 |
|
} |
3548 |
|
template <> void Options::assign( |
3549 |
|
options::sygusPbeMultiFairDiff__option_t, |
3550 |
|
std::string option, |
3551 |
|
std::string optionarg) |
3552 |
|
{ |
3553 |
|
auto parsedval = handleOption<int>(option, optionarg); |
3554 |
|
|
3555 |
|
quantifiers().sygusPbeMultiFairDiff = parsedval; |
3556 |
|
quantifiers().sygusPbeMultiFairDiff__setByUser__ = true; |
3557 |
|
Trace("options") << "user assigned option sygusPbeMultiFairDiff" << std::endl; |
3558 |
|
} |
3559 |
4 |
template <> void Options::assignBool( |
3560 |
|
options::sygusQePreproc__option_t, |
3561 |
|
std::string option, |
3562 |
|
bool value) |
3563 |
|
{ |
3564 |
|
|
3565 |
4 |
quantifiers().sygusQePreproc = value; |
3566 |
4 |
quantifiers().sygusQePreproc__setByUser__ = true; |
3567 |
4 |
Trace("options") << "user assigned option sygusQePreproc" << std::endl; |
3568 |
4 |
} |
3569 |
|
template <> void Options::assignBool( |
3570 |
|
options::sygusQueryGen__option_t, |
3571 |
|
std::string option, |
3572 |
|
bool value) |
3573 |
|
{ |
3574 |
|
|
3575 |
|
quantifiers().sygusQueryGen = value; |
3576 |
|
quantifiers().sygusQueryGen__setByUser__ = true; |
3577 |
|
Trace("options") << "user assigned option sygusQueryGen" << std::endl; |
3578 |
|
} |
3579 |
|
template <> void Options::assignBool( |
3580 |
|
options::sygusQueryGenCheck__option_t, |
3581 |
|
std::string option, |
3582 |
|
bool value) |
3583 |
|
{ |
3584 |
|
|
3585 |
|
quantifiers().sygusQueryGenCheck = value; |
3586 |
|
quantifiers().sygusQueryGenCheck__setByUser__ = true; |
3587 |
|
Trace("options") << "user assigned option sygusQueryGenCheck" << std::endl; |
3588 |
|
} |
3589 |
|
template <> void Options::assign( |
3590 |
|
options::sygusQueryGenDumpFiles__option_t, |
3591 |
|
std::string option, |
3592 |
|
std::string optionarg) |
3593 |
|
{ |
3594 |
|
auto parsedval = stringToSygusQueryDumpFilesMode(optionarg); |
3595 |
|
|
3596 |
|
quantifiers().sygusQueryGenDumpFiles = parsedval; |
3597 |
|
quantifiers().sygusQueryGenDumpFiles__setByUser__ = true; |
3598 |
|
Trace("options") << "user assigned option sygusQueryGenDumpFiles" << std::endl; |
3599 |
|
} |
3600 |
|
template <> void Options::assign( |
3601 |
|
options::sygusQueryGenThresh__option_t, |
3602 |
|
std::string option, |
3603 |
|
std::string optionarg) |
3604 |
|
{ |
3605 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
3606 |
|
|
3607 |
|
quantifiers().sygusQueryGenThresh = parsedval; |
3608 |
|
quantifiers().sygusQueryGenThresh__setByUser__ = true; |
3609 |
|
Trace("options") << "user assigned option sygusQueryGenThresh" << std::endl; |
3610 |
|
} |
3611 |
3 |
template <> void Options::assignBool( |
3612 |
|
options::sygusRecFun__option_t, |
3613 |
|
std::string option, |
3614 |
|
bool value) |
3615 |
|
{ |
3616 |
|
|
3617 |
3 |
quantifiers().sygusRecFun = value; |
3618 |
3 |
quantifiers().sygusRecFun__setByUser__ = true; |
3619 |
3 |
Trace("options") << "user assigned option sygusRecFun" << std::endl; |
3620 |
3 |
} |
3621 |
|
template <> void Options::assign( |
3622 |
|
options::sygusRecFunEvalLimit__option_t, |
3623 |
|
std::string option, |
3624 |
|
std::string optionarg) |
3625 |
|
{ |
3626 |
|
auto parsedval = handleOption<unsigned>(option, optionarg); |
3627 |
|
|
3628 |
|
quantifiers().sygusRecFunEvalLimit = parsedval; |
3629 |
|
quantifiers().sygusRecFunEvalLimit__setByUser__ = true; |
3630 |
|
Trace("options") << "user assigned option sygusRecFunEvalLimit" << std::endl; |
3631 |
|
} |
3632 |
8 |
template <> void Options::assignBool( |
3633 |
|
options::sygusRepairConst__option_t, |
3634 |
|
std::string option, |
3635 |
|
bool value) |
3636 |
|
{ |
3637 |
|
|
3638 |
8 |
quantifiers().sygusRepairConst = value; |
3639 |
8 |
quantifiers().sygusRepairConst__setByUser__ = true; |
3640 |
8 |
Trace("options") << "user assigned option sygusRepairConst" << std::endl; |
3641 |
8 |
} |
3642 |
|
template <> void Options::assign( |
3643 |
|
options::sygusRepairConstTimeout__option_t, |
3644 |
|
std::string option, |
3645 |
|
std::string optionarg) |
3646 |
|
{ |
3647 |
|
auto parsedval = handleOption<unsigned long>(option, optionarg); |
3648 |
|
|
3649 |
|
quantifiers().sygusRepairConstTimeout = parsedval; |
3650 |
|
quantifiers().sygusRepairConstTimeout__setByUser__ = true; |
3651 |
|
Trace("options") << "user assigned option sygusRepairConstTimeout" << std::endl; |
3652 |
|
} |
3653 |
6 |
template <> void Options::assignBool( |
3654 |
|
options::sygusRew__option_t, |
3655 |
|
std::string option, |
3656 |
|
bool value) |
3657 |
|
{ |
3658 |
|
|
3659 |
6 |
quantifiers().sygusRew = value; |
3660 |
6 |
quantifiers().sygusRew__setByUser__ = true; |
3661 |
6 |
Trace("options") << "user assigned option sygusRew" << std::endl; |
3662 |
6 |
} |
3663 |
1 |
template <> void Options::assignBool( |
3664 |
|
options::sygusRewSynth__option_t, |
3665 |
|
std::string option, |
3666 |
|
bool value) |
3667 |
|
{ |
3668 |
|
|
3669 |
1 |
quantifiers().sygusRewSynth = value; |
3670 |
1 |
quantifiers().sygusRewSynth__setByUser__ = true; |
3671 |
1 |
Trace("options") << "user assigned option sygusRewSynth" << std::endl; |
3672 |
1 |
} |
3673 |
|
template <> void Options::assignBool( |
3674 |
|
options::sygusRewSynthAccel__option_t, |
3675 |
|
std::string option, |
3676 |
|
bool value) |
3677 |
|
{ |
3678 |
|
|
3679 |
|
quantifiers().sygusRewSynthAccel = value; |
3680 |
|
quantifiers().sygusRewSynthAccel__setByUser__ = true; |
3681 |
|
Trace("options") << "user assigned option sygusRewSynthAccel" << std::endl; |
3682 |
|
} |
3683 |
3 |
template <> void Options::assignBool( |
3684 |
|
options::sygusRewSynthCheck__option_t, |
3685 |
|
std::string option, |
3686 |
|
bool value) |
3687 |
|
{ |
3688 |
|
|
3689 |
3 |
quantifiers().sygusRewSynthCheck = value; |
3690 |
3 |
quantifiers().sygusRewSynthCheck__setByUser__ = true; |
3691 |
3 |
Trace("options") << "user assigned option sygusRewSynthCheck" << std::endl; |
3692 |
3 |
} |
3693 |
|
template <> void Options::assignBool( |
3694 |
|
options::sygusRewSynthFilterCong__option_t, |
3695 |
|
std::string option, |
3696 |
|
bool value) |
3697 |
|
{ |
3698 |
|
|
3699 |
|
quantifiers().sygusRewSynthFilterCong = value; |
3700 |
|
quantifiers().sygusRewSynthFilterCong__setByUser__ = true; |
3701 |
|
Trace("options") << "user assigned option sygusRewSynthFilterCong" << std::endl; |
3702 |
|
} |
3703 |
|
template <> void Options::assignBool( |
3704 |
|
options::sygusRewSynthFilterMatch__option_t, |
3705 |
|
std::string option, |
3706 |
|
bool value) |
3707 |
|
{ |
3708 |
|
|
3709 |
|
quantifiers().sygusRewSynthFilterMatch = value; |
3710 |
|
quantifiers().sygusRewSynthFilterMatch__setByUser__ = true; |
3711 |
|
Trace("options") << "user assigned option sygusRewSynthFilterMatch" << std::endl; |
3712 |
|
} |
3713 |
|
template <> void Options::assignBool( |
3714 |
|
options::sygusRewSynthFilterNonLinear__option_t, |
3715 |
|
std::string option, |
3716 |
|
bool value) |
3717 |
|
{ |
3718 |
|
|
3719 |
|
quantifiers().sygusRewSynthFilterNonLinear = value; |
3720 |
|
quantifiers().sygusRewSynthFilterNonLinear__setByUser__ = true; |
3721 |
|
Trace("options") << "user assigned option sygusRewSynthFilterNonLinear" << std::endl; |
3722 |
|
} |
3723 |
|
template <> void Options::assignBool( |
3724 |
|
options::sygusRewSynthFilterOrder__option_t, |
3725 |
|
std::string option, |
3726 |
|
bool value) |
3727 |
|
{ |
3728 |
|
|
3729 |
|
quantifiers().sygusRewSynthFilterOrder = value; |
3730 |
|
quantifiers().sygusRewSynthFilterOrder__setByUser__ = true; |
3731 |
|
Trace("options") << "user assigned option sygusRewSynthFilterOrder" << std::endl; |
3732 |
|
} |
3733 |
247 |
template <> void Options::assignBool( |
3734 |
|
options::sygusRewSynthInput__option_t, |
3735 |
|
std::string option, |
3736 |
|
bool value) |
3737 |
|
{ |
3738 |
|
|
3739 |
247 |
quantifiers().sygusRewSynthInput = value; |
3740 |
247 |
quantifiers().sygusRewSynthInput__setByUser__ = true; |
3741 |
247 |
Trace("options") << "user assigned option sygusRewSynthInput" << std::endl; |
3742 |
247 |
} |
3743 |
|
template <> void Options::assign( |
3744 |
|
options::sygusRewSynthInputNVars__option_t, |
3745 |
|
std::string option, |
3746 |
|
std::string optionarg) |
3747 |
|
{ |
3748 |
|
auto parsedval = handleOption<int>(option, optionarg); |
3749 |
|
|
3750 |
|
quantifiers().sygusRewSynthInputNVars = parsedval; |
3751 |
|
quantifiers().sygusRewSynthInputNVars__setByUser__ = true; |
3752 |
|
Trace("options") << "user assigned option sygusRewSynthInputNVars" << std::endl; |
3753 |
|
} |
3754 |
|
template <> void Options::assignBool( |
3755 |
|
options::sygusRewSynthInputUseBool__option_t, |
3756 |
|
std::string option, |
3757 |
|
bool value) |
3758 |
|
{ |
3759 |
|
|
3760 |
|
quantifiers().sygusRewSynthInputUseBool = value; |
3761 |
|
quantifiers().sygusRewSynthInputUseBool__setByUser__ = true; |
3762 |
|
Trace("options") << "user assigned option sygusRewSynthInputUseBool" << std::endl; |
3763 |
|
} |
3764 |
|
template <> void Options::assignBool( |
3765 |
|
options::sygusRewSynthRec__option_t, |
3766 |
|
std::string option, |
3767 |
|
bool value) |
3768 |
|
{ |
3769 |
|
|
3770 |
|
quantifiers().sygusRewSynthRec = value; |
3771 |
|
quantifiers().sygusRewSynthRec__setByUser__ = true; |
3772 |
|
Trace("options") << "user assigned option sygusRewSynthRec" << std::endl; |
3773 |
|
} |
3774 |
|
template <> void Options::assignBool( |
3775 |
|
options::sygusRewVerify__option_t, |
3776 |
|
std::string option, |
3777 |
|
bool value) |
3778 |
|
{ |
3779 |
|
|
3780 |
|
quantifiers().sygusRewVerify = value; |
3781 |
|
quantifiers().sygusRewVerify__setByUser__ = true; |
3782 |
|
Trace("options") << "user assigned option sygusRewVerify" << std::endl; |
3783 |
|
} |
3784 |
7 |
template <> void Options::assignBool( |
3785 |
|
options::sygusRewVerifyAbort__option_t, |
3786 |
|
std::string option, |
3787 |
|
bool value) |
3788 |
|
{ |
3789 |
|
|
3790 |
7 |
quantifiers().sygusRewVerifyAbort = value; |
3791 |
7 |
quantifiers().sygusRewVerifyAbort__setByUser__ = true; |
3792 |
7 |
Trace("options") << "user assigned option sygusRewVerifyAbort" << std::endl; |
3793 |
7 |
} |
3794 |
|
template <> void Options::assignBool( |
3795 |
|
options::sygusSampleFpUniform__option_t, |
3796 |
|
std::string option, |
3797 |
|
bool value) |
3798 |
|
{ |
3799 |
|
|
3800 |
|
quantifiers().sygusSampleFpUniform = value; |
3801 |
|
quantifiers().sygusSampleFpUniform__setByUser__ = true; |
3802 |
|
Trace("options") << "user assigned option sygusSampleFpUniform" << std::endl; |
3803 |
|
} |
3804 |
|
template <> void Options::assignBool( |
3805 |
|
options::sygusSampleGrammar__option_t, |
3806 |
|
std::string option, |
3807 |
|
bool value) |
3808 |
|
{ |
3809 |
|
|
3810 |
|
quantifiers().sygusSampleGrammar = value; |
3811 |
|
quantifiers().sygusSampleGrammar__setByUser__ = true; |
3812 |
|
Trace("options") << "user assigned option sygusSampleGrammar" << std::endl; |
3813 |
|
} |
3814 |
7 |
template <> void Options::assign( |
3815 |
|
options::sygusSamples__option_t, |
3816 |
|
std::string option, |
3817 |
|
std::string optionarg) |
3818 |
|
{ |
3819 |
7 |
auto parsedval = handleOption<int>(option, optionarg); |
3820 |
|
|
3821 |
7 |
quantifiers().sygusSamples = parsedval; |
3822 |
7 |
quantifiers().sygusSamples__setByUser__ = true; |
3823 |
7 |
Trace("options") << "user assigned option sygusSamples" << std::endl; |
3824 |
7 |
} |
3825 |
|
template <> void Options::assignBool( |
3826 |
|
options::cegqiSingleInvAbort__option_t, |
3827 |
|
std::string option, |
3828 |
|
bool value) |
3829 |
|
{ |
3830 |
|
|
3831 |
|
quantifiers().cegqiSingleInvAbort = value; |
3832 |
|
quantifiers().cegqiSingleInvAbort__setByUser__ = true; |
3833 |
|
Trace("options") << "user assigned option cegqiSingleInvAbort" << std::endl; |
3834 |
|
} |
3835 |
|
template <> void Options::assignBool( |
3836 |
|
options::cegqiSingleInvPartial__option_t, |
3837 |
|
std::string option, |
3838 |
|
bool value) |
3839 |
|
{ |
3840 |
|
|
3841 |
|
quantifiers().cegqiSingleInvPartial = value; |
3842 |
|
quantifiers().cegqiSingleInvPartial__setByUser__ = true; |
3843 |
|
Trace("options") << "user assigned option cegqiSingleInvPartial" << std::endl; |
3844 |
|
} |
3845 |
1 |
template <> void Options::assign( |
3846 |
|
options::cegqiSingleInvReconstructLimit__option_t, |
3847 |
|
std::string option, |
3848 |
|
std::string optionarg) |
3849 |
|
{ |
3850 |
1 |
auto parsedval = handleOption<int>(option, optionarg); |
3851 |
|
|
3852 |
1 |
quantifiers().cegqiSingleInvReconstructLimit = parsedval; |
3853 |
1 |
quantifiers().cegqiSingleInvReconstructLimit__setByUser__ = true; |
3854 |
1 |
Trace("options") << "user assigned option cegqiSingleInvReconstructLimit" << std::endl; |
3855 |
1 |
} |
3856 |
|
template <> void Options::assign( |
3857 |
|
options::cegqiSingleInvReconstruct__option_t, |
3858 |
|
std::string option, |
3859 |
|
std::string optionarg) |
3860 |
|
{ |
3861 |
|
auto parsedval = stringToCegqiSingleInvRconsMode(optionarg); |
3862 |
|
|
3863 |
|
quantifiers().cegqiSingleInvReconstruct = parsedval; |
3864 |
|
quantifiers().cegqiSingleInvReconstruct__setByUser__ = true; |
3865 |
|
Trace("options") << "user assigned option cegqiSingleInvReconstruct" << std::endl; |
3866 |
|
} |
3867 |
|
template <> void Options::assignBool( |
3868 |
|
options::cegqiSingleInvReconstructConst__option_t, |
3869 |
|
std::string option, |
3870 |
|
bool value) |
3871 |
|
{ |
3872 |
|
|
3873 |
|
quantifiers().cegqiSingleInvReconstructConst = value; |
3874 |
|
quantifiers().cegqiSingleInvReconstructConst__setByUser__ = true; |
3875 |
|
Trace("options") << "user assigned option cegqiSingleInvReconstructConst" << std::endl; |
3876 |
|
} |
3877 |
47 |
template <> void Options::assign( |
3878 |
|
options::cegqiSingleInvMode__option_t, |
3879 |
|
std::string option, |
3880 |
|
std::string optionarg) |
3881 |
|
{ |
3882 |
47 |
auto parsedval = stringToCegqiSingleInvMode(optionarg); |
3883 |
|
|
3884 |
47 |
quantifiers().cegqiSingleInvMode = parsedval; |
3885 |
47 |
quantifiers().cegqiSingleInvMode__setByUser__ = true; |
3886 |
47 |
Trace("options") << "user assigned option cegqiSingleInvMode" << std::endl; |
3887 |
47 |
} |
3888 |
4 |
template <> void Options::assignBool( |
3889 |
|
options::sygusStream__option_t, |
3890 |
|
std::string option, |
3891 |
|
bool value) |
3892 |
|
{ |
3893 |
|
|
3894 |
4 |
quantifiers().sygusStream = value; |
3895 |
4 |
quantifiers().sygusStream__setByUser__ = true; |
3896 |
4 |
Trace("options") << "user assigned option sygusStream" << std::endl; |
3897 |
4 |
} |
3898 |
|
template <> void Options::assignBool( |
3899 |
|
options::sygusTemplEmbedGrammar__option_t, |
3900 |
|
std::string option, |
3901 |
|
bool value) |
3902 |
|
{ |
3903 |
|
|
3904 |
|
quantifiers().sygusTemplEmbedGrammar = value; |
3905 |
|
quantifiers().sygusTemplEmbedGrammar__setByUser__ = true; |
3906 |
|
Trace("options") << "user assigned option sygusTemplEmbedGrammar" << std::endl; |
3907 |
|
} |
3908 |
|
template <> void Options::assignBool( |
3909 |
|
options::sygusUnifCondIndNoRepeatSol__option_t, |
3910 |
|
std::string option, |
3911 |
|
bool value) |
3912 |
|
{ |
3913 |
|
|
3914 |
|
quantifiers().sygusUnifCondIndNoRepeatSol = value; |
3915 |
|
quantifiers().sygusUnifCondIndNoRepeatSol__setByUser__ = true; |
3916 |
|
Trace("options") << "user assigned option sygusUnifCondIndNoRepeatSol" << std::endl; |
3917 |
|
} |
3918 |
8 |
template <> void Options::assign( |
3919 |
|
options::sygusUnifPi__option_t, |
3920 |
|
std::string option, |
3921 |
|
std::string optionarg) |
3922 |
|
{ |
3923 |
8 |
auto parsedval = stringToSygusUnifPiMode(optionarg); |
3924 |
|
|
3925 |
8 |
quantifiers().sygusUnifPi = parsedval; |
3926 |
8 |
quantifiers().sygusUnifPi__setByUser__ = true; |
3927 |
8 |
Trace("options") << "user assigned option sygusUnifPi" << std::endl; |
3928 |
8 |
} |
3929 |
|
template <> void Options::assignBool( |
3930 |
|
options::sygusUnifShuffleCond__option_t, |
3931 |
|
std::string option, |
3932 |
|
bool value) |
3933 |
|
{ |
3934 |
|
|
3935 |
|
quantifiers().sygusUnifShuffleCond = value; |
3936 |
|
quantifiers().sygusUnifShuffleCond__setByUser__ = true; |
3937 |
|
Trace("options") << "user assigned option sygusUnifShuffleCond" << std::endl; |
3938 |
|
} |
3939 |
|
template <> void Options::assignBool( |
3940 |
|
options::termDbCd__option_t, |
3941 |
|
std::string option, |
3942 |
|
bool value) |
3943 |
|
{ |
3944 |
|
|
3945 |
|
quantifiers().termDbCd = value; |
3946 |
|
quantifiers().termDbCd__setByUser__ = true; |
3947 |
|
Trace("options") << "user assigned option termDbCd" << std::endl; |
3948 |
|
} |
3949 |
|
template <> void Options::assign( |
3950 |
|
options::termDbMode__option_t, |
3951 |
|
std::string option, |
3952 |
|
std::string optionarg) |
3953 |
|
{ |
3954 |
|
auto parsedval = stringToTermDbMode(optionarg); |
3955 |
|
|
3956 |
|
quantifiers().termDbMode = parsedval; |
3957 |
|
quantifiers().termDbMode__setByUser__ = true; |
3958 |
|
Trace("options") << "user assigned option termDbMode" << std::endl; |
3959 |
|
} |
3960 |
|
template <> void Options::assign( |
3961 |
|
options::triggerActiveSelMode__option_t, |
3962 |
|
std::string option, |
3963 |
|
std::string optionarg) |
3964 |
|
{ |
3965 |
|
auto parsedval = stringToTriggerActiveSelMode(optionarg); |
3966 |
|
|
3967 |
|
quantifiers().triggerActiveSelMode = parsedval; |
3968 |
|
quantifiers().triggerActiveSelMode__setByUser__ = true; |
3969 |
|
Trace("options") << "user assigned option triggerActiveSelMode" << std::endl; |
3970 |
|
} |
3971 |
|
template <> void Options::assign( |
3972 |
|
options::triggerSelMode__option_t, |
3973 |
|
std::string option, |
3974 |
|
std::string optionarg) |
3975 |
|
{ |
3976 |
|
auto parsedval = stringToTriggerSelMode(optionarg); |
3977 |
|
|
3978 |
|
quantifiers().triggerSelMode = parsedval; |
3979 |
|
quantifiers().triggerSelMode__setByUser__ = true; |
3980 |
|
Trace("options") << "user assigned option triggerSelMode" << std::endl; |
3981 |
|
} |
3982 |
|
template <> void Options::assign( |
3983 |
|
options::userPatternsQuant__option_t, |
3984 |
|
std::string option, |
3985 |
|
std::string optionarg) |
3986 |
|
{ |
3987 |
|
auto parsedval = stringToUserPatMode(optionarg); |
3988 |
|
|
3989 |
|
quantifiers().userPatternsQuant = parsedval; |
3990 |
|
quantifiers().userPatternsQuant__setByUser__ = true; |
3991 |
|
Trace("options") << "user assigned option userPatternsQuant" << std::endl; |
3992 |
|
} |
3993 |
|
template <> void Options::assignBool( |
3994 |
|
options::varElimQuant__option_t, |
3995 |
|
std::string option, |
3996 |
|
bool value) |
3997 |
|
{ |
3998 |
|
|
3999 |
|
quantifiers().varElimQuant = value; |
4000 |
|
quantifiers().varElimQuant__setByUser__ = true; |
4001 |
|
Trace("options") << "user assigned option varElimQuant" << std::endl; |
4002 |
|
} |
4003 |
7 |
template <> void Options::assignBool( |
4004 |
|
options::varIneqElimQuant__option_t, |
4005 |
|
std::string option, |
4006 |
|
bool value) |
4007 |
|
{ |
4008 |
|
|
4009 |
7 |
quantifiers().varIneqElimQuant = value; |
4010 |
7 |
quantifiers().varIneqElimQuant__setByUser__ = true; |
4011 |
7 |
Trace("options") << "user assigned option varIneqElimQuant" << std::endl; |
4012 |
7 |
} |
4013 |
|
template <> void Options::assign( |
4014 |
|
options::perCallResourceLimit__option_t, |
4015 |
|
std::string option, |
4016 |
|
std::string optionarg) |
4017 |
|
{ |
4018 |
|
auto parsedval = handleOption<uint64_t>(option, optionarg); |
4019 |
|
|
4020 |
|
resman().perCallResourceLimit = parsedval; |
4021 |
|
resman().perCallResourceLimit__setByUser__ = true; |
4022 |
|
Trace("options") << "user assigned option perCallResourceLimit" << std::endl; |
4023 |
|
} |
4024 |
|
template <> void Options::assign( |
4025 |
|
options::cumulativeResourceLimit__option_t, |
4026 |
|
std::string option, |
4027 |
|
std::string optionarg) |
4028 |
|
{ |
4029 |
|
auto parsedval = handleOption<uint64_t>(option, optionarg); |
4030 |
|
|
4031 |
|
resman().cumulativeResourceLimit = parsedval; |
4032 |
|
resman().cumulativeResourceLimit__setByUser__ = true; |
4033 |
|
Trace("options") << "user assigned option cumulativeResourceLimit" << std::endl; |
4034 |
|
} |
4035 |
6 |
template <> void Options::assign( |
4036 |
|
options::perCallMillisecondLimit__option_t, |
4037 |
|
std::string option, |
4038 |
|
std::string optionarg) |
4039 |
|
{ |
4040 |
6 |
auto parsedval = handleOption<uint64_t>(option, optionarg); |
4041 |
|
|
4042 |
6 |
resman().perCallMillisecondLimit = parsedval; |
4043 |
6 |
resman().perCallMillisecondLimit__setByUser__ = true; |
4044 |
6 |
Trace("options") << "user assigned option perCallMillisecondLimit" << std::endl; |
4045 |
6 |
} |
4046 |
|
template <> void Options::assign( |
4047 |
|
options::cumulativeMillisecondLimit__option_t, |
4048 |
|
std::string option, |
4049 |
|
std::string optionarg) |
4050 |
|
{ |
4051 |
|
auto parsedval = handleOption<uint64_t>(option, optionarg); |
4052 |
|
|
4053 |
|
resman().cumulativeMillisecondLimit = parsedval; |
4054 |
|
resman().cumulativeMillisecondLimit__setByUser__ = true; |
4055 |
|
Trace("options") << "user assigned option cumulativeMillisecondLimit" << std::endl; |
4056 |
|
} |
4057 |
|
template <> void Options::assignBool( |
4058 |
|
options::sepCheckNeg__option_t, |
4059 |
|
std::string option, |
4060 |
|
bool value) |
4061 |
|
{ |
4062 |
|
|
4063 |
|
sep().sepCheckNeg = value; |
4064 |
|
sep().sepCheckNeg__setByUser__ = true; |
4065 |
|
Trace("options") << "user assigned option sepCheckNeg" << std::endl; |
4066 |
|
} |
4067 |
|
template <> void Options::assignBool( |
4068 |
|
options::sepChildRefine__option_t, |
4069 |
|
std::string option, |
4070 |
|
bool value) |
4071 |
|
{ |
4072 |
|
|
4073 |
|
sep().sepChildRefine = value; |
4074 |
|
sep().sepChildRefine__setByUser__ = true; |
4075 |
|
Trace("options") << "user assigned option sepChildRefine" << std::endl; |
4076 |
|
} |
4077 |
|
template <> void Options::assignBool( |
4078 |
|
options::sepDisequalC__option_t, |
4079 |
|
std::string option, |
4080 |
|
bool value) |
4081 |
|
{ |
4082 |
|
|
4083 |
|
sep().sepDisequalC = value; |
4084 |
|
sep().sepDisequalC__setByUser__ = true; |
4085 |
|
Trace("options") << "user assigned option sepDisequalC" << std::endl; |
4086 |
|
} |
4087 |
|
template <> void Options::assignBool( |
4088 |
|
options::sepExp__option_t, |
4089 |
|
std::string option, |
4090 |
|
bool value) |
4091 |
|
{ |
4092 |
|
|
4093 |
|
sep().sepExp = value; |
4094 |
|
sep().sepExp__setByUser__ = true; |
4095 |
|
Trace("options") << "user assigned option sepExp" << std::endl; |
4096 |
|
} |
4097 |
|
template <> void Options::assignBool( |
4098 |
|
options::sepMinimalRefine__option_t, |
4099 |
|
std::string option, |
4100 |
|
bool value) |
4101 |
|
{ |
4102 |
|
|
4103 |
|
sep().sepMinimalRefine = value; |
4104 |
|
sep().sepMinimalRefine__setByUser__ = true; |
4105 |
|
Trace("options") << "user assigned option sepMinimalRefine" << std::endl; |
4106 |
|
} |
4107 |
1 |
template <> void Options::assignBool( |
4108 |
|
options::sepPreSkolemEmp__option_t, |
4109 |
|
std::string option, |
4110 |
|
bool value) |
4111 |
|
{ |
4112 |
|
|
4113 |
1 |
sep().sepPreSkolemEmp = value; |
4114 |
1 |
sep().sepPreSkolemEmp__setByUser__ = true; |
4115 |
1 |
Trace("options") << "user assigned option sepPreSkolemEmp" << std::endl; |
4116 |
1 |
} |
4117 |
116 |
template <> void Options::assignBool( |
4118 |
|
options::setsExt__option_t, |
4119 |
|
std::string option, |
4120 |
|
bool value) |
4121 |
|
{ |
4122 |
|
|
4123 |
116 |
sets().setsExt = value; |
4124 |
116 |
sets().setsExt__setByUser__ = true; |
4125 |
116 |
Trace("options") << "user assigned option setsExt" << std::endl; |
4126 |
116 |
} |
4127 |
2 |
template <> void Options::assignBool( |
4128 |
|
options::setsInferAsLemmas__option_t, |
4129 |
|
std::string option, |
4130 |
|
bool value) |
4131 |
|
{ |
4132 |
|
|
4133 |
2 |
sets().setsInferAsLemmas = value; |
4134 |
2 |
sets().setsInferAsLemmas__setByUser__ = true; |
4135 |
2 |
Trace("options") << "user assigned option setsInferAsLemmas" << std::endl; |
4136 |
2 |
} |
4137 |
|
template <> void Options::assignBool( |
4138 |
|
options::setsProxyLemmas__option_t, |
4139 |
|
std::string option, |
4140 |
|
bool value) |
4141 |
|
{ |
4142 |
|
|
4143 |
|
sets().setsProxyLemmas = value; |
4144 |
|
sets().setsProxyLemmas__setByUser__ = true; |
4145 |
|
Trace("options") << "user assigned option setsProxyLemmas" << std::endl; |
4146 |
|
} |
4147 |
4 |
template <> void Options::assignBool( |
4148 |
|
options::abstractValues__option_t, |
4149 |
|
std::string option, |
4150 |
|
bool value) |
4151 |
|
{ |
4152 |
|
|
4153 |
4 |
smt().abstractValues = value; |
4154 |
4 |
smt().abstractValues__setByUser__ = true; |
4155 |
4 |
Trace("options") << "user assigned option abstractValues" << std::endl; |
4156 |
4 |
} |
4157 |
31 |
template <> void Options::assignBool( |
4158 |
|
options::ackermann__option_t, |
4159 |
|
std::string option, |
4160 |
|
bool value) |
4161 |
|
{ |
4162 |
|
|
4163 |
31 |
smt().ackermann = value; |
4164 |
31 |
smt().ackermann__setByUser__ = true; |
4165 |
31 |
Trace("options") << "user assigned option ackermann" << std::endl; |
4166 |
31 |
} |
4167 |
21 |
template <> void Options::assign( |
4168 |
|
options::blockModelsMode__option_t, |
4169 |
|
std::string option, |
4170 |
|
std::string optionarg) |
4171 |
|
{ |
4172 |
21 |
auto parsedval = stringToBlockModelsMode(optionarg); |
4173 |
|
|
4174 |
21 |
smt().blockModelsMode = parsedval; |
4175 |
21 |
smt().blockModelsMode__setByUser__ = true; |
4176 |
21 |
Trace("options") << "user assigned option blockModelsMode" << std::endl; |
4177 |
21 |
} |
4178 |
80 |
template <> void Options::assign( |
4179 |
|
options::BVAndIntegerGranularity__option_t, |
4180 |
|
std::string option, |
4181 |
|
std::string optionarg) |
4182 |
|
{ |
4183 |
80 |
auto parsedval = handleOption<uint32_t>(option, optionarg); |
4184 |
|
|
4185 |
80 |
smt().BVAndIntegerGranularity = parsedval; |
4186 |
80 |
smt().BVAndIntegerGranularity__setByUser__ = true; |
4187 |
80 |
Trace("options") << "user assigned option BVAndIntegerGranularity" << std::endl; |
4188 |
80 |
} |
4189 |
12 |
template <> void Options::assignBool( |
4190 |
|
options::checkAbducts__option_t, |
4191 |
|
std::string option, |
4192 |
|
bool value) |
4193 |
|
{ |
4194 |
|
|
4195 |
12 |
smt().checkAbducts = value; |
4196 |
12 |
smt().checkAbducts__setByUser__ = true; |
4197 |
12 |
Trace("options") << "user assigned option checkAbducts" << std::endl; |
4198 |
12 |
} |
4199 |
8 |
template <> void Options::assignBool( |
4200 |
|
options::checkInterpols__option_t, |
4201 |
|
std::string option, |
4202 |
|
bool value) |
4203 |
|
{ |
4204 |
|
|
4205 |
8 |
smt().checkInterpols = value; |
4206 |
8 |
smt().checkInterpols__setByUser__ = true; |
4207 |
8 |
Trace("options") << "user assigned option checkInterpols" << std::endl; |
4208 |
8 |
} |
4209 |
106 |
template <> void Options::assignBool( |
4210 |
|
options::checkModels__option_t, |
4211 |
|
std::string option, |
4212 |
|
bool value) |
4213 |
|
{ |
4214 |
|
|
4215 |
106 |
smt().checkModels = value; |
4216 |
106 |
smt().checkModels__setByUser__ = true; |
4217 |
106 |
Trace("options") << "user assigned option checkModels" << std::endl; |
4218 |
106 |
} |
4219 |
1110 |
template <> void Options::assignBool( |
4220 |
|
options::checkProofs__option_t, |
4221 |
|
std::string option, |
4222 |
|
bool value) |
4223 |
|
{ |
4224 |
|
|
4225 |
1110 |
smt().checkProofs = value; |
4226 |
1110 |
smt().checkProofs__setByUser__ = true; |
4227 |
1110 |
Trace("options") << "user assigned option checkProofs" << std::endl; |
4228 |
1110 |
} |
4229 |
185 |
template <> void Options::assignBool( |
4230 |
|
options::checkSynthSol__option_t, |
4231 |
|
std::string option, |
4232 |
|
bool value) |
4233 |
|
{ |
4234 |
|
|
4235 |
185 |
smt().checkSynthSol = value; |
4236 |
185 |
smt().checkSynthSol__setByUser__ = true; |
4237 |
185 |
Trace("options") << "user assigned option checkSynthSol" << std::endl; |
4238 |
185 |
} |
4239 |
1120 |
template <> void Options::assignBool( |
4240 |
|
options::checkUnsatCores__option_t, |
4241 |
|
std::string option, |
4242 |
|
bool value) |
4243 |
|
{ |
4244 |
|
|
4245 |
1120 |
smt().checkUnsatCores = value; |
4246 |
1120 |
smt().checkUnsatCores__setByUser__ = true; |
4247 |
1120 |
Trace("options") << "user assigned option checkUnsatCores" << std::endl; |
4248 |
1120 |
} |
4249 |
1170 |
template <> void Options::assignBool( |
4250 |
|
options::debugCheckModels__option_t, |
4251 |
|
std::string option, |
4252 |
|
bool value) |
4253 |
|
{ |
4254 |
|
|
4255 |
1170 |
smt().debugCheckModels = value; |
4256 |
1170 |
smt().debugCheckModels__setByUser__ = true; |
4257 |
1170 |
Trace("options") << "user assigned option debugCheckModels" << std::endl; |
4258 |
1170 |
} |
4259 |
|
template <> void Options::assign( |
4260 |
|
options::diagnosticChannelName__option_t, |
4261 |
|
std::string option, |
4262 |
|
std::string optionarg) |
4263 |
|
{ |
4264 |
|
auto parsedval = handleOption<std::string>(option, optionarg); |
4265 |
|
|
4266 |
|
smt().diagnosticChannelName = parsedval; |
4267 |
|
smt().diagnosticChannelName__setByUser__ = true; |
4268 |
|
Trace("options") << "user assigned option diagnosticChannelName" << std::endl; |
4269 |
|
} |
4270 |
12 |
template <> void Options::assignBool( |
4271 |
|
options::dumpInstantiations__option_t, |
4272 |
|
std::string option, |
4273 |
|
bool value) |
4274 |
|
{ |
4275 |
|
|
4276 |
12 |
smt().dumpInstantiations = value; |
4277 |
12 |
smt().dumpInstantiations__setByUser__ = true; |
4278 |
12 |
Trace("options") << "user assigned option dumpInstantiations" << std::endl; |
4279 |
12 |
} |
4280 |
6 |
template <> void Options::assignBool( |
4281 |
|
options::dumpModels__option_t, |
4282 |
|
std::string option, |
4283 |
|
bool value) |
4284 |
|
{ |
4285 |
|
|
4286 |
6 |
smt().dumpModels = value; |
4287 |
6 |
smt().dumpModels__setByUser__ = true; |
4288 |
6 |
Trace("options") << "user assigned option dumpModels" << std::endl; |
4289 |
6 |
} |
4290 |
|
template <> void Options::assignBool( |
4291 |
|
options::dumpProofs__option_t, |
4292 |
|
std::string option, |
4293 |
|
bool value) |
4294 |
|
{ |
4295 |
|
|
4296 |
|
smt().dumpProofs = value; |
4297 |
|
smt().dumpProofs__setByUser__ = true; |
4298 |
|
Trace("options") << "user assigned option dumpProofs" << std::endl; |
4299 |
|
} |
4300 |
|
template <> void Options::assign( |
4301 |
|
options::dumpToFileName__option_t, |
4302 |
|
std::string option, |
4303 |
|
std::string optionarg) |
4304 |
|
{ |
4305 |
|
auto parsedval = handleOption<std::string>(option, optionarg); |
4306 |
|
|
4307 |
|
smt().dumpToFileName = parsedval; |
4308 |
|
smt().dumpToFileName__setByUser__ = true; |
4309 |
|
Trace("options") << "user assigned option dumpToFileName" << std::endl; |
4310 |
|
} |
4311 |
|
template <> void Options::assignBool( |
4312 |
|
options::dumpUnsatCores__option_t, |
4313 |
|
std::string option, |
4314 |
|
bool value) |
4315 |
|
{ |
4316 |
|
|
4317 |
|
smt().dumpUnsatCores = value; |
4318 |
|
smt().dumpUnsatCores__setByUser__ = true; |
4319 |
|
Trace("options") << "user assigned option dumpUnsatCores" << std::endl; |
4320 |
|
} |
4321 |
3 |
template <> void Options::assignBool( |
4322 |
|
options::dumpUnsatCoresFull__option_t, |
4323 |
|
std::string option, |
4324 |
|
bool value) |
4325 |
|
{ |
4326 |
|
|
4327 |
3 |
smt().dumpUnsatCoresFull = value; |
4328 |
3 |
smt().dumpUnsatCoresFull__setByUser__ = true; |
4329 |
3 |
Trace("options") << "user assigned option dumpUnsatCoresFull" << std::endl; |
4330 |
3 |
} |
4331 |
3 |
template <> void Options::assign( |
4332 |
|
options::dumpModeString__option_t, |
4333 |
|
std::string option, |
4334 |
|
std::string optionarg) |
4335 |
|
{ |
4336 |
6 |
auto parsedval = handleOption<std::string>(option, optionarg); |
4337 |
|
|
4338 |
3 |
smt().dumpModeString = parsedval; |
4339 |
3 |
smt().dumpModeString__setByUser__ = true; |
4340 |
3 |
Trace("options") << "user assigned option dumpModeString" << std::endl; |
4341 |
3 |
} |
4342 |
|
template <> void Options::assignBool( |
4343 |
|
options::earlyIteRemoval__option_t, |
4344 |
|
std::string option, |
4345 |
|
bool value) |
4346 |
|
{ |
4347 |
|
|
4348 |
|
smt().earlyIteRemoval = value; |
4349 |
|
smt().earlyIteRemoval__setByUser__ = true; |
4350 |
|
Trace("options") << "user assigned option earlyIteRemoval" << std::endl; |
4351 |
|
} |
4352 |
|
template <> void Options::assignBool( |
4353 |
|
options::expandDefinitions__option_t, |
4354 |
|
std::string option, |
4355 |
|
bool value) |
4356 |
|
{ |
4357 |
|
|
4358 |
|
smt().expandDefinitions = value; |
4359 |
|
smt().expandDefinitions__setByUser__ = true; |
4360 |
|
Trace("options") << "user assigned option expandDefinitions" << std::endl; |
4361 |
|
} |
4362 |
19 |
template <> void Options::assignBool( |
4363 |
|
options::extRewPrep__option_t, |
4364 |
|
std::string option, |
4365 |
|
bool value) |
4366 |
|
{ |
4367 |
|
|
4368 |
19 |
smt().extRewPrep = value; |
4369 |
19 |
smt().extRewPrep__setByUser__ = true; |
4370 |
19 |
Trace("options") << "user assigned option extRewPrep" << std::endl; |
4371 |
19 |
} |
4372 |
7 |
template <> void Options::assignBool( |
4373 |
|
options::extRewPrepAgg__option_t, |
4374 |
|
std::string option, |
4375 |
|
bool value) |
4376 |
|
{ |
4377 |
|
|
4378 |
7 |
smt().extRewPrepAgg = value; |
4379 |
7 |
smt().extRewPrepAgg__setByUser__ = true; |
4380 |
7 |
Trace("options") << "user assigned option extRewPrepAgg" << std::endl; |
4381 |
7 |
} |
4382 |
|
template <> void Options::assignBool( |
4383 |
|
options::forceNoLimitCpuWhileDump__option_t, |
4384 |
|
std::string option, |
4385 |
|
bool value) |
4386 |
|
{ |
4387 |
|
|
4388 |
|
smt().forceNoLimitCpuWhileDump = value; |
4389 |
|
smt().forceNoLimitCpuWhileDump__setByUser__ = true; |
4390 |
|
Trace("options") << "user assigned option forceNoLimitCpuWhileDump" << std::endl; |
4391 |
|
} |
4392 |
2 |
template <> void Options::assignBool( |
4393 |
|
options::foreignTheoryRewrite__option_t, |
4394 |
|
std::string option, |
4395 |
|
bool value) |
4396 |
|
{ |
4397 |
|
|
4398 |
2 |
smt().foreignTheoryRewrite = value; |
4399 |
2 |
smt().foreignTheoryRewrite__setByUser__ = true; |
4400 |
2 |
Trace("options") << "user assigned option foreignTheoryRewrite" << std::endl; |
4401 |
2 |
} |
4402 |
68 |
template <> void Options::assign( |
4403 |
|
options::iandMode__option_t, |
4404 |
|
std::string option, |
4405 |
|
std::string optionarg) |
4406 |
|
{ |
4407 |
68 |
auto parsedval = stringToIandMode(optionarg); |
4408 |
|
|
4409 |
68 |
smt().iandMode = parsedval; |
4410 |
68 |
smt().iandMode__setByUser__ = true; |
4411 |
68 |
Trace("options") << "user assigned option iandMode" << std::endl; |
4412 |
68 |
} |
4413 |
7021 |
template <> void Options::assignBool( |
4414 |
|
options::incrementalSolving__option_t, |
4415 |
|
std::string option, |
4416 |
|
bool value) |
4417 |
|
{ |
4418 |
|
|
4419 |
7021 |
smt().incrementalSolving = value; |
4420 |
7021 |
smt().incrementalSolving__setByUser__ = true; |
4421 |
7021 |
Trace("options") << "user assigned option incrementalSolving" << std::endl; |
4422 |
7021 |
} |
4423 |
2 |
template <> void Options::assignBool( |
4424 |
|
options::interactiveMode__option_t, |
4425 |
|
std::string option, |
4426 |
|
bool value) |
4427 |
|
{ |
4428 |
2 |
d_handler->setProduceAssertions(option, value); |
4429 |
2 |
smt().interactiveMode = value; |
4430 |
2 |
smt().interactiveMode__setByUser__ = true; |
4431 |
2 |
Trace("options") << "user assigned option interactiveMode" << std::endl; |
4432 |
2 |
} |
4433 |
3 |
template <> void Options::assignBool( |
4434 |
|
options::doITESimp__option_t, |
4435 |
|
std::string option, |
4436 |
|
bool value) |
4437 |
|
{ |
4438 |
|
|
4439 |
3 |
smt().doITESimp = value; |
4440 |
3 |
smt().doITESimp__setByUser__ = true; |
4441 |
3 |
Trace("options") << "user assigned option doITESimp" << std::endl; |
4442 |
3 |
} |
4443 |
6 |
template <> void Options::assign( |
4444 |
|
options::modelCoresMode__option_t, |
4445 |
|
std::string option, |
4446 |
|
std::string optionarg) |
4447 |
|
{ |
4448 |
6 |
auto parsedval = stringToModelCoresMode(optionarg); |
4449 |
|
|
4450 |
6 |
smt().modelCoresMode = parsedval; |
4451 |
6 |
smt().modelCoresMode__setByUser__ = true; |
4452 |
6 |
Trace("options") << "user assigned option modelCoresMode" << std::endl; |
4453 |
6 |
} |
4454 |
1 |
template <> void Options::assign( |
4455 |
|
options::modelUninterpPrint__option_t, |
4456 |
|
std::string option, |
4457 |
|
std::string optionarg) |
4458 |
|
{ |
4459 |
1 |
auto parsedval = stringToModelUninterpPrintMode(optionarg); |
4460 |
|
|
4461 |
1 |
smt().modelUninterpPrint = parsedval; |
4462 |
1 |
smt().modelUninterpPrint__setByUser__ = true; |
4463 |
1 |
Trace("options") << "user assigned option modelUninterpPrint" << std::endl; |
4464 |
1 |
} |
4465 |
1 |
template <> void Options::assignBool( |
4466 |
|
options::modelWitnessValue__option_t, |
4467 |
|
std::string option, |
4468 |
|
bool value) |
4469 |
|
{ |
4470 |
|
|
4471 |
1 |
smt().modelWitnessValue = value; |
4472 |
1 |
smt().modelWitnessValue__setByUser__ = true; |
4473 |
1 |
Trace("options") << "user assigned option modelWitnessValue" << std::endl; |
4474 |
1 |
} |
4475 |
|
template <> void Options::assignBool( |
4476 |
|
options::doITESimpOnRepeat__option_t, |
4477 |
|
std::string option, |
4478 |
|
bool value) |
4479 |
|
{ |
4480 |
|
|
4481 |
|
smt().doITESimpOnRepeat = value; |
4482 |
|
smt().doITESimpOnRepeat__setByUser__ = true; |
4483 |
|
Trace("options") << "user assigned option doITESimpOnRepeat" << std::endl; |
4484 |
|
} |
4485 |
20 |
template <> void Options::assignBool( |
4486 |
|
options::produceAbducts__option_t, |
4487 |
|
std::string option, |
4488 |
|
bool value) |
4489 |
|
{ |
4490 |
|
|
4491 |
20 |
smt().produceAbducts = value; |
4492 |
20 |
smt().produceAbducts__setByUser__ = true; |
4493 |
20 |
Trace("options") << "user assigned option produceAbducts" << std::endl; |
4494 |
20 |
} |
4495 |
18 |
template <> void Options::assignBool( |
4496 |
|
options::produceAssertions__option_t, |
4497 |
|
std::string option, |
4498 |
|
bool value) |
4499 |
|
{ |
4500 |
18 |
d_handler->setProduceAssertions(option, value); |
4501 |
18 |
smt().produceAssertions = value; |
4502 |
18 |
smt().produceAssertions__setByUser__ = true; |
4503 |
18 |
Trace("options") << "user assigned option produceAssertions" << std::endl; |
4504 |
18 |
} |
4505 |
4 |
template <> void Options::assignBool( |
4506 |
|
options::produceAssignments__option_t, |
4507 |
|
std::string option, |
4508 |
|
bool value) |
4509 |
|
{ |
4510 |
|
|
4511 |
4 |
smt().produceAssignments = value; |
4512 |
4 |
smt().produceAssignments__setByUser__ = true; |
4513 |
4 |
Trace("options") << "user assigned option produceAssignments" << std::endl; |
4514 |
4 |
} |
4515 |
11 |
template <> void Options::assign( |
4516 |
|
options::produceInterpols__option_t, |
4517 |
|
std::string option, |
4518 |
|
std::string optionarg) |
4519 |
|
{ |
4520 |
11 |
auto parsedval = stringToProduceInterpols(optionarg); |
4521 |
|
|
4522 |
11 |
smt().produceInterpols = parsedval; |
4523 |
11 |
smt().produceInterpols__setByUser__ = true; |
4524 |
11 |
Trace("options") << "user assigned option produceInterpols" << std::endl; |
4525 |
11 |
} |
4526 |
784 |
template <> void Options::assignBool( |
4527 |
|
options::produceModels__option_t, |
4528 |
|
std::string option, |
4529 |
|
bool value) |
4530 |
|
{ |
4531 |
|
|
4532 |
784 |
smt().produceModels = value; |
4533 |
784 |
smt().produceModels__setByUser__ = true; |
4534 |
784 |
Trace("options") << "user assigned option produceModels" << std::endl; |
4535 |
784 |
} |
4536 |
26 |
template <> void Options::assignBool( |
4537 |
|
options::produceProofs__option_t, |
4538 |
|
std::string option, |
4539 |
|
bool value) |
4540 |
|
{ |
4541 |
|
|
4542 |
26 |
smt().produceProofs = value; |
4543 |
26 |
smt().produceProofs__setByUser__ = true; |
4544 |
26 |
Trace("options") << "user assigned option produceProofs" << std::endl; |
4545 |
26 |
} |
4546 |
15 |
template <> void Options::assignBool( |
4547 |
|
options::unsatAssumptions__option_t, |
4548 |
|
std::string option, |
4549 |
|
bool value) |
4550 |
|
{ |
4551 |
|
|
4552 |
15 |
smt().unsatAssumptions = value; |
4553 |
15 |
smt().unsatAssumptions__setByUser__ = true; |
4554 |
15 |
Trace("options") << "user assigned option unsatAssumptions" << std::endl; |
4555 |
15 |
} |
4556 |
21 |
template <> void Options::assignBool( |
4557 |
|
options::unsatCores__option_t, |
4558 |
|
std::string option, |
4559 |
|
bool value) |
4560 |
|
{ |
4561 |
|
|
4562 |
21 |
smt().unsatCores = value; |
4563 |
21 |
smt().unsatCores__setByUser__ = true; |
4564 |
21 |
Trace("options") << "user assigned option unsatCores" << std::endl; |
4565 |
21 |
} |
4566 |
|
template <> void Options::assign( |
4567 |
|
options::regularChannelName__option_t, |
4568 |
|
std::string option, |
4569 |
|
std::string optionarg) |
4570 |
|
{ |
4571 |
|
auto parsedval = handleOption<std::string>(option, optionarg); |
4572 |
|
|
4573 |
|
smt().regularChannelName = parsedval; |
4574 |
|
smt().regularChannelName__setByUser__ = true; |
4575 |
|
Trace("options") << "user assigned option regularChannelName" << std::endl; |
4576 |
|
} |
4577 |
2 |
template <> void Options::assignBool( |
4578 |
|
options::repeatSimp__option_t, |
4579 |
|
std::string option, |
4580 |
|
bool value) |
4581 |
|
{ |
4582 |
|
|
4583 |
2 |
smt().repeatSimp = value; |
4584 |
2 |
smt().repeatSimp__setByUser__ = true; |
4585 |
2 |
Trace("options") << "user assigned option repeatSimp" << std::endl; |
4586 |
2 |
} |
4587 |
3 |
template <> void Options::assignBool( |
4588 |
|
options::compressItes__option_t, |
4589 |
|
std::string option, |
4590 |
|
bool value) |
4591 |
|
{ |
4592 |
|
|
4593 |
3 |
smt().compressItes = value; |
4594 |
3 |
smt().compressItes__setByUser__ = true; |
4595 |
3 |
Trace("options") << "user assigned option compressItes" << std::endl; |
4596 |
3 |
} |
4597 |
|
template <> void Options::assign( |
4598 |
|
options::zombieHuntThreshold__option_t, |
4599 |
|
std::string option, |
4600 |
|
std::string optionarg) |
4601 |
|
{ |
4602 |
|
auto parsedval = handleOption<uint32_t>(option, optionarg); |
4603 |
|
|
4604 |
|
smt().zombieHuntThreshold = parsedval; |
4605 |
|
smt().zombieHuntThreshold__setByUser__ = true; |
4606 |
|
Trace("options") << "user assigned option zombieHuntThreshold" << std::endl; |
4607 |
|
} |
4608 |
|
template <> void Options::assignBool( |
4609 |
|
options::simplifyWithCareEnabled__option_t, |
4610 |
|
std::string option, |
4611 |
|
bool value) |
4612 |
|
{ |
4613 |
|
|
4614 |
|
smt().simplifyWithCareEnabled = value; |
4615 |
|
smt().simplifyWithCareEnabled__setByUser__ = true; |
4616 |
|
Trace("options") << "user assigned option simplifyWithCareEnabled" << std::endl; |
4617 |
|
} |
4618 |
32 |
template <> void Options::assign( |
4619 |
|
options::simplificationMode__option_t, |
4620 |
|
std::string option, |
4621 |
|
std::string optionarg) |
4622 |
|
{ |
4623 |
32 |
auto parsedval = stringToSimplificationMode(optionarg); |
4624 |
|
|
4625 |
32 |
smt().simplificationMode = parsedval; |
4626 |
32 |
smt().simplificationMode__setByUser__ = true; |
4627 |
32 |
Trace("options") << "user assigned option simplificationMode" << std::endl; |
4628 |
32 |
} |
4629 |
133 |
template <> void Options::assign( |
4630 |
|
options::solveBVAsInt__option_t, |
4631 |
|
std::string option, |
4632 |
|
std::string optionarg) |
4633 |
|
{ |
4634 |
133 |
auto parsedval = stringToSolveBVAsIntMode(optionarg); |
4635 |
|
|
4636 |
133 |
smt().solveBVAsInt = parsedval; |
4637 |
133 |
smt().solveBVAsInt__setByUser__ = true; |
4638 |
133 |
Trace("options") << "user assigned option solveBVAsInt" << std::endl; |
4639 |
133 |
} |
4640 |
8 |
template <> void Options::assign( |
4641 |
|
options::solveIntAsBV__option_t, |
4642 |
|
std::string option, |
4643 |
|
std::string optionarg) |
4644 |
|
{ |
4645 |
8 |
auto parsedval = handleOption<uint32_t>(option, optionarg); |
4646 |
|
|
4647 |
8 |
smt().solveIntAsBV = parsedval; |
4648 |
8 |
smt().solveIntAsBV__setByUser__ = true; |
4649 |
8 |
Trace("options") << "user assigned option solveIntAsBV" << std::endl; |
4650 |
8 |
} |
4651 |
9 |
template <> void Options::assignBool( |
4652 |
|
options::solveRealAsInt__option_t, |
4653 |
|
std::string option, |
4654 |
|
bool value) |
4655 |
|
{ |
4656 |
|
|
4657 |
9 |
smt().solveRealAsInt = value; |
4658 |
9 |
smt().solveRealAsInt__setByUser__ = true; |
4659 |
9 |
Trace("options") << "user assigned option solveRealAsInt" << std::endl; |
4660 |
9 |
} |
4661 |
26 |
template <> void Options::assignBool( |
4662 |
|
options::sortInference__option_t, |
4663 |
|
std::string option, |
4664 |
|
bool value) |
4665 |
|
{ |
4666 |
|
|
4667 |
26 |
smt().sortInference = value; |
4668 |
26 |
smt().sortInference__setByUser__ = true; |
4669 |
26 |
Trace("options") << "user assigned option sortInference" << std::endl; |
4670 |
26 |
} |
4671 |
|
template <> void Options::assignBool( |
4672 |
|
options::doStaticLearning__option_t, |
4673 |
|
std::string option, |
4674 |
|
bool value) |
4675 |
|
{ |
4676 |
|
|
4677 |
|
smt().doStaticLearning = value; |
4678 |
|
smt().doStaticLearning__setByUser__ = true; |
4679 |
|
Trace("options") << "user assigned option doStaticLearning" << std::endl; |
4680 |
|
} |
4681 |
179 |
template <> void Options::assign( |
4682 |
|
options::sygusOut__option_t, |
4683 |
|
std::string option, |
4684 |
|
std::string optionarg) |
4685 |
|
{ |
4686 |
179 |
auto parsedval = stringToSygusSolutionOutMode(optionarg); |
4687 |
|
|
4688 |
179 |
smt().sygusOut = parsedval; |
4689 |
179 |
smt().sygusOut__setByUser__ = true; |
4690 |
179 |
Trace("options") << "user assigned option sygusOut" << std::endl; |
4691 |
179 |
} |
4692 |
|
template <> void Options::assignBool( |
4693 |
|
options::sygusPrintCallbacks__option_t, |
4694 |
|
std::string option, |
4695 |
|
bool value) |
4696 |
|
{ |
4697 |
|
|
4698 |
|
smt().sygusPrintCallbacks = value; |
4699 |
|
smt().sygusPrintCallbacks__setByUser__ = true; |
4700 |
|
Trace("options") << "user assigned option sygusPrintCallbacks" << std::endl; |
4701 |
|
} |
4702 |
107 |
template <> void Options::assignBool( |
4703 |
|
options::unconstrainedSimp__option_t, |
4704 |
|
std::string option, |
4705 |
|
bool value) |
4706 |
|
{ |
4707 |
|
|
4708 |
107 |
smt().unconstrainedSimp = value; |
4709 |
107 |
smt().unconstrainedSimp__setByUser__ = true; |
4710 |
107 |
Trace("options") << "user assigned option unconstrainedSimp" << std::endl; |
4711 |
107 |
} |
4712 |
|
template <> void Options::assign( |
4713 |
|
options::unsatCoresMode__option_t, |
4714 |
|
std::string option, |
4715 |
|
std::string optionarg) |
4716 |
|
{ |
4717 |
|
auto parsedval = stringToUnsatCoresMode(optionarg); |
4718 |
|
|
4719 |
|
smt().unsatCoresMode = parsedval; |
4720 |
|
smt().unsatCoresMode__setByUser__ = true; |
4721 |
|
Trace("options") << "user assigned option unsatCoresMode" << std::endl; |
4722 |
|
} |
4723 |
31 |
template <> void Options::assignBool( |
4724 |
|
options::regExpElim__option_t, |
4725 |
|
std::string option, |
4726 |
|
bool value) |
4727 |
|
{ |
4728 |
|
|
4729 |
31 |
strings().regExpElim = value; |
4730 |
31 |
strings().regExpElim__setByUser__ = true; |
4731 |
31 |
Trace("options") << "user assigned option regExpElim" << std::endl; |
4732 |
31 |
} |
4733 |
9 |
template <> void Options::assignBool( |
4734 |
|
options::regExpElimAgg__option_t, |
4735 |
|
std::string option, |
4736 |
|
bool value) |
4737 |
|
{ |
4738 |
|
|
4739 |
9 |
strings().regExpElimAgg = value; |
4740 |
9 |
strings().regExpElimAgg__setByUser__ = true; |
4741 |
9 |
Trace("options") << "user assigned option regExpElimAgg" << std::endl; |
4742 |
9 |
} |
4743 |
|
template <> void Options::assign( |
4744 |
|
options::stringRegExpInterMode__option_t, |
4745 |
|
std::string option, |
4746 |
|
std::string optionarg) |
4747 |
|
{ |
4748 |
|
auto parsedval = stringToRegExpInterMode(optionarg); |
4749 |
|
|
4750 |
|
strings().stringRegExpInterMode = parsedval; |
4751 |
|
strings().stringRegExpInterMode__setByUser__ = true; |
4752 |
|
Trace("options") << "user assigned option stringRegExpInterMode" << std::endl; |
4753 |
|
} |
4754 |
|
template <> void Options::assignBool( |
4755 |
|
options::stringCheckEntailLen__option_t, |
4756 |
|
std::string option, |
4757 |
|
bool value) |
4758 |
|
{ |
4759 |
|
|
4760 |
|
strings().stringCheckEntailLen = value; |
4761 |
|
strings().stringCheckEntailLen__setByUser__ = true; |
4762 |
|
Trace("options") << "user assigned option stringCheckEntailLen" << std::endl; |
4763 |
|
} |
4764 |
2 |
template <> void Options::assignBool( |
4765 |
|
options::stringEager__option_t, |
4766 |
|
std::string option, |
4767 |
|
bool value) |
4768 |
|
{ |
4769 |
|
|
4770 |
2 |
strings().stringEager = value; |
4771 |
2 |
strings().stringEager__setByUser__ = true; |
4772 |
2 |
Trace("options") << "user assigned option stringEager" << std::endl; |
4773 |
2 |
} |
4774 |
|
template <> void Options::assignBool( |
4775 |
|
options::stringEagerEval__option_t, |
4776 |
|
std::string option, |
4777 |
|
bool value) |
4778 |
|
{ |
4779 |
|
|
4780 |
|
strings().stringEagerEval = value; |
4781 |
|
strings().stringEagerEval__setByUser__ = true; |
4782 |
|
Trace("options") << "user assigned option stringEagerEval" << std::endl; |
4783 |
|
} |
4784 |
|
template <> void Options::assignBool( |
4785 |
|
options::stringEagerLen__option_t, |
4786 |
|
std::string option, |
4787 |
|
bool value) |
4788 |
|
{ |
4789 |
|
|
4790 |
|
strings().stringEagerLen = value; |
4791 |
|
strings().stringEagerLen__setByUser__ = true; |
4792 |
|
Trace("options") << "user assigned option stringEagerLen" << std::endl; |
4793 |
|
} |
4794 |
486 |
template <> void Options::assignBool( |
4795 |
|
options::stringExp__option_t, |
4796 |
|
std::string option, |
4797 |
|
bool value) |
4798 |
|
{ |
4799 |
|
|
4800 |
486 |
strings().stringExp = value; |
4801 |
486 |
strings().stringExp__setByUser__ = true; |
4802 |
486 |
Trace("options") << "user assigned option stringExp" << std::endl; |
4803 |
486 |
} |
4804 |
|
template <> void Options::assignBool( |
4805 |
|
options::stringFlatForms__option_t, |
4806 |
|
std::string option, |
4807 |
|
bool value) |
4808 |
|
{ |
4809 |
|
|
4810 |
|
strings().stringFlatForms = value; |
4811 |
|
strings().stringFlatForms__setByUser__ = true; |
4812 |
|
Trace("options") << "user assigned option stringFlatForms" << std::endl; |
4813 |
|
} |
4814 |
47 |
template <> void Options::assignBool( |
4815 |
|
options::stringFMF__option_t, |
4816 |
|
std::string option, |
4817 |
|
bool value) |
4818 |
|
{ |
4819 |
|
|
4820 |
47 |
strings().stringFMF = value; |
4821 |
47 |
strings().stringFMF__setByUser__ = true; |
4822 |
47 |
Trace("options") << "user assigned option stringFMF" << std::endl; |
4823 |
47 |
} |
4824 |
|
template <> void Options::assignBool( |
4825 |
|
options::stringGuessModel__option_t, |
4826 |
|
std::string option, |
4827 |
|
bool value) |
4828 |
|
{ |
4829 |
|
|
4830 |
|
strings().stringGuessModel = value; |
4831 |
|
strings().stringGuessModel__setByUser__ = true; |
4832 |
|
Trace("options") << "user assigned option stringGuessModel" << std::endl; |
4833 |
|
} |
4834 |
|
template <> void Options::assignBool( |
4835 |
|
options::stringInferAsLemmas__option_t, |
4836 |
|
std::string option, |
4837 |
|
bool value) |
4838 |
|
{ |
4839 |
|
|
4840 |
|
strings().stringInferAsLemmas = value; |
4841 |
|
strings().stringInferAsLemmas__setByUser__ = true; |
4842 |
|
Trace("options") << "user assigned option stringInferAsLemmas" << std::endl; |
4843 |
|
} |
4844 |
|
template <> void Options::assignBool( |
4845 |
|
options::stringInferSym__option_t, |
4846 |
|
std::string option, |
4847 |
|
bool value) |
4848 |
|
{ |
4849 |
|
|
4850 |
|
strings().stringInferSym = value; |
4851 |
|
strings().stringInferSym__setByUser__ = true; |
4852 |
|
Trace("options") << "user assigned option stringInferSym" << std::endl; |
4853 |
|
} |
4854 |
2 |
template <> void Options::assignBool( |
4855 |
|
options::stringIgnNegMembership__option_t, |
4856 |
|
std::string option, |
4857 |
|
bool value) |
4858 |
|
{ |
4859 |
|
|
4860 |
2 |
strings().stringIgnNegMembership = value; |
4861 |
2 |
strings().stringIgnNegMembership__setByUser__ = true; |
4862 |
2 |
Trace("options") << "user assigned option stringIgnNegMembership" << std::endl; |
4863 |
2 |
} |
4864 |
28 |
template <> void Options::assignBool( |
4865 |
|
options::stringLazyPreproc__option_t, |
4866 |
|
std::string option, |
4867 |
|
bool value) |
4868 |
|
{ |
4869 |
|
|
4870 |
28 |
strings().stringLazyPreproc = value; |
4871 |
28 |
strings().stringLazyPreproc__setByUser__ = true; |
4872 |
28 |
Trace("options") << "user assigned option stringLazyPreproc" << std::endl; |
4873 |
28 |
} |
4874 |
|
template <> void Options::assignBool( |
4875 |
|
options::stringLenNorm__option_t, |
4876 |
|
std::string option, |
4877 |
|
bool value) |
4878 |
|
{ |
4879 |
|
|
4880 |
|
strings().stringLenNorm = value; |
4881 |
|
strings().stringLenNorm__setByUser__ = true; |
4882 |
|
Trace("options") << "user assigned option stringLenNorm" << std::endl; |
4883 |
|
} |
4884 |
|
template <> void Options::assignBool( |
4885 |
|
options::stringLenPropCsp__option_t, |
4886 |
|
std::string option, |
4887 |
|
bool value) |
4888 |
|
{ |
4889 |
|
|
4890 |
|
strings().stringLenPropCsp = value; |
4891 |
|
strings().stringLenPropCsp__setByUser__ = true; |
4892 |
|
Trace("options") << "user assigned option stringLenPropCsp" << std::endl; |
4893 |
|
} |
4894 |
|
template <> void Options::assignBool( |
4895 |
|
options::stringMinPrefixExplain__option_t, |
4896 |
|
std::string option, |
4897 |
|
bool value) |
4898 |
|
{ |
4899 |
|
|
4900 |
|
strings().stringMinPrefixExplain = value; |
4901 |
|
strings().stringMinPrefixExplain__setByUser__ = true; |
4902 |
|
Trace("options") << "user assigned option stringMinPrefixExplain" << std::endl; |
4903 |
|
} |
4904 |
|
template <> void Options::assign( |
4905 |
|
options::stringProcessLoopMode__option_t, |
4906 |
|
std::string option, |
4907 |
|
std::string optionarg) |
4908 |
|
{ |
4909 |
|
auto parsedval = stringToProcessLoopMode(optionarg); |
4910 |
|
|
4911 |
|
strings().stringProcessLoopMode = parsedval; |
4912 |
|
strings().stringProcessLoopMode__setByUser__ = true; |
4913 |
|
Trace("options") << "user assigned option stringProcessLoopMode" << std::endl; |
4914 |
|
} |
4915 |
|
template <> void Options::assignBool( |
4916 |
|
options::stringRExplainLemmas__option_t, |
4917 |
|
std::string option, |
4918 |
|
bool value) |
4919 |
|
{ |
4920 |
|
|
4921 |
|
strings().stringRExplainLemmas = value; |
4922 |
|
strings().stringRExplainLemmas__setByUser__ = true; |
4923 |
|
Trace("options") << "user assigned option stringRExplainLemmas" << std::endl; |
4924 |
|
} |
4925 |
|
template <> void Options::assignBool( |
4926 |
|
options::stringUnifiedVSpt__option_t, |
4927 |
|
std::string option, |
4928 |
|
bool value) |
4929 |
|
{ |
4930 |
|
|
4931 |
|
strings().stringUnifiedVSpt = value; |
4932 |
|
strings().stringUnifiedVSpt__setByUser__ = true; |
4933 |
|
Trace("options") << "user assigned option stringUnifiedVSpt" << std::endl; |
4934 |
|
} |
4935 |
2 |
template <> void Options::assignBool( |
4936 |
|
options::assignFunctionValues__option_t, |
4937 |
|
std::string option, |
4938 |
|
bool value) |
4939 |
|
{ |
4940 |
|
|
4941 |
2 |
theory().assignFunctionValues = value; |
4942 |
2 |
theory().assignFunctionValues__setByUser__ = true; |
4943 |
2 |
Trace("options") << "user assigned option assignFunctionValues" << std::endl; |
4944 |
2 |
} |
4945 |
|
template <> void Options::assignBool( |
4946 |
|
options::condenseFunctionValues__option_t, |
4947 |
|
std::string option, |
4948 |
|
bool value) |
4949 |
|
{ |
4950 |
|
|
4951 |
|
theory().condenseFunctionValues = value; |
4952 |
|
theory().condenseFunctionValues__setByUser__ = true; |
4953 |
|
Trace("options") << "user assigned option condenseFunctionValues" << std::endl; |
4954 |
|
} |
4955 |
|
template <> void Options::assign( |
4956 |
|
options::eeMode__option_t, |
4957 |
|
std::string option, |
4958 |
|
std::string optionarg) |
4959 |
|
{ |
4960 |
|
auto parsedval = stringToEqEngineMode(optionarg); |
4961 |
|
|
4962 |
|
theory().eeMode = parsedval; |
4963 |
|
theory().eeMode__setByUser__ = true; |
4964 |
|
Trace("options") << "user assigned option eeMode" << std::endl; |
4965 |
|
} |
4966 |
|
template <> void Options::assignBool( |
4967 |
|
options::relevanceFilter__option_t, |
4968 |
|
std::string option, |
4969 |
|
bool value) |
4970 |
|
{ |
4971 |
|
|
4972 |
|
theory().relevanceFilter = value; |
4973 |
|
theory().relevanceFilter__setByUser__ = true; |
4974 |
|
Trace("options") << "user assigned option relevanceFilter" << std::endl; |
4975 |
|
} |
4976 |
|
template <> void Options::assign( |
4977 |
|
options::tcMode__option_t, |
4978 |
|
std::string option, |
4979 |
|
std::string optionarg) |
4980 |
|
{ |
4981 |
|
auto parsedval = stringToTcMode(optionarg); |
4982 |
|
|
4983 |
|
theory().tcMode = parsedval; |
4984 |
|
theory().tcMode__setByUser__ = true; |
4985 |
|
Trace("options") << "user assigned option tcMode" << std::endl; |
4986 |
|
} |
4987 |
5 |
template <> void Options::assign( |
4988 |
|
options::theoryOfMode__option_t, |
4989 |
|
std::string option, |
4990 |
|
std::string optionarg) |
4991 |
|
{ |
4992 |
5 |
auto parsedval = stringToTheoryOfMode(optionarg); |
4993 |
|
|
4994 |
5 |
theory().theoryOfMode = parsedval; |
4995 |
5 |
theory().theoryOfMode__setByUser__ = true; |
4996 |
5 |
Trace("options") << "user assigned option theoryOfMode" << std::endl; |
4997 |
5 |
} |
4998 |
|
template <> void Options::assignBool( |
4999 |
|
options::ufSymmetryBreaker__option_t, |
5000 |
|
std::string option, |
5001 |
|
bool value) |
5002 |
|
{ |
5003 |
|
|
5004 |
|
uf().ufSymmetryBreaker = value; |
5005 |
|
uf().ufSymmetryBreaker__setByUser__ = true; |
5006 |
|
Trace("options") << "user assigned option ufSymmetryBreaker" << std::endl; |
5007 |
|
} |
5008 |
151 |
template <> void Options::assignBool( |
5009 |
|
options::ufHo__option_t, |
5010 |
|
std::string option, |
5011 |
|
bool value) |
5012 |
|
{ |
5013 |
|
|
5014 |
151 |
uf().ufHo = value; |
5015 |
151 |
uf().ufHo__setByUser__ = true; |
5016 |
151 |
Trace("options") << "user assigned option ufHo" << std::endl; |
5017 |
151 |
} |
5018 |
|
template <> void Options::assignBool( |
5019 |
|
options::ufHoExt__option_t, |
5020 |
|
std::string option, |
5021 |
|
bool value) |
5022 |
|
{ |
5023 |
|
|
5024 |
|
uf().ufHoExt = value; |
5025 |
|
uf().ufHoExt__setByUser__ = true; |
5026 |
|
Trace("options") << "user assigned option ufHoExt" << std::endl; |
5027 |
|
} |
5028 |
|
template <> void Options::assign( |
5029 |
|
options::ufssAbortCardinality__option_t, |
5030 |
|
std::string option, |
5031 |
|
std::string optionarg) |
5032 |
|
{ |
5033 |
|
auto parsedval = handleOption<int>(option, optionarg); |
5034 |
|
|
5035 |
|
uf().ufssAbortCardinality = parsedval; |
5036 |
|
uf().ufssAbortCardinality__setByUser__ = true; |
5037 |
|
Trace("options") << "user assigned option ufssAbortCardinality" << std::endl; |
5038 |
|
} |
5039 |
|
template <> void Options::assignBool( |
5040 |
|
options::ufssFairness__option_t, |
5041 |
|
std::string option, |
5042 |
|
bool value) |
5043 |
|
{ |
5044 |
|
|
5045 |
|
uf().ufssFairness = value; |
5046 |
|
uf().ufssFairness__setByUser__ = true; |
5047 |
|
Trace("options") << "user assigned option ufssFairness" << std::endl; |
5048 |
|
} |
5049 |
4 |
template <> void Options::assignBool( |
5050 |
|
options::ufssFairnessMonotone__option_t, |
5051 |
|
std::string option, |
5052 |
|
bool value) |
5053 |
|
{ |
5054 |
|
|
5055 |
4 |
uf().ufssFairnessMonotone = value; |
5056 |
4 |
uf().ufssFairnessMonotone__setByUser__ = true; |
5057 |
4 |
Trace("options") << "user assigned option ufssFairnessMonotone" << std::endl; |
5058 |
4 |
} |
5059 |
|
template <> void Options::assign( |
5060 |
|
options::ufssTotalityLimited__option_t, |
5061 |
|
std::string option, |
5062 |
|
std::string optionarg) |
5063 |
|
{ |
5064 |
|
auto parsedval = handleOption<int>(option, optionarg); |
5065 |
|
|
5066 |
|
uf().ufssTotalityLimited = parsedval; |
5067 |
|
uf().ufssTotalityLimited__setByUser__ = true; |
5068 |
|
Trace("options") << "user assigned option ufssTotalityLimited" << std::endl; |
5069 |
|
} |
5070 |
|
template <> void Options::assignBool( |
5071 |
|
options::ufssTotalitySymBreak__option_t, |
5072 |
|
std::string option, |
5073 |
|
bool value) |
5074 |
|
{ |
5075 |
|
|
5076 |
|
uf().ufssTotalitySymBreak = value; |
5077 |
|
uf().ufssTotalitySymBreak__setByUser__ = true; |
5078 |
|
Trace("options") << "user assigned option ufssTotalitySymBreak" << std::endl; |
5079 |
|
} |
5080 |
7 |
template <> void Options::assign( |
5081 |
|
options::ufssMode__option_t, |
5082 |
|
std::string option, |
5083 |
|
std::string optionarg) |
5084 |
|
{ |
5085 |
7 |
auto parsedval = stringToUfssMode(optionarg); |
5086 |
|
|
5087 |
7 |
uf().ufssMode = parsedval; |
5088 |
7 |
uf().ufssMode__setByUser__ = true; |
5089 |
7 |
Trace("options") << "user assigned option ufssMode" << std::endl; |
5090 |
7 |
} |
5091 |
|
// clang-format on |
5092 |
|
|
5093 |
9398 |
static const std::string mostCommonOptionsDescription = |
5094 |
|
"\ |
5095 |
|
Most commonly-used cvc5 options:\n" |
5096 |
|
// clang-format off |
5097 |
|
" --lang=LANG | --input-language=LANG | -L LANG\n" |
5098 |
|
" force input language (default is \"auto\"; see --lang\n" |
5099 |
|
" help)\n" |
5100 |
|
" --output-lang=LANG | --output-language=LANG\n" |
5101 |
|
" force output language (default is \"auto\"; see\n" |
5102 |
|
" --output-lang help)\n" |
5103 |
|
" --quiet | -q decrease verbosity (may be repeated)\n" |
5104 |
|
" --stats give statistics on exit [*]\n" |
5105 |
|
" --verbose | -v increase verbosity (may be repeated)\n" |
5106 |
|
" --copyright show cvc5 copyright information\n" |
5107 |
|
" --help | -h full command line reference\n" |
5108 |
|
" --seed=N | -s N seed for random number generator\n" |
5109 |
|
" --show-config show cvc5 static configuration\n" |
5110 |
|
" --version | -V identify this cvc5 binary\n" |
5111 |
|
" --strict-parsing be less tolerant of non-conforming inputs [*]\n" |
5112 |
|
" --rlimit-per=N | --reproducible-resource-limit=N\n" |
5113 |
|
" set resource limit per query\n" |
5114 |
|
" --rlimit=N set resource limit\n" |
5115 |
|
" --tlimit-per=MS set time limit per query in milliseconds\n" |
5116 |
|
" --tlimit=MS set time limit in milliseconds of wall clock time\n" |
5117 |
|
" --dump-to=FILE all dumping goes to FILE (instead of stdout)\n" |
5118 |
|
" --dump=MODE dump preprocessed assertions, etc., see --dump=help\n" |
5119 |
|
" --incremental | -i enable incremental solving [*]\n" |
5120 |
|
" --produce-assertions keep an assertions list (enables get-assertions\n" |
5121 |
|
" command) [*]\n" |
5122 |
|
" --produce-models | -m support the get-value and get-model commands [*]\n" |
5123 |
|
// clang-format on |
5124 |
|
; |
5125 |
|
|
5126 |
|
// clang-format off |
5127 |
9398 |
static const std::string optionsDescription = |
5128 |
|
mostCommonOptionsDescription + "\n\nAdditional cvc5 options:\n" |
5129 |
|
"\nFrom the Arithmetic Theory module:\n" |
5130 |
|
" --approx-branch-depth=N\n" |
5131 |
|
" maximum branch depth the approximate solver is allowed\n" |
5132 |
|
" to take\n" |
5133 |
|
" --arith-brab whether to use simple rounding, similar to a unit-cube\n" |
5134 |
|
" test, for integers [*]\n" |
5135 |
|
" --arith-no-partial-fun do not use partial function semantics for arithmetic\n" |
5136 |
|
" (not SMT LIB compliant) [*]\n" |
5137 |
|
" --arith-prop-clauses=N rows shorter than this are propagated as clauses\n" |
5138 |
|
" --arith-prop=MODE turns on arithmetic propagation (default is 'old', see\n" |
5139 |
|
" --arith-prop=help)\n" |
5140 |
|
" --arith-rewrite-equalities\n" |
5141 |
|
" turns on the preprocessing rewrite turning equalities\n" |
5142 |
|
" into a conjunction of inequalities [*]\n" |
5143 |
|
" --collect-pivot-stats collect the pivot history [*]\n" |
5144 |
|
" --cut-all-bounded turns on the integer solving step of periodically\n" |
5145 |
|
" cutting all integer variables that have both upper and\n" |
5146 |
|
" lower bounds [*]\n" |
5147 |
|
" --dio-decomps let skolem variables for integer divisibility\n" |
5148 |
|
" constraints leak from the dio solver [*]\n" |
5149 |
|
" --dio-repeat handle dio solver constraints in mass or one at a time\n" |
5150 |
|
" [*]\n" |
5151 |
|
" --dio-solver turns on Linear Diophantine Equation solver (Griggio,\n" |
5152 |
|
" JSAT 2012) [*]\n" |
5153 |
|
" --dio-turns=N turns in a row dio solver cutting gets\n" |
5154 |
|
" --error-selection-rule=RULE\n" |
5155 |
|
" change the pivot rule for the basic variable (default\n" |
5156 |
|
" is 'min', see --pivot-rule help)\n" |
5157 |
|
" --fc-penalties turns on degenerate pivot penalties [*]\n" |
5158 |
|
" --heuristic-pivots=N the number of times to apply the heuristic pivot rule;\n" |
5159 |
|
" if N < 0, this defaults to the number of variables; if\n" |
5160 |
|
" this is unset, this is tuned by the logic selection\n" |
5161 |
|
" --lemmas-on-replay-failure\n" |
5162 |
|
" attempt to use external lemmas if approximate solve\n" |
5163 |
|
" integer failed [*]\n" |
5164 |
|
" --maxCutsInContext=N maximum cuts in a given context before signalling a\n" |
5165 |
|
" restart\n" |
5166 |
|
" --miplib-trick turns on the preprocessing step of attempting to infer\n" |
5167 |
|
" bounds on miplib problems [*]\n" |
5168 |
|
" --miplib-trick-subs=N do substitution for miplib 'tmp' vars if defined in <=\n" |
5169 |
|
" N eliminated vars\n" |
5170 |
|
" --new-prop use the new row propagation system [*]\n" |
5171 |
|
" --nl-cad whether to use the cylindrical algebraic decomposition\n" |
5172 |
|
" solver for non-linear arithmetic [*]\n" |
5173 |
|
" --nl-cad-initial whether to use the linear model as initial guess for\n" |
5174 |
|
" the cylindrical algebraic decomposition solver [*]\n" |
5175 |
|
" --nl-ext-ent-conf check for entailed conflicts in non-linear solver [*]\n" |
5176 |
|
" --nl-ext-factor use factoring inference in non-linear incremental\n" |
5177 |
|
" linearization solver [*]\n" |
5178 |
|
" --nl-ext-inc-prec whether to increment the precision for irrational\n" |
5179 |
|
" function constraints [*]\n" |
5180 |
|
" --nl-ext-purify purify non-linear terms at preprocess [*]\n" |
5181 |
|
" --nl-ext-rbound use resolution-style inference for inferring new bounds\n" |
5182 |
|
" in non-linear incremental linearization solver [*]\n" |
5183 |
|
" --nl-ext-rewrite do context-dependent simplification based on rewrites\n" |
5184 |
|
" in non-linear solver [*]\n" |
5185 |
|
" --nl-ext-split-zero initial splits on zero for all variables [*]\n" |
5186 |
|
" --nl-ext-tf-taylor-deg=N\n" |
5187 |
|
" initial degree of polynomials for Taylor approximation\n" |
5188 |
|
" --nl-ext-tf-tplanes use non-terminating tangent plane strategy for\n" |
5189 |
|
" transcendental functions for non-linear incremental\n" |
5190 |
|
" linearization solver [*]\n" |
5191 |
|
" --nl-ext-tplanes use non-terminating tangent plane strategy for\n" |
5192 |
|
" non-linear incremental linearization solver [*]\n" |
5193 |
|
" --nl-ext-tplanes-interleave\n" |
5194 |
|
" interleave tangent plane strategy for non-linear\n" |
5195 |
|
" incremental linearization solver [*]\n" |
5196 |
|
" --nl-ext=MODE incremental linearization approach to non-linear\n" |
5197 |
|
" --nl-icp whether to use ICP-style propagations for non-linear\n" |
5198 |
|
" arithmetic [*]\n" |
5199 |
|
" --nl-rlv=MODE choose mode for using relevance of assertoins in\n" |
5200 |
|
" non-linear arithmetic\n" |
5201 |
|
" --pb-rewrites apply pseudo boolean rewrites [*]\n" |
5202 |
|
" --pivot-threshold=N sets the number of pivots using --pivot-rule per basic\n" |
5203 |
|
" variable per simplex instance before using variable\n" |
5204 |
|
" order\n" |
5205 |
|
" --pp-assert-max-sub-size=N\n" |
5206 |
|
" threshold for substituting an equality in ppAssert\n" |
5207 |
|
" --prop-row-length=N sets the maximum row length to be used in propagation\n" |
5208 |
|
" --replay-early-close-depth=N\n" |
5209 |
|
" multiples of the depths to try to close the approx log\n" |
5210 |
|
" eagerly\n" |
5211 |
|
" --replay-failure-penalty=N\n" |
5212 |
|
" number of solve integer attempts to skips after a\n" |
5213 |
|
" numeric failure\n" |
5214 |
|
" --replay-lemma-reject-cut=N\n" |
5215 |
|
" maximum complexity of any coefficient while outputting\n" |
5216 |
|
" replaying cut lemmas\n" |
5217 |
|
" --replay-num-err-penalty=N\n" |
5218 |
|
" number of solve integer attempts to skips after a\n" |
5219 |
|
" numeric failure\n" |
5220 |
|
" --replay-reject-cut=N maximum complexity of any coefficient while replaying\n" |
5221 |
|
" cuts\n" |
5222 |
|
" --replay-soi-major-threshold-pen=N\n" |
5223 |
|
" threshold for a major tolerance failure by the\n" |
5224 |
|
" approximate solver\n" |
5225 |
|
" --replay-soi-major-threshold=T\n" |
5226 |
|
" threshold for a major tolerance failure by the\n" |
5227 |
|
" approximate solver\n" |
5228 |
|
" --replay-soi-minor-threshold-pen=N\n" |
5229 |
|
" threshold for a minor tolerance failure by the\n" |
5230 |
|
" approximate solver\n" |
5231 |
|
" --replay-soi-minor-threshold=T\n" |
5232 |
|
" threshold for a minor tolerance failure by the\n" |
5233 |
|
" approximate solver\n" |
5234 |
|
" --restrict-pivots have a pivot cap for simplex at effort levels below\n" |
5235 |
|
" fullEffort [*]\n" |
5236 |
|
" --revert-arith-models-on-unsat\n" |
5237 |
|
" revert the arithmetic model to a known safe model on\n" |
5238 |
|
" unsat if one is cached [*]\n" |
5239 |
|
" --rr-turns=N round robin turn\n" |
5240 |
|
" --se-solve-int attempt to use the approximate solve integer method on\n" |
5241 |
|
" standard effort [*]\n" |
5242 |
|
" --simplex-check-period=N\n" |
5243 |
|
" the number of pivots to do in simplex before rechecking\n" |
5244 |
|
" for a conflict on all variables\n" |
5245 |
|
" --soi-qe use quick explain to minimize the sum of infeasibility\n" |
5246 |
|
" conflicts [*]\n" |
5247 |
|
" --standard-effort-variable-order-pivots=N\n" |
5248 |
|
" limits the number of pivots in a single invocation of\n" |
5249 |
|
" check() at a non-full effort level using Bland's pivot\n" |
5250 |
|
" rule (EXPERTS only)\n" |
5251 |
|
" --unate-lemmas=MODE determines which lemmas to add before solving (default\n" |
5252 |
|
" is 'all', see --unate-lemmas=help)\n" |
5253 |
|
" --use-approx attempt to use an approximate solver [*]\n" |
5254 |
|
" --use-fcsimplex use focusing and converging simplex (FMCAD 2013\n" |
5255 |
|
" submission) [*]\n" |
5256 |
|
" --use-soi use sum of infeasibility simplex (FMCAD 2013\n" |
5257 |
|
" submission) [*]\n" |
5258 |
|
"\nFrom the Arrays Theory module:\n" |
5259 |
|
" --arrays-config=N set different array option configurations - for\n" |
5260 |
|
" developers only\n" |
5261 |
|
" --arrays-eager-index turn on eager index splitting for generated array\n" |
5262 |
|
" lemmas [*]\n" |
5263 |
|
" --arrays-eager-lemmas turn on eager lemma generation for arrays [*]\n" |
5264 |
|
" --arrays-exp enable experimental features in the theory of arrays\n" |
5265 |
|
" [*]\n" |
5266 |
|
" --arrays-model-based turn on model-based array solver [*]\n" |
5267 |
|
" --arrays-optimize-linear\n" |
5268 |
|
" turn on optimization for linear array terms (see de\n" |
5269 |
|
" Moura FMCAD 09 arrays paper) [*]\n" |
5270 |
|
" --arrays-prop=N propagation effort for arrays: 0 is none, 1 is some, 2\n" |
5271 |
|
" is full\n" |
5272 |
|
" --arrays-reduce-sharing\n" |
5273 |
|
" use model information to reduce size of care graph for\n" |
5274 |
|
" arrays [*]\n" |
5275 |
|
" --arrays-weak-equiv use algorithm from Christ/Hoenicke (SMT 2014) [*]\n" |
5276 |
|
"\nFrom the Base module:\n" |
5277 |
|
" --debug=TAG | -d TAG debug something (e.g. -d arith), can repeat\n" |
5278 |
|
" --parse-only exit after parsing input [*]\n" |
5279 |
|
" --preprocess-only exit after preprocessing input [*]\n" |
5280 |
|
" --print-success print the \"success\" output required of SMT-LIBv2 [*]\n" |
5281 |
|
" --stats-all print unchanged (defaulted) statistics as well (EXPERTS\n" |
5282 |
|
" only) [*]\n" |
5283 |
|
" --stats-every-query in incremental mode, print stats after every\n" |
5284 |
|
" satisfiability or validity query [*]\n" |
5285 |
|
" --stats-expert print expert (non-public) statistics as well (EXPERTS\n" |
5286 |
|
" only) [*]\n" |
5287 |
|
" --trace=TAG | -t TAG trace something (e.g. -t pushpop), can repeat\n" |
5288 |
|
" --verbosity=N the verbosity level of cvc5\n" |
5289 |
|
"\nFrom the Bitvector Theory module:\n" |
5290 |
|
" --bitblast-aig bitblast by first converting to AIG (implies\n" |
5291 |
|
" --bitblast=eager) [*]\n" |
5292 |
|
" --bitblast=MODE choose bitblasting mode, see --bitblast=help\n" |
5293 |
|
" --bitwise-eq lift equivalence with one-bit bit-vectors to be boolean\n" |
5294 |
|
" operations [*]\n" |
5295 |
|
" --bool-to-bv=MODE convert booleans to bit-vectors of size 1 at various\n" |
5296 |
|
" levels of aggressiveness, see --bool-to-bv=help\n" |
5297 |
|
" --bv-aig-simp=COMMAND abc command to run AIG simplifications (implies\n" |
5298 |
|
" --bitblast-aig, default is \"balance;drw\") (EXPERTS\n" |
5299 |
|
" only)\n" |
5300 |
|
" --bv-alg-extf algebraic inferences for extended functions [*]\n" |
5301 |
|
" --bv-algebraic-budget=N\n" |
5302 |
|
" the budget allowed for the algebraic solver in number\n" |
5303 |
|
" of SAT conflicts (EXPERTS only)\n" |
5304 |
|
" --bv-algebraic-solver turn on experimental algebraic solver for the\n" |
5305 |
|
" bit-vector theory (only if --bitblast=lazy) [*]\n" |
5306 |
|
" --bv-assert-input assert input assertions on user-level 0 instead of\n" |
5307 |
|
" assuming them in the bit-vector SAT solver [*]\n" |
5308 |
|
" --bv-eager-explanations\n" |
5309 |
|
" compute bit-blasting propagation explanations eagerly\n" |
5310 |
|
" (EXPERTS only) [*]\n" |
5311 |
|
" --bv-eq-solver use the equality engine for the bit-vector theory (only\n" |
5312 |
|
" if --bitblast=lazy) [*]\n" |
5313 |
|
" --bv-extract-arith enable rewrite pushing extract [i:0] over arithmetic\n" |
5314 |
|
" operations (can blow up) (EXPERTS only) [*]\n" |
5315 |
|
" --bv-gauss-elim simplify formula via Gaussian Elimination if applicable\n" |
5316 |
|
" (EXPERTS only) [*]\n" |
5317 |
|
" --bv-inequality-solver turn on the inequality solver for the bit-vector theory\n" |
5318 |
|
" (only if --bitblast=lazy) [*]\n" |
5319 |
|
" --bv-intro-pow2 introduce bitvector powers of two as a preprocessing\n" |
5320 |
|
" pass (EXPERTS only) [*]\n" |
5321 |
|
" --bv-lazy-reduce-extf reduce extended functions like bv2nat and int2bv at\n" |
5322 |
|
" last call instead of full effort [*]\n" |
5323 |
|
" --bv-lazy-rewrite-extf lazily rewrite extended functions like bv2nat and\n" |
5324 |
|
" int2bv [*]\n" |
5325 |
|
" --bv-num-func=N number of function symbols in conflicts that are\n" |
5326 |
|
" generalized (EXPERTS only)\n" |
5327 |
|
" --bv-print-consts-as-indexed-symbols\n" |
5328 |
|
" print bit-vector constants in decimal (e.g. (_ bv1 4))\n" |
5329 |
|
" instead of binary (e.g. #b0001), applies to SMT-LIB 2.x\n" |
5330 |
|
" [*]\n" |
5331 |
|
" --bv-propagate use bit-vector propagation in the bit-blaster [*]\n" |
5332 |
|
" --bv-quick-xplain minimize bv conflicts using the QuickXplain algorithm\n" |
5333 |
|
" (EXPERTS only) [*]\n" |
5334 |
|
" --bv-sat-solver=MODE choose which sat solver to use, see\n" |
5335 |
|
" --bv-sat-solver=help (EXPERTS only)\n" |
5336 |
|
" --bv-solver=MODE choose bit-vector solver, see --bv-solver=help\n" |
5337 |
|
" --bv-to-bool lift bit-vectors of size 1 to booleans when possible\n" |
5338 |
|
" [*]\n" |
5339 |
|
"\nFrom the Datatypes Theory module:\n" |
5340 |
|
" --cdt-bisimilar do bisimilarity check for co-datatypes [*]\n" |
5341 |
|
" --dt-binary-split do binary splits for datatype constructor types [*]\n" |
5342 |
|
" --dt-blast-splits when applicable, blast splitting lemmas for all\n" |
5343 |
|
" variables at once [*]\n" |
5344 |
|
" --dt-cyclic do cyclicity check for datatypes [*]\n" |
5345 |
|
" --dt-force-assignment force the datatypes solver to give specific values to\n" |
5346 |
|
" all datatypes terms before answering sat [*]\n" |
5347 |
|
" --dt-infer-as-lemmas always send lemmas out instead of making internal\n" |
5348 |
|
" inferences [*]\n" |
5349 |
|
" --dt-nested-rec allow nested recursion in datatype definitions [*]\n" |
5350 |
|
" --dt-polite-optimize turn on optimization for polite combination [*]\n" |
5351 |
|
" --dt-rewrite-error-sel rewrite incorrectly applied selectors to arbitrary\n" |
5352 |
|
" ground term (EXPERTS only) [*]\n" |
5353 |
|
" --dt-share-sel internally use shared selectors across multiple\n" |
5354 |
|
" constructors [*]\n" |
5355 |
|
" --sygus-abort-size=N tells enumerative sygus to only consider solutions up\n" |
5356 |
|
" to term size N (-1 == no limit, default)\n" |
5357 |
|
" --sygus-fair-max use max instead of sum for multi-function sygus\n" |
5358 |
|
" conjectures [*]\n" |
5359 |
|
" --sygus-fair=MODE if and how to apply fairness for sygus\n" |
5360 |
|
" --sygus-sym-break simple sygus symmetry breaking lemmas [*]\n" |
5361 |
|
" --sygus-sym-break-agg use aggressive checks for simple sygus symmetry\n" |
5362 |
|
" breaking lemmas [*]\n" |
5363 |
|
" --sygus-sym-break-dynamic\n" |
5364 |
|
" dynamic sygus symmetry breaking lemmas [*]\n" |
5365 |
|
" --sygus-sym-break-lazy lazily add symmetry breaking lemmas for terms [*]\n" |
5366 |
|
" --sygus-sym-break-pbe sygus symmetry breaking lemmas based on pbe conjectures\n" |
5367 |
|
" [*]\n" |
5368 |
|
" --sygus-sym-break-rlv add relevancy conditions to symmetry breaking lemmas\n" |
5369 |
|
" [*]\n" |
5370 |
|
"\nFrom the Decision Heuristics module:\n" |
5371 |
|
" --decision-random-weight=N\n" |
5372 |
|
" assign random weights to nodes between 0 and N-1 (0:\n" |
5373 |
|
" disable) (EXPERTS only)\n" |
5374 |
|
" --decision-threshold=N ignore all nodes greater than threshold in first\n" |
5375 |
|
" attempt to pick decision (EXPERTS only)\n" |
5376 |
|
" --decision-use-weight use the weight nodes (locally, by looking at children)\n" |
5377 |
|
" to direct recursive search (EXPERTS only) [*]\n" |
5378 |
|
" --decision-weight-internal=HOW\n" |
5379 |
|
" compute weights of internal nodes using children: off,\n" |
5380 |
|
" max, sum, usr1 (EXPERTS only)\n" |
5381 |
|
" --decision=MODE | --decision-mode=MODE\n" |
5382 |
|
" choose decision mode, see --decision=help\n" |
5383 |
|
"\nFrom the Expression module:\n" |
5384 |
|
" --dag-thresh=N dagify common subexprs appearing > N times (1 ==\n" |
5385 |
|
" default, 0 == don't dagify)\n" |
5386 |
|
" --expr-depth=N print exprs to depth N (0 == default, -1 == no limit)\n" |
5387 |
|
" --type-checking type check expressions [*]\n" |
5388 |
|
"\nFrom the Floating-Point module:\n" |
5389 |
|
" --fp-exp Allow floating-point sorts of all sizes, rather than\n" |
5390 |
|
" only Float32 (8/24) or Float64 (11/53) (experimental)\n" |
5391 |
|
" [*]\n" |
5392 |
|
"\nFrom the Driver module:\n" |
5393 |
|
" --early-exit do not run destructors at exit; default on except in\n" |
5394 |
|
" debug builds (EXPERTS only) [*]\n" |
5395 |
|
" --interactive force interactive/non-interactive mode [*]\n" |
5396 |
|
" --segv-spin spin on segfault/other crash waiting for gdb [*]\n" |
5397 |
|
" --show-debug-tags show all available tags for debugging\n" |
5398 |
|
" --show-trace-tags show all available tags for tracing\n" |
5399 |
|
" --tear-down-incremental=N\n" |
5400 |
|
" implement PUSH/POP/multi-query by destroying and\n" |
5401 |
|
" recreating SmtEngine every N queries (EXPERTS only)\n" |
5402 |
|
"\nFrom the Parser module:\n" |
5403 |
|
" --force-logic=LOGIC set the logic, and override all further user attempts\n" |
5404 |
|
" to change it (EXPERTS only)\n" |
5405 |
|
" --global-declarations force all declarations and definitions to be global [*]\n" |
5406 |
|
" --mmap memory map file input [*]\n" |
5407 |
|
" --semantic-checks enable semantic checks, including type checks [*]\n" |
5408 |
|
"\nFrom the Printing module:\n" |
5409 |
|
" --flatten-ho-chains print (binary) application chains in a flattened way,\n" |
5410 |
|
" e.g. (a b c) rather than ((a b) c) [*]\n" |
5411 |
|
" --inst-format=MODE print format mode for instantiations, see\n" |
5412 |
|
" --inst-format=help\n" |
5413 |
|
" --model-format=MODE print format mode for models, see --model-format=help\n" |
5414 |
|
" --print-inst-full print instantiations for formulas that do not have\n" |
5415 |
|
" given identifiers [*]\n" |
5416 |
|
" --print-inst=MODE print format for printing instantiations\n" |
5417 |
|
"\nFrom the Proof module:\n" |
5418 |
|
" --proof-eager-checking check proofs eagerly with proof for local debugging [*]\n" |
5419 |
|
" --proof-format-mode=MODE\n" |
5420 |
|
" select language of proof output\n" |
5421 |
|
" --proof-granularity=MODE\n" |
5422 |
|
" modes for proof granularity\n" |
5423 |
|
" --proof-pedantic=N assertion failure for any incorrect rule application or\n" |
5424 |
|
" untrusted lemma having pedantic level <=N with proof\n" |
5425 |
|
" --proof-print-conclusion\n" |
5426 |
|
" Print conclusion of proof steps when printing AST [*]\n" |
5427 |
|
"\nFrom the SAT Layer module:\n" |
5428 |
|
" --minisat-dump-dimacs instead of solving minisat dumps the asserted clauses\n" |
5429 |
|
" in Dimacs format [*]\n" |
5430 |
|
" --minisat-elimination use Minisat elimination [*]\n" |
5431 |
|
" --random-freq=P | --random-frequency=P\n" |
5432 |
|
" sets the frequency of random decisions in the sat\n" |
5433 |
|
" solver (P=0.0 by default)\n" |
5434 |
|
" --random-seed=S sets the random seed for the sat solver\n" |
5435 |
|
" --refine-conflicts refine theory conflict clauses (default false) [*]\n" |
5436 |
|
" --restart-int-base=N sets the base restart interval for the sat solver (N=25\n" |
5437 |
|
" by default)\n" |
5438 |
|
" --restart-int-inc=F sets the restart interval increase factor for the sat\n" |
5439 |
|
" solver (F=3.0 by default)\n" |
5440 |
|
"\nFrom the Quantifiers module:\n" |
5441 |
|
" --ag-miniscope-quant perform aggressive miniscoping for quantifiers [*]\n" |
5442 |
|
" --cegis-sample=MODE mode for using samples in the counterexample-guided\n" |
5443 |
|
" inductive synthesis loop\n" |
5444 |
|
" --cegqi turns on counterexample-based quantifier instantiation\n" |
5445 |
|
" [*]\n" |
5446 |
|
" --cegqi-all apply counterexample-based instantiation to all\n" |
5447 |
|
" quantified formulas [*]\n" |
5448 |
|
" --cegqi-bv use word-level inversion approach for\n" |
5449 |
|
" counterexample-guided quantifier instantiation for\n" |
5450 |
|
" bit-vectors [*]\n" |
5451 |
|
" --cegqi-bv-concat-inv compute inverse for concat over equalities rather than\n" |
5452 |
|
" producing an invertibility condition [*]\n" |
5453 |
|
" --cegqi-bv-ineq=MODE choose mode for handling bit-vector inequalities with\n" |
5454 |
|
" counterexample-guided instantiation\n" |
5455 |
|
" --cegqi-bv-interleave-value\n" |
5456 |
|
" interleave model value instantiation with word-level\n" |
5457 |
|
" inversion approach [*]\n" |
5458 |
|
" --cegqi-bv-linear linearize adder chains for variables [*]\n" |
5459 |
|
" --cegqi-bv-rm-extract replaces extract terms with variables for\n" |
5460 |
|
" counterexample-guided instantiation for bit-vectors [*]\n" |
5461 |
|
" --cegqi-bv-solve-nl try to solve non-linear bv literals using model value\n" |
5462 |
|
" projections [*]\n" |
5463 |
|
" --cegqi-full turns on full effort counterexample-based quantifier\n" |
5464 |
|
" instantiation, which may resort to model-value\n" |
5465 |
|
" instantiation [*]\n" |
5466 |
|
" --cegqi-innermost only process innermost quantified formulas in\n" |
5467 |
|
" counterexample-based quantifier instantiation [*]\n" |
5468 |
|
" --cegqi-midpoint choose substitutions based on midpoints of lower and\n" |
5469 |
|
" upper bounds for counterexample-based quantifier\n" |
5470 |
|
" instantiation [*]\n" |
5471 |
|
" --cegqi-min-bounds use minimally constrained lower/upper bound for\n" |
5472 |
|
" counterexample-based quantifier instantiation [*]\n" |
5473 |
|
" --cegqi-model guide instantiations by model values for\n" |
5474 |
|
" counterexample-based quantifier instantiation [*]\n" |
5475 |
|
" --cegqi-multi-inst when applicable, do multi instantiations per quantifier\n" |
5476 |
|
" per round in counterexample-based quantifier\n" |
5477 |
|
" instantiation [*]\n" |
5478 |
|
" --cegqi-nested-qe process nested quantified formulas with quantifier\n" |
5479 |
|
" elimination in counterexample-based quantifier\n" |
5480 |
|
" instantiation [*]\n" |
5481 |
|
" --cegqi-nopt non-optimal bounds for counterexample-based quantifier\n" |
5482 |
|
" instantiation [*]\n" |
5483 |
|
" --cegqi-repeat-lit solve literals more than once in counterexample-based\n" |
5484 |
|
" quantifier instantiation [*]\n" |
5485 |
|
" --cegqi-round-up-lia round up integer lower bounds in substitutions for\n" |
5486 |
|
" counterexample-based quantifier instantiation [*]\n" |
5487 |
|
" --cegqi-sat answer sat when quantifiers are asserted with\n" |
5488 |
|
" counterexample-based quantifier instantiation [*]\n" |
5489 |
|
" --cegqi-use-inf-int use integer infinity for vts in counterexample-based\n" |
5490 |
|
" quantifier instantiation [*]\n" |
5491 |
|
" --cegqi-use-inf-real use real infinity for vts in counterexample-based\n" |
5492 |
|
" quantifier instantiation [*]\n" |
5493 |
|
" --cond-var-split-agg-quant\n" |
5494 |
|
" aggressive split quantified formulas that lead to\n" |
5495 |
|
" variable eliminations [*]\n" |
5496 |
|
" --cond-var-split-quant split quantified formulas that lead to variable\n" |
5497 |
|
" eliminations [*]\n" |
5498 |
|
" --conjecture-filter-active-terms\n" |
5499 |
|
" filter based on active terms [*]\n" |
5500 |
|
" --conjecture-filter-canonical\n" |
5501 |
|
" filter based on canonicity [*]\n" |
5502 |
|
" --conjecture-filter-model\n" |
5503 |
|
" filter based on model [*]\n" |
5504 |
|
" --conjecture-gen generate candidate conjectures for inductive proofs [*]\n" |
5505 |
|
" --conjecture-gen-gt-enum=N\n" |
5506 |
|
" number of ground terms to generate for model filtering\n" |
5507 |
|
" --conjecture-gen-max-depth=N\n" |
5508 |
|
" maximum depth of terms to consider for conjectures\n" |
5509 |
|
" --conjecture-gen-per-round=N\n" |
5510 |
|
" number of conjectures to generate per instantiation\n" |
5511 |
|
" round\n" |
5512 |
|
" --conjecture-gen-uee-intro\n" |
5513 |
|
" more aggressive merging for universal equality engine,\n" |
5514 |
|
" introduces terms [*]\n" |
5515 |
|
" --conjecture-no-filter do not filter conjectures [*]\n" |
5516 |
|
" --debug-inst print instantiations during solving (for debugging) [*]\n" |
5517 |
|
" --debug-sygus print enumerated terms and candidates generated by the\n" |
5518 |
|
" sygus solver (for debugging) [*]\n" |
5519 |
|
" --dt-stc-ind apply strengthening for existential quantification over\n" |
5520 |
|
" datatypes based on structural induction [*]\n" |
5521 |
|
" --dt-var-exp-quant expand datatype variables bound to one constructor in\n" |
5522 |
|
" quantifiers [*]\n" |
5523 |
|
" --e-matching whether to do heuristic E-matching [*]\n" |
5524 |
|
" --elim-taut-quant eliminate tautological disjuncts of quantified formulas\n" |
5525 |
|
" [*]\n" |
5526 |
|
" --ext-rewrite-quant apply extended rewriting to bodies of quantified\n" |
5527 |
|
" formulas [*]\n" |
5528 |
|
" --finite-model-find use finite model finding heuristic for quantifier\n" |
5529 |
|
" instantiation [*]\n" |
5530 |
|
" --fmf-bound finite model finding on bounded quantification [*]\n" |
5531 |
|
" --fmf-bound-int finite model finding on bounded integer quantification\n" |
5532 |
|
" [*]\n" |
5533 |
|
" --fmf-bound-lazy enforce bounds for bounded quantification lazily via\n" |
5534 |
|
" use of proxy variables [*]\n" |
5535 |
|
" --fmf-fmc-simple simple models in full model check for finite model\n" |
5536 |
|
" finding [*]\n" |
5537 |
|
" --fmf-fresh-dc use fresh distinguished representative when applying\n" |
5538 |
|
" Inst-Gen techniques [*]\n" |
5539 |
|
" --fmf-fun find models for recursively defined functions, assumes\n" |
5540 |
|
" functions are admissible [*]\n" |
5541 |
|
" --fmf-fun-rlv find models for recursively defined functions, assumes\n" |
5542 |
|
" functions are admissible, allows empty type when\n" |
5543 |
|
" function is irrelevant [*]\n" |
5544 |
|
" --fmf-inst-engine use instantiation engine in conjunction with finite\n" |
5545 |
|
" model finding [*]\n" |
5546 |
|
" --fmf-type-completion-thresh=N\n" |
5547 |
|
" the maximum cardinality of an interpreted type for\n" |
5548 |
|
" which exhaustive enumeration in finite model finding is\n" |
5549 |
|
" attempted\n" |
5550 |
|
" --fs-interleave interleave enumerative instantiation with other\n" |
5551 |
|
" techniques [*]\n" |
5552 |
|
" --fs-stratify stratify effort levels in enumerative instantiation,\n" |
5553 |
|
" which favors speed over fairness [*]\n" |
5554 |
|
" --fs-sum enumerating tuples of quantifiers by increasing the sum\n" |
5555 |
|
" of indices, rather than the maximum [*]\n" |
5556 |
|
" --full-saturate-quant enumerative instantiation: instantiate with ground\n" |
5557 |
|
" terms from relevant domain, then arbitrary ground terms\n" |
5558 |
|
" before answering unknown [*]\n" |
5559 |
|
" --full-saturate-quant-limit=N\n" |
5560 |
|
" maximum number of rounds of enumerative instantiation\n" |
5561 |
|
" to apply (-1 means no limit)\n" |
5562 |
|
" --full-saturate-quant-rd\n" |
5563 |
|
" whether to use relevant domain first for enumerative\n" |
5564 |
|
" instantiation strategy [*]\n" |
5565 |
|
" --global-negate do global negation of input formula [*]\n" |
5566 |
|
" --ho-elim eagerly eliminate higher-order constraints [*]\n" |
5567 |
|
" --ho-elim-store-ax use store axiom during ho-elim [*]\n" |
5568 |
|
" --ho-matching do higher-order matching algorithm for triggers with\n" |
5569 |
|
" variable operators [*]\n" |
5570 |
|
" --ho-matching-var-priority\n" |
5571 |
|
" give priority to variable arguments over constant\n" |
5572 |
|
" arguments [*]\n" |
5573 |
|
" --ho-merge-term-db merge term indices modulo equality [*]\n" |
5574 |
|
" --increment-triggers generate additional triggers as needed during search\n" |
5575 |
|
" [*]\n" |
5576 |
|
" --inst-level-input-only\n" |
5577 |
|
" only input terms are assigned instantiation level zero\n" |
5578 |
|
" [*]\n" |
5579 |
|
" --inst-max-level=N maximum inst level of terms used to instantiate\n" |
5580 |
|
" quantified formulas with (-1 == no limit, default)\n" |
5581 |
|
" --inst-no-entail do not consider instances of quantified formulas that\n" |
5582 |
|
" are currently entailed [*]\n" |
5583 |
|
" --inst-when-phase=N instantiation rounds quantifiers takes (>=1) before\n" |
5584 |
|
" allowing theory combination to happen\n" |
5585 |
|
" --inst-when-strict-interleave\n" |
5586 |
|
" ensure theory combination and standard quantifier\n" |
5587 |
|
" effort strategies take turns [*]\n" |
5588 |
|
" --inst-when-tc-first allow theory combination to happen once initially,\n" |
5589 |
|
" before quantifier strategies are run [*]\n" |
5590 |
|
" --inst-when=MODE when to apply instantiation\n" |
5591 |
|
" --int-wf-ind apply strengthening for integers based on well-founded\n" |
5592 |
|
" induction [*]\n" |
5593 |
|
" --ite-dtt-split-quant split ites with dt testers as conditions [*]\n" |
5594 |
|
" --ite-lift-quant=MODE ite lifting mode for quantified formulas\n" |
5595 |
|
" --literal-matching=MODE\n" |
5596 |
|
" choose literal matching mode\n" |
5597 |
|
" --macros-quant perform quantifiers macro expansion [*]\n" |
5598 |
|
" --macros-quant-mode=MODE\n" |
5599 |
|
" mode for quantifiers macro expansion\n" |
5600 |
|
" --mbqi-interleave interleave model-based quantifier instantiation with\n" |
5601 |
|
" other techniques [*]\n" |
5602 |
|
" --mbqi-one-inst-per-round\n" |
5603 |
|
" only add one instantiation per quantifier per round for\n" |
5604 |
|
" mbqi [*]\n" |
5605 |
|
" --mbqi=MODE choose mode for model-based quantifier instantiation\n" |
5606 |
|
" --miniscope-quant miniscope quantifiers [*]\n" |
5607 |
|
" --miniscope-quant-fv miniscope quantifiers for ground subformulas [*]\n" |
5608 |
|
" --multi-trigger-cache caching version of multi triggers [*]\n" |
5609 |
|
" --multi-trigger-linear implementation of multi triggers where maximum number\n" |
5610 |
|
" of instantiations is linear wrt number of ground terms\n" |
5611 |
|
" [*]\n" |
5612 |
|
" --multi-trigger-priority\n" |
5613 |
|
" only try multi triggers if single triggers give no\n" |
5614 |
|
" instantiations [*]\n" |
5615 |
|
" --multi-trigger-when-single\n" |
5616 |
|
" select multi triggers when single triggers exist [*]\n" |
5617 |
|
" --partial-triggers use triggers that do not contain all free variables [*]\n" |
5618 |
|
" --pool-inst pool-based instantiation: instantiate with ground terms\n" |
5619 |
|
" occurring in user-specified pools [*]\n" |
5620 |
|
" --pre-skolem-quant apply skolemization eagerly to bodies of quantified\n" |
5621 |
|
" formulas [*]\n" |
5622 |
|
" --pre-skolem-quant-agg apply skolemization to quantified formulas aggressively\n" |
5623 |
|
" [*]\n" |
5624 |
|
" --pre-skolem-quant-nested\n" |
5625 |
|
" apply skolemization to nested quantified formulas [*]\n" |
5626 |
|
" --prenex-quant-user prenex quantified formulas with user patterns [*]\n" |
5627 |
|
" --prenex-quant=MODE prenex mode for quantified formulas\n" |
5628 |
|
" --purify-triggers purify triggers, e.g. f( x+1 ) becomes f( y ), x mapsto\n" |
5629 |
|
" y-1 [*]\n" |
5630 |
|
" --qcf-all-conflict add all available conflicting instances during\n" |
5631 |
|
" conflict-based instantiation [*]\n" |
5632 |
|
" --qcf-eager-check-rd optimization, eagerly check relevant domain of matched\n" |
5633 |
|
" position [*]\n" |
5634 |
|
" --qcf-eager-test optimization, test qcf instances eagerly [*]\n" |
5635 |
|
" --qcf-nested-conflict consider conflicts for nested quantifiers [*]\n" |
5636 |
|
" --qcf-skip-rd optimization, skip instances based on possibly\n" |
5637 |
|
" irrelevant portions of quantified formulas [*]\n" |
5638 |
|
" --qcf-tconstraint enable entailment checks for t-constraints in qcf\n" |
5639 |
|
" algorithm [*]\n" |
5640 |
|
" --qcf-vo-exp qcf experimental variable ordering [*]\n" |
5641 |
|
" --quant-alpha-equiv infer alpha equivalence between quantified formulas [*]\n" |
5642 |
|
" --quant-cf enable conflict find mechanism for quantifiers [*]\n" |
5643 |
|
" --quant-cf-mode=MODE what effort to apply conflict find mechanism\n" |
5644 |
|
" --quant-cf-when=MODE when to invoke conflict find mechanism for quantifiers\n" |
5645 |
|
" --quant-dsplit-mode=MODE\n" |
5646 |
|
" mode for dynamic quantifiers splitting\n" |
5647 |
|
" --quant-fun-wd assume that function defined by quantifiers are well\n" |
5648 |
|
" defined [*]\n" |
5649 |
|
" --quant-ind use all available techniques for inductive reasoning\n" |
5650 |
|
" [*]\n" |
5651 |
|
" --quant-rep-mode=MODE selection mode for representatives in quantifiers\n" |
5652 |
|
" engine\n" |
5653 |
|
" --quant-split apply splitting to quantified formulas based on\n" |
5654 |
|
" variable disjoint disjuncts [*]\n" |
5655 |
|
" --register-quant-body-terms\n" |
5656 |
|
" consider ground terms within bodies of quantified\n" |
5657 |
|
" formulas for matching [*]\n" |
5658 |
|
" --relational-triggers choose relational triggers such as x = f(y), x >= f(y)\n" |
5659 |
|
" [*]\n" |
5660 |
|
" --relevant-triggers prefer triggers that are more relevant based on SInE\n" |
5661 |
|
" style analysis [*]\n" |
5662 |
|
" --strict-triggers only instantiate quantifiers with user patterns based\n" |
5663 |
|
" on triggers [*]\n" |
5664 |
|
" --sygus use sygus solver (default is true for sygus inputs) [*]\n" |
5665 |
|
" --sygus-active-gen-cfactor=N\n" |
5666 |
|
" the branching factor for the number of interpreted\n" |
5667 |
|
" constants to consider for each size when using\n" |
5668 |
|
" --sygus-active-gen=enum\n" |
5669 |
|
" --sygus-active-gen=MODE\n" |
5670 |
|
" mode for actively-generated sygus enumerators\n" |
5671 |
|
" --sygus-add-const-grammar\n" |
5672 |
|
" statically add constants appearing in conjecture to\n" |
5673 |
|
" grammars [*]\n" |
5674 |
|
" --sygus-arg-relevant static inference techniques for computing whether\n" |
5675 |
|
" arguments of functions-to-synthesize are relevant [*]\n" |
5676 |
|
" --sygus-auto-unfold enable approach which automatically unfolds transition\n" |
5677 |
|
" systems for directly solving invariant synthesis\n" |
5678 |
|
" problems [*]\n" |
5679 |
|
" --sygus-bool-ite-return-const\n" |
5680 |
|
" Only use Boolean constants for return values in\n" |
5681 |
|
" unification-based function synthesis [*]\n" |
5682 |
|
" --sygus-core-connective\n" |
5683 |
|
" use unsat core analysis to construct Boolean connective\n" |
5684 |
|
" to sygus conjectures [*]\n" |
5685 |
|
" --sygus-crepair-abort abort if constant repair techniques are not applicable\n" |
5686 |
|
" [*]\n" |
5687 |
|
" --sygus-eval-opt use optimized approach for evaluation in sygus [*]\n" |
5688 |
|
" --sygus-eval-unfold do unfolding of sygus evaluation functions [*]\n" |
5689 |
|
" --sygus-eval-unfold-bool\n" |
5690 |
|
" do unfolding of Boolean evaluation functions that\n" |
5691 |
|
" appear in refinement lemmas [*]\n" |
5692 |
|
" --sygus-expr-miner-check-timeout=N\n" |
5693 |
|
" timeout (in milliseconds) for satisfiability checks in\n" |
5694 |
|
" expression miners\n" |
5695 |
|
" --sygus-ext-rew use extended rewriter for sygus [*]\n" |
5696 |
|
" --sygus-filter-sol-rev compute backwards filtering to compute whether previous\n" |
5697 |
|
" solutions are filtered based on later ones (EXPERTS\n" |
5698 |
|
" only) [*]\n" |
5699 |
|
" --sygus-filter-sol=MODE\n" |
5700 |
|
" mode for filtering sygus solutions\n" |
5701 |
|
" --sygus-grammar-cons=MODE\n" |
5702 |
|
" mode for SyGuS grammar construction\n" |
5703 |
|
" --sygus-grammar-norm statically normalize sygus grammars based on flattening\n" |
5704 |
|
" (linearization) [*]\n" |
5705 |
|
" --sygus-inference attempt to preprocess arbitrary inputs to sygus\n" |
5706 |
|
" conjectures [*]\n" |
5707 |
|
" --sygus-inst Enable SyGuS instantiation quantifiers module [*]\n" |
5708 |
|
" --sygus-inst-mode=MODE select instantiation lemma mode\n" |
5709 |
|
" --sygus-inst-scope=MODE\n" |
5710 |
|
" select scope of ground terms\n" |
5711 |
|
" --sygus-inst-term-sel=MODE\n" |
5712 |
|
" granularity for ground terms\n" |
5713 |
|
" --sygus-inv-templ-when-sg\n" |
5714 |
|
" use invariant templates (with solution reconstruction)\n" |
5715 |
|
" for syntax guided problems [*]\n" |
5716 |
|
" --sygus-inv-templ=MODE template mode for sygus invariant synthesis (weaken\n" |
5717 |
|
" pre-condition, strengthen post-condition, or none)\n" |
5718 |
|
" --sygus-min-grammar statically minimize sygus grammars [*]\n" |
5719 |
|
" --sygus-pbe enable approach which unifies conditional solutions,\n" |
5720 |
|
" specialized for programming-by-examples (pbe)\n" |
5721 |
|
" conjectures [*]\n" |
5722 |
|
" --sygus-pbe-multi-fair when using multiple enumerators, ensure that we only\n" |
5723 |
|
" register value of minimial term size [*]\n" |
5724 |
|
" --sygus-pbe-multi-fair-diff=N\n" |
5725 |
|
" when using multiple enumerators, ensure that we only\n" |
5726 |
|
" register values of minimial term size plus this value\n" |
5727 |
|
" (default 0)\n" |
5728 |
|
" --sygus-qe-preproc use quantifier elimination as a preprocessing step for\n" |
5729 |
|
" sygus [*]\n" |
5730 |
|
" --sygus-query-gen use sygus to enumerate interesting satisfiability\n" |
5731 |
|
" queries [*]\n" |
5732 |
|
" --sygus-query-gen-check\n" |
5733 |
|
" use interesting satisfiability queries to check\n" |
5734 |
|
" soundness of cvc5 [*]\n" |
5735 |
|
" --sygus-query-gen-dump-files=MODE\n" |
5736 |
|
" mode for dumping external files corresponding to\n" |
5737 |
|
" interesting satisfiability queries with sygus-query-gen\n" |
5738 |
|
" --sygus-query-gen-thresh=N\n" |
5739 |
|
" number of points that we allow to be equal for\n" |
5740 |
|
" enumerating satisfiable queries with sygus-query-gen\n" |
5741 |
|
" --sygus-rec-fun enable efficient support for recursive functions in\n" |
5742 |
|
" sygus grammars [*]\n" |
5743 |
|
" --sygus-rec-fun-eval-limit=N\n" |
5744 |
|
" use a hard limit for how many times in a given\n" |
5745 |
|
" evaluator call a recursive function can be evaluated\n" |
5746 |
|
" (so infinite loops can be avoided)\n" |
5747 |
|
" --sygus-repair-const use approach to repair constants in sygus candidate\n" |
5748 |
|
" solutions [*]\n" |
5749 |
|
" --sygus-repair-const-timeout=N\n" |
5750 |
|
" timeout (in milliseconds) for the satisfiability check\n" |
5751 |
|
" to repair constants in sygus candidate solutions\n" |
5752 |
|
" --sygus-rr use sygus to enumerate and verify correctness of\n" |
5753 |
|
" rewrite rules [*]\n" |
5754 |
|
" --sygus-rr-synth use sygus to enumerate candidate rewrite rules [*]\n" |
5755 |
|
" --sygus-rr-synth-accel add dynamic symmetry breaking clauses based on\n" |
5756 |
|
" candidate rewrites [*]\n" |
5757 |
|
" --sygus-rr-synth-check use satisfiability check to verify correctness of\n" |
5758 |
|
" candidate rewrites [*]\n" |
5759 |
|
" --sygus-rr-synth-filter-cong\n" |
5760 |
|
" filter candidate rewrites based on congruence [*]\n" |
5761 |
|
" --sygus-rr-synth-filter-match\n" |
5762 |
|
" filter candidate rewrites based on matching [*]\n" |
5763 |
|
" --sygus-rr-synth-filter-nl\n" |
5764 |
|
" filter non-linear candidate rewrites [*]\n" |
5765 |
|
" --sygus-rr-synth-filter-order\n" |
5766 |
|
" filter candidate rewrites based on variable ordering\n" |
5767 |
|
" [*]\n" |
5768 |
|
" --sygus-rr-synth-input synthesize rewrite rules based on the input formula [*]\n" |
5769 |
|
" --sygus-rr-synth-input-nvars=N\n" |
5770 |
|
" the maximum number of variables per type that appear in\n" |
5771 |
|
" rewrites from sygus-rr-synth-input\n" |
5772 |
|
" --sygus-rr-synth-input-use-bool\n" |
5773 |
|
" synthesize Boolean rewrite rules based on the input\n" |
5774 |
|
" formula [*]\n" |
5775 |
|
" --sygus-rr-synth-rec synthesize rewrite rules over all sygus grammar types\n" |
5776 |
|
" recursively [*]\n" |
5777 |
|
" --sygus-rr-verify use sygus to verify the correctness of rewrite rules\n" |
5778 |
|
" via sampling [*]\n" |
5779 |
|
" --sygus-rr-verify-abort\n" |
5780 |
|
" abort when sygus-rr-verify finds an instance of\n" |
5781 |
|
" unsoundness [*]\n" |
5782 |
|
" --sygus-sample-fp-uniform\n" |
5783 |
|
" sample floating-point values uniformly instead of in a\n" |
5784 |
|
" biased fashion [*]\n" |
5785 |
|
" --sygus-sample-grammar when applicable, use grammar for choosing sample points\n" |
5786 |
|
" [*]\n" |
5787 |
|
" --sygus-samples=N number of points to consider when doing sygus rewriter\n" |
5788 |
|
" sample testing\n" |
5789 |
|
" --sygus-si-abort abort if synthesis conjecture is not single invocation\n" |
5790 |
|
" [*]\n" |
5791 |
|
" --sygus-si-partial combined techniques for synthesis conjectures that are\n" |
5792 |
|
" partially single invocation [*]\n" |
5793 |
|
" --sygus-si-rcons-limit=N\n" |
5794 |
|
" number of rounds of enumeration to use during solution\n" |
5795 |
|
" reconstruction (negative means unlimited)\n" |
5796 |
|
" --sygus-si-rcons=MODE policy for reconstructing solutions for single\n" |
5797 |
|
" invocation conjectures\n" |
5798 |
|
" --sygus-si-reconstruct-const\n" |
5799 |
|
" include constants when reconstruct solutions for single\n" |
5800 |
|
" invocation conjectures in original grammar [*]\n" |
5801 |
|
" --sygus-si=MODE mode for processing single invocation synthesis\n" |
5802 |
|
" conjectures\n" |
5803 |
|
" --sygus-stream enumerate a stream of solutions instead of terminating\n" |
5804 |
|
" after the first one [*]\n" |
5805 |
|
" --sygus-templ-embed-grammar\n" |
5806 |
|
" embed sygus templates into grammars [*]\n" |
5807 |
|
" --sygus-unif-cond-independent-no-repeat-sol\n" |
5808 |
|
" Do not try repeated solutions when using independent\n" |
5809 |
|
" synthesis of conditions in unification-based function\n" |
5810 |
|
" synthesis [*]\n" |
5811 |
|
" --sygus-unif-pi=MODE mode for synthesis via piecewise-indepedent unification\n" |
5812 |
|
" --sygus-unif-shuffle-cond\n" |
5813 |
|
" Shuffle condition pool when building solutions (may\n" |
5814 |
|
" change solutions sizes) [*]\n" |
5815 |
|
" --term-db-cd register terms in term database based on the SAT\n" |
5816 |
|
" context [*]\n" |
5817 |
|
" --term-db-mode=MODE which ground terms to consider for instantiation\n" |
5818 |
|
" --trigger-active-sel=MODE\n" |
5819 |
|
" selection mode to activate triggers\n" |
5820 |
|
" --trigger-sel=MODE selection mode for triggers\n" |
5821 |
|
" --user-pat=MODE policy for handling user-provided patterns for\n" |
5822 |
|
" quantifier instantiation\n" |
5823 |
|
" --var-elim-quant enable simple variable elimination for quantified\n" |
5824 |
|
" formulas [*]\n" |
5825 |
|
" --var-ineq-elim-quant enable variable elimination based on infinite\n" |
5826 |
|
" projection of unbound arithmetic variables [*]\n" |
5827 |
|
"\nFrom the Resource Manager module:\n" |
5828 |
|
" --rweight=VAL=N set a single resource weight (EXPERTS only)\n" |
5829 |
|
"\nFrom the Separation Logic Theory module:\n" |
5830 |
|
" --sep-check-neg check negated spatial assertions [*]\n" |
5831 |
|
" --sep-child-refine child-specific refinements of negated star, positive\n" |
5832 |
|
" wand [*]\n" |
5833 |
|
" --sep-deq-c assume cardinality elements are distinct [*]\n" |
5834 |
|
" --sep-exp experimental flag for sep [*]\n" |
5835 |
|
" --sep-min-refine only add refinement lemmas for minimal (innermost)\n" |
5836 |
|
" assertions [*]\n" |
5837 |
|
" --sep-pre-skolem-emp eliminate emp constraint at preprocess time [*]\n" |
5838 |
|
"\nFrom the Sets Theory module:\n" |
5839 |
|
" --sets-ext enable extended symbols such as complement and universe\n" |
5840 |
|
" in theory of sets [*]\n" |
5841 |
|
" --sets-infer-as-lemmas send inferences as lemmas [*]\n" |
5842 |
|
" --sets-proxy-lemmas introduce proxy variables eagerly to shorten lemmas [*]\n" |
5843 |
|
"\nFrom the SMT Layer module:\n" |
5844 |
|
" --abstract-values in models, output arrays (and in future, maybe others)\n" |
5845 |
|
" using abstract values, as required by the SMT-LIB\n" |
5846 |
|
" standard [*]\n" |
5847 |
|
" --ackermann eliminate functions by ackermannization [*]\n" |
5848 |
|
" --block-models=MODE mode for producing several models\n" |
5849 |
|
" --check-abducts checks whether produced solutions to get-abduct are\n" |
5850 |
|
" correct [*]\n" |
5851 |
|
" --check-interpols checks whether produced solutions to get-interpol are\n" |
5852 |
|
" correct [*]\n" |
5853 |
|
" --check-models after SAT/INVALID/UNKNOWN, check that the generated\n" |
5854 |
|
" model satisfies user assertions [*]\n" |
5855 |
|
" --check-proofs after UNSAT/VALID, check the generated proof (with\n" |
5856 |
|
" proof) [*]\n" |
5857 |
|
" --check-synth-sol checks whether produced solutions to\n" |
5858 |
|
" functions-to-synthesize satisfy the conjecture [*]\n" |
5859 |
|
" --check-unsat-cores after UNSAT/VALID, produce and check an unsat core\n" |
5860 |
|
" (expensive) [*]\n" |
5861 |
|
" --debug-check-models after SAT/INVALID/UNKNOWN, check that the generated\n" |
5862 |
|
" model satisfies user and internal assertions [*]\n" |
5863 |
|
" --diagnostic-output-channel=CHANNEL\n" |
5864 |
|
" set the diagnostic output channel of the solver\n" |
5865 |
|
" --dump-instantiations output instantiations of quantified formulas after\n" |
5866 |
|
" every UNSAT/VALID response [*]\n" |
5867 |
|
" --dump-models output models after every SAT/INVALID/UNKNOWN response\n" |
5868 |
|
" [*]\n" |
5869 |
|
" --dump-proofs output proofs after every UNSAT/VALID response [*]\n" |
5870 |
|
" --dump-unsat-cores output unsat cores after every UNSAT/VALID response [*]\n" |
5871 |
|
" --dump-unsat-cores-full\n" |
5872 |
|
" dump the full unsat core, including unlabeled\n" |
5873 |
|
" assertions [*]\n" |
5874 |
|
" --early-ite-removal remove ITEs early in preprocessing [*]\n" |
5875 |
|
" --expand-definitions always expand symbol definitions in output [*]\n" |
5876 |
|
" --ext-rew-prep use extended rewriter as a preprocessing pass [*]\n" |
5877 |
|
" --ext-rew-prep-agg use aggressive extended rewriter as a preprocessing\n" |
5878 |
|
" pass [*]\n" |
5879 |
|
" --force-no-limit-cpu-while-dump\n" |
5880 |
|
" Force no CPU limit when dumping models and proofs [*]\n" |
5881 |
|
" --foreign-theory-rewrite\n" |
5882 |
|
" Cross-theory rewrites [*]\n" |
5883 |
|
" --ite-simp turn on ite simplification (Kim (and Somenzi) et al.,\n" |
5884 |
|
" SAT 2009) [*]\n" |
5885 |
|
" --model-cores=MODE mode for producing model cores\n" |
5886 |
|
" --model-u-print=MODE | --model-uninterp-print=MODE\n" |
5887 |
|
" determines how to print uninterpreted elements in\n" |
5888 |
|
" models\n" |
5889 |
|
" --model-witness-value in models, use a witness constant for choice functions\n" |
5890 |
|
" [*]\n" |
5891 |
|
" --on-repeat-ite-simp do the ite simplification pass again if repeating\n" |
5892 |
|
" simplification [*]\n" |
5893 |
|
" --produce-assignments support the get-assignment command [*]\n" |
5894 |
|
" --produce-proofs produce proofs, support check-proofs and get-proof [*]\n" |
5895 |
|
" --produce-unsat-assumptions\n" |
5896 |
|
" turn on unsat assumptions generation [*]\n" |
5897 |
|
" --produce-unsat-cores turn on unsat core generation. Unless otherwise\n" |
5898 |
|
" specified, cores will be produced using SAT soving\n" |
5899 |
|
" under assumptions and preprocessing proofs. [*]\n" |
5900 |
|
" --regular-output-channel=CHANNEL\n" |
5901 |
|
" set the regular output channel of the solver\n" |
5902 |
|
" --repeat-simp make multiple passes with nonclausal simplifier [*]\n" |
5903 |
|
" --simp-ite-compress enables compressing ites after ite simplification [*]\n" |
5904 |
|
" --simp-ite-hunt-zombies=N\n" |
5905 |
|
" post ite compression enables zombie removal while the\n" |
5906 |
|
" number of nodes is above this threshold\n" |
5907 |
|
" --simp-with-care enables simplifyWithCare in ite simplificiation [*]\n" |
5908 |
|
" --simplification=MODE | --simplification-mode=MODE\n" |
5909 |
|
" choose simplification mode, see --simplification=help\n" |
5910 |
|
" --sort-inference calculate sort inference of input problem, convert the\n" |
5911 |
|
" input based on monotonic sorts [*]\n" |
5912 |
|
" --static-learning use static learning (on by default) [*]\n" |
5913 |
|
" --sygus-out=MODE output mode for sygus\n" |
5914 |
|
" --sygus-print-callbacks\n" |
5915 |
|
" use sygus print callbacks to print sygus terms in the\n" |
5916 |
|
" user-provided form (disable for debugging) [*]\n" |
5917 |
|
" --unconstrained-simp turn on unconstrained simplification (see\n" |
5918 |
|
" Bruttomesso/Brummayer PhD thesis). Fully supported only\n" |
5919 |
|
" in (subsets of) the logic QF_ABV. [*]\n" |
5920 |
|
" --unsat-cores-mode=MODE\n" |
5921 |
|
" choose unsat core mode, see --unsat-cores-mode=help\n" |
5922 |
|
"\nFrom the Strings Theory module:\n" |
5923 |
|
" --re-elim elimination techniques for regular expressions [*]\n" |
5924 |
|
" --re-elim-agg aggressive elimination techniques for regular\n" |
5925 |
|
" expressions [*]\n" |
5926 |
|
" --re-inter-mode=MODE determines which regular expressions intersections to\n" |
5927 |
|
" compute (EXPERTS only)\n" |
5928 |
|
" --strings-check-entail-len\n" |
5929 |
|
" check entailment between length terms to reduce\n" |
5930 |
|
" splitting [*]\n" |
5931 |
|
" --strings-eager strings eager check [*]\n" |
5932 |
|
" --strings-eager-eval perform eager context-dependent evaluation for\n" |
5933 |
|
" applications of string kinds [*]\n" |
5934 |
|
" --strings-eager-len strings eager length lemmas [*]\n" |
5935 |
|
" --strings-exp experimental features in the theory of strings [*]\n" |
5936 |
|
" --strings-ff do flat form inferences [*]\n" |
5937 |
|
" --strings-fmf the finite model finding used by the theory of strings\n" |
5938 |
|
" [*]\n" |
5939 |
|
" --strings-guess-model use model guessing to avoid string extended function\n" |
5940 |
|
" reductions [*]\n" |
5941 |
|
" --strings-infer-as-lemmas\n" |
5942 |
|
" always send lemmas out instead of making internal\n" |
5943 |
|
" inferences [*]\n" |
5944 |
|
" --strings-infer-sym strings split on empty string [*]\n" |
5945 |
|
" --strings-inm internal for strings: ignore negative membership\n" |
5946 |
|
" constraints (fragment checking is needed, left to users\n" |
5947 |
|
" for now) [*]\n" |
5948 |
|
" --strings-lazy-pp perform string preprocessing lazily [*]\n" |
5949 |
|
" --strings-len-norm strings length normalization lemma [*]\n" |
5950 |
|
" --strings-lprop-csp do length propagation based on constant splits [*]\n" |
5951 |
|
" --strings-min-prefix-explain\n" |
5952 |
|
" minimize explanations for prefix of normal forms in\n" |
5953 |
|
" strings [*]\n" |
5954 |
|
" --strings-process-loop-mode=MODE\n" |
5955 |
|
" determines how to process looping string equations\n" |
5956 |
|
" (EXPERTS only)\n" |
5957 |
|
" --strings-rexplain-lemmas\n" |
5958 |
|
" regression explanations for string lemmas [*]\n" |
5959 |
|
" --strings-unified-vspt use a single skolem for the variable splitting rule [*]\n" |
5960 |
|
"\nFrom the Theory Layer module:\n" |
5961 |
|
" --assign-function-values\n" |
5962 |
|
" assign values for uninterpreted functions in models [*]\n" |
5963 |
|
" --condense-function-values\n" |
5964 |
|
" condense values for functions in models rather than\n" |
5965 |
|
" explicitly representing them [*]\n" |
5966 |
|
" --ee-mode=MODE mode for managing equalities across theory solvers\n" |
5967 |
|
" (EXPERTS only)\n" |
5968 |
|
" --relevance-filter enable analysis of relevance of asserted literals with\n" |
5969 |
|
" respect to the input formula [*]\n" |
5970 |
|
" --tc-mode=MODE mode for theory combination (EXPERTS only)\n" |
5971 |
|
" --theoryof-mode=MODE mode for Theory::theoryof() (EXPERTS only)\n" |
5972 |
|
"\nFrom the Uninterpreted Functions Theory module:\n" |
5973 |
|
" --symmetry-breaker | --uf-symmetry-breaker\n" |
5974 |
|
" use UF symmetry breaker (Deharbe et al., CADE 2011) [*]\n" |
5975 |
|
" --uf-ho enable support for higher-order reasoning [*]\n" |
5976 |
|
" --uf-ho-ext apply extensionality on function symbols [*]\n" |
5977 |
|
" --uf-ss-abort-card=N tells the uf with cardinality to only consider models\n" |
5978 |
|
" that interpret uninterpreted sorts of cardinality at\n" |
5979 |
|
" most N (-1 == no limit, default)\n" |
5980 |
|
" --uf-ss-fair use fair strategy for finite model finding multiple\n" |
5981 |
|
" sorts [*]\n" |
5982 |
|
" --uf-ss-fair-monotone group monotone sorts when enforcing fairness for finite\n" |
5983 |
|
" model finding [*]\n" |
5984 |
|
" --uf-ss-totality-limited=N\n" |
5985 |
|
" apply totality axioms, but only up to cardinality N (-1\n" |
5986 |
|
" == do not apply totality axioms, default)\n" |
5987 |
|
" --uf-ss-totality-sym-break\n" |
5988 |
|
" apply symmetry breaking for totality axioms [*]\n" |
5989 |
|
" --uf-ss=MODE mode of operation for uf with cardinality solver.\n"; |
5990 |
|
// clang-format on |
5991 |
|
|
5992 |
9398 |
static const std::string optionsFootnote = "\n\ |
5993 |
|
[*] Each of these options has a --no-OPTIONNAME variant, which reverses the\n\ |
5994 |
|
sense of the option.\n\ |
5995 |
|
"; |
5996 |
|
|
5997 |
9398 |
static const std::string languageDescription = |
5998 |
|
"\ |
5999 |
|
Languages currently supported as arguments to the -L / --lang option:\n\ |
6000 |
|
auto attempt to automatically determine language\n\ |
6001 |
|
cvc | presentation | pl CVC presentation language\n\ |
6002 |
|
smt | smtlib | smt2 |\n\ |
6003 |
|
smt2.6 | smtlib2.6 SMT-LIB format 2.6 with support for the strings standard\n\ |
6004 |
|
tptp TPTP format (cnf, fof and tff)\n\ |
6005 |
|
sygus | sygus2 SyGuS version 2.0\n\ |
6006 |
|
\n\ |
6007 |
|
Languages currently supported as arguments to the --output-lang option:\n\ |
6008 |
|
auto match output language to input language\n\ |
6009 |
|
cvc | presentation | pl CVC presentation language\n\ |
6010 |
|
smt | smtlib | smt2 |\n\ |
6011 |
|
smt2.6 | smtlib2.6 SMT-LIB format 2.6 with support for the strings standard\n\ |
6012 |
|
tptp TPTP format\n\ |
6013 |
|
ast internal format (simple syntax trees)\n\ |
6014 |
|
"; |
6015 |
|
|
6016 |
|
std::string Options::getDescription() const { |
6017 |
|
return optionsDescription; |
6018 |
|
} |
6019 |
|
|
6020 |
|
void Options::printUsage(const std::string msg, std::ostream& out) { |
6021 |
|
out << msg << optionsDescription << std::endl |
6022 |
|
<< optionsFootnote << std::endl << std::flush; |
6023 |
|
} |
6024 |
|
|
6025 |
|
void Options::printShortUsage(const std::string msg, std::ostream& out) { |
6026 |
|
out << msg << mostCommonOptionsDescription << std::endl |
6027 |
|
<< optionsFootnote << std::endl |
6028 |
|
<< "For full usage, please use --help." |
6029 |
|
<< std::endl << std::endl << std::flush; |
6030 |
|
} |
6031 |
|
|
6032 |
|
void Options::printLanguageHelp(std::ostream& out) { |
6033 |
|
out << languageDescription << std::flush; |
6034 |
|
} |
6035 |
|
|
6036 |
|
/** |
6037 |
|
* This is a table of long options. By policy, each short option |
6038 |
|
* should have an equivalent long option (but the reverse isn't the |
6039 |
|
* case), so this table should thus contain all command-line options. |
6040 |
|
* |
6041 |
|
* Each option in this array has four elements: |
6042 |
|
* |
6043 |
|
* 1. the long option string |
6044 |
|
* 2. argument behavior for the option: |
6045 |
|
* no_argument - no argument permitted |
6046 |
|
* required_argument - an argument is expected |
6047 |
|
* optional_argument - an argument is permitted but not required |
6048 |
|
* 3. this is a pointer to an int which is set to the 4th entry of the |
6049 |
|
* array if the option is present; or NULL, in which case |
6050 |
|
* getopt_long() returns the 4th entry |
6051 |
|
* 4. the return value for getopt_long() when this long option (or the |
6052 |
|
* value to set the 3rd entry to; see #3) |
6053 |
|
* |
6054 |
|
* If you add something here, you should add it in src/main/usage.h |
6055 |
|
* also, to document it. |
6056 |
|
* |
6057 |
|
* If you add something that has a short option equivalent, you should |
6058 |
|
* add it to the getopt_long() call in parseOptions(). |
6059 |
|
*/ |
6060 |
|
// clang-format off |
6061 |
|
static struct option cmdlineOptions[] = { |
6062 |
|
{ "approx-branch-depth", required_argument, nullptr, 256 }, |
6063 |
|
{ "arith-brab", no_argument, nullptr, 257 }, |
6064 |
|
{ "no-arith-brab", no_argument, nullptr, 258 }, |
6065 |
|
{ "arith-no-partial-fun", no_argument, nullptr, 259 }, |
6066 |
|
{ "no-arith-no-partial-fun", no_argument, nullptr, 260 }, |
6067 |
|
{ "arith-prop-clauses", required_argument, nullptr, 261 }, |
6068 |
|
{ "arith-prop", required_argument, nullptr, 262 }, |
6069 |
|
{ "arith-rewrite-equalities", no_argument, nullptr, 263 }, |
6070 |
|
{ "no-arith-rewrite-equalities", no_argument, nullptr, 264 }, |
6071 |
|
{ "collect-pivot-stats", no_argument, nullptr, 265 }, |
6072 |
|
{ "no-collect-pivot-stats", no_argument, nullptr, 266 }, |
6073 |
|
{ "cut-all-bounded", no_argument, nullptr, 267 }, |
6074 |
|
{ "no-cut-all-bounded", no_argument, nullptr, 268 }, |
6075 |
|
{ "dio-decomps", no_argument, nullptr, 269 }, |
6076 |
|
{ "no-dio-decomps", no_argument, nullptr, 270 }, |
6077 |
|
{ "dio-repeat", no_argument, nullptr, 271 }, |
6078 |
|
{ "no-dio-repeat", no_argument, nullptr, 272 }, |
6079 |
|
{ "dio-solver", no_argument, nullptr, 273 }, |
6080 |
|
{ "no-dio-solver", no_argument, nullptr, 274 }, |
6081 |
|
{ "dio-turns", required_argument, nullptr, 275 }, |
6082 |
|
{ "error-selection-rule", required_argument, nullptr, 276 }, |
6083 |
|
{ "fc-penalties", no_argument, nullptr, 277 }, |
6084 |
|
{ "no-fc-penalties", no_argument, nullptr, 278 }, |
6085 |
|
{ "heuristic-pivots", required_argument, nullptr, 279 }, |
6086 |
|
{ "lemmas-on-replay-failure", no_argument, nullptr, 280 }, |
6087 |
|
{ "no-lemmas-on-replay-failure", no_argument, nullptr, 281 }, |
6088 |
|
{ "maxCutsInContext", required_argument, nullptr, 282 }, |
6089 |
|
{ "miplib-trick", no_argument, nullptr, 283 }, |
6090 |
|
{ "no-miplib-trick", no_argument, nullptr, 284 }, |
6091 |
|
{ "miplib-trick-subs", required_argument, nullptr, 285 }, |
6092 |
|
{ "new-prop", no_argument, nullptr, 286 }, |
6093 |
|
{ "no-new-prop", no_argument, nullptr, 287 }, |
6094 |
|
{ "nl-cad", no_argument, nullptr, 288 }, |
6095 |
|
{ "no-nl-cad", no_argument, nullptr, 289 }, |
6096 |
|
{ "nl-cad-initial", no_argument, nullptr, 290 }, |
6097 |
|
{ "no-nl-cad-initial", no_argument, nullptr, 291 }, |
6098 |
|
{ "nl-ext-ent-conf", no_argument, nullptr, 292 }, |
6099 |
|
{ "no-nl-ext-ent-conf", no_argument, nullptr, 293 }, |
6100 |
|
{ "nl-ext-factor", no_argument, nullptr, 294 }, |
6101 |
|
{ "no-nl-ext-factor", no_argument, nullptr, 295 }, |
6102 |
|
{ "nl-ext-inc-prec", no_argument, nullptr, 296 }, |
6103 |
|
{ "no-nl-ext-inc-prec", no_argument, nullptr, 297 }, |
6104 |
|
{ "nl-ext-purify", no_argument, nullptr, 298 }, |
6105 |
|
{ "no-nl-ext-purify", no_argument, nullptr, 299 }, |
6106 |
|
{ "nl-ext-rbound", no_argument, nullptr, 300 }, |
6107 |
|
{ "no-nl-ext-rbound", no_argument, nullptr, 301 }, |
6108 |
|
{ "nl-ext-rewrite", no_argument, nullptr, 302 }, |
6109 |
|
{ "no-nl-ext-rewrite", no_argument, nullptr, 303 }, |
6110 |
|
{ "nl-ext-split-zero", no_argument, nullptr, 304 }, |
6111 |
|
{ "no-nl-ext-split-zero", no_argument, nullptr, 305 }, |
6112 |
|
{ "nl-ext-tf-taylor-deg", required_argument, nullptr, 306 }, |
6113 |
|
{ "nl-ext-tf-tplanes", no_argument, nullptr, 307 }, |
6114 |
|
{ "no-nl-ext-tf-tplanes", no_argument, nullptr, 308 }, |
6115 |
|
{ "nl-ext-tplanes", no_argument, nullptr, 309 }, |
6116 |
|
{ "no-nl-ext-tplanes", no_argument, nullptr, 310 }, |
6117 |
|
{ "nl-ext-tplanes-interleave", no_argument, nullptr, 311 }, |
6118 |
|
{ "no-nl-ext-tplanes-interleave", no_argument, nullptr, 312 }, |
6119 |
|
{ "nl-ext", required_argument, nullptr, 313 }, |
6120 |
|
{ "nl-icp", no_argument, nullptr, 314 }, |
6121 |
|
{ "no-nl-icp", no_argument, nullptr, 315 }, |
6122 |
|
{ "nl-rlv", required_argument, nullptr, 316 }, |
6123 |
|
{ "pb-rewrites", no_argument, nullptr, 317 }, |
6124 |
|
{ "no-pb-rewrites", no_argument, nullptr, 318 }, |
6125 |
|
{ "pivot-threshold", required_argument, nullptr, 319 }, |
6126 |
|
{ "pp-assert-max-sub-size", required_argument, nullptr, 320 }, |
6127 |
|
{ "prop-row-length", required_argument, nullptr, 321 }, |
6128 |
|
{ "replay-early-close-depth", required_argument, nullptr, 322 }, |
6129 |
|
{ "replay-failure-penalty", required_argument, nullptr, 323 }, |
6130 |
|
{ "replay-lemma-reject-cut", required_argument, nullptr, 324 }, |
6131 |
|
{ "replay-num-err-penalty", required_argument, nullptr, 325 }, |
6132 |
|
{ "replay-reject-cut", required_argument, nullptr, 326 }, |
6133 |
|
{ "replay-soi-major-threshold-pen", required_argument, nullptr, 327 }, |
6134 |
|
{ "replay-soi-major-threshold", required_argument, nullptr, 328 }, |
6135 |
|
{ "replay-soi-minor-threshold-pen", required_argument, nullptr, 329 }, |
6136 |
|
{ "replay-soi-minor-threshold", required_argument, nullptr, 330 }, |
6137 |
|
{ "restrict-pivots", no_argument, nullptr, 331 }, |
6138 |
|
{ "no-restrict-pivots", no_argument, nullptr, 332 }, |
6139 |
|
{ "revert-arith-models-on-unsat", no_argument, nullptr, 333 }, |
6140 |
|
{ "no-revert-arith-models-on-unsat", no_argument, nullptr, 334 }, |
6141 |
|
{ "rr-turns", required_argument, nullptr, 335 }, |
6142 |
|
{ "se-solve-int", no_argument, nullptr, 336 }, |
6143 |
|
{ "no-se-solve-int", no_argument, nullptr, 337 }, |
6144 |
|
{ "simplex-check-period", required_argument, nullptr, 338 }, |
6145 |
|
{ "soi-qe", no_argument, nullptr, 339 }, |
6146 |
|
{ "no-soi-qe", no_argument, nullptr, 340 }, |
6147 |
|
{ "standard-effort-variable-order-pivots", required_argument, nullptr, 341 }, |
6148 |
|
{ "unate-lemmas", required_argument, nullptr, 342 }, |
6149 |
|
{ "use-approx", no_argument, nullptr, 343 }, |
6150 |
|
{ "no-use-approx", no_argument, nullptr, 344 }, |
6151 |
|
{ "use-fcsimplex", no_argument, nullptr, 345 }, |
6152 |
|
{ "no-use-fcsimplex", no_argument, nullptr, 346 }, |
6153 |
|
{ "use-soi", no_argument, nullptr, 347 }, |
6154 |
|
{ "no-use-soi", no_argument, nullptr, 348 }, |
6155 |
|
{ "arrays-config", required_argument, nullptr, 349 }, |
6156 |
|
{ "arrays-eager-index", no_argument, nullptr, 350 }, |
6157 |
|
{ "no-arrays-eager-index", no_argument, nullptr, 351 }, |
6158 |
|
{ "arrays-eager-lemmas", no_argument, nullptr, 352 }, |
6159 |
|
{ "no-arrays-eager-lemmas", no_argument, nullptr, 353 }, |
6160 |
|
{ "arrays-exp", no_argument, nullptr, 354 }, |
6161 |
|
{ "no-arrays-exp", no_argument, nullptr, 355 }, |
6162 |
|
{ "arrays-model-based", no_argument, nullptr, 356 }, |
6163 |
|
{ "no-arrays-model-based", no_argument, nullptr, 357 }, |
6164 |
|
{ "arrays-optimize-linear", no_argument, nullptr, 358 }, |
6165 |
|
{ "no-arrays-optimize-linear", no_argument, nullptr, 359 }, |
6166 |
|
{ "arrays-prop", required_argument, nullptr, 360 }, |
6167 |
|
{ "arrays-reduce-sharing", no_argument, nullptr, 361 }, |
6168 |
|
{ "no-arrays-reduce-sharing", no_argument, nullptr, 362 }, |
6169 |
|
{ "arrays-weak-equiv", no_argument, nullptr, 363 }, |
6170 |
|
{ "no-arrays-weak-equiv", no_argument, nullptr, 364 }, |
6171 |
|
{ "debug", required_argument, nullptr, 365 }, |
6172 |
|
{ "lang", required_argument, nullptr, 366 }, |
6173 |
|
{ "input-language", required_argument, nullptr, 367 }, |
6174 |
|
{ "output-lang", required_argument, nullptr, 368 }, |
6175 |
|
{ "output-language", required_argument, nullptr, 369 }, |
6176 |
|
{ "parse-only", no_argument, nullptr, 370 }, |
6177 |
|
{ "no-parse-only", no_argument, nullptr, 371 }, |
6178 |
|
{ "preprocess-only", no_argument, nullptr, 372 }, |
6179 |
|
{ "no-preprocess-only", no_argument, nullptr, 373 }, |
6180 |
|
{ "print-success", no_argument, nullptr, 374 }, |
6181 |
|
{ "no-print-success", no_argument, nullptr, 375 }, |
6182 |
|
{ "quiet", no_argument, nullptr, 376 }, |
6183 |
|
{ "stats", no_argument, nullptr, 377 }, |
6184 |
|
{ "no-stats", no_argument, nullptr, 378 }, |
6185 |
|
{ "stats-all", no_argument, nullptr, 379 }, |
6186 |
|
{ "no-stats-all", no_argument, nullptr, 380 }, |
6187 |
|
{ "stats-every-query", no_argument, nullptr, 381 }, |
6188 |
|
{ "no-stats-every-query", no_argument, nullptr, 382 }, |
6189 |
|
{ "stats-expert", no_argument, nullptr, 383 }, |
6190 |
|
{ "no-stats-expert", no_argument, nullptr, 384 }, |
6191 |
|
{ "trace", required_argument, nullptr, 385 }, |
6192 |
|
{ "verbose", no_argument, nullptr, 386 }, |
6193 |
|
{ "verbosity", required_argument, nullptr, 387 }, |
6194 |
|
{ "bitblast-aig", no_argument, nullptr, 388 }, |
6195 |
|
{ "no-bitblast-aig", no_argument, nullptr, 389 }, |
6196 |
|
{ "bitblast", required_argument, nullptr, 390 }, |
6197 |
|
{ "bitwise-eq", no_argument, nullptr, 391 }, |
6198 |
|
{ "no-bitwise-eq", no_argument, nullptr, 392 }, |
6199 |
|
{ "bool-to-bv", required_argument, nullptr, 393 }, |
6200 |
|
{ "bv-abstraction", no_argument, nullptr, 394 }, |
6201 |
|
{ "no-bv-abstraction", no_argument, nullptr, 395 }, |
6202 |
|
{ "bv-aig-simp", required_argument, nullptr, 396 }, |
6203 |
|
{ "bv-alg-extf", no_argument, nullptr, 397 }, |
6204 |
|
{ "no-bv-alg-extf", no_argument, nullptr, 398 }, |
6205 |
|
{ "bv-algebraic-budget", required_argument, nullptr, 399 }, |
6206 |
|
{ "bv-algebraic-solver", no_argument, nullptr, 400 }, |
6207 |
|
{ "no-bv-algebraic-solver", no_argument, nullptr, 401 }, |
6208 |
|
{ "bv-assert-input", no_argument, nullptr, 402 }, |
6209 |
|
{ "no-bv-assert-input", no_argument, nullptr, 403 }, |
6210 |
|
{ "bv-eager-explanations", no_argument, nullptr, 404 }, |
6211 |
|
{ "no-bv-eager-explanations", no_argument, nullptr, 405 }, |
6212 |
|
{ "bv-eq-solver", no_argument, nullptr, 406 }, |
6213 |
|
{ "no-bv-eq-solver", no_argument, nullptr, 407 }, |
6214 |
|
{ "bv-extract-arith", no_argument, nullptr, 408 }, |
6215 |
|
{ "no-bv-extract-arith", no_argument, nullptr, 409 }, |
6216 |
|
{ "bv-gauss-elim", no_argument, nullptr, 410 }, |
6217 |
|
{ "no-bv-gauss-elim", no_argument, nullptr, 411 }, |
6218 |
|
{ "bv-inequality-solver", no_argument, nullptr, 412 }, |
6219 |
|
{ "no-bv-inequality-solver", no_argument, nullptr, 413 }, |
6220 |
|
{ "bv-intro-pow2", no_argument, nullptr, 414 }, |
6221 |
|
{ "no-bv-intro-pow2", no_argument, nullptr, 415 }, |
6222 |
|
{ "bv-lazy-reduce-extf", no_argument, nullptr, 416 }, |
6223 |
|
{ "no-bv-lazy-reduce-extf", no_argument, nullptr, 417 }, |
6224 |
|
{ "bv-lazy-rewrite-extf", no_argument, nullptr, 418 }, |
6225 |
|
{ "no-bv-lazy-rewrite-extf", no_argument, nullptr, 419 }, |
6226 |
|
{ "bv-num-func", required_argument, nullptr, 420 }, |
6227 |
|
{ "bv-print-consts-as-indexed-symbols", no_argument, nullptr, 421 }, |
6228 |
|
{ "no-bv-print-consts-as-indexed-symbols", no_argument, nullptr, 422 }, |
6229 |
|
{ "bv-propagate", no_argument, nullptr, 423 }, |
6230 |
|
{ "no-bv-propagate", no_argument, nullptr, 424 }, |
6231 |
|
{ "bv-quick-xplain", no_argument, nullptr, 425 }, |
6232 |
|
{ "no-bv-quick-xplain", no_argument, nullptr, 426 }, |
6233 |
|
{ "bv-sat-solver", required_argument, nullptr, 427 }, |
6234 |
|
{ "bv-skolemize", no_argument, nullptr, 428 }, |
6235 |
|
{ "no-bv-skolemize", no_argument, nullptr, 429 }, |
6236 |
|
{ "bv-solver", required_argument, nullptr, 430 }, |
6237 |
|
{ "bv-to-bool", no_argument, nullptr, 431 }, |
6238 |
|
{ "no-bv-to-bool", no_argument, nullptr, 432 }, |
6239 |
|
{ "cdt-bisimilar", no_argument, nullptr, 433 }, |
6240 |
|
{ "no-cdt-bisimilar", no_argument, nullptr, 434 }, |
6241 |
|
{ "dt-binary-split", no_argument, nullptr, 435 }, |
6242 |
|
{ "no-dt-binary-split", no_argument, nullptr, 436 }, |
6243 |
|
{ "dt-blast-splits", no_argument, nullptr, 437 }, |
6244 |
|
{ "no-dt-blast-splits", no_argument, nullptr, 438 }, |
6245 |
|
{ "dt-cyclic", no_argument, nullptr, 439 }, |
6246 |
|
{ "no-dt-cyclic", no_argument, nullptr, 440 }, |
6247 |
|
{ "dt-force-assignment", no_argument, nullptr, 441 }, |
6248 |
|
{ "no-dt-force-assignment", no_argument, nullptr, 442 }, |
6249 |
|
{ "dt-infer-as-lemmas", no_argument, nullptr, 443 }, |
6250 |
|
{ "no-dt-infer-as-lemmas", no_argument, nullptr, 444 }, |
6251 |
|
{ "dt-nested-rec", no_argument, nullptr, 445 }, |
6252 |
|
{ "no-dt-nested-rec", no_argument, nullptr, 446 }, |
6253 |
|
{ "dt-polite-optimize", no_argument, nullptr, 447 }, |
6254 |
|
{ "no-dt-polite-optimize", no_argument, nullptr, 448 }, |
6255 |
|
{ "dt-rewrite-error-sel", no_argument, nullptr, 449 }, |
6256 |
|
{ "no-dt-rewrite-error-sel", no_argument, nullptr, 450 }, |
6257 |
|
{ "dt-share-sel", no_argument, nullptr, 451 }, |
6258 |
|
{ "no-dt-share-sel", no_argument, nullptr, 452 }, |
6259 |
|
{ "sygus-abort-size", required_argument, nullptr, 453 }, |
6260 |
|
{ "sygus-fair-max", no_argument, nullptr, 454 }, |
6261 |
|
{ "no-sygus-fair-max", no_argument, nullptr, 455 }, |
6262 |
|
{ "sygus-fair", required_argument, nullptr, 456 }, |
6263 |
|
{ "sygus-sym-break", no_argument, nullptr, 457 }, |
6264 |
|
{ "no-sygus-sym-break", no_argument, nullptr, 458 }, |
6265 |
|
{ "sygus-sym-break-agg", no_argument, nullptr, 459 }, |
6266 |
|
{ "no-sygus-sym-break-agg", no_argument, nullptr, 460 }, |
6267 |
|
{ "sygus-sym-break-dynamic", no_argument, nullptr, 461 }, |
6268 |
|
{ "no-sygus-sym-break-dynamic", no_argument, nullptr, 462 }, |
6269 |
|
{ "sygus-sym-break-lazy", no_argument, nullptr, 463 }, |
6270 |
|
{ "no-sygus-sym-break-lazy", no_argument, nullptr, 464 }, |
6271 |
|
{ "sygus-sym-break-pbe", no_argument, nullptr, 465 }, |
6272 |
|
{ "no-sygus-sym-break-pbe", no_argument, nullptr, 466 }, |
6273 |
|
{ "sygus-sym-break-rlv", no_argument, nullptr, 467 }, |
6274 |
|
{ "no-sygus-sym-break-rlv", no_argument, nullptr, 468 }, |
6275 |
|
{ "decision-random-weight", required_argument, nullptr, 469 }, |
6276 |
|
{ "decision-threshold", required_argument, nullptr, 470 }, |
6277 |
|
{ "decision-use-weight", no_argument, nullptr, 471 }, |
6278 |
|
{ "no-decision-use-weight", no_argument, nullptr, 472 }, |
6279 |
|
{ "decision-weight-internal", required_argument, nullptr, 473 }, |
6280 |
|
{ "decision", required_argument, nullptr, 474 }, |
6281 |
|
{ "decision-mode", required_argument, nullptr, 475 }, |
6282 |
|
{ "dag-thresh", required_argument, nullptr, 476 }, |
6283 |
|
{ "expr-depth", required_argument, nullptr, 477 }, |
6284 |
|
{ "type-checking", no_argument, nullptr, 478 }, |
6285 |
|
{ "no-type-checking", no_argument, nullptr, 479 }, |
6286 |
|
{ "fp-exp", no_argument, nullptr, 480 }, |
6287 |
|
{ "no-fp-exp", no_argument, nullptr, 481 }, |
6288 |
|
{ "copyright", no_argument, nullptr, 482 }, |
6289 |
|
{ "early-exit", no_argument, nullptr, 483 }, |
6290 |
|
{ "no-early-exit", no_argument, nullptr, 484 }, |
6291 |
|
{ "help", no_argument, nullptr, 485 }, |
6292 |
|
{ "interactive", no_argument, nullptr, 486 }, |
6293 |
|
{ "no-interactive", no_argument, nullptr, 487 }, |
6294 |
|
{ "interactive-prompt", no_argument, nullptr, 488 }, |
6295 |
|
{ "no-interactive-prompt", no_argument, nullptr, 489 }, |
6296 |
|
{ "seed", required_argument, nullptr, 490 }, |
6297 |
|
{ "segv-spin", no_argument, nullptr, 491 }, |
6298 |
|
{ "no-segv-spin", no_argument, nullptr, 492 }, |
6299 |
|
{ "show-config", no_argument, nullptr, 493 }, |
6300 |
|
{ "show-debug-tags", no_argument, nullptr, 494 }, |
6301 |
|
{ "show-trace-tags", no_argument, nullptr, 495 }, |
6302 |
|
{ "tear-down-incremental", required_argument, nullptr, 496 }, |
6303 |
|
{ "version", no_argument, nullptr, 497 }, |
6304 |
|
{ "filesystem-access", no_argument, nullptr, 498 }, |
6305 |
|
{ "no-filesystem-access", no_argument, nullptr, 499 }, |
6306 |
|
{ "force-logic", required_argument, nullptr, 500 }, |
6307 |
|
{ "global-declarations", no_argument, nullptr, 501 }, |
6308 |
|
{ "no-global-declarations", no_argument, nullptr, 502 }, |
6309 |
|
{ "mmap", no_argument, nullptr, 503 }, |
6310 |
|
{ "no-mmap", no_argument, nullptr, 504 }, |
6311 |
|
{ "semantic-checks", no_argument, nullptr, 505 }, |
6312 |
|
{ "no-semantic-checks", no_argument, nullptr, 506 }, |
6313 |
|
{ "strict-parsing", no_argument, nullptr, 507 }, |
6314 |
|
{ "no-strict-parsing", no_argument, nullptr, 508 }, |
6315 |
|
{ "flatten-ho-chains", no_argument, nullptr, 509 }, |
6316 |
|
{ "no-flatten-ho-chains", no_argument, nullptr, 510 }, |
6317 |
|
{ "inst-format", required_argument, nullptr, 511 }, |
6318 |
|
{ "model-format", required_argument, nullptr, 512 }, |
6319 |
|
{ "print-inst-full", no_argument, nullptr, 513 }, |
6320 |
|
{ "no-print-inst-full", no_argument, nullptr, 514 }, |
6321 |
|
{ "print-inst", required_argument, nullptr, 515 }, |
6322 |
|
{ "proof-eager-checking", no_argument, nullptr, 516 }, |
6323 |
|
{ "no-proof-eager-checking", no_argument, nullptr, 517 }, |
6324 |
|
{ "proof-format-mode", required_argument, nullptr, 518 }, |
6325 |
|
{ "proof-granularity", required_argument, nullptr, 519 }, |
6326 |
|
{ "proof-pedantic", required_argument, nullptr, 520 }, |
6327 |
|
{ "proof-print-conclusion", no_argument, nullptr, 521 }, |
6328 |
|
{ "no-proof-print-conclusion", no_argument, nullptr, 522 }, |
6329 |
|
{ "minisat-dump-dimacs", no_argument, nullptr, 523 }, |
6330 |
|
{ "no-minisat-dump-dimacs", no_argument, nullptr, 524 }, |
6331 |
|
{ "minisat-elimination", no_argument, nullptr, 525 }, |
6332 |
|
{ "no-minisat-elimination", no_argument, nullptr, 526 }, |
6333 |
|
{ "random-freq", required_argument, nullptr, 527 }, |
6334 |
|
{ "random-frequency", required_argument, nullptr, 528 }, |
6335 |
|
{ "random-seed", required_argument, nullptr, 529 }, |
6336 |
|
{ "refine-conflicts", no_argument, nullptr, 530 }, |
6337 |
|
{ "no-refine-conflicts", no_argument, nullptr, 531 }, |
6338 |
|
{ "restart-int-base", required_argument, nullptr, 532 }, |
6339 |
|
{ "restart-int-inc", required_argument, nullptr, 533 }, |
6340 |
|
{ "ag-miniscope-quant", no_argument, nullptr, 534 }, |
6341 |
|
{ "no-ag-miniscope-quant", no_argument, nullptr, 535 }, |
6342 |
|
{ "cegis-sample", required_argument, nullptr, 536 }, |
6343 |
|
{ "cegqi", no_argument, nullptr, 537 }, |
6344 |
|
{ "no-cegqi", no_argument, nullptr, 538 }, |
6345 |
|
{ "cegqi-all", no_argument, nullptr, 539 }, |
6346 |
|
{ "no-cegqi-all", no_argument, nullptr, 540 }, |
6347 |
|
{ "cegqi-bv", no_argument, nullptr, 541 }, |
6348 |
|
{ "no-cegqi-bv", no_argument, nullptr, 542 }, |
6349 |
|
{ "cegqi-bv-concat-inv", no_argument, nullptr, 543 }, |
6350 |
|
{ "no-cegqi-bv-concat-inv", no_argument, nullptr, 544 }, |
6351 |
|
{ "cegqi-bv-ineq", required_argument, nullptr, 545 }, |
6352 |
|
{ "cegqi-bv-interleave-value", no_argument, nullptr, 546 }, |
6353 |
|
{ "no-cegqi-bv-interleave-value", no_argument, nullptr, 547 }, |
6354 |
|
{ "cegqi-bv-linear", no_argument, nullptr, 548 }, |
6355 |
|
{ "no-cegqi-bv-linear", no_argument, nullptr, 549 }, |
6356 |
|
{ "cegqi-bv-rm-extract", no_argument, nullptr, 550 }, |
6357 |
|
{ "no-cegqi-bv-rm-extract", no_argument, nullptr, 551 }, |
6358 |
|
{ "cegqi-bv-solve-nl", no_argument, nullptr, 552 }, |
6359 |
|
{ "no-cegqi-bv-solve-nl", no_argument, nullptr, 553 }, |
6360 |
|
{ "cegqi-full", no_argument, nullptr, 554 }, |
6361 |
|
{ "no-cegqi-full", no_argument, nullptr, 555 }, |
6362 |
|
{ "cegqi-innermost", no_argument, nullptr, 556 }, |
6363 |
|
{ "no-cegqi-innermost", no_argument, nullptr, 557 }, |
6364 |
|
{ "cegqi-midpoint", no_argument, nullptr, 558 }, |
6365 |
|
{ "no-cegqi-midpoint", no_argument, nullptr, 559 }, |
6366 |
|
{ "cegqi-min-bounds", no_argument, nullptr, 560 }, |
6367 |
|
{ "no-cegqi-min-bounds", no_argument, nullptr, 561 }, |
6368 |
|
{ "cegqi-model", no_argument, nullptr, 562 }, |
6369 |
|
{ "no-cegqi-model", no_argument, nullptr, 563 }, |
6370 |
|
{ "cegqi-multi-inst", no_argument, nullptr, 564 }, |
6371 |
|
{ "no-cegqi-multi-inst", no_argument, nullptr, 565 }, |
6372 |
|
{ "cegqi-nested-qe", no_argument, nullptr, 566 }, |
6373 |
|
{ "no-cegqi-nested-qe", no_argument, nullptr, 567 }, |
6374 |
|
{ "cegqi-nopt", no_argument, nullptr, 568 }, |
6375 |
|
{ "no-cegqi-nopt", no_argument, nullptr, 569 }, |
6376 |
|
{ "cegqi-repeat-lit", no_argument, nullptr, 570 }, |
6377 |
|
{ "no-cegqi-repeat-lit", no_argument, nullptr, 571 }, |
6378 |
|
{ "cegqi-round-up-lia", no_argument, nullptr, 572 }, |
6379 |
|
{ "no-cegqi-round-up-lia", no_argument, nullptr, 573 }, |
6380 |
|
{ "cegqi-sat", no_argument, nullptr, 574 }, |
6381 |
|
{ "no-cegqi-sat", no_argument, nullptr, 575 }, |
6382 |
|
{ "cegqi-use-inf-int", no_argument, nullptr, 576 }, |
6383 |
|
{ "no-cegqi-use-inf-int", no_argument, nullptr, 577 }, |
6384 |
|
{ "cegqi-use-inf-real", no_argument, nullptr, 578 }, |
6385 |
|
{ "no-cegqi-use-inf-real", no_argument, nullptr, 579 }, |
6386 |
|
{ "cond-var-split-agg-quant", no_argument, nullptr, 580 }, |
6387 |
|
{ "no-cond-var-split-agg-quant", no_argument, nullptr, 581 }, |
6388 |
|
{ "cond-var-split-quant", no_argument, nullptr, 582 }, |
6389 |
|
{ "no-cond-var-split-quant", no_argument, nullptr, 583 }, |
6390 |
|
{ "conjecture-filter-active-terms", no_argument, nullptr, 584 }, |
6391 |
|
{ "no-conjecture-filter-active-terms", no_argument, nullptr, 585 }, |
6392 |
|
{ "conjecture-filter-canonical", no_argument, nullptr, 586 }, |
6393 |
|
{ "no-conjecture-filter-canonical", no_argument, nullptr, 587 }, |
6394 |
|
{ "conjecture-filter-model", no_argument, nullptr, 588 }, |
6395 |
|
{ "no-conjecture-filter-model", no_argument, nullptr, 589 }, |
6396 |
|
{ "conjecture-gen", no_argument, nullptr, 590 }, |
6397 |
|
{ "no-conjecture-gen", no_argument, nullptr, 591 }, |
6398 |
|
{ "conjecture-gen-gt-enum", required_argument, nullptr, 592 }, |
6399 |
|
{ "conjecture-gen-max-depth", required_argument, nullptr, 593 }, |
6400 |
|
{ "conjecture-gen-per-round", required_argument, nullptr, 594 }, |
6401 |
|
{ "conjecture-gen-uee-intro", no_argument, nullptr, 595 }, |
6402 |
|
{ "no-conjecture-gen-uee-intro", no_argument, nullptr, 596 }, |
6403 |
|
{ "conjecture-no-filter", no_argument, nullptr, 597 }, |
6404 |
|
{ "no-conjecture-no-filter", no_argument, nullptr, 598 }, |
6405 |
|
{ "debug-inst", no_argument, nullptr, 599 }, |
6406 |
|
{ "no-debug-inst", no_argument, nullptr, 600 }, |
6407 |
|
{ "debug-sygus", no_argument, nullptr, 601 }, |
6408 |
|
{ "no-debug-sygus", no_argument, nullptr, 602 }, |
6409 |
|
{ "dt-stc-ind", no_argument, nullptr, 603 }, |
6410 |
|
{ "no-dt-stc-ind", no_argument, nullptr, 604 }, |
6411 |
|
{ "dt-var-exp-quant", no_argument, nullptr, 605 }, |
6412 |
|
{ "no-dt-var-exp-quant", no_argument, nullptr, 606 }, |
6413 |
|
{ "e-matching", no_argument, nullptr, 607 }, |
6414 |
|
{ "no-e-matching", no_argument, nullptr, 608 }, |
6415 |
|
{ "elim-taut-quant", no_argument, nullptr, 609 }, |
6416 |
|
{ "no-elim-taut-quant", no_argument, nullptr, 610 }, |
6417 |
|
{ "ext-rewrite-quant", no_argument, nullptr, 611 }, |
6418 |
|
{ "no-ext-rewrite-quant", no_argument, nullptr, 612 }, |
6419 |
|
{ "finite-model-find", no_argument, nullptr, 613 }, |
6420 |
|
{ "no-finite-model-find", no_argument, nullptr, 614 }, |
6421 |
|
{ "fmf-bound", no_argument, nullptr, 615 }, |
6422 |
|
{ "no-fmf-bound", no_argument, nullptr, 616 }, |
6423 |
|
{ "fmf-bound-int", no_argument, nullptr, 617 }, |
6424 |
|
{ "no-fmf-bound-int", no_argument, nullptr, 618 }, |
6425 |
|
{ "fmf-bound-lazy", no_argument, nullptr, 619 }, |
6426 |
|
{ "no-fmf-bound-lazy", no_argument, nullptr, 620 }, |
6427 |
|
{ "fmf-fmc-simple", no_argument, nullptr, 621 }, |
6428 |
|
{ "no-fmf-fmc-simple", no_argument, nullptr, 622 }, |
6429 |
|
{ "fmf-fresh-dc", no_argument, nullptr, 623 }, |
6430 |
|
{ "no-fmf-fresh-dc", no_argument, nullptr, 624 }, |
6431 |
|
{ "fmf-fun", no_argument, nullptr, 625 }, |
6432 |
|
{ "no-fmf-fun", no_argument, nullptr, 626 }, |
6433 |
|
{ "fmf-fun-rlv", no_argument, nullptr, 627 }, |
6434 |
|
{ "no-fmf-fun-rlv", no_argument, nullptr, 628 }, |
6435 |
|
{ "fmf-inst-engine", no_argument, nullptr, 629 }, |
6436 |
|
{ "no-fmf-inst-engine", no_argument, nullptr, 630 }, |
6437 |
|
{ "fmf-type-completion-thresh", required_argument, nullptr, 631 }, |
6438 |
|
{ "fs-interleave", no_argument, nullptr, 632 }, |
6439 |
|
{ "no-fs-interleave", no_argument, nullptr, 633 }, |
6440 |
|
{ "fs-stratify", no_argument, nullptr, 634 }, |
6441 |
|
{ "no-fs-stratify", no_argument, nullptr, 635 }, |
6442 |
|
{ "fs-sum", no_argument, nullptr, 636 }, |
6443 |
|
{ "no-fs-sum", no_argument, nullptr, 637 }, |
6444 |
|
{ "full-saturate-quant", no_argument, nullptr, 638 }, |
6445 |
|
{ "no-full-saturate-quant", no_argument, nullptr, 639 }, |
6446 |
|
{ "full-saturate-quant-limit", required_argument, nullptr, 640 }, |
6447 |
|
{ "full-saturate-quant-rd", no_argument, nullptr, 641 }, |
6448 |
|
{ "no-full-saturate-quant-rd", no_argument, nullptr, 642 }, |
6449 |
|
{ "global-negate", no_argument, nullptr, 643 }, |
6450 |
|
{ "no-global-negate", no_argument, nullptr, 644 }, |
6451 |
|
{ "ho-elim", no_argument, nullptr, 645 }, |
6452 |
|
{ "no-ho-elim", no_argument, nullptr, 646 }, |
6453 |
|
{ "ho-elim-store-ax", no_argument, nullptr, 647 }, |
6454 |
|
{ "no-ho-elim-store-ax", no_argument, nullptr, 648 }, |
6455 |
|
{ "ho-matching", no_argument, nullptr, 649 }, |
6456 |
|
{ "no-ho-matching", no_argument, nullptr, 650 }, |
6457 |
|
{ "ho-matching-var-priority", no_argument, nullptr, 651 }, |
6458 |
|
{ "no-ho-matching-var-priority", no_argument, nullptr, 652 }, |
6459 |
|
{ "ho-merge-term-db", no_argument, nullptr, 653 }, |
6460 |
|
{ "no-ho-merge-term-db", no_argument, nullptr, 654 }, |
6461 |
|
{ "increment-triggers", no_argument, nullptr, 655 }, |
6462 |
|
{ "no-increment-triggers", no_argument, nullptr, 656 }, |
6463 |
|
{ "inst-level-input-only", no_argument, nullptr, 657 }, |
6464 |
|
{ "no-inst-level-input-only", no_argument, nullptr, 658 }, |
6465 |
|
{ "inst-max-level", required_argument, nullptr, 659 }, |
6466 |
|
{ "inst-no-entail", no_argument, nullptr, 660 }, |
6467 |
|
{ "no-inst-no-entail", no_argument, nullptr, 661 }, |
6468 |
|
{ "inst-when-phase", required_argument, nullptr, 662 }, |
6469 |
|
{ "inst-when-strict-interleave", no_argument, nullptr, 663 }, |
6470 |
|
{ "no-inst-when-strict-interleave", no_argument, nullptr, 664 }, |
6471 |
|
{ "inst-when-tc-first", no_argument, nullptr, 665 }, |
6472 |
|
{ "no-inst-when-tc-first", no_argument, nullptr, 666 }, |
6473 |
|
{ "inst-when", required_argument, nullptr, 667 }, |
6474 |
|
{ "int-wf-ind", no_argument, nullptr, 668 }, |
6475 |
|
{ "no-int-wf-ind", no_argument, nullptr, 669 }, |
6476 |
|
{ "ite-dtt-split-quant", no_argument, nullptr, 670 }, |
6477 |
|
{ "no-ite-dtt-split-quant", no_argument, nullptr, 671 }, |
6478 |
|
{ "ite-lift-quant", required_argument, nullptr, 672 }, |
6479 |
|
{ "literal-matching", required_argument, nullptr, 673 }, |
6480 |
|
{ "macros-quant", no_argument, nullptr, 674 }, |
6481 |
|
{ "no-macros-quant", no_argument, nullptr, 675 }, |
6482 |
|
{ "macros-quant-mode", required_argument, nullptr, 676 }, |
6483 |
|
{ "mbqi-interleave", no_argument, nullptr, 677 }, |
6484 |
|
{ "no-mbqi-interleave", no_argument, nullptr, 678 }, |
6485 |
|
{ "mbqi-one-inst-per-round", no_argument, nullptr, 679 }, |
6486 |
|
{ "no-mbqi-one-inst-per-round", no_argument, nullptr, 680 }, |
6487 |
|
{ "mbqi", required_argument, nullptr, 681 }, |
6488 |
|
{ "miniscope-quant", no_argument, nullptr, 682 }, |
6489 |
|
{ "no-miniscope-quant", no_argument, nullptr, 683 }, |
6490 |
|
{ "miniscope-quant-fv", no_argument, nullptr, 684 }, |
6491 |
|
{ "no-miniscope-quant-fv", no_argument, nullptr, 685 }, |
6492 |
|
{ "multi-trigger-cache", no_argument, nullptr, 686 }, |
6493 |
|
{ "no-multi-trigger-cache", no_argument, nullptr, 687 }, |
6494 |
|
{ "multi-trigger-linear", no_argument, nullptr, 688 }, |
6495 |
|
{ "no-multi-trigger-linear", no_argument, nullptr, 689 }, |
6496 |
|
{ "multi-trigger-priority", no_argument, nullptr, 690 }, |
6497 |
|
{ "no-multi-trigger-priority", no_argument, nullptr, 691 }, |
6498 |
|
{ "multi-trigger-when-single", no_argument, nullptr, 692 }, |
6499 |
|
{ "no-multi-trigger-when-single", no_argument, nullptr, 693 }, |
6500 |
|
{ "partial-triggers", no_argument, nullptr, 694 }, |
6501 |
|
{ "no-partial-triggers", no_argument, nullptr, 695 }, |
6502 |
|
{ "pool-inst", no_argument, nullptr, 696 }, |
6503 |
|
{ "no-pool-inst", no_argument, nullptr, 697 }, |
6504 |
|
{ "pre-skolem-quant", no_argument, nullptr, 698 }, |
6505 |
|
{ "no-pre-skolem-quant", no_argument, nullptr, 699 }, |
6506 |
|
{ "pre-skolem-quant-agg", no_argument, nullptr, 700 }, |
6507 |
|
{ "no-pre-skolem-quant-agg", no_argument, nullptr, 701 }, |
6508 |
|
{ "pre-skolem-quant-nested", no_argument, nullptr, 702 }, |
6509 |
|
{ "no-pre-skolem-quant-nested", no_argument, nullptr, 703 }, |
6510 |
|
{ "prenex-quant-user", no_argument, nullptr, 704 }, |
6511 |
|
{ "no-prenex-quant-user", no_argument, nullptr, 705 }, |
6512 |
|
{ "prenex-quant", required_argument, nullptr, 706 }, |
6513 |
|
{ "purify-triggers", no_argument, nullptr, 707 }, |
6514 |
|
{ "no-purify-triggers", no_argument, nullptr, 708 }, |
6515 |
|
{ "qcf-all-conflict", no_argument, nullptr, 709 }, |
6516 |
|
{ "no-qcf-all-conflict", no_argument, nullptr, 710 }, |
6517 |
|
{ "qcf-eager-check-rd", no_argument, nullptr, 711 }, |
6518 |
|
{ "no-qcf-eager-check-rd", no_argument, nullptr, 712 }, |
6519 |
|
{ "qcf-eager-test", no_argument, nullptr, 713 }, |
6520 |
|
{ "no-qcf-eager-test", no_argument, nullptr, 714 }, |
6521 |
|
{ "qcf-nested-conflict", no_argument, nullptr, 715 }, |
6522 |
|
{ "no-qcf-nested-conflict", no_argument, nullptr, 716 }, |
6523 |
|
{ "qcf-skip-rd", no_argument, nullptr, 717 }, |
6524 |
|
{ "no-qcf-skip-rd", no_argument, nullptr, 718 }, |
6525 |
|
{ "qcf-tconstraint", no_argument, nullptr, 719 }, |
6526 |
|
{ "no-qcf-tconstraint", no_argument, nullptr, 720 }, |
6527 |
|
{ "qcf-vo-exp", no_argument, nullptr, 721 }, |
6528 |
|
{ "no-qcf-vo-exp", no_argument, nullptr, 722 }, |
6529 |
|
{ "quant-alpha-equiv", no_argument, nullptr, 723 }, |
6530 |
|
{ "no-quant-alpha-equiv", no_argument, nullptr, 724 }, |
6531 |
|
{ "quant-cf", no_argument, nullptr, 725 }, |
6532 |
|
{ "no-quant-cf", no_argument, nullptr, 726 }, |
6533 |
|
{ "quant-cf-mode", required_argument, nullptr, 727 }, |
6534 |
|
{ "quant-cf-when", required_argument, nullptr, 728 }, |
6535 |
|
{ "quant-dsplit-mode", required_argument, nullptr, 729 }, |
6536 |
|
{ "quant-fun-wd", no_argument, nullptr, 730 }, |
6537 |
|
{ "no-quant-fun-wd", no_argument, nullptr, 731 }, |
6538 |
|
{ "quant-ind", no_argument, nullptr, 732 }, |
6539 |
|
{ "no-quant-ind", no_argument, nullptr, 733 }, |
6540 |
|
{ "quant-rep-mode", required_argument, nullptr, 734 }, |
6541 |
|
{ "quant-split", no_argument, nullptr, 735 }, |
6542 |
|
{ "no-quant-split", no_argument, nullptr, 736 }, |
6543 |
|
{ "register-quant-body-terms", no_argument, nullptr, 737 }, |
6544 |
|
{ "no-register-quant-body-terms", no_argument, nullptr, 738 }, |
6545 |
|
{ "relational-triggers", no_argument, nullptr, 739 }, |
6546 |
|
{ "no-relational-triggers", no_argument, nullptr, 740 }, |
6547 |
|
{ "relevant-triggers", no_argument, nullptr, 741 }, |
6548 |
|
{ "no-relevant-triggers", no_argument, nullptr, 742 }, |
6549 |
|
{ "strict-triggers", no_argument, nullptr, 743 }, |
6550 |
|
{ "no-strict-triggers", no_argument, nullptr, 744 }, |
6551 |
|
{ "sygus", no_argument, nullptr, 745 }, |
6552 |
|
{ "no-sygus", no_argument, nullptr, 746 }, |
6553 |
|
{ "sygus-active-gen-cfactor", required_argument, nullptr, 747 }, |
6554 |
|
{ "sygus-active-gen", required_argument, nullptr, 748 }, |
6555 |
|
{ "sygus-add-const-grammar", no_argument, nullptr, 749 }, |
6556 |
|
{ "no-sygus-add-const-grammar", no_argument, nullptr, 750 }, |
6557 |
|
{ "sygus-arg-relevant", no_argument, nullptr, 751 }, |
6558 |
|
{ "no-sygus-arg-relevant", no_argument, nullptr, 752 }, |
6559 |
|
{ "sygus-auto-unfold", no_argument, nullptr, 753 }, |
6560 |
|
{ "no-sygus-auto-unfold", no_argument, nullptr, 754 }, |
6561 |
|
{ "sygus-bool-ite-return-const", no_argument, nullptr, 755 }, |
6562 |
|
{ "no-sygus-bool-ite-return-const", no_argument, nullptr, 756 }, |
6563 |
|
{ "sygus-core-connective", no_argument, nullptr, 757 }, |
6564 |
|
{ "no-sygus-core-connective", no_argument, nullptr, 758 }, |
6565 |
|
{ "sygus-crepair-abort", no_argument, nullptr, 759 }, |
6566 |
|
{ "no-sygus-crepair-abort", no_argument, nullptr, 760 }, |
6567 |
|
{ "sygus-eval-opt", no_argument, nullptr, 761 }, |
6568 |
|
{ "no-sygus-eval-opt", no_argument, nullptr, 762 }, |
6569 |
|
{ "sygus-eval-unfold", no_argument, nullptr, 763 }, |
6570 |
|
{ "no-sygus-eval-unfold", no_argument, nullptr, 764 }, |
6571 |
|
{ "sygus-eval-unfold-bool", no_argument, nullptr, 765 }, |
6572 |
|
{ "no-sygus-eval-unfold-bool", no_argument, nullptr, 766 }, |
6573 |
|
{ "sygus-expr-miner-check-timeout", required_argument, nullptr, 767 }, |
6574 |
|
{ "sygus-ext-rew", no_argument, nullptr, 768 }, |
6575 |
|
{ "no-sygus-ext-rew", no_argument, nullptr, 769 }, |
6576 |
|
{ "sygus-filter-sol-rev", no_argument, nullptr, 770 }, |
6577 |
|
{ "no-sygus-filter-sol-rev", no_argument, nullptr, 771 }, |
6578 |
|
{ "sygus-filter-sol", required_argument, nullptr, 772 }, |
6579 |
|
{ "sygus-grammar-cons", required_argument, nullptr, 773 }, |
6580 |
|
{ "sygus-grammar-norm", no_argument, nullptr, 774 }, |
6581 |
|
{ "no-sygus-grammar-norm", no_argument, nullptr, 775 }, |
6582 |
|
{ "sygus-inference", no_argument, nullptr, 776 }, |
6583 |
|
{ "no-sygus-inference", no_argument, nullptr, 777 }, |
6584 |
|
{ "sygus-inst", no_argument, nullptr, 778 }, |
6585 |
|
{ "no-sygus-inst", no_argument, nullptr, 779 }, |
6586 |
|
{ "sygus-inst-mode", required_argument, nullptr, 780 }, |
6587 |
|
{ "sygus-inst-scope", required_argument, nullptr, 781 }, |
6588 |
|
{ "sygus-inst-term-sel", required_argument, nullptr, 782 }, |
6589 |
|
{ "sygus-inv-templ-when-sg", no_argument, nullptr, 783 }, |
6590 |
|
{ "no-sygus-inv-templ-when-sg", no_argument, nullptr, 784 }, |
6591 |
|
{ "sygus-inv-templ", required_argument, nullptr, 785 }, |
6592 |
|
{ "sygus-min-grammar", no_argument, nullptr, 786 }, |
6593 |
|
{ "no-sygus-min-grammar", no_argument, nullptr, 787 }, |
6594 |
|
{ "sygus-pbe", no_argument, nullptr, 788 }, |
6595 |
|
{ "no-sygus-pbe", no_argument, nullptr, 789 }, |
6596 |
|
{ "sygus-pbe-multi-fair", no_argument, nullptr, 790 }, |
6597 |
|
{ "no-sygus-pbe-multi-fair", no_argument, nullptr, 791 }, |
6598 |
|
{ "sygus-pbe-multi-fair-diff", required_argument, nullptr, 792 }, |
6599 |
|
{ "sygus-qe-preproc", no_argument, nullptr, 793 }, |
6600 |
|
{ "no-sygus-qe-preproc", no_argument, nullptr, 794 }, |
6601 |
|
{ "sygus-query-gen", no_argument, nullptr, 795 }, |
6602 |
|
{ "no-sygus-query-gen", no_argument, nullptr, 796 }, |
6603 |
|
{ "sygus-query-gen-check", no_argument, nullptr, 797 }, |
6604 |
|
{ "no-sygus-query-gen-check", no_argument, nullptr, 798 }, |
6605 |
|
{ "sygus-query-gen-dump-files", required_argument, nullptr, 799 }, |
6606 |
|
{ "sygus-query-gen-thresh", required_argument, nullptr, 800 }, |
6607 |
|
{ "sygus-rec-fun", no_argument, nullptr, 801 }, |
6608 |
|
{ "no-sygus-rec-fun", no_argument, nullptr, 802 }, |
6609 |
|
{ "sygus-rec-fun-eval-limit", required_argument, nullptr, 803 }, |
6610 |
|
{ "sygus-repair-const", no_argument, nullptr, 804 }, |
6611 |
|
{ "no-sygus-repair-const", no_argument, nullptr, 805 }, |
6612 |
|
{ "sygus-repair-const-timeout", required_argument, nullptr, 806 }, |
6613 |
|
{ "sygus-rr", no_argument, nullptr, 807 }, |
6614 |
|
{ "no-sygus-rr", no_argument, nullptr, 808 }, |
6615 |
|
{ "sygus-rr-synth", no_argument, nullptr, 809 }, |
6616 |
|
{ "no-sygus-rr-synth", no_argument, nullptr, 810 }, |
6617 |
|
{ "sygus-rr-synth-accel", no_argument, nullptr, 811 }, |
6618 |
|
{ "no-sygus-rr-synth-accel", no_argument, nullptr, 812 }, |
6619 |
|
{ "sygus-rr-synth-check", no_argument, nullptr, 813 }, |
6620 |
|
{ "no-sygus-rr-synth-check", no_argument, nullptr, 814 }, |
6621 |
|
{ "sygus-rr-synth-filter-cong", no_argument, nullptr, 815 }, |
6622 |
|
{ "no-sygus-rr-synth-filter-cong", no_argument, nullptr, 816 }, |
6623 |
|
{ "sygus-rr-synth-filter-match", no_argument, nullptr, 817 }, |
6624 |
|
{ "no-sygus-rr-synth-filter-match", no_argument, nullptr, 818 }, |
6625 |
|
{ "sygus-rr-synth-filter-nl", no_argument, nullptr, 819 }, |
6626 |
|
{ "no-sygus-rr-synth-filter-nl", no_argument, nullptr, 820 }, |
6627 |
|
{ "sygus-rr-synth-filter-order", no_argument, nullptr, 821 }, |
6628 |
|
{ "no-sygus-rr-synth-filter-order", no_argument, nullptr, 822 }, |
6629 |
|
{ "sygus-rr-synth-input", no_argument, nullptr, 823 }, |
6630 |
|
{ "no-sygus-rr-synth-input", no_argument, nullptr, 824 }, |
6631 |
|
{ "sygus-rr-synth-input-nvars", required_argument, nullptr, 825 }, |
6632 |
|
{ "sygus-rr-synth-input-use-bool", no_argument, nullptr, 826 }, |
6633 |
|
{ "no-sygus-rr-synth-input-use-bool", no_argument, nullptr, 827 }, |
6634 |
|
{ "sygus-rr-synth-rec", no_argument, nullptr, 828 }, |
6635 |
|
{ "no-sygus-rr-synth-rec", no_argument, nullptr, 829 }, |
6636 |
|
{ "sygus-rr-verify", no_argument, nullptr, 830 }, |
6637 |
|
{ "no-sygus-rr-verify", no_argument, nullptr, 831 }, |
6638 |
|
{ "sygus-rr-verify-abort", no_argument, nullptr, 832 }, |
6639 |
|
{ "no-sygus-rr-verify-abort", no_argument, nullptr, 833 }, |
6640 |
|
{ "sygus-sample-fp-uniform", no_argument, nullptr, 834 }, |
6641 |
|
{ "no-sygus-sample-fp-uniform", no_argument, nullptr, 835 }, |
6642 |
|
{ "sygus-sample-grammar", no_argument, nullptr, 836 }, |
6643 |
|
{ "no-sygus-sample-grammar", no_argument, nullptr, 837 }, |
6644 |
|
{ "sygus-samples", required_argument, nullptr, 838 }, |
6645 |
|
{ "sygus-si-abort", no_argument, nullptr, 839 }, |
6646 |
|
{ "no-sygus-si-abort", no_argument, nullptr, 840 }, |
6647 |
|
{ "sygus-si-partial", no_argument, nullptr, 841 }, |
6648 |
|
{ "no-sygus-si-partial", no_argument, nullptr, 842 }, |
6649 |
|
{ "sygus-si-rcons-limit", required_argument, nullptr, 843 }, |
6650 |
|
{ "sygus-si-rcons", required_argument, nullptr, 844 }, |
6651 |
|
{ "sygus-si-reconstruct-const", no_argument, nullptr, 845 }, |
6652 |
|
{ "no-sygus-si-reconstruct-const", no_argument, nullptr, 846 }, |
6653 |
|
{ "sygus-si", required_argument, nullptr, 847 }, |
6654 |
|
{ "sygus-stream", no_argument, nullptr, 848 }, |
6655 |
|
{ "no-sygus-stream", no_argument, nullptr, 849 }, |
6656 |
|
{ "sygus-templ-embed-grammar", no_argument, nullptr, 850 }, |
6657 |
|
{ "no-sygus-templ-embed-grammar", no_argument, nullptr, 851 }, |
6658 |
|
{ "sygus-unif-cond-independent-no-repeat-sol", no_argument, nullptr, 852 }, |
6659 |
|
{ "no-sygus-unif-cond-independent-no-repeat-sol", no_argument, nullptr, 853 }, |
6660 |
|
{ "sygus-unif-pi", required_argument, nullptr, 854 }, |
6661 |
|
{ "sygus-unif-shuffle-cond", no_argument, nullptr, 855 }, |
6662 |
|
{ "no-sygus-unif-shuffle-cond", no_argument, nullptr, 856 }, |
6663 |
|
{ "term-db-cd", no_argument, nullptr, 857 }, |
6664 |
|
{ "no-term-db-cd", no_argument, nullptr, 858 }, |
6665 |
|
{ "term-db-mode", required_argument, nullptr, 859 }, |
6666 |
|
{ "trigger-active-sel", required_argument, nullptr, 860 }, |
6667 |
|
{ "trigger-sel", required_argument, nullptr, 861 }, |
6668 |
|
{ "user-pat", required_argument, nullptr, 862 }, |
6669 |
|
{ "var-elim-quant", no_argument, nullptr, 863 }, |
6670 |
|
{ "no-var-elim-quant", no_argument, nullptr, 864 }, |
6671 |
|
{ "var-ineq-elim-quant", no_argument, nullptr, 865 }, |
6672 |
|
{ "no-var-ineq-elim-quant", no_argument, nullptr, 866 }, |
6673 |
|
{ "rlimit-per", required_argument, nullptr, 867 }, |
6674 |
|
{ "reproducible-resource-limit", required_argument, nullptr, 868 }, |
6675 |
|
{ "rlimit", required_argument, nullptr, 869 }, |
6676 |
|
{ "rweight", required_argument, nullptr, 870 }, |
6677 |
|
{ "tlimit-per", required_argument, nullptr, 871 }, |
6678 |
|
{ "tlimit", required_argument, nullptr, 872 }, |
6679 |
|
{ "sep-check-neg", no_argument, nullptr, 873 }, |
6680 |
|
{ "no-sep-check-neg", no_argument, nullptr, 874 }, |
6681 |
|
{ "sep-child-refine", no_argument, nullptr, 875 }, |
6682 |
|
{ "no-sep-child-refine", no_argument, nullptr, 876 }, |
6683 |
|
{ "sep-deq-c", no_argument, nullptr, 877 }, |
6684 |
|
{ "no-sep-deq-c", no_argument, nullptr, 878 }, |
6685 |
|
{ "sep-exp", no_argument, nullptr, 879 }, |
6686 |
|
{ "no-sep-exp", no_argument, nullptr, 880 }, |
6687 |
|
{ "sep-min-refine", no_argument, nullptr, 881 }, |
6688 |
|
{ "no-sep-min-refine", no_argument, nullptr, 882 }, |
6689 |
|
{ "sep-pre-skolem-emp", no_argument, nullptr, 883 }, |
6690 |
|
{ "no-sep-pre-skolem-emp", no_argument, nullptr, 884 }, |
6691 |
|
{ "sets-ext", no_argument, nullptr, 885 }, |
6692 |
|
{ "no-sets-ext", no_argument, nullptr, 886 }, |
6693 |
|
{ "sets-infer-as-lemmas", no_argument, nullptr, 887 }, |
6694 |
|
{ "no-sets-infer-as-lemmas", no_argument, nullptr, 888 }, |
6695 |
|
{ "sets-proxy-lemmas", no_argument, nullptr, 889 }, |
6696 |
|
{ "no-sets-proxy-lemmas", no_argument, nullptr, 890 }, |
6697 |
|
{ "abstract-values", no_argument, nullptr, 891 }, |
6698 |
|
{ "no-abstract-values", no_argument, nullptr, 892 }, |
6699 |
|
{ "ackermann", no_argument, nullptr, 893 }, |
6700 |
|
{ "no-ackermann", no_argument, nullptr, 894 }, |
6701 |
|
{ "block-models", required_argument, nullptr, 895 }, |
6702 |
|
{ "bvand-integer-granularity", required_argument, nullptr, 896 }, |
6703 |
|
{ "check-abducts", no_argument, nullptr, 897 }, |
6704 |
|
{ "no-check-abducts", no_argument, nullptr, 898 }, |
6705 |
|
{ "check-interpols", no_argument, nullptr, 899 }, |
6706 |
|
{ "no-check-interpols", no_argument, nullptr, 900 }, |
6707 |
|
{ "check-models", no_argument, nullptr, 901 }, |
6708 |
|
{ "no-check-models", no_argument, nullptr, 902 }, |
6709 |
|
{ "check-proofs", no_argument, nullptr, 903 }, |
6710 |
|
{ "no-check-proofs", no_argument, nullptr, 904 }, |
6711 |
|
{ "check-synth-sol", no_argument, nullptr, 905 }, |
6712 |
|
{ "no-check-synth-sol", no_argument, nullptr, 906 }, |
6713 |
|
{ "check-unsat-cores", no_argument, nullptr, 907 }, |
6714 |
|
{ "no-check-unsat-cores", no_argument, nullptr, 908 }, |
6715 |
|
{ "debug-check-models", no_argument, nullptr, 909 }, |
6716 |
|
{ "no-debug-check-models", no_argument, nullptr, 910 }, |
6717 |
|
{ "diagnostic-output-channel", required_argument, nullptr, 911 }, |
6718 |
|
{ "dump-instantiations", no_argument, nullptr, 912 }, |
6719 |
|
{ "no-dump-instantiations", no_argument, nullptr, 913 }, |
6720 |
|
{ "dump-models", no_argument, nullptr, 914 }, |
6721 |
|
{ "no-dump-models", no_argument, nullptr, 915 }, |
6722 |
|
{ "dump-proofs", no_argument, nullptr, 916 }, |
6723 |
|
{ "no-dump-proofs", no_argument, nullptr, 917 }, |
6724 |
|
{ "dump-to", required_argument, nullptr, 918 }, |
6725 |
|
{ "dump-unsat-cores", no_argument, nullptr, 919 }, |
6726 |
|
{ "no-dump-unsat-cores", no_argument, nullptr, 920 }, |
6727 |
|
{ "dump-unsat-cores-full", no_argument, nullptr, 921 }, |
6728 |
|
{ "no-dump-unsat-cores-full", no_argument, nullptr, 922 }, |
6729 |
|
{ "dump", required_argument, nullptr, 923 }, |
6730 |
|
{ "early-ite-removal", no_argument, nullptr, 924 }, |
6731 |
|
{ "no-early-ite-removal", no_argument, nullptr, 925 }, |
6732 |
|
{ "expand-definitions", no_argument, nullptr, 926 }, |
6733 |
|
{ "no-expand-definitions", no_argument, nullptr, 927 }, |
6734 |
|
{ "ext-rew-prep", no_argument, nullptr, 928 }, |
6735 |
|
{ "no-ext-rew-prep", no_argument, nullptr, 929 }, |
6736 |
|
{ "ext-rew-prep-agg", no_argument, nullptr, 930 }, |
6737 |
|
{ "no-ext-rew-prep-agg", no_argument, nullptr, 931 }, |
6738 |
|
{ "force-no-limit-cpu-while-dump", no_argument, nullptr, 932 }, |
6739 |
|
{ "no-force-no-limit-cpu-while-dump", no_argument, nullptr, 933 }, |
6740 |
|
{ "foreign-theory-rewrite", no_argument, nullptr, 934 }, |
6741 |
|
{ "no-foreign-theory-rewrite", no_argument, nullptr, 935 }, |
6742 |
|
{ "iand-mode", required_argument, nullptr, 936 }, |
6743 |
|
{ "incremental", no_argument, nullptr, 937 }, |
6744 |
|
{ "no-incremental", no_argument, nullptr, 938 }, |
6745 |
|
{ "interactive-mode", no_argument, nullptr, 939 }, |
6746 |
|
{ "no-interactive-mode", no_argument, nullptr, 940 }, |
6747 |
|
{ "ite-simp", no_argument, nullptr, 941 }, |
6748 |
|
{ "no-ite-simp", no_argument, nullptr, 942 }, |
6749 |
|
{ "model-cores", required_argument, nullptr, 943 }, |
6750 |
|
{ "model-u-print", required_argument, nullptr, 944 }, |
6751 |
|
{ "model-uninterp-print", required_argument, nullptr, 945 }, |
6752 |
|
{ "model-witness-value", no_argument, nullptr, 946 }, |
6753 |
|
{ "no-model-witness-value", no_argument, nullptr, 947 }, |
6754 |
|
{ "on-repeat-ite-simp", no_argument, nullptr, 948 }, |
6755 |
|
{ "no-on-repeat-ite-simp", no_argument, nullptr, 949 }, |
6756 |
|
{ "produce-abducts", no_argument, nullptr, 950 }, |
6757 |
|
{ "no-produce-abducts", no_argument, nullptr, 951 }, |
6758 |
|
{ "produce-assertions", no_argument, nullptr, 952 }, |
6759 |
|
{ "no-produce-assertions", no_argument, nullptr, 953 }, |
6760 |
|
{ "produce-assignments", no_argument, nullptr, 954 }, |
6761 |
|
{ "no-produce-assignments", no_argument, nullptr, 955 }, |
6762 |
|
{ "produce-interpols", required_argument, nullptr, 956 }, |
6763 |
|
{ "produce-models", no_argument, nullptr, 957 }, |
6764 |
|
{ "no-produce-models", no_argument, nullptr, 958 }, |
6765 |
|
{ "produce-proofs", no_argument, nullptr, 959 }, |
6766 |
|
{ "no-produce-proofs", no_argument, nullptr, 960 }, |
6767 |
|
{ "produce-unsat-assumptions", no_argument, nullptr, 961 }, |
6768 |
|
{ "no-produce-unsat-assumptions", no_argument, nullptr, 962 }, |
6769 |
|
{ "produce-unsat-cores", no_argument, nullptr, 963 }, |
6770 |
|
{ "no-produce-unsat-cores", no_argument, nullptr, 964 }, |
6771 |
|
{ "regular-output-channel", required_argument, nullptr, 965 }, |
6772 |
|
{ "repeat-simp", no_argument, nullptr, 966 }, |
6773 |
|
{ "no-repeat-simp", no_argument, nullptr, 967 }, |
6774 |
|
{ "simp-ite-compress", no_argument, nullptr, 968 }, |
6775 |
|
{ "no-simp-ite-compress", no_argument, nullptr, 969 }, |
6776 |
|
{ "simp-ite-hunt-zombies", required_argument, nullptr, 970 }, |
6777 |
|
{ "simp-with-care", no_argument, nullptr, 971 }, |
6778 |
|
{ "no-simp-with-care", no_argument, nullptr, 972 }, |
6779 |
|
{ "simplification", required_argument, nullptr, 973 }, |
6780 |
|
{ "simplification-mode", required_argument, nullptr, 974 }, |
6781 |
|
{ "solve-bv-as-int", required_argument, nullptr, 975 }, |
6782 |
|
{ "solve-int-as-bv", required_argument, nullptr, 976 }, |
6783 |
|
{ "solve-real-as-int", no_argument, nullptr, 977 }, |
6784 |
|
{ "no-solve-real-as-int", no_argument, nullptr, 978 }, |
6785 |
|
{ "sort-inference", no_argument, nullptr, 979 }, |
6786 |
|
{ "no-sort-inference", no_argument, nullptr, 980 }, |
6787 |
|
{ "static-learning", no_argument, nullptr, 981 }, |
6788 |
|
{ "no-static-learning", no_argument, nullptr, 982 }, |
6789 |
|
{ "sygus-out", required_argument, nullptr, 983 }, |
6790 |
|
{ "sygus-print-callbacks", no_argument, nullptr, 984 }, |
6791 |
|
{ "no-sygus-print-callbacks", no_argument, nullptr, 985 }, |
6792 |
|
{ "unconstrained-simp", no_argument, nullptr, 986 }, |
6793 |
|
{ "no-unconstrained-simp", no_argument, nullptr, 987 }, |
6794 |
|
{ "unsat-cores-mode", required_argument, nullptr, 988 }, |
6795 |
|
{ "re-elim", no_argument, nullptr, 989 }, |
6796 |
|
{ "no-re-elim", no_argument, nullptr, 990 }, |
6797 |
|
{ "re-elim-agg", no_argument, nullptr, 991 }, |
6798 |
|
{ "no-re-elim-agg", no_argument, nullptr, 992 }, |
6799 |
|
{ "re-inter-mode", required_argument, nullptr, 993 }, |
6800 |
|
{ "strings-check-entail-len", no_argument, nullptr, 994 }, |
6801 |
|
{ "no-strings-check-entail-len", no_argument, nullptr, 995 }, |
6802 |
|
{ "strings-eager", no_argument, nullptr, 996 }, |
6803 |
|
{ "no-strings-eager", no_argument, nullptr, 997 }, |
6804 |
|
{ "strings-eager-eval", no_argument, nullptr, 998 }, |
6805 |
|
{ "no-strings-eager-eval", no_argument, nullptr, 999 }, |
6806 |
|
{ "strings-eager-len", no_argument, nullptr, 1000 }, |
6807 |
|
{ "no-strings-eager-len", no_argument, nullptr, 1001 }, |
6808 |
|
{ "strings-exp", no_argument, nullptr, 1002 }, |
6809 |
|
{ "no-strings-exp", no_argument, nullptr, 1003 }, |
6810 |
|
{ "strings-ff", no_argument, nullptr, 1004 }, |
6811 |
|
{ "no-strings-ff", no_argument, nullptr, 1005 }, |
6812 |
|
{ "strings-fmf", no_argument, nullptr, 1006 }, |
6813 |
|
{ "no-strings-fmf", no_argument, nullptr, 1007 }, |
6814 |
|
{ "strings-guess-model", no_argument, nullptr, 1008 }, |
6815 |
|
{ "no-strings-guess-model", no_argument, nullptr, 1009 }, |
6816 |
|
{ "strings-infer-as-lemmas", no_argument, nullptr, 1010 }, |
6817 |
|
{ "no-strings-infer-as-lemmas", no_argument, nullptr, 1011 }, |
6818 |
|
{ "strings-infer-sym", no_argument, nullptr, 1012 }, |
6819 |
|
{ "no-strings-infer-sym", no_argument, nullptr, 1013 }, |
6820 |
|
{ "strings-inm", no_argument, nullptr, 1014 }, |
6821 |
|
{ "no-strings-inm", no_argument, nullptr, 1015 }, |
6822 |
|
{ "strings-lazy-pp", no_argument, nullptr, 1016 }, |
6823 |
|
{ "no-strings-lazy-pp", no_argument, nullptr, 1017 }, |
6824 |
|
{ "strings-len-norm", no_argument, nullptr, 1018 }, |
6825 |
|
{ "no-strings-len-norm", no_argument, nullptr, 1019 }, |
6826 |
|
{ "strings-lprop-csp", no_argument, nullptr, 1020 }, |
6827 |
|
{ "no-strings-lprop-csp", no_argument, nullptr, 1021 }, |
6828 |
|
{ "strings-min-prefix-explain", no_argument, nullptr, 1022 }, |
6829 |
|
{ "no-strings-min-prefix-explain", no_argument, nullptr, 1023 }, |
6830 |
|
{ "strings-process-loop-mode", required_argument, nullptr, 1024 }, |
6831 |
|
{ "strings-rexplain-lemmas", no_argument, nullptr, 1025 }, |
6832 |
|
{ "no-strings-rexplain-lemmas", no_argument, nullptr, 1026 }, |
6833 |
|
{ "strings-unified-vspt", no_argument, nullptr, 1027 }, |
6834 |
|
{ "no-strings-unified-vspt", no_argument, nullptr, 1028 }, |
6835 |
|
{ "assign-function-values", no_argument, nullptr, 1029 }, |
6836 |
|
{ "no-assign-function-values", no_argument, nullptr, 1030 }, |
6837 |
|
{ "condense-function-values", no_argument, nullptr, 1031 }, |
6838 |
|
{ "no-condense-function-values", no_argument, nullptr, 1032 }, |
6839 |
|
{ "ee-mode", required_argument, nullptr, 1033 }, |
6840 |
|
{ "relevance-filter", no_argument, nullptr, 1034 }, |
6841 |
|
{ "no-relevance-filter", no_argument, nullptr, 1035 }, |
6842 |
|
{ "tc-mode", required_argument, nullptr, 1036 }, |
6843 |
|
{ "theoryof-mode", required_argument, nullptr, 1037 }, |
6844 |
|
{ "symmetry-breaker", no_argument, nullptr, 1038 }, |
6845 |
|
{ "uf-symmetry-breaker", no_argument, nullptr, 1039 }, |
6846 |
|
{ "no-symmetry-breaker", no_argument, nullptr, 1040 }, |
6847 |
|
{ "no-uf-symmetry-breaker", no_argument, nullptr, 1041 }, |
6848 |
|
{ "uf-ho", no_argument, nullptr, 1042 }, |
6849 |
|
{ "no-uf-ho", no_argument, nullptr, 1043 }, |
6850 |
|
{ "uf-ho-ext", no_argument, nullptr, 1044 }, |
6851 |
|
{ "no-uf-ho-ext", no_argument, nullptr, 1045 }, |
6852 |
|
{ "uf-ss-abort-card", required_argument, nullptr, 1046 }, |
6853 |
|
{ "uf-ss-fair", no_argument, nullptr, 1047 }, |
6854 |
|
{ "no-uf-ss-fair", no_argument, nullptr, 1048 }, |
6855 |
|
{ "uf-ss-fair-monotone", no_argument, nullptr, 1049 }, |
6856 |
|
{ "no-uf-ss-fair-monotone", no_argument, nullptr, 1050 }, |
6857 |
|
{ "uf-ss-totality-limited", required_argument, nullptr, 1051 }, |
6858 |
|
{ "uf-ss-totality-sym-break", no_argument, nullptr, 1052 }, |
6859 |
|
{ "no-uf-ss-totality-sym-break", no_argument, nullptr, 1053 }, |
6860 |
|
{ "uf-ss", required_argument, nullptr, 1054 }, |
6861 |
|
{nullptr, no_argument, nullptr, '\0'}}; |
6862 |
|
// clang-format on |
6863 |
|
|
6864 |
|
namespace options { |
6865 |
|
|
6866 |
|
/** Set a given Options* as "current" just for a particular scope. */ |
6867 |
|
class OptionsGuard { |
6868 |
|
Options** d_field; |
6869 |
|
Options* d_old; |
6870 |
|
public: |
6871 |
8445 |
OptionsGuard(Options** field, Options* opts) : |
6872 |
|
d_field(field), |
6873 |
8445 |
d_old(*field) { |
6874 |
8445 |
*field = opts; |
6875 |
8445 |
} |
6876 |
11882 |
~OptionsGuard() { |
6877 |
5941 |
*d_field = d_old; |
6878 |
5941 |
} |
6879 |
|
};/* class OptionsGuard */ |
6880 |
|
|
6881 |
|
} // namespace options |
6882 |
|
|
6883 |
|
/** |
6884 |
|
* Parse argc/argv and put the result into a cvc5::Options. |
6885 |
|
* The return value is what's left of the command line (that is, the |
6886 |
|
* non-option arguments). |
6887 |
|
* |
6888 |
|
* Throws OptionException on failures. |
6889 |
|
*/ |
6890 |
8445 |
std::vector<std::string> Options::parseOptions(Options* options, |
6891 |
|
int argc, |
6892 |
|
char* argv[]) |
6893 |
|
{ |
6894 |
8445 |
Assert(options != NULL); |
6895 |
8445 |
Assert(argv != NULL); |
6896 |
|
|
6897 |
14386 |
options::OptionsGuard guard(&s_current, options); |
6898 |
|
|
6899 |
8445 |
const char *progName = argv[0]; |
6900 |
|
|
6901 |
|
// To debug options parsing, you may prefer to simply uncomment this |
6902 |
|
// and recompile. Debug flags have not been parsed yet so these have |
6903 |
|
// not been set. |
6904 |
|
//DebugChannel.on("options"); |
6905 |
|
|
6906 |
8445 |
Debug("options") << "Options::parseOptions == " << options << std::endl; |
6907 |
8445 |
Debug("options") << "argv == " << argv << std::endl; |
6908 |
|
|
6909 |
|
// Find the base name of the program. |
6910 |
8445 |
const char *x = strrchr(progName, '/'); |
6911 |
8445 |
if(x != NULL) { |
6912 |
8383 |
progName = x + 1; |
6913 |
|
} |
6914 |
8445 |
options->base().binary_name = std::string(progName); |
6915 |
|
|
6916 |
8445 |
std::vector<std::string> nonoptions; |
6917 |
8445 |
options->parseOptionsRecursive(argc, argv, &nonoptions); |
6918 |
5941 |
if(Debug.isOn("options")){ |
6919 |
|
for(std::vector<std::string>::const_iterator i = nonoptions.begin(), |
6920 |
|
iend = nonoptions.end(); i != iend; ++i){ |
6921 |
|
Debug("options") << "nonoptions " << *i << std::endl; |
6922 |
|
} |
6923 |
|
} |
6924 |
|
|
6925 |
11882 |
return nonoptions; |
6926 |
|
} |
6927 |
|
|
6928 |
|
std::string suggestCommandLineOptions(const std::string& optionName) |
6929 |
|
{ |
6930 |
|
DidYouMean didYouMean; |
6931 |
|
|
6932 |
|
const char* opt; |
6933 |
|
for(size_t i = 0; (opt = cmdlineOptions[i].name) != nullptr; ++i) { |
6934 |
|
didYouMean.addWord(std::string("--") + cmdlineOptions[i].name); |
6935 |
|
} |
6936 |
|
|
6937 |
|
return didYouMean.getMatchAsString(optionName.substr(0, optionName.find('='))); |
6938 |
|
} |
6939 |
|
|
6940 |
8445 |
void Options::parseOptionsRecursive(int argc, |
6941 |
|
char* argv[], |
6942 |
|
std::vector<std::string>* nonoptions) |
6943 |
|
{ |
6944 |
|
|
6945 |
8445 |
if(Debug.isOn("options")) { |
6946 |
|
Debug("options") << "starting a new parseOptionsRecursive with " |
6947 |
|
<< argc << " arguments" << std::endl; |
6948 |
|
for( int i = 0; i < argc ; i++ ){ |
6949 |
|
Assert(argv[i] != NULL); |
6950 |
|
Debug("options") << " argv[" << i << "] = " << argv[i] << std::endl; |
6951 |
|
} |
6952 |
|
} |
6953 |
|
|
6954 |
|
// Reset getopt(), in the case of multiple calls to parseOptions(). |
6955 |
|
// This can be = 1 in newer GNU getopt, but older (< 2007) require = 0. |
6956 |
8445 |
optind = 0; |
6957 |
|
#if HAVE_DECL_OPTRESET |
6958 |
|
optreset = 1; // on BSD getopt() (e.g. Mac OS), might need this |
6959 |
|
#endif /* HAVE_DECL_OPTRESET */ |
6960 |
|
|
6961 |
|
// We must parse the binary name, which is manually ignored below. Setting |
6962 |
|
// this to 1 leads to incorrect behavior on some platforms. |
6963 |
8445 |
int main_optind = 0; |
6964 |
|
int old_optind; |
6965 |
|
|
6966 |
|
|
6967 |
|
while(true) { // Repeat Forever |
6968 |
|
|
6969 |
23220 |
optopt = 0; |
6970 |
30791 |
std::string option, optionarg; |
6971 |
|
|
6972 |
23220 |
optind = main_optind; |
6973 |
23220 |
old_optind = main_optind; |
6974 |
|
|
6975 |
|
// If we encounter an element that is not at zero and does not start |
6976 |
|
// with a "-", this is a non-option. We consume this element as a |
6977 |
|
// non-option. |
6978 |
37933 |
if (main_optind > 0 && main_optind < argc && |
6979 |
8834 |
argv[main_optind][0] != '-') { |
6980 |
11758 |
Debug("options") << "enqueueing " << argv[main_optind] |
6981 |
5879 |
<< " as a non-option." << std::endl; |
6982 |
5879 |
nonoptions->push_back(argv[main_optind]); |
6983 |
5879 |
++main_optind; |
6984 |
5879 |
continue; |
6985 |
|
} |
6986 |
|
|
6987 |
|
|
6988 |
34682 |
Debug("options") << "[ before, main_optind == " << main_optind << " ]" |
6989 |
17341 |
<< std::endl; |
6990 |
17341 |
Debug("options") << "[ before, optind == " << optind << " ]" << std::endl; |
6991 |
34682 |
Debug("options") << "[ argc == " << argc << ", argv == " << argv << " ]" |
6992 |
17341 |
<< std::endl; |
6993 |
|
// clang-format off |
6994 |
17341 |
int c = getopt_long(argc, argv, |
6995 |
|
"+:d:L:qt:vhs:Vim", |
6996 |
17341 |
cmdlineOptions, NULL); |
6997 |
|
// clang-format on |
6998 |
|
|
6999 |
17341 |
main_optind = optind; |
7000 |
|
|
7001 |
34682 |
Debug("options") << "[ got " << int(c) << " (" << char(c) << ") ]" |
7002 |
17341 |
<< "[ next option will be at pos: " << optind << " ]" |
7003 |
17341 |
<< std::endl; |
7004 |
|
|
7005 |
|
// The initial getopt_long call should always determine that argv[0] |
7006 |
|
// is not an option and returns -1. We always manually advance beyond |
7007 |
|
// this element. |
7008 |
18666 |
if ( old_optind == 0 && c == -1 ) { |
7009 |
1325 |
Assert(main_optind > 0); |
7010 |
1325 |
continue; |
7011 |
|
} |
7012 |
|
|
7013 |
16016 |
if ( c == -1 ) { |
7014 |
5941 |
if(Debug.isOn("options")) { |
7015 |
|
Debug("options") << "done with option parsing" << std::endl; |
7016 |
|
for(int index = optind; index < argc; ++index) { |
7017 |
|
Debug("options") << "remaining " << argv[index] << std::endl; |
7018 |
|
} |
7019 |
|
} |
7020 |
5941 |
break; |
7021 |
|
} |
7022 |
|
|
7023 |
10075 |
option = argv[old_optind == 0 ? 1 : old_optind]; |
7024 |
10075 |
optionarg = (optarg == NULL) ? "" : optarg; |
7025 |
|
|
7026 |
20150 |
Debug("preemptGetopt") << "processing option " << c |
7027 |
10075 |
<< " (`" << char(c) << "'), " << option << std::endl; |
7028 |
|
|
7029 |
|
// clang-format off |
7030 |
10075 |
switch(c) |
7031 |
|
{ |
7032 |
|
case 256: // --approx-branch-depth=N |
7033 |
|
assign(options::maxApproxDepth, option, optionarg); |
7034 |
|
break; |
7035 |
2 |
case 257: // --arith-brab |
7036 |
2 |
assignBool(options::brabTest, option, true); |
7037 |
2 |
break; |
7038 |
2 |
case 258:// --no-arith-brab |
7039 |
2 |
assignBool(options::brabTest, option, false); |
7040 |
2 |
break; |
7041 |
|
case 259: // --arith-no-partial-fun |
7042 |
|
assignBool(options::arithNoPartialFun, option, true); |
7043 |
|
break; |
7044 |
|
case 260:// --no-arith-no-partial-fun |
7045 |
|
assignBool(options::arithNoPartialFun, option, false); |
7046 |
|
break; |
7047 |
|
case 261: // --arith-prop-clauses=N |
7048 |
|
assign(options::arithPropAsLemmaLength, option, optionarg); |
7049 |
|
break; |
7050 |
|
case 262: // --arith-prop=MODE |
7051 |
|
assign(options::arithPropagationMode, option, optionarg); |
7052 |
|
break; |
7053 |
4 |
case 263: // --arith-rewrite-equalities |
7054 |
4 |
assignBool(options::arithRewriteEq, option, true); |
7055 |
4 |
break; |
7056 |
|
case 264:// --no-arith-rewrite-equalities |
7057 |
|
assignBool(options::arithRewriteEq, option, false); |
7058 |
|
break; |
7059 |
|
case 265: // --collect-pivot-stats |
7060 |
|
assignBool(options::collectPivots, option, true); |
7061 |
|
break; |
7062 |
|
case 266:// --no-collect-pivot-stats |
7063 |
|
assignBool(options::collectPivots, option, false); |
7064 |
|
break; |
7065 |
|
case 267: // --cut-all-bounded |
7066 |
|
assignBool(options::doCutAllBounded, option, true); |
7067 |
|
break; |
7068 |
|
case 268:// --no-cut-all-bounded |
7069 |
|
assignBool(options::doCutAllBounded, option, false); |
7070 |
|
break; |
7071 |
|
case 269: // --dio-decomps |
7072 |
|
assignBool(options::exportDioDecompositions, option, true); |
7073 |
|
break; |
7074 |
|
case 270:// --no-dio-decomps |
7075 |
|
assignBool(options::exportDioDecompositions, option, false); |
7076 |
|
break; |
7077 |
|
case 271: // --dio-repeat |
7078 |
|
assignBool(options::dioRepeat, option, true); |
7079 |
|
break; |
7080 |
|
case 272:// --no-dio-repeat |
7081 |
|
assignBool(options::dioRepeat, option, false); |
7082 |
|
break; |
7083 |
|
case 273: // --dio-solver |
7084 |
|
assignBool(options::arithDioSolver, option, true); |
7085 |
|
break; |
7086 |
|
case 274:// --no-dio-solver |
7087 |
|
assignBool(options::arithDioSolver, option, false); |
7088 |
|
break; |
7089 |
|
case 275: // --dio-turns=N |
7090 |
|
assign(options::dioSolverTurns, option, optionarg); |
7091 |
|
break; |
7092 |
|
case 276: // --error-selection-rule=RULE |
7093 |
|
assign(options::arithErrorSelectionRule, option, optionarg); |
7094 |
|
break; |
7095 |
|
case 277: // --fc-penalties |
7096 |
|
assignBool(options::havePenalties, option, true); |
7097 |
|
break; |
7098 |
|
case 278:// --no-fc-penalties |
7099 |
|
assignBool(options::havePenalties, option, false); |
7100 |
|
break; |
7101 |
|
case 279: // --heuristic-pivots=N |
7102 |
|
assign(options::arithHeuristicPivots, option, optionarg); |
7103 |
|
break; |
7104 |
|
case 280: // --lemmas-on-replay-failure |
7105 |
|
assignBool(options::replayFailureLemma, option, true); |
7106 |
|
break; |
7107 |
|
case 281:// --no-lemmas-on-replay-failure |
7108 |
|
assignBool(options::replayFailureLemma, option, false); |
7109 |
|
break; |
7110 |
|
case 282: // --maxCutsInContext=N |
7111 |
|
assign(options::maxCutsInContext, option, optionarg); |
7112 |
|
break; |
7113 |
8 |
case 283: // --miplib-trick |
7114 |
8 |
assignBool(options::arithMLTrick, option, true); |
7115 |
8 |
break; |
7116 |
|
case 284:// --no-miplib-trick |
7117 |
|
assignBool(options::arithMLTrick, option, false); |
7118 |
|
break; |
7119 |
|
case 285: // --miplib-trick-subs=N |
7120 |
|
assign(options::arithMLTrickSubstitutions, option, optionarg); |
7121 |
|
break; |
7122 |
|
case 286: // --new-prop |
7123 |
|
assignBool(options::newProp, option, true); |
7124 |
|
break; |
7125 |
8 |
case 287:// --no-new-prop |
7126 |
8 |
assignBool(options::newProp, option, false); |
7127 |
8 |
break; |
7128 |
5 |
case 288: // --nl-cad |
7129 |
5 |
assignBool(options::nlCad, option, true); |
7130 |
5 |
break; |
7131 |
|
case 289:// --no-nl-cad |
7132 |
|
assignBool(options::nlCad, option, false); |
7133 |
|
break; |
7134 |
|
case 290: // --nl-cad-initial |
7135 |
|
assignBool(options::nlCadUseInitial, option, true); |
7136 |
|
break; |
7137 |
|
case 291:// --no-nl-cad-initial |
7138 |
|
assignBool(options::nlCadUseInitial, option, false); |
7139 |
|
break; |
7140 |
|
case 292: // --nl-ext-ent-conf |
7141 |
|
assignBool(options::nlExtEntailConflicts, option, true); |
7142 |
|
break; |
7143 |
|
case 293:// --no-nl-ext-ent-conf |
7144 |
|
assignBool(options::nlExtEntailConflicts, option, false); |
7145 |
|
break; |
7146 |
|
case 294: // --nl-ext-factor |
7147 |
|
assignBool(options::nlExtFactor, option, true); |
7148 |
|
break; |
7149 |
|
case 295:// --no-nl-ext-factor |
7150 |
|
assignBool(options::nlExtFactor, option, false); |
7151 |
|
break; |
7152 |
|
case 296: // --nl-ext-inc-prec |
7153 |
|
assignBool(options::nlExtIncPrecision, option, true); |
7154 |
|
break; |
7155 |
2 |
case 297:// --no-nl-ext-inc-prec |
7156 |
2 |
assignBool(options::nlExtIncPrecision, option, false); |
7157 |
2 |
break; |
7158 |
2 |
case 298: // --nl-ext-purify |
7159 |
2 |
assignBool(options::nlExtPurify, option, true); |
7160 |
2 |
break; |
7161 |
|
case 299:// --no-nl-ext-purify |
7162 |
|
assignBool(options::nlExtPurify, option, false); |
7163 |
|
break; |
7164 |
|
case 300: // --nl-ext-rbound |
7165 |
|
assignBool(options::nlExtResBound, option, true); |
7166 |
|
break; |
7167 |
|
case 301:// --no-nl-ext-rbound |
7168 |
|
assignBool(options::nlExtResBound, option, false); |
7169 |
|
break; |
7170 |
|
case 302: // --nl-ext-rewrite |
7171 |
|
assignBool(options::nlExtRewrites, option, true); |
7172 |
|
break; |
7173 |
|
case 303:// --no-nl-ext-rewrite |
7174 |
|
assignBool(options::nlExtRewrites, option, false); |
7175 |
|
break; |
7176 |
|
case 304: // --nl-ext-split-zero |
7177 |
|
assignBool(options::nlExtSplitZero, option, true); |
7178 |
|
break; |
7179 |
|
case 305:// --no-nl-ext-split-zero |
7180 |
|
assignBool(options::nlExtSplitZero, option, false); |
7181 |
|
break; |
7182 |
|
case 306: // --nl-ext-tf-taylor-deg=N |
7183 |
|
assign(options::nlExtTfTaylorDegree, option, optionarg); |
7184 |
|
break; |
7185 |
39 |
case 307: // --nl-ext-tf-tplanes |
7186 |
39 |
assignBool(options::nlExtTfTangentPlanes, option, true); |
7187 |
39 |
break; |
7188 |
2 |
case 308:// --no-nl-ext-tf-tplanes |
7189 |
2 |
assignBool(options::nlExtTfTangentPlanes, option, false); |
7190 |
2 |
break; |
7191 |
41 |
case 309: // --nl-ext-tplanes |
7192 |
41 |
assignBool(options::nlExtTangentPlanes, option, true); |
7193 |
41 |
break; |
7194 |
|
case 310:// --no-nl-ext-tplanes |
7195 |
|
assignBool(options::nlExtTangentPlanes, option, false); |
7196 |
|
break; |
7197 |
|
case 311: // --nl-ext-tplanes-interleave |
7198 |
|
assignBool(options::nlExtTangentPlanesInterleave, option, true); |
7199 |
|
break; |
7200 |
|
case 312:// --no-nl-ext-tplanes-interleave |
7201 |
|
assignBool(options::nlExtTangentPlanesInterleave, option, false); |
7202 |
|
break; |
7203 |
128 |
case 313: // --nl-ext=MODE |
7204 |
128 |
assign(options::nlExt, option, optionarg); |
7205 |
128 |
break; |
7206 |
2 |
case 314: // --nl-icp |
7207 |
2 |
assignBool(options::nlICP, option, true); |
7208 |
2 |
break; |
7209 |
|
case 315:// --no-nl-icp |
7210 |
|
assignBool(options::nlICP, option, false); |
7211 |
|
break; |
7212 |
10 |
case 316: // --nl-rlv=MODE |
7213 |
10 |
assign(options::nlRlvMode, option, optionarg); |
7214 |
10 |
break; |
7215 |
2 |
case 317: // --pb-rewrites |
7216 |
2 |
assignBool(options::pbRewrites, option, true); |
7217 |
2 |
break; |
7218 |
|
case 318:// --no-pb-rewrites |
7219 |
|
assignBool(options::pbRewrites, option, false); |
7220 |
|
break; |
7221 |
|
case 319: // --pivot-threshold=N |
7222 |
|
assign(options::arithPivotThreshold, option, optionarg); |
7223 |
|
break; |
7224 |
|
case 320: // --pp-assert-max-sub-size=N |
7225 |
|
assign(options::ppAssertMaxSubSize, option, optionarg); |
7226 |
|
break; |
7227 |
|
case 321: // --prop-row-length=N |
7228 |
|
assign(options::arithPropagateMaxLength, option, optionarg); |
7229 |
|
break; |
7230 |
|
case 322: // --replay-early-close-depth=N |
7231 |
|
assign(options::replayEarlyCloseDepths, option, optionarg); |
7232 |
|
break; |
7233 |
|
case 323: // --replay-failure-penalty=N |
7234 |
|
assign(options::replayFailurePenalty, option, optionarg); |
7235 |
|
break; |
7236 |
|
case 324: // --replay-lemma-reject-cut=N |
7237 |
|
assign(options::lemmaRejectCutSize, option, optionarg); |
7238 |
|
break; |
7239 |
|
case 325: // --replay-num-err-penalty=N |
7240 |
|
assign(options::replayNumericFailurePenalty, option, optionarg); |
7241 |
|
break; |
7242 |
|
case 326: // --replay-reject-cut=N |
7243 |
|
assign(options::replayRejectCutSize, option, optionarg); |
7244 |
|
break; |
7245 |
|
case 327: // --replay-soi-major-threshold-pen=N |
7246 |
|
assign(options::soiApproxMajorFailurePen, option, optionarg); |
7247 |
|
break; |
7248 |
|
case 328: // --replay-soi-major-threshold=T |
7249 |
|
assign(options::soiApproxMajorFailure, option, optionarg); |
7250 |
|
break; |
7251 |
|
case 329: // --replay-soi-minor-threshold-pen=N |
7252 |
|
assign(options::soiApproxMinorFailurePen, option, optionarg); |
7253 |
|
break; |
7254 |
|
case 330: // --replay-soi-minor-threshold=T |
7255 |
|
assign(options::soiApproxMinorFailure, option, optionarg); |
7256 |
|
break; |
7257 |
|
case 331: // --restrict-pivots |
7258 |
|
assignBool(options::restrictedPivots, option, true); |
7259 |
|
break; |
7260 |
|
case 332:// --no-restrict-pivots |
7261 |
|
assignBool(options::restrictedPivots, option, false); |
7262 |
|
break; |
7263 |
|
case 333: // --revert-arith-models-on-unsat |
7264 |
|
assignBool(options::revertArithModels, option, true); |
7265 |
|
break; |
7266 |
|
case 334:// --no-revert-arith-models-on-unsat |
7267 |
|
assignBool(options::revertArithModels, option, false); |
7268 |
|
break; |
7269 |
|
case 335: // --rr-turns=N |
7270 |
|
assign(options::rrTurns, option, optionarg); |
7271 |
|
break; |
7272 |
|
case 336: // --se-solve-int |
7273 |
|
assignBool(options::trySolveIntStandardEffort, option, true); |
7274 |
|
break; |
7275 |
|
case 337:// --no-se-solve-int |
7276 |
|
assignBool(options::trySolveIntStandardEffort, option, false); |
7277 |
|
break; |
7278 |
|
case 338: // --simplex-check-period=N |
7279 |
|
assign(options::arithSimplexCheckPeriod, option, optionarg); |
7280 |
|
break; |
7281 |
|
case 339: // --soi-qe |
7282 |
|
assignBool(options::soiQuickExplain, option, true); |
7283 |
|
break; |
7284 |
|
case 340:// --no-soi-qe |
7285 |
|
assignBool(options::soiQuickExplain, option, false); |
7286 |
|
break; |
7287 |
|
case 341: // --standard-effort-variable-order-pivots=N |
7288 |
|
assign(options::arithStandardCheckVarOrderPivots, option, optionarg); |
7289 |
|
break; |
7290 |
|
case 342: // --unate-lemmas=MODE |
7291 |
|
assign(options::arithUnateLemmaMode, option, optionarg); |
7292 |
|
break; |
7293 |
|
case 343: // --use-approx |
7294 |
|
assignBool(options::useApprox, option, true); |
7295 |
|
break; |
7296 |
|
case 344:// --no-use-approx |
7297 |
|
assignBool(options::useApprox, option, false); |
7298 |
|
break; |
7299 |
|
case 345: // --use-fcsimplex |
7300 |
|
assignBool(options::useFC, option, true); |
7301 |
|
break; |
7302 |
|
case 346:// --no-use-fcsimplex |
7303 |
|
assignBool(options::useFC, option, false); |
7304 |
|
break; |
7305 |
|
case 347: // --use-soi |
7306 |
|
assignBool(options::useSOI, option, true); |
7307 |
|
break; |
7308 |
|
case 348:// --no-use-soi |
7309 |
|
assignBool(options::useSOI, option, false); |
7310 |
|
break; |
7311 |
|
case 349: // --arrays-config=N |
7312 |
|
assign(options::arraysConfig, option, optionarg); |
7313 |
|
break; |
7314 |
|
case 350: // --arrays-eager-index |
7315 |
|
assignBool(options::arraysEagerIndexSplitting, option, true); |
7316 |
|
break; |
7317 |
|
case 351:// --no-arrays-eager-index |
7318 |
|
assignBool(options::arraysEagerIndexSplitting, option, false); |
7319 |
|
break; |
7320 |
|
case 352: // --arrays-eager-lemmas |
7321 |
|
assignBool(options::arraysEagerLemmas, option, true); |
7322 |
|
break; |
7323 |
|
case 353:// --no-arrays-eager-lemmas |
7324 |
|
assignBool(options::arraysEagerLemmas, option, false); |
7325 |
|
break; |
7326 |
3 |
case 354: // --arrays-exp |
7327 |
3 |
assignBool(options::arraysExp, option, true); |
7328 |
3 |
break; |
7329 |
|
case 355:// --no-arrays-exp |
7330 |
|
assignBool(options::arraysExp, option, false); |
7331 |
|
break; |
7332 |
|
case 356: // --arrays-model-based |
7333 |
|
assignBool(options::arraysModelBased, option, true); |
7334 |
|
break; |
7335 |
|
case 357:// --no-arrays-model-based |
7336 |
|
assignBool(options::arraysModelBased, option, false); |
7337 |
|
break; |
7338 |
|
case 358: // --arrays-optimize-linear |
7339 |
|
assignBool(options::arraysOptimizeLinear, option, true); |
7340 |
|
break; |
7341 |
|
case 359:// --no-arrays-optimize-linear |
7342 |
|
assignBool(options::arraysOptimizeLinear, option, false); |
7343 |
|
break; |
7344 |
|
case 360: // --arrays-prop=N |
7345 |
|
assign(options::arraysPropagate, option, optionarg); |
7346 |
|
break; |
7347 |
|
case 361: // --arrays-reduce-sharing |
7348 |
|
assignBool(options::arraysReduceSharing, option, true); |
7349 |
|
break; |
7350 |
|
case 362:// --no-arrays-reduce-sharing |
7351 |
|
assignBool(options::arraysReduceSharing, option, false); |
7352 |
|
break; |
7353 |
|
case 363: // --arrays-weak-equiv |
7354 |
|
assignBool(options::arraysWeakEquivalence, option, true); |
7355 |
|
break; |
7356 |
|
case 364:// --no-arrays-weak-equiv |
7357 |
|
assignBool(options::arraysWeakEquivalence, option, false); |
7358 |
|
break; |
7359 |
|
case 'd': |
7360 |
|
case 365: // --debug=TAG |
7361 |
|
d_handler->enableDebugTag(option, optionarg); |
7362 |
|
break; |
7363 |
224 |
case 'L': |
7364 |
|
case 366: // --lang=LANG |
7365 |
|
case 367: // --input-language |
7366 |
224 |
assign(options::inputLanguage, option, optionarg); |
7367 |
224 |
break; |
7368 |
62 |
case 368: // --output-lang=LANG |
7369 |
|
case 369: // --output-language |
7370 |
62 |
assign(options::outputLanguage, option, optionarg); |
7371 |
62 |
break; |
7372 |
|
case 370: // --parse-only |
7373 |
|
assignBool(options::parseOnly, option, true); |
7374 |
|
break; |
7375 |
|
case 371:// --no-parse-only |
7376 |
|
assignBool(options::parseOnly, option, false); |
7377 |
|
break; |
7378 |
3 |
case 372: // --preprocess-only |
7379 |
3 |
assignBool(options::preprocessOnly, option, true); |
7380 |
3 |
break; |
7381 |
|
case 373:// --no-preprocess-only |
7382 |
|
assignBool(options::preprocessOnly, option, false); |
7383 |
|
break; |
7384 |
2 |
case 374: // --print-success |
7385 |
2 |
assignBool(options::printSuccess, option, true); |
7386 |
2 |
break; |
7387 |
|
case 375:// --no-print-success |
7388 |
|
assignBool(options::printSuccess, option, false); |
7389 |
|
break; |
7390 |
162 |
case 'q': |
7391 |
|
case 376: // --quiet |
7392 |
162 |
d_handler->decreaseVerbosity(option); |
7393 |
162 |
break; |
7394 |
|
case 377: // --stats |
7395 |
|
assignBool(options::statistics, option, true); |
7396 |
|
break; |
7397 |
|
case 378:// --no-stats |
7398 |
|
assignBool(options::statistics, option, false); |
7399 |
|
break; |
7400 |
|
case 379: // --stats-all |
7401 |
|
assignBool(options::statisticsAll, option, true); |
7402 |
|
break; |
7403 |
|
case 380:// --no-stats-all |
7404 |
|
assignBool(options::statisticsAll, option, false); |
7405 |
|
break; |
7406 |
|
case 381: // --stats-every-query |
7407 |
|
assignBool(options::statisticsEveryQuery, option, true); |
7408 |
|
break; |
7409 |
|
case 382:// --no-stats-every-query |
7410 |
|
assignBool(options::statisticsEveryQuery, option, false); |
7411 |
|
break; |
7412 |
|
case 383: // --stats-expert |
7413 |
|
assignBool(options::statisticsExpert, option, true); |
7414 |
|
break; |
7415 |
|
case 384:// --no-stats-expert |
7416 |
|
assignBool(options::statisticsExpert, option, false); |
7417 |
|
break; |
7418 |
|
case 't': |
7419 |
|
case 385: // --trace=TAG |
7420 |
|
d_handler->enableTraceTag(option, optionarg); |
7421 |
|
break; |
7422 |
3 |
case 'v': |
7423 |
|
case 386: // --verbose |
7424 |
3 |
d_handler->increaseVerbosity(option); |
7425 |
3 |
break; |
7426 |
|
case 387: // --verbosity=N |
7427 |
|
assign(options::verbosity, option, optionarg); |
7428 |
|
break; |
7429 |
|
case 388: // --bitblast-aig |
7430 |
|
assignBool(options::bitvectorAig, option, true); |
7431 |
|
break; |
7432 |
|
case 389:// --no-bitblast-aig |
7433 |
|
assignBool(options::bitvectorAig, option, false); |
7434 |
|
break; |
7435 |
36 |
case 390: // --bitblast=MODE |
7436 |
36 |
assign(options::bitblastMode, option, optionarg); |
7437 |
36 |
break; |
7438 |
|
case 391: // --bitwise-eq |
7439 |
|
assignBool(options::bitwiseEq, option, true); |
7440 |
|
break; |
7441 |
|
case 392:// --no-bitwise-eq |
7442 |
|
assignBool(options::bitwiseEq, option, false); |
7443 |
|
break; |
7444 |
12 |
case 393: // --bool-to-bv=MODE |
7445 |
12 |
assign(options::boolToBitvector, option, optionarg); |
7446 |
12 |
break; |
7447 |
4 |
case 394: // --bv-abstraction |
7448 |
4 |
assignBool(options::bvAbstraction, option, true); |
7449 |
4 |
break; |
7450 |
|
case 395:// --no-bv-abstraction |
7451 |
|
assignBool(options::bvAbstraction, option, false); |
7452 |
|
break; |
7453 |
|
case 396: // --bv-aig-simp=COMMAND |
7454 |
|
assign(options::bitvectorAigSimplifications, option, optionarg); |
7455 |
|
break; |
7456 |
|
case 397: // --bv-alg-extf |
7457 |
|
assignBool(options::bvAlgExtf, option, true); |
7458 |
|
break; |
7459 |
|
case 398:// --no-bv-alg-extf |
7460 |
|
assignBool(options::bvAlgExtf, option, false); |
7461 |
|
break; |
7462 |
|
case 399: // --bv-algebraic-budget=N |
7463 |
|
assign(options::bitvectorAlgebraicBudget, option, optionarg); |
7464 |
|
break; |
7465 |
|
case 400: // --bv-algebraic-solver |
7466 |
|
assignBool(options::bitvectorAlgebraicSolver, option, true); |
7467 |
|
break; |
7468 |
|
case 401:// --no-bv-algebraic-solver |
7469 |
|
assignBool(options::bitvectorAlgebraicSolver, option, false); |
7470 |
|
break; |
7471 |
|
case 402: // --bv-assert-input |
7472 |
|
assignBool(options::bvAssertInput, option, true); |
7473 |
|
break; |
7474 |
|
case 403:// --no-bv-assert-input |
7475 |
|
assignBool(options::bvAssertInput, option, false); |
7476 |
|
break; |
7477 |
|
case 404: // --bv-eager-explanations |
7478 |
|
assignBool(options::bvEagerExplanations, option, true); |
7479 |
|
break; |
7480 |
|
case 405:// --no-bv-eager-explanations |
7481 |
|
assignBool(options::bvEagerExplanations, option, false); |
7482 |
|
break; |
7483 |
|
case 406: // --bv-eq-solver |
7484 |
|
assignBool(options::bitvectorEqualitySolver, option, true); |
7485 |
|
break; |
7486 |
2 |
case 407:// --no-bv-eq-solver |
7487 |
2 |
assignBool(options::bitvectorEqualitySolver, option, false); |
7488 |
2 |
break; |
7489 |
|
case 408: // --bv-extract-arith |
7490 |
|
assignBool(options::bvExtractArithRewrite, option, true); |
7491 |
|
break; |
7492 |
|
case 409:// --no-bv-extract-arith |
7493 |
|
assignBool(options::bvExtractArithRewrite, option, false); |
7494 |
|
break; |
7495 |
|
case 410: // --bv-gauss-elim |
7496 |
|
assignBool(options::bvGaussElim, option, true); |
7497 |
|
break; |
7498 |
|
case 411:// --no-bv-gauss-elim |
7499 |
|
assignBool(options::bvGaussElim, option, false); |
7500 |
|
break; |
7501 |
|
case 412: // --bv-inequality-solver |
7502 |
|
assignBool(options::bitvectorInequalitySolver, option, true); |
7503 |
|
break; |
7504 |
|
case 413:// --no-bv-inequality-solver |
7505 |
|
assignBool(options::bitvectorInequalitySolver, option, false); |
7506 |
|
break; |
7507 |
2 |
case 414: // --bv-intro-pow2 |
7508 |
2 |
assignBool(options::bvIntroducePow2, option, true); |
7509 |
2 |
break; |
7510 |
|
case 415:// --no-bv-intro-pow2 |
7511 |
|
assignBool(options::bvIntroducePow2, option, false); |
7512 |
|
break; |
7513 |
|
case 416: // --bv-lazy-reduce-extf |
7514 |
|
assignBool(options::bvLazyReduceExtf, option, true); |
7515 |
|
break; |
7516 |
|
case 417:// --no-bv-lazy-reduce-extf |
7517 |
|
assignBool(options::bvLazyReduceExtf, option, false); |
7518 |
|
break; |
7519 |
|
case 418: // --bv-lazy-rewrite-extf |
7520 |
|
assignBool(options::bvLazyRewriteExtf, option, true); |
7521 |
|
break; |
7522 |
|
case 419:// --no-bv-lazy-rewrite-extf |
7523 |
|
assignBool(options::bvLazyRewriteExtf, option, false); |
7524 |
|
break; |
7525 |
|
case 420: // --bv-num-func=N |
7526 |
|
assign(options::bvNumFunc, option, optionarg); |
7527 |
|
break; |
7528 |
2 |
case 421: // --bv-print-consts-as-indexed-symbols |
7529 |
2 |
assignBool(options::bvPrintConstsAsIndexedSymbols, option, true); |
7530 |
2 |
break; |
7531 |
|
case 422:// --no-bv-print-consts-as-indexed-symbols |
7532 |
|
assignBool(options::bvPrintConstsAsIndexedSymbols, option, false); |
7533 |
|
break; |
7534 |
|
case 423: // --bv-propagate |
7535 |
|
assignBool(options::bitvectorPropagate, option, true); |
7536 |
|
break; |
7537 |
|
case 424:// --no-bv-propagate |
7538 |
|
assignBool(options::bitvectorPropagate, option, false); |
7539 |
|
break; |
7540 |
|
case 425: // --bv-quick-xplain |
7541 |
|
assignBool(options::bitvectorQuickXplain, option, true); |
7542 |
|
break; |
7543 |
|
case 426:// --no-bv-quick-xplain |
7544 |
|
assignBool(options::bitvectorQuickXplain, option, false); |
7545 |
|
break; |
7546 |
14 |
case 427: // --bv-sat-solver=MODE |
7547 |
14 |
assign(options::bvSatSolver, option, optionarg); |
7548 |
14 |
break; |
7549 |
|
case 428: // --bv-skolemize |
7550 |
|
assignBool(options::skolemizeArguments, option, true); |
7551 |
|
break; |
7552 |
|
case 429:// --no-bv-skolemize |
7553 |
|
assignBool(options::skolemizeArguments, option, false); |
7554 |
|
break; |
7555 |
14 |
case 430: // --bv-solver=MODE |
7556 |
14 |
assign(options::bvSolver, option, optionarg); |
7557 |
14 |
break; |
7558 |
10 |
case 431: // --bv-to-bool |
7559 |
10 |
assignBool(options::bitvectorToBool, option, true); |
7560 |
10 |
break; |
7561 |
|
case 432:// --no-bv-to-bool |
7562 |
|
assignBool(options::bitvectorToBool, option, false); |
7563 |
|
break; |
7564 |
|
case 433: // --cdt-bisimilar |
7565 |
|
assignBool(options::cdtBisimilar, option, true); |
7566 |
|
break; |
7567 |
|
case 434:// --no-cdt-bisimilar |
7568 |
|
assignBool(options::cdtBisimilar, option, false); |
7569 |
|
break; |
7570 |
|
case 435: // --dt-binary-split |
7571 |
|
assignBool(options::dtBinarySplit, option, true); |
7572 |
|
break; |
7573 |
|
case 436:// --no-dt-binary-split |
7574 |
|
assignBool(options::dtBinarySplit, option, false); |
7575 |
|
break; |
7576 |
|
case 437: // --dt-blast-splits |
7577 |
|
assignBool(options::dtBlastSplits, option, true); |
7578 |
|
break; |
7579 |
|
case 438:// --no-dt-blast-splits |
7580 |
|
assignBool(options::dtBlastSplits, option, false); |
7581 |
|
break; |
7582 |
|
case 439: // --dt-cyclic |
7583 |
|
assignBool(options::dtCyclic, option, true); |
7584 |
|
break; |
7585 |
|
case 440:// --no-dt-cyclic |
7586 |
|
assignBool(options::dtCyclic, option, false); |
7587 |
|
break; |
7588 |
|
case 441: // --dt-force-assignment |
7589 |
|
assignBool(options::dtForceAssignment, option, true); |
7590 |
|
break; |
7591 |
|
case 442:// --no-dt-force-assignment |
7592 |
|
assignBool(options::dtForceAssignment, option, false); |
7593 |
|
break; |
7594 |
|
case 443: // --dt-infer-as-lemmas |
7595 |
|
assignBool(options::dtInferAsLemmas, option, true); |
7596 |
|
break; |
7597 |
|
case 444:// --no-dt-infer-as-lemmas |
7598 |
|
assignBool(options::dtInferAsLemmas, option, false); |
7599 |
|
break; |
7600 |
10 |
case 445: // --dt-nested-rec |
7601 |
10 |
assignBool(options::dtNestedRec, option, true); |
7602 |
10 |
break; |
7603 |
|
case 446:// --no-dt-nested-rec |
7604 |
|
assignBool(options::dtNestedRec, option, false); |
7605 |
|
break; |
7606 |
|
case 447: // --dt-polite-optimize |
7607 |
|
assignBool(options::dtPoliteOptimize, option, true); |
7608 |
|
break; |
7609 |
|
case 448:// --no-dt-polite-optimize |
7610 |
|
assignBool(options::dtPoliteOptimize, option, false); |
7611 |
|
break; |
7612 |
5 |
case 449: // --dt-rewrite-error-sel |
7613 |
5 |
assignBool(options::dtRewriteErrorSel, option, true); |
7614 |
5 |
break; |
7615 |
|
case 450:// --no-dt-rewrite-error-sel |
7616 |
|
assignBool(options::dtRewriteErrorSel, option, false); |
7617 |
|
break; |
7618 |
|
case 451: // --dt-share-sel |
7619 |
|
assignBool(options::dtSharedSelectors, option, true); |
7620 |
|
break; |
7621 |
|
case 452:// --no-dt-share-sel |
7622 |
|
assignBool(options::dtSharedSelectors, option, false); |
7623 |
|
break; |
7624 |
11 |
case 453: // --sygus-abort-size=N |
7625 |
11 |
assign(options::sygusAbortSize, option, optionarg); |
7626 |
11 |
break; |
7627 |
|
case 454: // --sygus-fair-max |
7628 |
|
assignBool(options::sygusFairMax, option, true); |
7629 |
|
break; |
7630 |
|
case 455:// --no-sygus-fair-max |
7631 |
|
assignBool(options::sygusFairMax, option, false); |
7632 |
|
break; |
7633 |
2 |
case 456: // --sygus-fair=MODE |
7634 |
2 |
assign(options::sygusFair, option, optionarg); |
7635 |
2 |
break; |
7636 |
|
case 457: // --sygus-sym-break |
7637 |
|
assignBool(options::sygusSymBreak, option, true); |
7638 |
|
break; |
7639 |
6 |
case 458:// --no-sygus-sym-break |
7640 |
6 |
assignBool(options::sygusSymBreak, option, false); |
7641 |
6 |
break; |
7642 |
|
case 459: // --sygus-sym-break-agg |
7643 |
|
assignBool(options::sygusSymBreakAgg, option, true); |
7644 |
|
break; |
7645 |
|
case 460:// --no-sygus-sym-break-agg |
7646 |
|
assignBool(options::sygusSymBreakAgg, option, false); |
7647 |
|
break; |
7648 |
|
case 461: // --sygus-sym-break-dynamic |
7649 |
|
assignBool(options::sygusSymBreakDynamic, option, true); |
7650 |
|
break; |
7651 |
|
case 462:// --no-sygus-sym-break-dynamic |
7652 |
|
assignBool(options::sygusSymBreakDynamic, option, false); |
7653 |
|
break; |
7654 |
|
case 463: // --sygus-sym-break-lazy |
7655 |
|
assignBool(options::sygusSymBreakLazy, option, true); |
7656 |
|
break; |
7657 |
|
case 464:// --no-sygus-sym-break-lazy |
7658 |
|
assignBool(options::sygusSymBreakLazy, option, false); |
7659 |
|
break; |
7660 |
|
case 465: // --sygus-sym-break-pbe |
7661 |
|
assignBool(options::sygusSymBreakPbe, option, true); |
7662 |
|
break; |
7663 |
|
case 466:// --no-sygus-sym-break-pbe |
7664 |
|
assignBool(options::sygusSymBreakPbe, option, false); |
7665 |
|
break; |
7666 |
|
case 467: // --sygus-sym-break-rlv |
7667 |
|
assignBool(options::sygusSymBreakRlv, option, true); |
7668 |
|
break; |
7669 |
|
case 468:// --no-sygus-sym-break-rlv |
7670 |
|
assignBool(options::sygusSymBreakRlv, option, false); |
7671 |
|
break; |
7672 |
|
case 469: // --decision-random-weight=N |
7673 |
|
assign(options::decisionRandomWeight, option, optionarg); |
7674 |
|
break; |
7675 |
|
case 470: // --decision-threshold=N |
7676 |
|
assign(options::decisionThreshold, option, optionarg); |
7677 |
|
break; |
7678 |
|
case 471: // --decision-use-weight |
7679 |
|
assignBool(options::decisionUseWeight, option, true); |
7680 |
|
break; |
7681 |
|
case 472:// --no-decision-use-weight |
7682 |
|
assignBool(options::decisionUseWeight, option, false); |
7683 |
|
break; |
7684 |
|
case 473: // --decision-weight-internal=HOW |
7685 |
|
assign(options::decisionWeightInternal, option, optionarg); |
7686 |
|
break; |
7687 |
68 |
case 474: // --decision=MODE |
7688 |
|
case 475: // --decision-mode |
7689 |
68 |
assign(options::decisionMode, option, optionarg); |
7690 |
68 |
break; |
7691 |
1 |
case 476: // --dag-thresh=N |
7692 |
1 |
assign(options::defaultDagThresh, option, optionarg); |
7693 |
1 |
break; |
7694 |
|
case 477: // --expr-depth=N |
7695 |
|
assign(options::defaultExprDepth, option, optionarg); |
7696 |
|
break; |
7697 |
|
case 478: // --type-checking |
7698 |
|
assignBool(options::typeChecking, option, true); |
7699 |
|
break; |
7700 |
|
case 479:// --no-type-checking |
7701 |
|
assignBool(options::typeChecking, option, false); |
7702 |
|
break; |
7703 |
22 |
case 480: // --fp-exp |
7704 |
22 |
assignBool(options::fpExp, option, true); |
7705 |
22 |
break; |
7706 |
|
case 481:// --no-fp-exp |
7707 |
|
assignBool(options::fpExp, option, false); |
7708 |
|
break; |
7709 |
|
case 482: // --copyright |
7710 |
|
d_handler->copyright(option); |
7711 |
|
break; |
7712 |
|
case 483: // --early-exit |
7713 |
|
assignBool(options::earlyExit, option, true); |
7714 |
|
break; |
7715 |
|
case 484:// --no-early-exit |
7716 |
|
assignBool(options::earlyExit, option, false); |
7717 |
|
break; |
7718 |
|
case 'h': |
7719 |
|
case 485: // --help |
7720 |
|
assignBool(options::help, option, true); |
7721 |
|
break; |
7722 |
|
case 486: // --interactive |
7723 |
|
assignBool(options::interactive, option, true); |
7724 |
|
break; |
7725 |
|
case 487:// --no-interactive |
7726 |
|
assignBool(options::interactive, option, false); |
7727 |
|
break; |
7728 |
|
case 488: // --interactive-prompt |
7729 |
|
assignBool(options::interactivePrompt, option, true); |
7730 |
|
break; |
7731 |
|
case 489:// --no-interactive-prompt |
7732 |
|
assignBool(options::interactivePrompt, option, false); |
7733 |
|
break; |
7734 |
|
case 's': |
7735 |
|
case 490: // --seed=N |
7736 |
|
assign(options::seed, option, optionarg); |
7737 |
|
break; |
7738 |
|
case 491: // --segv-spin |
7739 |
|
assignBool(options::segvSpin, option, true); |
7740 |
|
break; |
7741 |
|
case 492:// --no-segv-spin |
7742 |
|
assignBool(options::segvSpin, option, false); |
7743 |
|
break; |
7744 |
2504 |
case 493: // --show-config |
7745 |
2504 |
d_handler->showConfiguration(option); |
7746 |
|
break; |
7747 |
|
case 494: // --show-debug-tags |
7748 |
|
d_handler->showDebugTags(option); |
7749 |
|
break; |
7750 |
|
case 495: // --show-trace-tags |
7751 |
|
d_handler->showTraceTags(option); |
7752 |
|
break; |
7753 |
|
case 496: // --tear-down-incremental=N |
7754 |
|
assign(options::tearDownIncremental, option, optionarg); |
7755 |
|
break; |
7756 |
|
case 'V': |
7757 |
|
case 497: // --version |
7758 |
|
assignBool(options::version, option, true); |
7759 |
|
break; |
7760 |
|
case 498: // --filesystem-access |
7761 |
|
assignBool(options::filesystemAccess, option, true); |
7762 |
|
break; |
7763 |
|
case 499:// --no-filesystem-access |
7764 |
|
assignBool(options::filesystemAccess, option, false); |
7765 |
|
break; |
7766 |
9 |
case 500: // --force-logic=LOGIC |
7767 |
9 |
assign(options::forceLogicString, option, optionarg); |
7768 |
9 |
break; |
7769 |
|
case 501: // --global-declarations |
7770 |
17 |
assignBool(options::globalDeclarations, option, true); |
7771 |
|
break; |
7772 |
|
case 502:// --no-global-declarations |
7773 |
|
assignBool(options::globalDeclarations, option, false); |
7774 |
|
break; |
7775 |
|
case 503: // --mmap |
7776 |
|
assignBool(options::memoryMap, option, true); |
7777 |
|
break; |
7778 |
|
case 504:// --no-mmap |
7779 |
|
assignBool(options::memoryMap, option, false); |
7780 |
|
break; |
7781 |
|
case 505: // --semantic-checks |
7782 |
|
assignBool(options::semanticChecks, option, true); |
7783 |
|
break; |
7784 |
|
case 506:// --no-semantic-checks |
7785 |
|
assignBool(options::semanticChecks, option, false); |
7786 |
|
break; |
7787 |
9 |
case 507: // --strict-parsing |
7788 |
9 |
assignBool(options::strictParsing, option, true); |
7789 |
9 |
break; |
7790 |
|
case 508:// --no-strict-parsing |
7791 |
|
assignBool(options::strictParsing, option, false); |
7792 |
|
break; |
7793 |
|
case 509: // --flatten-ho-chains |
7794 |
|
assignBool(options::flattenHOChains, option, true); |
7795 |
|
break; |
7796 |
|
case 510:// --no-flatten-ho-chains |
7797 |
|
assignBool(options::flattenHOChains, option, false); |
7798 |
|
break; |
7799 |
|
case 511: // --inst-format=MODE |
7800 |
|
assign(options::instFormatMode, option, optionarg); |
7801 |
|
break; |
7802 |
|
case 512: // --model-format=MODE |
7803 |
|
assign(options::modelFormatMode, option, optionarg); |
7804 |
|
break; |
7805 |
9 |
case 513: // --print-inst-full |
7806 |
9 |
assignBool(options::printInstFull, option, true); |
7807 |
9 |
break; |
7808 |
3 |
case 514:// --no-print-inst-full |
7809 |
3 |
assignBool(options::printInstFull, option, false); |
7810 |
3 |
break; |
7811 |
3 |
case 515: // --print-inst=MODE |
7812 |
3 |
assign(options::printInstMode, option, optionarg); |
7813 |
3 |
break; |
7814 |
2 |
case 516: // --proof-eager-checking |
7815 |
2 |
assignBool(options::proofEagerChecking, option, true); |
7816 |
2 |
break; |
7817 |
|
case 517:// --no-proof-eager-checking |
7818 |
|
assignBool(options::proofEagerChecking, option, false); |
7819 |
|
break; |
7820 |
|
case 518: // --proof-format-mode=MODE |
7821 |
|
assign(options::proofFormatMode, option, optionarg); |
7822 |
|
break; |
7823 |
|
case 519: // --proof-granularity=MODE |
7824 |
|
assign(options::proofGranularityMode, option, optionarg); |
7825 |
|
break; |
7826 |
|
case 520: // --proof-pedantic=N |
7827 |
|
assign(options::proofPedantic, option, optionarg); |
7828 |
|
break; |
7829 |
|
case 521: // --proof-print-conclusion |
7830 |
|
assignBool(options::proofPrintConclusion, option, true); |
7831 |
|
break; |
7832 |
|
case 522:// --no-proof-print-conclusion |
7833 |
|
assignBool(options::proofPrintConclusion, option, false); |
7834 |
|
break; |
7835 |
|
case 523: // --minisat-dump-dimacs |
7836 |
|
assignBool(options::minisatDumpDimacs, option, true); |
7837 |
|
break; |
7838 |
|
case 524:// --no-minisat-dump-dimacs |
7839 |
|
assignBool(options::minisatDumpDimacs, option, false); |
7840 |
|
break; |
7841 |
|
case 525: // --minisat-elimination |
7842 |
|
assignBool(options::minisatUseElim, option, true); |
7843 |
|
break; |
7844 |
|
case 526:// --no-minisat-elimination |
7845 |
|
assignBool(options::minisatUseElim, option, false); |
7846 |
|
break; |
7847 |
|
case 527: // --random-freq=P |
7848 |
|
case 528: // --random-frequency |
7849 |
|
assign(options::satRandomFreq, option, optionarg); |
7850 |
|
break; |
7851 |
|
case 529: // --random-seed=S |
7852 |
|
assign(options::satRandomSeed, option, optionarg); |
7853 |
|
break; |
7854 |
|
case 530: // --refine-conflicts |
7855 |
|
assignBool(options::sat_refine_conflicts, option, true); |
7856 |
|
break; |
7857 |
|
case 531:// --no-refine-conflicts |
7858 |
|
assignBool(options::sat_refine_conflicts, option, false); |
7859 |
|
break; |
7860 |
|
case 532: // --restart-int-base=N |
7861 |
|
assign(options::satRestartFirst, option, optionarg); |
7862 |
|
break; |
7863 |
|
case 533: // --restart-int-inc=F |
7864 |
|
assign(options::satRestartInc, option, optionarg); |
7865 |
|
break; |
7866 |
|
case 534: // --ag-miniscope-quant |
7867 |
|
assignBool(options::aggressiveMiniscopeQuant, option, true); |
7868 |
|
break; |
7869 |
|
case 535:// --no-ag-miniscope-quant |
7870 |
|
assignBool(options::aggressiveMiniscopeQuant, option, false); |
7871 |
|
break; |
7872 |
2 |
case 536: // --cegis-sample=MODE |
7873 |
2 |
assign(options::cegisSample, option, optionarg); |
7874 |
2 |
break; |
7875 |
17 |
case 537: // --cegqi |
7876 |
17 |
assignBool(options::cegqi, option, true); |
7877 |
17 |
break; |
7878 |
2 |
case 538:// --no-cegqi |
7879 |
2 |
assignBool(options::cegqi, option, false); |
7880 |
2 |
break; |
7881 |
15 |
case 539: // --cegqi-all |
7882 |
15 |
assignBool(options::cegqiAll, option, true); |
7883 |
15 |
break; |
7884 |
|
case 540:// --no-cegqi-all |
7885 |
|
assignBool(options::cegqiAll, option, false); |
7886 |
|
break; |
7887 |
106 |
case 541: // --cegqi-bv |
7888 |
106 |
assignBool(options::cegqiBv, option, true); |
7889 |
106 |
break; |
7890 |
|
case 542:// --no-cegqi-bv |
7891 |
|
assignBool(options::cegqiBv, option, false); |
7892 |
|
break; |
7893 |
|
case 543: // --cegqi-bv-concat-inv |
7894 |
|
assignBool(options::cegqiBvConcInv, option, true); |
7895 |
|
break; |
7896 |
|
case 544:// --no-cegqi-bv-concat-inv |
7897 |
|
assignBool(options::cegqiBvConcInv, option, false); |
7898 |
|
break; |
7899 |
82 |
case 545: // --cegqi-bv-ineq=MODE |
7900 |
82 |
assign(options::cegqiBvIneqMode, option, optionarg); |
7901 |
82 |
break; |
7902 |
|
case 546: // --cegqi-bv-interleave-value |
7903 |
|
assignBool(options::cegqiBvInterleaveValue, option, true); |
7904 |
|
break; |
7905 |
|
case 547:// --no-cegqi-bv-interleave-value |
7906 |
|
assignBool(options::cegqiBvInterleaveValue, option, false); |
7907 |
|
break; |
7908 |
|
case 548: // --cegqi-bv-linear |
7909 |
|
assignBool(options::cegqiBvLinearize, option, true); |
7910 |
|
break; |
7911 |
|
case 549:// --no-cegqi-bv-linear |
7912 |
|
assignBool(options::cegqiBvLinearize, option, false); |
7913 |
|
break; |
7914 |
2 |
case 550: // --cegqi-bv-rm-extract |
7915 |
2 |
assignBool(options::cegqiBvRmExtract, option, true); |
7916 |
2 |
break; |
7917 |
|
case 551:// --no-cegqi-bv-rm-extract |
7918 |
|
assignBool(options::cegqiBvRmExtract, option, false); |
7919 |
|
break; |
7920 |
|
case 552: // --cegqi-bv-solve-nl |
7921 |
|
assignBool(options::cegqiBvSolveNl, option, true); |
7922 |
|
break; |
7923 |
|
case 553:// --no-cegqi-bv-solve-nl |
7924 |
|
assignBool(options::cegqiBvSolveNl, option, false); |
7925 |
|
break; |
7926 |
3 |
case 554: // --cegqi-full |
7927 |
3 |
assignBool(options::cegqiFullEffort, option, true); |
7928 |
3 |
break; |
7929 |
82 |
case 555:// --no-cegqi-full |
7930 |
82 |
assignBool(options::cegqiFullEffort, option, false); |
7931 |
82 |
break; |
7932 |
|
case 556: // --cegqi-innermost |
7933 |
|
assignBool(options::cegqiInnermost, option, true); |
7934 |
|
break; |
7935 |
|
case 557:// --no-cegqi-innermost |
7936 |
|
assignBool(options::cegqiInnermost, option, false); |
7937 |
|
break; |
7938 |
|
case 558: // --cegqi-midpoint |
7939 |
|
assignBool(options::cegqiMidpoint, option, true); |
7940 |
|
break; |
7941 |
|
case 559:// --no-cegqi-midpoint |
7942 |
|
assignBool(options::cegqiMidpoint, option, false); |
7943 |
|
break; |
7944 |
|
case 560: // --cegqi-min-bounds |
7945 |
|
assignBool(options::cegqiMinBounds, option, true); |
7946 |
|
break; |
7947 |
|
case 561:// --no-cegqi-min-bounds |
7948 |
|
assignBool(options::cegqiMinBounds, option, false); |
7949 |
|
break; |
7950 |
|
case 562: // --cegqi-model |
7951 |
|
assignBool(options::cegqiModel, option, true); |
7952 |
|
break; |
7953 |
|
case 563:// --no-cegqi-model |
7954 |
|
assignBool(options::cegqiModel, option, false); |
7955 |
|
break; |
7956 |
3 |
case 564: // --cegqi-multi-inst |
7957 |
3 |
assignBool(options::cegqiMultiInst, option, true); |
7958 |
3 |
break; |
7959 |
|
case 565:// --no-cegqi-multi-inst |
7960 |
|
assignBool(options::cegqiMultiInst, option, false); |
7961 |
|
break; |
7962 |
7 |
case 566: // --cegqi-nested-qe |
7963 |
7 |
assignBool(options::cegqiNestedQE, option, true); |
7964 |
7 |
break; |
7965 |
|
case 567:// --no-cegqi-nested-qe |
7966 |
|
assignBool(options::cegqiNestedQE, option, false); |
7967 |
|
break; |
7968 |
|
case 568: // --cegqi-nopt |
7969 |
|
assignBool(options::cegqiNopt, option, true); |
7970 |
|
break; |
7971 |
|
case 569:// --no-cegqi-nopt |
7972 |
|
assignBool(options::cegqiNopt, option, false); |
7973 |
|
break; |
7974 |
|
case 570: // --cegqi-repeat-lit |
7975 |
|
assignBool(options::cegqiRepeatLit, option, true); |
7976 |
|
break; |
7977 |
|
case 571:// --no-cegqi-repeat-lit |
7978 |
|
assignBool(options::cegqiRepeatLit, option, false); |
7979 |
|
break; |
7980 |
|
case 572: // --cegqi-round-up-lia |
7981 |
|
assignBool(options::cegqiRoundUpLowerLia, option, true); |
7982 |
|
break; |
7983 |
|
case 573:// --no-cegqi-round-up-lia |
7984 |
|
assignBool(options::cegqiRoundUpLowerLia, option, false); |
7985 |
|
break; |
7986 |
|
case 574: // --cegqi-sat |
7987 |
|
assignBool(options::cegqiSat, option, true); |
7988 |
|
break; |
7989 |
|
case 575:// --no-cegqi-sat |
7990 |
|
assignBool(options::cegqiSat, option, false); |
7991 |
|
break; |
7992 |
3 |
case 576: // --cegqi-use-inf-int |
7993 |
3 |
assignBool(options::cegqiUseInfInt, option, true); |
7994 |
3 |
break; |
7995 |
|
case 577:// --no-cegqi-use-inf-int |
7996 |
|
assignBool(options::cegqiUseInfInt, option, false); |
7997 |
|
break; |
7998 |
3 |
case 578: // --cegqi-use-inf-real |
7999 |
3 |
assignBool(options::cegqiUseInfReal, option, true); |
8000 |
3 |
break; |
8001 |
|
case 579:// --no-cegqi-use-inf-real |
8002 |
|
assignBool(options::cegqiUseInfReal, option, false); |
8003 |
|
break; |
8004 |
|
case 580: // --cond-var-split-agg-quant |
8005 |
|
assignBool(options::condVarSplitQuantAgg, option, true); |
8006 |
|
break; |
8007 |
|
case 581:// --no-cond-var-split-agg-quant |
8008 |
|
assignBool(options::condVarSplitQuantAgg, option, false); |
8009 |
|
break; |
8010 |
|
case 582: // --cond-var-split-quant |
8011 |
|
assignBool(options::condVarSplitQuant, option, true); |
8012 |
|
break; |
8013 |
|
case 583:// --no-cond-var-split-quant |
8014 |
|
assignBool(options::condVarSplitQuant, option, false); |
8015 |
|
break; |
8016 |
|
case 584: // --conjecture-filter-active-terms |
8017 |
|
assignBool(options::conjectureFilterActiveTerms, option, true); |
8018 |
|
break; |
8019 |
|
case 585:// --no-conjecture-filter-active-terms |
8020 |
|
assignBool(options::conjectureFilterActiveTerms, option, false); |
8021 |
|
break; |
8022 |
|
case 586: // --conjecture-filter-canonical |
8023 |
|
assignBool(options::conjectureFilterCanonical, option, true); |
8024 |
|
break; |
8025 |
|
case 587:// --no-conjecture-filter-canonical |
8026 |
|
assignBool(options::conjectureFilterCanonical, option, false); |
8027 |
|
break; |
8028 |
|
case 588: // --conjecture-filter-model |
8029 |
|
assignBool(options::conjectureFilterModel, option, true); |
8030 |
|
break; |
8031 |
|
case 589:// --no-conjecture-filter-model |
8032 |
|
assignBool(options::conjectureFilterModel, option, false); |
8033 |
|
break; |
8034 |
3 |
case 590: // --conjecture-gen |
8035 |
3 |
assignBool(options::conjectureGen, option, true); |
8036 |
3 |
break; |
8037 |
|
case 591:// --no-conjecture-gen |
8038 |
|
assignBool(options::conjectureGen, option, false); |
8039 |
|
break; |
8040 |
|
case 592: // --conjecture-gen-gt-enum=N |
8041 |
|
assign(options::conjectureGenGtEnum, option, optionarg); |
8042 |
|
break; |
8043 |
|
case 593: // --conjecture-gen-max-depth=N |
8044 |
|
assign(options::conjectureGenMaxDepth, option, optionarg); |
8045 |
|
break; |
8046 |
|
case 594: // --conjecture-gen-per-round=N |
8047 |
|
assign(options::conjectureGenPerRound, option, optionarg); |
8048 |
|
break; |
8049 |
|
case 595: // --conjecture-gen-uee-intro |
8050 |
|
assignBool(options::conjectureUeeIntro, option, true); |
8051 |
|
break; |
8052 |
|
case 596:// --no-conjecture-gen-uee-intro |
8053 |
|
assignBool(options::conjectureUeeIntro, option, false); |
8054 |
|
break; |
8055 |
|
case 597: // --conjecture-no-filter |
8056 |
|
assignBool(options::conjectureNoFilter, option, true); |
8057 |
|
break; |
8058 |
|
case 598:// --no-conjecture-no-filter |
8059 |
|
assignBool(options::conjectureNoFilter, option, false); |
8060 |
|
break; |
8061 |
2 |
case 599: // --debug-inst |
8062 |
2 |
assignBool(options::debugInst, option, true); |
8063 |
2 |
break; |
8064 |
|
case 600:// --no-debug-inst |
8065 |
|
assignBool(options::debugInst, option, false); |
8066 |
|
break; |
8067 |
1 |
case 601: // --debug-sygus |
8068 |
1 |
assignBool(options::debugSygus, option, true); |
8069 |
1 |
break; |
8070 |
|
case 602:// --no-debug-sygus |
8071 |
|
assignBool(options::debugSygus, option, false); |
8072 |
|
break; |
8073 |
|
case 603: // --dt-stc-ind |
8074 |
|
assignBool(options::dtStcInduction, option, true); |
8075 |
|
break; |
8076 |
|
case 604:// --no-dt-stc-ind |
8077 |
|
assignBool(options::dtStcInduction, option, false); |
8078 |
|
break; |
8079 |
|
case 605: // --dt-var-exp-quant |
8080 |
|
assignBool(options::dtVarExpandQuant, option, true); |
8081 |
|
break; |
8082 |
|
case 606:// --no-dt-var-exp-quant |
8083 |
|
assignBool(options::dtVarExpandQuant, option, false); |
8084 |
|
break; |
8085 |
|
case 607: // --e-matching |
8086 |
|
assignBool(options::eMatching, option, true); |
8087 |
|
break; |
8088 |
|
case 608:// --no-e-matching |
8089 |
|
assignBool(options::eMatching, option, false); |
8090 |
|
break; |
8091 |
|
case 609: // --elim-taut-quant |
8092 |
|
assignBool(options::elimTautQuant, option, true); |
8093 |
|
break; |
8094 |
|
case 610:// --no-elim-taut-quant |
8095 |
|
assignBool(options::elimTautQuant, option, false); |
8096 |
|
break; |
8097 |
9 |
case 611: // --ext-rewrite-quant |
8098 |
9 |
assignBool(options::extRewriteQuant, option, true); |
8099 |
9 |
break; |
8100 |
|
case 612:// --no-ext-rewrite-quant |
8101 |
|
assignBool(options::extRewriteQuant, option, false); |
8102 |
|
break; |
8103 |
161 |
case 613: // --finite-model-find |
8104 |
161 |
assignBool(options::finiteModelFind, option, true); |
8105 |
161 |
break; |
8106 |
1 |
case 614:// --no-finite-model-find |
8107 |
1 |
assignBool(options::finiteModelFind, option, false); |
8108 |
1 |
break; |
8109 |
27 |
case 615: // --fmf-bound |
8110 |
27 |
assignBool(options::fmfBound, option, true); |
8111 |
27 |
break; |
8112 |
|
case 616:// --no-fmf-bound |
8113 |
|
assignBool(options::fmfBound, option, false); |
8114 |
|
break; |
8115 |
6 |
case 617: // --fmf-bound-int |
8116 |
6 |
assignBool(options::fmfBoundInt, option, true); |
8117 |
6 |
break; |
8118 |
|
case 618:// --no-fmf-bound-int |
8119 |
|
assignBool(options::fmfBoundInt, option, false); |
8120 |
|
break; |
8121 |
3 |
case 619: // --fmf-bound-lazy |
8122 |
3 |
assignBool(options::fmfBoundLazy, option, true); |
8123 |
3 |
break; |
8124 |
|
case 620:// --no-fmf-bound-lazy |
8125 |
|
assignBool(options::fmfBoundLazy, option, false); |
8126 |
|
break; |
8127 |
|
case 621: // --fmf-fmc-simple |
8128 |
|
assignBool(options::fmfFmcSimple, option, true); |
8129 |
|
break; |
8130 |
|
case 622:// --no-fmf-fmc-simple |
8131 |
|
assignBool(options::fmfFmcSimple, option, false); |
8132 |
|
break; |
8133 |
|
case 623: // --fmf-fresh-dc |
8134 |
|
assignBool(options::fmfFreshDistConst, option, true); |
8135 |
|
break; |
8136 |
|
case 624:// --no-fmf-fresh-dc |
8137 |
|
assignBool(options::fmfFreshDistConst, option, false); |
8138 |
|
break; |
8139 |
35 |
case 625: // --fmf-fun |
8140 |
35 |
assignBool(options::fmfFunWellDefined, option, true); |
8141 |
35 |
break; |
8142 |
|
case 626:// --no-fmf-fun |
8143 |
|
assignBool(options::fmfFunWellDefined, option, false); |
8144 |
|
break; |
8145 |
10 |
case 627: // --fmf-fun-rlv |
8146 |
10 |
assignBool(options::fmfFunWellDefinedRelevant, option, true); |
8147 |
10 |
break; |
8148 |
|
case 628:// --no-fmf-fun-rlv |
8149 |
|
assignBool(options::fmfFunWellDefinedRelevant, option, false); |
8150 |
|
break; |
8151 |
7 |
case 629: // --fmf-inst-engine |
8152 |
7 |
assignBool(options::fmfInstEngine, option, true); |
8153 |
7 |
break; |
8154 |
|
case 630:// --no-fmf-inst-engine |
8155 |
|
assignBool(options::fmfInstEngine, option, false); |
8156 |
|
break; |
8157 |
|
case 631: // --fmf-type-completion-thresh=N |
8158 |
|
assign(options::fmfTypeCompletionThresh, option, optionarg); |
8159 |
|
break; |
8160 |
|
case 632: // --fs-interleave |
8161 |
|
assignBool(options::fullSaturateInterleave, option, true); |
8162 |
|
break; |
8163 |
|
case 633:// --no-fs-interleave |
8164 |
|
assignBool(options::fullSaturateInterleave, option, false); |
8165 |
|
break; |
8166 |
3 |
case 634: // --fs-stratify |
8167 |
3 |
assignBool(options::fullSaturateStratify, option, true); |
8168 |
3 |
break; |
8169 |
|
case 635:// --no-fs-stratify |
8170 |
|
assignBool(options::fullSaturateStratify, option, false); |
8171 |
|
break; |
8172 |
|
case 636: // --fs-sum |
8173 |
|
assignBool(options::fullSaturateSum, option, true); |
8174 |
|
break; |
8175 |
|
case 637:// --no-fs-sum |
8176 |
|
assignBool(options::fullSaturateSum, option, false); |
8177 |
|
break; |
8178 |
65 |
case 638: // --full-saturate-quant |
8179 |
65 |
assignBool(options::fullSaturateQuant, option, true); |
8180 |
65 |
break; |
8181 |
|
case 639:// --no-full-saturate-quant |
8182 |
|
assignBool(options::fullSaturateQuant, option, false); |
8183 |
|
break; |
8184 |
3 |
case 640: // --full-saturate-quant-limit=N |
8185 |
3 |
assign(options::fullSaturateLimit, option, optionarg); |
8186 |
3 |
break; |
8187 |
|
case 641: // --full-saturate-quant-rd |
8188 |
|
assignBool(options::fullSaturateQuantRd, option, true); |
8189 |
|
break; |
8190 |
|
case 642:// --no-full-saturate-quant-rd |
8191 |
|
assignBool(options::fullSaturateQuantRd, option, false); |
8192 |
|
break; |
8193 |
6 |
case 643: // --global-negate |
8194 |
6 |
assignBool(options::globalNegate, option, true); |
8195 |
6 |
break; |
8196 |
|
case 644:// --no-global-negate |
8197 |
|
assignBool(options::globalNegate, option, false); |
8198 |
|
break; |
8199 |
11 |
case 645: // --ho-elim |
8200 |
11 |
assignBool(options::hoElim, option, true); |
8201 |
11 |
break; |
8202 |
|
case 646:// --no-ho-elim |
8203 |
|
assignBool(options::hoElim, option, false); |
8204 |
|
break; |
8205 |
1 |
case 647: // --ho-elim-store-ax |
8206 |
1 |
assignBool(options::hoElimStoreAx, option, true); |
8207 |
1 |
break; |
8208 |
|
case 648:// --no-ho-elim-store-ax |
8209 |
|
assignBool(options::hoElimStoreAx, option, false); |
8210 |
|
break; |
8211 |
|
case 649: // --ho-matching |
8212 |
|
assignBool(options::hoMatching, option, true); |
8213 |
|
break; |
8214 |
|
case 650:// --no-ho-matching |
8215 |
|
assignBool(options::hoMatching, option, false); |
8216 |
|
break; |
8217 |
|
case 651: // --ho-matching-var-priority |
8218 |
|
assignBool(options::hoMatchingVarArgPriority, option, true); |
8219 |
|
break; |
8220 |
|
case 652:// --no-ho-matching-var-priority |
8221 |
|
assignBool(options::hoMatchingVarArgPriority, option, false); |
8222 |
|
break; |
8223 |
|
case 653: // --ho-merge-term-db |
8224 |
|
assignBool(options::hoMergeTermDb, option, true); |
8225 |
|
break; |
8226 |
|
case 654:// --no-ho-merge-term-db |
8227 |
|
assignBool(options::hoMergeTermDb, option, false); |
8228 |
|
break; |
8229 |
|
case 655: // --increment-triggers |
8230 |
|
assignBool(options::incrementTriggers, option, true); |
8231 |
|
break; |
8232 |
|
case 656:// --no-increment-triggers |
8233 |
|
assignBool(options::incrementTriggers, option, false); |
8234 |
|
break; |
8235 |
|
case 657: // --inst-level-input-only |
8236 |
|
assignBool(options::instLevelInputOnly, option, true); |
8237 |
|
break; |
8238 |
|
case 658:// --no-inst-level-input-only |
8239 |
|
assignBool(options::instLevelInputOnly, option, false); |
8240 |
|
break; |
8241 |
3 |
case 659: // --inst-max-level=N |
8242 |
3 |
assign(options::instMaxLevel, option, optionarg); |
8243 |
3 |
break; |
8244 |
|
case 660: // --inst-no-entail |
8245 |
|
assignBool(options::instNoEntail, option, true); |
8246 |
|
break; |
8247 |
|
case 661:// --no-inst-no-entail |
8248 |
|
assignBool(options::instNoEntail, option, false); |
8249 |
|
break; |
8250 |
|
case 662: // --inst-when-phase=N |
8251 |
|
assign(options::instWhenPhase, option, optionarg); |
8252 |
|
break; |
8253 |
|
case 663: // --inst-when-strict-interleave |
8254 |
|
assignBool(options::instWhenStrictInterleave, option, true); |
8255 |
|
break; |
8256 |
|
case 664:// --no-inst-when-strict-interleave |
8257 |
|
assignBool(options::instWhenStrictInterleave, option, false); |
8258 |
|
break; |
8259 |
|
case 665: // --inst-when-tc-first |
8260 |
|
assignBool(options::instWhenTcFirst, option, true); |
8261 |
|
break; |
8262 |
|
case 666:// --no-inst-when-tc-first |
8263 |
|
assignBool(options::instWhenTcFirst, option, false); |
8264 |
|
break; |
8265 |
3 |
case 667: // --inst-when=MODE |
8266 |
3 |
assign(options::instWhenMode, option, optionarg); |
8267 |
3 |
break; |
8268 |
3 |
case 668: // --int-wf-ind |
8269 |
3 |
assignBool(options::intWfInduction, option, true); |
8270 |
3 |
break; |
8271 |
|
case 669:// --no-int-wf-ind |
8272 |
|
assignBool(options::intWfInduction, option, false); |
8273 |
|
break; |
8274 |
|
case 670: // --ite-dtt-split-quant |
8275 |
|
assignBool(options::iteDtTesterSplitQuant, option, true); |
8276 |
|
break; |
8277 |
|
case 671:// --no-ite-dtt-split-quant |
8278 |
|
assignBool(options::iteDtTesterSplitQuant, option, false); |
8279 |
|
break; |
8280 |
|
case 672: // --ite-lift-quant=MODE |
8281 |
|
assign(options::iteLiftQuant, option, optionarg); |
8282 |
|
break; |
8283 |
|
case 673: // --literal-matching=MODE |
8284 |
|
assign(options::literalMatchMode, option, optionarg); |
8285 |
|
break; |
8286 |
17 |
case 674: // --macros-quant |
8287 |
17 |
assignBool(options::macrosQuant, option, true); |
8288 |
17 |
break; |
8289 |
|
case 675:// --no-macros-quant |
8290 |
|
assignBool(options::macrosQuant, option, false); |
8291 |
|
break; |
8292 |
2 |
case 676: // --macros-quant-mode=MODE |
8293 |
2 |
assign(options::macrosQuantMode, option, optionarg); |
8294 |
2 |
break; |
8295 |
|
case 677: // --mbqi-interleave |
8296 |
|
assignBool(options::mbqiInterleave, option, true); |
8297 |
|
break; |
8298 |
|
case 678:// --no-mbqi-interleave |
8299 |
|
assignBool(options::mbqiInterleave, option, false); |
8300 |
|
break; |
8301 |
|
case 679: // --mbqi-one-inst-per-round |
8302 |
|
assignBool(options::fmfOneInstPerRound, option, true); |
8303 |
|
break; |
8304 |
|
case 680:// --no-mbqi-one-inst-per-round |
8305 |
|
assignBool(options::fmfOneInstPerRound, option, false); |
8306 |
|
break; |
8307 |
|
case 681: // --mbqi=MODE |
8308 |
|
assign(options::mbqiMode, option, optionarg); |
8309 |
|
break; |
8310 |
|
case 682: // --miniscope-quant |
8311 |
|
assignBool(options::miniscopeQuant, option, true); |
8312 |
|
break; |
8313 |
|
case 683:// --no-miniscope-quant |
8314 |
|
assignBool(options::miniscopeQuant, option, false); |
8315 |
|
break; |
8316 |
|
case 684: // --miniscope-quant-fv |
8317 |
|
assignBool(options::miniscopeQuantFreeVar, option, true); |
8318 |
|
break; |
8319 |
|
case 685:// --no-miniscope-quant-fv |
8320 |
|
assignBool(options::miniscopeQuantFreeVar, option, false); |
8321 |
|
break; |
8322 |
3 |
case 686: // --multi-trigger-cache |
8323 |
3 |
assignBool(options::multiTriggerCache, option, true); |
8324 |
3 |
break; |
8325 |
|
case 687:// --no-multi-trigger-cache |
8326 |
|
assignBool(options::multiTriggerCache, option, false); |
8327 |
|
break; |
8328 |
|
case 688: // --multi-trigger-linear |
8329 |
|
assignBool(options::multiTriggerLinear, option, true); |
8330 |
|
break; |
8331 |
|
case 689:// --no-multi-trigger-linear |
8332 |
|
assignBool(options::multiTriggerLinear, option, false); |
8333 |
|
break; |
8334 |
|
case 690: // --multi-trigger-priority |
8335 |
|
assignBool(options::multiTriggerPriority, option, true); |
8336 |
|
break; |
8337 |
|
case 691:// --no-multi-trigger-priority |
8338 |
|
assignBool(options::multiTriggerPriority, option, false); |
8339 |
|
break; |
8340 |
|
case 692: // --multi-trigger-when-single |
8341 |
|
assignBool(options::multiTriggerWhenSingle, option, true); |
8342 |
|
break; |
8343 |
|
case 693:// --no-multi-trigger-when-single |
8344 |
|
assignBool(options::multiTriggerWhenSingle, option, false); |
8345 |
|
break; |
8346 |
3 |
case 694: // --partial-triggers |
8347 |
3 |
assignBool(options::partialTriggers, option, true); |
8348 |
3 |
break; |
8349 |
|
case 695:// --no-partial-triggers |
8350 |
|
assignBool(options::partialTriggers, option, false); |
8351 |
|
break; |
8352 |
3 |
case 696: // --pool-inst |
8353 |
3 |
assignBool(options::poolInst, option, true); |
8354 |
3 |
break; |
8355 |
|
case 697:// --no-pool-inst |
8356 |
|
assignBool(options::poolInst, option, false); |
8357 |
|
break; |
8358 |
|
case 698: // --pre-skolem-quant |
8359 |
|
assignBool(options::preSkolemQuant, option, true); |
8360 |
|
break; |
8361 |
|
case 699:// --no-pre-skolem-quant |
8362 |
|
assignBool(options::preSkolemQuant, option, false); |
8363 |
|
break; |
8364 |
|
case 700: // --pre-skolem-quant-agg |
8365 |
|
assignBool(options::preSkolemQuantAgg, option, true); |
8366 |
|
break; |
8367 |
|
case 701:// --no-pre-skolem-quant-agg |
8368 |
|
assignBool(options::preSkolemQuantAgg, option, false); |
8369 |
|
break; |
8370 |
|
case 702: // --pre-skolem-quant-nested |
8371 |
|
assignBool(options::preSkolemQuantNested, option, true); |
8372 |
|
break; |
8373 |
|
case 703:// --no-pre-skolem-quant-nested |
8374 |
|
assignBool(options::preSkolemQuantNested, option, false); |
8375 |
|
break; |
8376 |
|
case 704: // --prenex-quant-user |
8377 |
|
assignBool(options::prenexQuantUser, option, true); |
8378 |
|
break; |
8379 |
|
case 705:// --no-prenex-quant-user |
8380 |
|
assignBool(options::prenexQuantUser, option, false); |
8381 |
|
break; |
8382 |
|
case 706: // --prenex-quant=MODE |
8383 |
|
assign(options::prenexQuant, option, optionarg); |
8384 |
|
break; |
8385 |
3 |
case 707: // --purify-triggers |
8386 |
3 |
assignBool(options::purifyTriggers, option, true); |
8387 |
3 |
break; |
8388 |
|
case 708:// --no-purify-triggers |
8389 |
|
assignBool(options::purifyTriggers, option, false); |
8390 |
|
break; |
8391 |
|
case 709: // --qcf-all-conflict |
8392 |
|
assignBool(options::qcfAllConflict, option, true); |
8393 |
|
break; |
8394 |
|
case 710:// --no-qcf-all-conflict |
8395 |
|
assignBool(options::qcfAllConflict, option, false); |
8396 |
|
break; |
8397 |
|
case 711: // --qcf-eager-check-rd |
8398 |
|
assignBool(options::qcfEagerCheckRd, option, true); |
8399 |
|
break; |
8400 |
|
case 712:// --no-qcf-eager-check-rd |
8401 |
|
assignBool(options::qcfEagerCheckRd, option, false); |
8402 |
|
break; |
8403 |
|
case 713: // --qcf-eager-test |
8404 |
|
assignBool(options::qcfEagerTest, option, true); |
8405 |
|
break; |
8406 |
|
case 714:// --no-qcf-eager-test |
8407 |
|
assignBool(options::qcfEagerTest, option, false); |
8408 |
|
break; |
8409 |
|
case 715: // --qcf-nested-conflict |
8410 |
|
assignBool(options::qcfNestedConflict, option, true); |
8411 |
|
break; |
8412 |
|
case 716:// --no-qcf-nested-conflict |
8413 |
|
assignBool(options::qcfNestedConflict, option, false); |
8414 |
|
break; |
8415 |
|
case 717: // --qcf-skip-rd |
8416 |
|
assignBool(options::qcfSkipRd, option, true); |
8417 |
|
break; |
8418 |
|
case 718:// --no-qcf-skip-rd |
8419 |
|
assignBool(options::qcfSkipRd, option, false); |
8420 |
|
break; |
8421 |
6 |
case 719: // --qcf-tconstraint |
8422 |
6 |
assignBool(options::qcfTConstraint, option, true); |
8423 |
6 |
break; |
8424 |
|
case 720:// --no-qcf-tconstraint |
8425 |
|
assignBool(options::qcfTConstraint, option, false); |
8426 |
|
break; |
8427 |
|
case 721: // --qcf-vo-exp |
8428 |
|
assignBool(options::qcfVoExp, option, true); |
8429 |
|
break; |
8430 |
|
case 722:// --no-qcf-vo-exp |
8431 |
|
assignBool(options::qcfVoExp, option, false); |
8432 |
|
break; |
8433 |
|
case 723: // --quant-alpha-equiv |
8434 |
|
assignBool(options::quantAlphaEquiv, option, true); |
8435 |
|
break; |
8436 |
|
case 724:// --no-quant-alpha-equiv |
8437 |
|
assignBool(options::quantAlphaEquiv, option, false); |
8438 |
|
break; |
8439 |
|
case 725: // --quant-cf |
8440 |
|
assignBool(options::quantConflictFind, option, true); |
8441 |
|
break; |
8442 |
|
case 726:// --no-quant-cf |
8443 |
|
assignBool(options::quantConflictFind, option, false); |
8444 |
|
break; |
8445 |
|
case 727: // --quant-cf-mode=MODE |
8446 |
|
assign(options::qcfMode, option, optionarg); |
8447 |
|
break; |
8448 |
|
case 728: // --quant-cf-when=MODE |
8449 |
|
assign(options::qcfWhenMode, option, optionarg); |
8450 |
|
break; |
8451 |
|
case 729: // --quant-dsplit-mode=MODE |
8452 |
|
assign(options::quantDynamicSplit, option, optionarg); |
8453 |
|
break; |
8454 |
|
case 730: // --quant-fun-wd |
8455 |
|
assignBool(options::quantFunWellDefined, option, true); |
8456 |
|
break; |
8457 |
|
case 731:// --no-quant-fun-wd |
8458 |
|
assignBool(options::quantFunWellDefined, option, false); |
8459 |
|
break; |
8460 |
6 |
case 732: // --quant-ind |
8461 |
6 |
assignBool(options::quantInduction, option, true); |
8462 |
6 |
break; |
8463 |
|
case 733:// --no-quant-ind |
8464 |
|
assignBool(options::quantInduction, option, false); |
8465 |
|
break; |
8466 |
|
case 734: // --quant-rep-mode=MODE |
8467 |
|
assign(options::quantRepMode, option, optionarg); |
8468 |
|
break; |
8469 |
|
case 735: // --quant-split |
8470 |
|
assignBool(options::quantSplit, option, true); |
8471 |
|
break; |
8472 |
|
case 736:// --no-quant-split |
8473 |
|
assignBool(options::quantSplit, option, false); |
8474 |
|
break; |
8475 |
|
case 737: // --register-quant-body-terms |
8476 |
|
assignBool(options::registerQuantBodyTerms, option, true); |
8477 |
|
break; |
8478 |
|
case 738:// --no-register-quant-body-terms |
8479 |
|
assignBool(options::registerQuantBodyTerms, option, false); |
8480 |
|
break; |
8481 |
12 |
case 739: // --relational-triggers |
8482 |
12 |
assignBool(options::relationalTriggers, option, true); |
8483 |
12 |
break; |
8484 |
3 |
case 740:// --no-relational-triggers |
8485 |
3 |
assignBool(options::relationalTriggers, option, false); |
8486 |
3 |
break; |
8487 |
3 |
case 741: // --relevant-triggers |
8488 |
3 |
assignBool(options::relevantTriggers, option, true); |
8489 |
3 |
break; |
8490 |
|
case 742:// --no-relevant-triggers |
8491 |
|
assignBool(options::relevantTriggers, option, false); |
8492 |
|
break; |
8493 |
|
case 743: // --strict-triggers |
8494 |
|
assignBool(options::strictTriggers, option, true); |
8495 |
|
break; |
8496 |
|
case 744:// --no-strict-triggers |
8497 |
|
assignBool(options::strictTriggers, option, false); |
8498 |
|
break; |
8499 |
|
case 745: // --sygus |
8500 |
|
assignBool(options::sygus, option, true); |
8501 |
|
break; |
8502 |
|
case 746:// --no-sygus |
8503 |
|
assignBool(options::sygus, option, false); |
8504 |
|
break; |
8505 |
|
case 747: // --sygus-active-gen-cfactor=N |
8506 |
|
assign(options::sygusActiveGenEnumConsts, option, optionarg); |
8507 |
|
break; |
8508 |
13 |
case 748: // --sygus-active-gen=MODE |
8509 |
13 |
assign(options::sygusActiveGenMode, option, optionarg); |
8510 |
13 |
break; |
8511 |
1 |
case 749: // --sygus-add-const-grammar |
8512 |
1 |
assignBool(options::sygusAddConstGrammar, option, true); |
8513 |
1 |
break; |
8514 |
1 |
case 750:// --no-sygus-add-const-grammar |
8515 |
1 |
assignBool(options::sygusAddConstGrammar, option, false); |
8516 |
1 |
break; |
8517 |
3 |
case 751: // --sygus-arg-relevant |
8518 |
3 |
assignBool(options::sygusArgRelevant, option, true); |
8519 |
3 |
break; |
8520 |
|
case 752:// --no-sygus-arg-relevant |
8521 |
|
assignBool(options::sygusArgRelevant, option, false); |
8522 |
|
break; |
8523 |
|
case 753: // --sygus-auto-unfold |
8524 |
|
assignBool(options::sygusInvAutoUnfold, option, true); |
8525 |
|
break; |
8526 |
|
case 754:// --no-sygus-auto-unfold |
8527 |
|
assignBool(options::sygusInvAutoUnfold, option, false); |
8528 |
|
break; |
8529 |
1 |
case 755: // --sygus-bool-ite-return-const |
8530 |
1 |
assignBool(options::sygusBoolIteReturnConst, option, true); |
8531 |
1 |
break; |
8532 |
|
case 756:// --no-sygus-bool-ite-return-const |
8533 |
|
assignBool(options::sygusBoolIteReturnConst, option, false); |
8534 |
|
break; |
8535 |
5 |
case 757: // --sygus-core-connective |
8536 |
5 |
assignBool(options::sygusCoreConnective, option, true); |
8537 |
5 |
break; |
8538 |
|
case 758:// --no-sygus-core-connective |
8539 |
|
assignBool(options::sygusCoreConnective, option, false); |
8540 |
|
break; |
8541 |
|
case 759: // --sygus-crepair-abort |
8542 |
|
assignBool(options::sygusConstRepairAbort, option, true); |
8543 |
|
break; |
8544 |
|
case 760:// --no-sygus-crepair-abort |
8545 |
|
assignBool(options::sygusConstRepairAbort, option, false); |
8546 |
|
break; |
8547 |
|
case 761: // --sygus-eval-opt |
8548 |
|
assignBool(options::sygusEvalOpt, option, true); |
8549 |
|
break; |
8550 |
|
case 762:// --no-sygus-eval-opt |
8551 |
|
assignBool(options::sygusEvalOpt, option, false); |
8552 |
|
break; |
8553 |
|
case 763: // --sygus-eval-unfold |
8554 |
|
assignBool(options::sygusEvalUnfold, option, true); |
8555 |
|
break; |
8556 |
|
case 764:// --no-sygus-eval-unfold |
8557 |
|
assignBool(options::sygusEvalUnfold, option, false); |
8558 |
|
break; |
8559 |
|
case 765: // --sygus-eval-unfold-bool |
8560 |
|
assignBool(options::sygusEvalUnfoldBool, option, true); |
8561 |
|
break; |
8562 |
|
case 766:// --no-sygus-eval-unfold-bool |
8563 |
|
assignBool(options::sygusEvalUnfoldBool, option, false); |
8564 |
|
break; |
8565 |
|
case 767: // --sygus-expr-miner-check-timeout=N |
8566 |
|
assign(options::sygusExprMinerCheckTimeout, option, optionarg); |
8567 |
|
break; |
8568 |
|
case 768: // --sygus-ext-rew |
8569 |
|
assignBool(options::sygusExtRew, option, true); |
8570 |
|
break; |
8571 |
|
case 769:// --no-sygus-ext-rew |
8572 |
|
assignBool(options::sygusExtRew, option, false); |
8573 |
|
break; |
8574 |
|
case 770: // --sygus-filter-sol-rev |
8575 |
|
assignBool(options::sygusFilterSolRevSubsume, option, true); |
8576 |
|
break; |
8577 |
|
case 771:// --no-sygus-filter-sol-rev |
8578 |
|
assignBool(options::sygusFilterSolRevSubsume, option, false); |
8579 |
|
break; |
8580 |
|
case 772: // --sygus-filter-sol=MODE |
8581 |
|
assign(options::sygusFilterSolMode, option, optionarg); |
8582 |
|
break; |
8583 |
6 |
case 773: // --sygus-grammar-cons=MODE |
8584 |
6 |
assign(options::sygusGrammarConsMode, option, optionarg); |
8585 |
6 |
break; |
8586 |
|
case 774: // --sygus-grammar-norm |
8587 |
|
assignBool(options::sygusGrammarNorm, option, true); |
8588 |
|
break; |
8589 |
|
case 775:// --no-sygus-grammar-norm |
8590 |
|
assignBool(options::sygusGrammarNorm, option, false); |
8591 |
|
break; |
8592 |
46 |
case 776: // --sygus-inference |
8593 |
46 |
assignBool(options::sygusInference, option, true); |
8594 |
46 |
break; |
8595 |
|
case 777:// --no-sygus-inference |
8596 |
|
assignBool(options::sygusInference, option, false); |
8597 |
|
break; |
8598 |
14 |
case 778: // --sygus-inst |
8599 |
14 |
assignBool(options::sygusInst, option, true); |
8600 |
14 |
break; |
8601 |
|
case 779:// --no-sygus-inst |
8602 |
|
assignBool(options::sygusInst, option, false); |
8603 |
|
break; |
8604 |
|
case 780: // --sygus-inst-mode=MODE |
8605 |
|
assign(options::sygusInstMode, option, optionarg); |
8606 |
|
break; |
8607 |
|
case 781: // --sygus-inst-scope=MODE |
8608 |
|
assign(options::sygusInstScope, option, optionarg); |
8609 |
|
break; |
8610 |
|
case 782: // --sygus-inst-term-sel=MODE |
8611 |
|
assign(options::sygusInstTermSel, option, optionarg); |
8612 |
|
break; |
8613 |
|
case 783: // --sygus-inv-templ-when-sg |
8614 |
|
assignBool(options::sygusInvTemplWhenSyntax, option, true); |
8615 |
|
break; |
8616 |
|
case 784:// --no-sygus-inv-templ-when-sg |
8617 |
|
assignBool(options::sygusInvTemplWhenSyntax, option, false); |
8618 |
|
break; |
8619 |
3 |
case 785: // --sygus-inv-templ=MODE |
8620 |
3 |
assign(options::sygusInvTemplMode, option, optionarg); |
8621 |
3 |
break; |
8622 |
|
case 786: // --sygus-min-grammar |
8623 |
|
assignBool(options::sygusMinGrammar, option, true); |
8624 |
|
break; |
8625 |
|
case 787:// --no-sygus-min-grammar |
8626 |
|
assignBool(options::sygusMinGrammar, option, false); |
8627 |
|
break; |
8628 |
|
case 788: // --sygus-pbe |
8629 |
|
assignBool(options::sygusUnifPbe, option, true); |
8630 |
|
break; |
8631 |
6 |
case 789:// --no-sygus-pbe |
8632 |
6 |
assignBool(options::sygusUnifPbe, option, false); |
8633 |
6 |
break; |
8634 |
|
case 790: // --sygus-pbe-multi-fair |
8635 |
|
assignBool(options::sygusPbeMultiFair, option, true); |
8636 |
|
break; |
8637 |
|
case 791:// --no-sygus-pbe-multi-fair |
8638 |
|
assignBool(options::sygusPbeMultiFair, option, false); |
8639 |
|
break; |
8640 |
|
case 792: // --sygus-pbe-multi-fair-diff=N |
8641 |
|
assign(options::sygusPbeMultiFairDiff, option, optionarg); |
8642 |
|
break; |
8643 |
4 |
case 793: // --sygus-qe-preproc |
8644 |
4 |
assignBool(options::sygusQePreproc, option, true); |
8645 |
4 |
break; |
8646 |
|
case 794:// --no-sygus-qe-preproc |
8647 |
|
assignBool(options::sygusQePreproc, option, false); |
8648 |
|
break; |
8649 |
|
case 795: // --sygus-query-gen |
8650 |
|
assignBool(options::sygusQueryGen, option, true); |
8651 |
|
break; |
8652 |
|
case 796:// --no-sygus-query-gen |
8653 |
|
assignBool(options::sygusQueryGen, option, false); |
8654 |
|
break; |
8655 |
|
case 797: // --sygus-query-gen-check |
8656 |
|
assignBool(options::sygusQueryGenCheck, option, true); |
8657 |
|
break; |
8658 |
|
case 798:// --no-sygus-query-gen-check |
8659 |
|
assignBool(options::sygusQueryGenCheck, option, false); |
8660 |
|
break; |
8661 |
|
case 799: // --sygus-query-gen-dump-files=MODE |
8662 |
|
assign(options::sygusQueryGenDumpFiles, option, optionarg); |
8663 |
|
break; |
8664 |
|
case 800: // --sygus-query-gen-thresh=N |
8665 |
|
assign(options::sygusQueryGenThresh, option, optionarg); |
8666 |
|
break; |
8667 |
1 |
case 801: // --sygus-rec-fun |
8668 |
1 |
assignBool(options::sygusRecFun, option, true); |
8669 |
1 |
break; |
8670 |
|
case 802:// --no-sygus-rec-fun |
8671 |
|
assignBool(options::sygusRecFun, option, false); |
8672 |
|
break; |
8673 |
|
case 803: // --sygus-rec-fun-eval-limit=N |
8674 |
|
assign(options::sygusRecFunEvalLimit, option, optionarg); |
8675 |
|
break; |
8676 |
5 |
case 804: // --sygus-repair-const |
8677 |
5 |
assignBool(options::sygusRepairConst, option, true); |
8678 |
5 |
break; |
8679 |
3 |
case 805:// --no-sygus-repair-const |
8680 |
3 |
assignBool(options::sygusRepairConst, option, false); |
8681 |
3 |
break; |
8682 |
|
case 806: // --sygus-repair-const-timeout=N |
8683 |
|
assign(options::sygusRepairConstTimeout, option, optionarg); |
8684 |
|
break; |
8685 |
6 |
case 807: // --sygus-rr |
8686 |
6 |
assignBool(options::sygusRew, option, true); |
8687 |
6 |
break; |
8688 |
|
case 808:// --no-sygus-rr |
8689 |
|
assignBool(options::sygusRew, option, false); |
8690 |
|
break; |
8691 |
1 |
case 809: // --sygus-rr-synth |
8692 |
1 |
assignBool(options::sygusRewSynth, option, true); |
8693 |
1 |
break; |
8694 |
|
case 810:// --no-sygus-rr-synth |
8695 |
|
assignBool(options::sygusRewSynth, option, false); |
8696 |
|
break; |
8697 |
|
case 811: // --sygus-rr-synth-accel |
8698 |
|
assignBool(options::sygusRewSynthAccel, option, true); |
8699 |
|
break; |
8700 |
|
case 812:// --no-sygus-rr-synth-accel |
8701 |
|
assignBool(options::sygusRewSynthAccel, option, false); |
8702 |
|
break; |
8703 |
3 |
case 813: // --sygus-rr-synth-check |
8704 |
3 |
assignBool(options::sygusRewSynthCheck, option, true); |
8705 |
3 |
break; |
8706 |
|
case 814:// --no-sygus-rr-synth-check |
8707 |
|
assignBool(options::sygusRewSynthCheck, option, false); |
8708 |
|
break; |
8709 |
|
case 815: // --sygus-rr-synth-filter-cong |
8710 |
|
assignBool(options::sygusRewSynthFilterCong, option, true); |
8711 |
|
break; |
8712 |
|
case 816:// --no-sygus-rr-synth-filter-cong |
8713 |
|
assignBool(options::sygusRewSynthFilterCong, option, false); |
8714 |
|
break; |
8715 |
|
case 817: // --sygus-rr-synth-filter-match |
8716 |
|
assignBool(options::sygusRewSynthFilterMatch, option, true); |
8717 |
|
break; |
8718 |
|
case 818:// --no-sygus-rr-synth-filter-match |
8719 |
|
assignBool(options::sygusRewSynthFilterMatch, option, false); |
8720 |
|
break; |
8721 |
|
case 819: // --sygus-rr-synth-filter-nl |
8722 |
|
assignBool(options::sygusRewSynthFilterNonLinear, option, true); |
8723 |
|
break; |
8724 |
|
case 820:// --no-sygus-rr-synth-filter-nl |
8725 |
|
assignBool(options::sygusRewSynthFilterNonLinear, option, false); |
8726 |
|
break; |
8727 |
|
case 821: // --sygus-rr-synth-filter-order |
8728 |
|
assignBool(options::sygusRewSynthFilterOrder, option, true); |
8729 |
|
break; |
8730 |
|
case 822:// --no-sygus-rr-synth-filter-order |
8731 |
|
assignBool(options::sygusRewSynthFilterOrder, option, false); |
8732 |
|
break; |
8733 |
|
case 823: // --sygus-rr-synth-input |
8734 |
|
assignBool(options::sygusRewSynthInput, option, true); |
8735 |
|
break; |
8736 |
|
case 824:// --no-sygus-rr-synth-input |
8737 |
|
assignBool(options::sygusRewSynthInput, option, false); |
8738 |
|
break; |
8739 |
|
case 825: // --sygus-rr-synth-input-nvars=N |
8740 |
|
assign(options::sygusRewSynthInputNVars, option, optionarg); |
8741 |
|
break; |
8742 |
|
case 826: // --sygus-rr-synth-input-use-bool |
8743 |
|
assignBool(options::sygusRewSynthInputUseBool, option, true); |
8744 |
|
break; |
8745 |
|
case 827:// --no-sygus-rr-synth-input-use-bool |
8746 |
|
assignBool(options::sygusRewSynthInputUseBool, option, false); |
8747 |
|
break; |
8748 |
|
case 828: // --sygus-rr-synth-rec |
8749 |
|
assignBool(options::sygusRewSynthRec, option, true); |
8750 |
|
break; |
8751 |
|
case 829:// --no-sygus-rr-synth-rec |
8752 |
|
assignBool(options::sygusRewSynthRec, option, false); |
8753 |
|
break; |
8754 |
|
case 830: // --sygus-rr-verify |
8755 |
|
assignBool(options::sygusRewVerify, option, true); |
8756 |
|
break; |
8757 |
|
case 831:// --no-sygus-rr-verify |
8758 |
|
assignBool(options::sygusRewVerify, option, false); |
8759 |
|
break; |
8760 |
7 |
case 832: // --sygus-rr-verify-abort |
8761 |
7 |
assignBool(options::sygusRewVerifyAbort, option, true); |
8762 |
7 |
break; |
8763 |
|
case 833:// --no-sygus-rr-verify-abort |
8764 |
|
assignBool(options::sygusRewVerifyAbort, option, false); |
8765 |
|
break; |
8766 |
|
case 834: // --sygus-sample-fp-uniform |
8767 |
|
assignBool(options::sygusSampleFpUniform, option, true); |
8768 |
|
break; |
8769 |
|
case 835:// --no-sygus-sample-fp-uniform |
8770 |
|
assignBool(options::sygusSampleFpUniform, option, false); |
8771 |
|
break; |
8772 |
|
case 836: // --sygus-sample-grammar |
8773 |
|
assignBool(options::sygusSampleGrammar, option, true); |
8774 |
|
break; |
8775 |
|
case 837:// --no-sygus-sample-grammar |
8776 |
|
assignBool(options::sygusSampleGrammar, option, false); |
8777 |
|
break; |
8778 |
7 |
case 838: // --sygus-samples=N |
8779 |
7 |
assign(options::sygusSamples, option, optionarg); |
8780 |
7 |
break; |
8781 |
|
case 839: // --sygus-si-abort |
8782 |
|
assignBool(options::cegqiSingleInvAbort, option, true); |
8783 |
|
break; |
8784 |
|
case 840:// --no-sygus-si-abort |
8785 |
|
assignBool(options::cegqiSingleInvAbort, option, false); |
8786 |
|
break; |
8787 |
|
case 841: // --sygus-si-partial |
8788 |
|
assignBool(options::cegqiSingleInvPartial, option, true); |
8789 |
|
break; |
8790 |
|
case 842:// --no-sygus-si-partial |
8791 |
|
assignBool(options::cegqiSingleInvPartial, option, false); |
8792 |
|
break; |
8793 |
1 |
case 843: // --sygus-si-rcons-limit=N |
8794 |
1 |
assign(options::cegqiSingleInvReconstructLimit, option, optionarg); |
8795 |
1 |
break; |
8796 |
|
case 844: // --sygus-si-rcons=MODE |
8797 |
|
assign(options::cegqiSingleInvReconstruct, option, optionarg); |
8798 |
|
break; |
8799 |
|
case 845: // --sygus-si-reconstruct-const |
8800 |
|
assignBool(options::cegqiSingleInvReconstructConst, option, true); |
8801 |
|
break; |
8802 |
|
case 846:// --no-sygus-si-reconstruct-const |
8803 |
|
assignBool(options::cegqiSingleInvReconstructConst, option, false); |
8804 |
|
break; |
8805 |
47 |
case 847: // --sygus-si=MODE |
8806 |
47 |
assign(options::cegqiSingleInvMode, option, optionarg); |
8807 |
47 |
break; |
8808 |
4 |
case 848: // --sygus-stream |
8809 |
4 |
assignBool(options::sygusStream, option, true); |
8810 |
4 |
break; |
8811 |
|
case 849:// --no-sygus-stream |
8812 |
|
assignBool(options::sygusStream, option, false); |
8813 |
|
break; |
8814 |
|
case 850: // --sygus-templ-embed-grammar |
8815 |
|
assignBool(options::sygusTemplEmbedGrammar, option, true); |
8816 |
|
break; |
8817 |
|
case 851:// --no-sygus-templ-embed-grammar |
8818 |
|
assignBool(options::sygusTemplEmbedGrammar, option, false); |
8819 |
|
break; |
8820 |
|
case 852: // --sygus-unif-cond-independent-no-repeat-sol |
8821 |
|
assignBool(options::sygusUnifCondIndNoRepeatSol, option, true); |
8822 |
|
break; |
8823 |
|
case 853:// --no-sygus-unif-cond-independent-no-repeat-sol |
8824 |
|
assignBool(options::sygusUnifCondIndNoRepeatSol, option, false); |
8825 |
|
break; |
8826 |
8 |
case 854: // --sygus-unif-pi=MODE |
8827 |
8 |
assign(options::sygusUnifPi, option, optionarg); |
8828 |
8 |
break; |
8829 |
|
case 855: // --sygus-unif-shuffle-cond |
8830 |
|
assignBool(options::sygusUnifShuffleCond, option, true); |
8831 |
|
break; |
8832 |
|
case 856:// --no-sygus-unif-shuffle-cond |
8833 |
|
assignBool(options::sygusUnifShuffleCond, option, false); |
8834 |
|
break; |
8835 |
|
case 857: // --term-db-cd |
8836 |
|
assignBool(options::termDbCd, option, true); |
8837 |
|
break; |
8838 |
|
case 858:// --no-term-db-cd |
8839 |
|
assignBool(options::termDbCd, option, false); |
8840 |
|
break; |
8841 |
|
case 859: // --term-db-mode=MODE |
8842 |
|
assign(options::termDbMode, option, optionarg); |
8843 |
|
break; |
8844 |
|
case 860: // --trigger-active-sel=MODE |
8845 |
|
assign(options::triggerActiveSelMode, option, optionarg); |
8846 |
|
break; |
8847 |
|
case 861: // --trigger-sel=MODE |
8848 |
|
assign(options::triggerSelMode, option, optionarg); |
8849 |
|
break; |
8850 |
|
case 862: // --user-pat=MODE |
8851 |
|
assign(options::userPatternsQuant, option, optionarg); |
8852 |
|
break; |
8853 |
|
case 863: // --var-elim-quant |
8854 |
|
assignBool(options::varElimQuant, option, true); |
8855 |
|
break; |
8856 |
|
case 864:// --no-var-elim-quant |
8857 |
|
assignBool(options::varElimQuant, option, false); |
8858 |
|
break; |
8859 |
2 |
case 865: // --var-ineq-elim-quant |
8860 |
2 |
assignBool(options::varIneqElimQuant, option, true); |
8861 |
2 |
break; |
8862 |
|
case 866:// --no-var-ineq-elim-quant |
8863 |
|
assignBool(options::varIneqElimQuant, option, false); |
8864 |
|
break; |
8865 |
|
case 867: // --rlimit-per=N |
8866 |
|
case 868: // --reproducible-resource-limit |
8867 |
|
assign(options::perCallResourceLimit, option, optionarg); |
8868 |
|
break; |
8869 |
|
case 869: // --rlimit=N |
8870 |
|
assign(options::cumulativeResourceLimit, option, optionarg); |
8871 |
|
break; |
8872 |
|
case 870: // --rweight=VAL=N |
8873 |
|
d_handler->setResourceWeight(option, optionarg); |
8874 |
|
break; |
8875 |
6 |
case 871: // --tlimit-per=MS |
8876 |
6 |
assign(options::perCallMillisecondLimit, option, optionarg); |
8877 |
6 |
break; |
8878 |
|
case 872: // --tlimit=MS |
8879 |
|
assign(options::cumulativeMillisecondLimit, option, optionarg); |
8880 |
|
break; |
8881 |
|
case 873: // --sep-check-neg |
8882 |
|
assignBool(options::sepCheckNeg, option, true); |
8883 |
|
break; |
8884 |
|
case 874:// --no-sep-check-neg |
8885 |
|
assignBool(options::sepCheckNeg, option, false); |
8886 |
|
break; |
8887 |
|
case 875: // --sep-child-refine |
8888 |
|
assignBool(options::sepChildRefine, option, true); |
8889 |
|
break; |
8890 |
|
case 876:// --no-sep-child-refine |
8891 |
|
assignBool(options::sepChildRefine, option, false); |
8892 |
|
break; |
8893 |
|
case 877: // --sep-deq-c |
8894 |
|
assignBool(options::sepDisequalC, option, true); |
8895 |
|
break; |
8896 |
|
case 878:// --no-sep-deq-c |
8897 |
|
assignBool(options::sepDisequalC, option, false); |
8898 |
|
break; |
8899 |
|
case 879: // --sep-exp |
8900 |
|
assignBool(options::sepExp, option, true); |
8901 |
|
break; |
8902 |
|
case 880:// --no-sep-exp |
8903 |
|
assignBool(options::sepExp, option, false); |
8904 |
|
break; |
8905 |
|
case 881: // --sep-min-refine |
8906 |
|
assignBool(options::sepMinimalRefine, option, true); |
8907 |
|
break; |
8908 |
|
case 882:// --no-sep-min-refine |
8909 |
|
assignBool(options::sepMinimalRefine, option, false); |
8910 |
|
break; |
8911 |
1 |
case 883: // --sep-pre-skolem-emp |
8912 |
1 |
assignBool(options::sepPreSkolemEmp, option, true); |
8913 |
1 |
break; |
8914 |
|
case 884:// --no-sep-pre-skolem-emp |
8915 |
|
assignBool(options::sepPreSkolemEmp, option, false); |
8916 |
|
break; |
8917 |
32 |
case 885: // --sets-ext |
8918 |
32 |
assignBool(options::setsExt, option, true); |
8919 |
32 |
break; |
8920 |
|
case 886:// --no-sets-ext |
8921 |
|
assignBool(options::setsExt, option, false); |
8922 |
|
break; |
8923 |
2 |
case 887: // --sets-infer-as-lemmas |
8924 |
2 |
assignBool(options::setsInferAsLemmas, option, true); |
8925 |
2 |
break; |
8926 |
|
case 888:// --no-sets-infer-as-lemmas |
8927 |
|
assignBool(options::setsInferAsLemmas, option, false); |
8928 |
|
break; |
8929 |
|
case 889: // --sets-proxy-lemmas |
8930 |
|
assignBool(options::setsProxyLemmas, option, true); |
8931 |
|
break; |
8932 |
|
case 890:// --no-sets-proxy-lemmas |
8933 |
|
assignBool(options::setsProxyLemmas, option, false); |
8934 |
|
break; |
8935 |
4 |
case 891: // --abstract-values |
8936 |
4 |
assignBool(options::abstractValues, option, true); |
8937 |
4 |
break; |
8938 |
|
case 892:// --no-abstract-values |
8939 |
|
assignBool(options::abstractValues, option, false); |
8940 |
|
break; |
8941 |
31 |
case 893: // --ackermann |
8942 |
31 |
assignBool(options::ackermann, option, true); |
8943 |
31 |
break; |
8944 |
|
case 894:// --no-ackermann |
8945 |
|
assignBool(options::ackermann, option, false); |
8946 |
|
break; |
8947 |
7 |
case 895: // --block-models=MODE |
8948 |
7 |
assign(options::blockModelsMode, option, optionarg); |
8949 |
7 |
break; |
8950 |
80 |
case 896: // --bvand-integer-granularity=N |
8951 |
80 |
assign(options::BVAndIntegerGranularity, option, optionarg); |
8952 |
80 |
break; |
8953 |
12 |
case 897: // --check-abducts |
8954 |
12 |
assignBool(options::checkAbducts, option, true); |
8955 |
12 |
break; |
8956 |
|
case 898:// --no-check-abducts |
8957 |
|
assignBool(options::checkAbducts, option, false); |
8958 |
|
break; |
8959 |
8 |
case 899: // --check-interpols |
8960 |
8 |
assignBool(options::checkInterpols, option, true); |
8961 |
8 |
break; |
8962 |
|
case 900:// --no-check-interpols |
8963 |
|
assignBool(options::checkInterpols, option, false); |
8964 |
|
break; |
8965 |
14 |
case 901: // --check-models |
8966 |
14 |
assignBool(options::checkModels, option, true); |
8967 |
14 |
break; |
8968 |
83 |
case 902:// --no-check-models |
8969 |
83 |
assignBool(options::checkModels, option, false); |
8970 |
83 |
break; |
8971 |
1104 |
case 903: // --check-proofs |
8972 |
1104 |
assignBool(options::checkProofs, option, true); |
8973 |
1104 |
break; |
8974 |
6 |
case 904:// --no-check-proofs |
8975 |
6 |
assignBool(options::checkProofs, option, false); |
8976 |
6 |
break; |
8977 |
179 |
case 905: // --check-synth-sol |
8978 |
179 |
assignBool(options::checkSynthSol, option, true); |
8979 |
179 |
break; |
8980 |
6 |
case 906:// --no-check-synth-sol |
8981 |
6 |
assignBool(options::checkSynthSol, option, false); |
8982 |
6 |
break; |
8983 |
1080 |
case 907: // --check-unsat-cores |
8984 |
1080 |
assignBool(options::checkUnsatCores, option, true); |
8985 |
1080 |
break; |
8986 |
36 |
case 908:// --no-check-unsat-cores |
8987 |
36 |
assignBool(options::checkUnsatCores, option, false); |
8988 |
36 |
break; |
8989 |
1170 |
case 909: // --debug-check-models |
8990 |
1170 |
assignBool(options::debugCheckModels, option, true); |
8991 |
1170 |
break; |
8992 |
|
case 910:// --no-debug-check-models |
8993 |
|
assignBool(options::debugCheckModels, option, false); |
8994 |
|
break; |
8995 |
|
case 911: // --diagnostic-output-channel=CHANNEL |
8996 |
|
assign(options::diagnosticChannelName, option, optionarg); |
8997 |
|
break; |
8998 |
12 |
case 912: // --dump-instantiations |
8999 |
12 |
assignBool(options::dumpInstantiations, option, true); |
9000 |
12 |
break; |
9001 |
|
case 913:// --no-dump-instantiations |
9002 |
|
assignBool(options::dumpInstantiations, option, false); |
9003 |
|
break; |
9004 |
6 |
case 914: // --dump-models |
9005 |
6 |
assignBool(options::dumpModels, option, true); |
9006 |
6 |
break; |
9007 |
|
case 915:// --no-dump-models |
9008 |
|
assignBool(options::dumpModels, option, false); |
9009 |
|
break; |
9010 |
|
case 916: // --dump-proofs |
9011 |
|
assignBool(options::dumpProofs, option, true); |
9012 |
|
break; |
9013 |
|
case 917:// --no-dump-proofs |
9014 |
|
assignBool(options::dumpProofs, option, false); |
9015 |
|
break; |
9016 |
|
case 918: // --dump-to=FILE |
9017 |
|
assign(options::dumpToFileName, option, optionarg); |
9018 |
|
break; |
9019 |
|
case 919: // --dump-unsat-cores |
9020 |
|
assignBool(options::dumpUnsatCores, option, true); |
9021 |
|
break; |
9022 |
|
case 920:// --no-dump-unsat-cores |
9023 |
|
assignBool(options::dumpUnsatCores, option, false); |
9024 |
|
break; |
9025 |
3 |
case 921: // --dump-unsat-cores-full |
9026 |
3 |
assignBool(options::dumpUnsatCoresFull, option, true); |
9027 |
3 |
break; |
9028 |
|
case 922:// --no-dump-unsat-cores-full |
9029 |
|
assignBool(options::dumpUnsatCoresFull, option, false); |
9030 |
|
break; |
9031 |
3 |
case 923: // --dump=MODE |
9032 |
3 |
assign(options::dumpModeString, option, optionarg); |
9033 |
3 |
break; |
9034 |
|
case 924: // --early-ite-removal |
9035 |
|
assignBool(options::earlyIteRemoval, option, true); |
9036 |
|
break; |
9037 |
|
case 925:// --no-early-ite-removal |
9038 |
|
assignBool(options::earlyIteRemoval, option, false); |
9039 |
|
break; |
9040 |
|
case 926: // --expand-definitions |
9041 |
|
assignBool(options::expandDefinitions, option, true); |
9042 |
|
break; |
9043 |
|
case 927:// --no-expand-definitions |
9044 |
|
assignBool(options::expandDefinitions, option, false); |
9045 |
|
break; |
9046 |
17 |
case 928: // --ext-rew-prep |
9047 |
17 |
assignBool(options::extRewPrep, option, true); |
9048 |
17 |
break; |
9049 |
|
case 929:// --no-ext-rew-prep |
9050 |
|
assignBool(options::extRewPrep, option, false); |
9051 |
|
break; |
9052 |
7 |
case 930: // --ext-rew-prep-agg |
9053 |
7 |
assignBool(options::extRewPrepAgg, option, true); |
9054 |
7 |
break; |
9055 |
|
case 931:// --no-ext-rew-prep-agg |
9056 |
|
assignBool(options::extRewPrepAgg, option, false); |
9057 |
|
break; |
9058 |
|
case 932: // --force-no-limit-cpu-while-dump |
9059 |
|
assignBool(options::forceNoLimitCpuWhileDump, option, true); |
9060 |
|
break; |
9061 |
|
case 933:// --no-force-no-limit-cpu-while-dump |
9062 |
|
assignBool(options::forceNoLimitCpuWhileDump, option, false); |
9063 |
|
break; |
9064 |
2 |
case 934: // --foreign-theory-rewrite |
9065 |
2 |
assignBool(options::foreignTheoryRewrite, option, true); |
9066 |
2 |
break; |
9067 |
|
case 935:// --no-foreign-theory-rewrite |
9068 |
|
assignBool(options::foreignTheoryRewrite, option, false); |
9069 |
|
break; |
9070 |
68 |
case 936: // --iand-mode=mode |
9071 |
68 |
assign(options::iandMode, option, optionarg); |
9072 |
68 |
break; |
9073 |
622 |
case 'i': |
9074 |
|
case 937: // --incremental |
9075 |
622 |
assignBool(options::incrementalSolving, option, true); |
9076 |
622 |
break; |
9077 |
|
case 938:// --no-incremental |
9078 |
|
assignBool(options::incrementalSolving, option, false); |
9079 |
|
break; |
9080 |
|
case 939: // --interactive-mode |
9081 |
|
assignBool(options::interactiveMode, option, true); |
9082 |
|
break; |
9083 |
|
case 940:// --no-interactive-mode |
9084 |
|
assignBool(options::interactiveMode, option, false); |
9085 |
|
break; |
9086 |
|
case 941: // --ite-simp |
9087 |
|
assignBool(options::doITESimp, option, true); |
9088 |
|
break; |
9089 |
|
case 942:// --no-ite-simp |
9090 |
|
assignBool(options::doITESimp, option, false); |
9091 |
|
break; |
9092 |
6 |
case 943: // --model-cores=MODE |
9093 |
6 |
assign(options::modelCoresMode, option, optionarg); |
9094 |
6 |
break; |
9095 |
1 |
case 944: // --model-u-print=MODE |
9096 |
|
case 945: // --model-uninterp-print |
9097 |
1 |
assign(options::modelUninterpPrint, option, optionarg); |
9098 |
1 |
break; |
9099 |
1 |
case 946: // --model-witness-value |
9100 |
1 |
assignBool(options::modelWitnessValue, option, true); |
9101 |
1 |
break; |
9102 |
|
case 947:// --no-model-witness-value |
9103 |
|
assignBool(options::modelWitnessValue, option, false); |
9104 |
|
break; |
9105 |
|
case 948: // --on-repeat-ite-simp |
9106 |
|
assignBool(options::doITESimpOnRepeat, option, true); |
9107 |
|
break; |
9108 |
|
case 949:// --no-on-repeat-ite-simp |
9109 |
|
assignBool(options::doITESimpOnRepeat, option, false); |
9110 |
|
break; |
9111 |
11 |
case 950: // --produce-abducts |
9112 |
11 |
assignBool(options::produceAbducts, option, true); |
9113 |
11 |
break; |
9114 |
|
case 951:// --no-produce-abducts |
9115 |
|
assignBool(options::produceAbducts, option, false); |
9116 |
|
break; |
9117 |
|
case 952: // --produce-assertions |
9118 |
|
assignBool(options::produceAssertions, option, true); |
9119 |
|
break; |
9120 |
|
case 953:// --no-produce-assertions |
9121 |
|
assignBool(options::produceAssertions, option, false); |
9122 |
|
break; |
9123 |
|
case 954: // --produce-assignments |
9124 |
|
assignBool(options::produceAssignments, option, true); |
9125 |
|
break; |
9126 |
|
case 955:// --no-produce-assignments |
9127 |
|
assignBool(options::produceAssignments, option, false); |
9128 |
|
break; |
9129 |
8 |
case 956: // --produce-interpols=MODE |
9130 |
8 |
assign(options::produceInterpols, option, optionarg); |
9131 |
8 |
break; |
9132 |
37 |
case 'm': |
9133 |
|
case 957: // --produce-models |
9134 |
37 |
assignBool(options::produceModels, option, true); |
9135 |
37 |
break; |
9136 |
2 |
case 958:// --no-produce-models |
9137 |
2 |
assignBool(options::produceModels, option, false); |
9138 |
2 |
break; |
9139 |
4 |
case 959: // --produce-proofs |
9140 |
4 |
assignBool(options::produceProofs, option, true); |
9141 |
4 |
break; |
9142 |
20 |
case 960:// --no-produce-proofs |
9143 |
20 |
assignBool(options::produceProofs, option, false); |
9144 |
20 |
break; |
9145 |
|
case 961: // --produce-unsat-assumptions |
9146 |
|
assignBool(options::unsatAssumptions, option, true); |
9147 |
|
break; |
9148 |
|
case 962:// --no-produce-unsat-assumptions |
9149 |
|
assignBool(options::unsatAssumptions, option, false); |
9150 |
|
break; |
9151 |
4 |
case 963: // --produce-unsat-cores |
9152 |
4 |
assignBool(options::unsatCores, option, true); |
9153 |
4 |
break; |
9154 |
2 |
case 964:// --no-produce-unsat-cores |
9155 |
2 |
assignBool(options::unsatCores, option, false); |
9156 |
2 |
break; |
9157 |
|
case 965: // --regular-output-channel=CHANNEL |
9158 |
|
assign(options::regularChannelName, option, optionarg); |
9159 |
|
break; |
9160 |
2 |
case 966: // --repeat-simp |
9161 |
2 |
assignBool(options::repeatSimp, option, true); |
9162 |
2 |
break; |
9163 |
|
case 967:// --no-repeat-simp |
9164 |
|
assignBool(options::repeatSimp, option, false); |
9165 |
|
break; |
9166 |
|
case 968: // --simp-ite-compress |
9167 |
|
assignBool(options::compressItes, option, true); |
9168 |
|
break; |
9169 |
|
case 969:// --no-simp-ite-compress |
9170 |
|
assignBool(options::compressItes, option, false); |
9171 |
|
break; |
9172 |
|
case 970: // --simp-ite-hunt-zombies=N |
9173 |
|
assign(options::zombieHuntThreshold, option, optionarg); |
9174 |
|
break; |
9175 |
|
case 971: // --simp-with-care |
9176 |
|
assignBool(options::simplifyWithCareEnabled, option, true); |
9177 |
|
break; |
9178 |
|
case 972:// --no-simp-with-care |
9179 |
|
assignBool(options::simplifyWithCareEnabled, option, false); |
9180 |
|
break; |
9181 |
31 |
case 973: // --simplification=MODE |
9182 |
|
case 974: // --simplification-mode |
9183 |
31 |
assign(options::simplificationMode, option, optionarg); |
9184 |
31 |
break; |
9185 |
119 |
case 975: // --solve-bv-as-int=MODE |
9186 |
119 |
assign(options::solveBVAsInt, option, optionarg); |
9187 |
119 |
break; |
9188 |
4 |
case 976: // --solve-int-as-bv=N |
9189 |
4 |
assign(options::solveIntAsBV, option, optionarg); |
9190 |
4 |
break; |
9191 |
9 |
case 977: // --solve-real-as-int |
9192 |
9 |
assignBool(options::solveRealAsInt, option, true); |
9193 |
9 |
break; |
9194 |
|
case 978:// --no-solve-real-as-int |
9195 |
|
assignBool(options::solveRealAsInt, option, false); |
9196 |
|
break; |
9197 |
20 |
case 979: // --sort-inference |
9198 |
20 |
assignBool(options::sortInference, option, true); |
9199 |
20 |
break; |
9200 |
|
case 980:// --no-sort-inference |
9201 |
|
assignBool(options::sortInference, option, false); |
9202 |
|
break; |
9203 |
|
case 981: // --static-learning |
9204 |
|
assignBool(options::doStaticLearning, option, true); |
9205 |
|
break; |
9206 |
|
case 982:// --no-static-learning |
9207 |
|
assignBool(options::doStaticLearning, option, false); |
9208 |
|
break; |
9209 |
179 |
case 983: // --sygus-out=MODE |
9210 |
179 |
assign(options::sygusOut, option, optionarg); |
9211 |
179 |
break; |
9212 |
|
case 984: // --sygus-print-callbacks |
9213 |
|
assignBool(options::sygusPrintCallbacks, option, true); |
9214 |
|
break; |
9215 |
|
case 985:// --no-sygus-print-callbacks |
9216 |
|
assignBool(options::sygusPrintCallbacks, option, false); |
9217 |
|
break; |
9218 |
104 |
case 986: // --unconstrained-simp |
9219 |
104 |
assignBool(options::unconstrainedSimp, option, true); |
9220 |
104 |
break; |
9221 |
3 |
case 987:// --no-unconstrained-simp |
9222 |
3 |
assignBool(options::unconstrainedSimp, option, false); |
9223 |
3 |
break; |
9224 |
|
case 988: // --unsat-cores-mode=MODE |
9225 |
|
assign(options::unsatCoresMode, option, optionarg); |
9226 |
|
break; |
9227 |
10 |
case 989: // --re-elim |
9228 |
10 |
assignBool(options::regExpElim, option, true); |
9229 |
10 |
break; |
9230 |
7 |
case 990:// --no-re-elim |
9231 |
7 |
assignBool(options::regExpElim, option, false); |
9232 |
7 |
break; |
9233 |
3 |
case 991: // --re-elim-agg |
9234 |
3 |
assignBool(options::regExpElimAgg, option, true); |
9235 |
3 |
break; |
9236 |
|
case 992:// --no-re-elim-agg |
9237 |
|
assignBool(options::regExpElimAgg, option, false); |
9238 |
|
break; |
9239 |
|
case 993: // --re-inter-mode=MODE |
9240 |
|
assign(options::stringRegExpInterMode, option, optionarg); |
9241 |
|
break; |
9242 |
|
case 994: // --strings-check-entail-len |
9243 |
|
assignBool(options::stringCheckEntailLen, option, true); |
9244 |
|
break; |
9245 |
|
case 995:// --no-strings-check-entail-len |
9246 |
|
assignBool(options::stringCheckEntailLen, option, false); |
9247 |
|
break; |
9248 |
2 |
case 996: // --strings-eager |
9249 |
2 |
assignBool(options::stringEager, option, true); |
9250 |
2 |
break; |
9251 |
|
case 997:// --no-strings-eager |
9252 |
|
assignBool(options::stringEager, option, false); |
9253 |
|
break; |
9254 |
|
case 998: // --strings-eager-eval |
9255 |
|
assignBool(options::stringEagerEval, option, true); |
9256 |
|
break; |
9257 |
|
case 999:// --no-strings-eager-eval |
9258 |
|
assignBool(options::stringEagerEval, option, false); |
9259 |
|
break; |
9260 |
|
case 1000: // --strings-eager-len |
9261 |
|
assignBool(options::stringEagerLen, option, true); |
9262 |
|
break; |
9263 |
|
case 1001:// --no-strings-eager-len |
9264 |
|
assignBool(options::stringEagerLen, option, false); |
9265 |
|
break; |
9266 |
267 |
case 1002: // --strings-exp |
9267 |
267 |
assignBool(options::stringExp, option, true); |
9268 |
267 |
break; |
9269 |
|
case 1003:// --no-strings-exp |
9270 |
|
assignBool(options::stringExp, option, false); |
9271 |
|
break; |
9272 |
|
case 1004: // --strings-ff |
9273 |
|
assignBool(options::stringFlatForms, option, true); |
9274 |
|
break; |
9275 |
|
case 1005:// --no-strings-ff |
9276 |
|
assignBool(options::stringFlatForms, option, false); |
9277 |
|
break; |
9278 |
23 |
case 1006: // --strings-fmf |
9279 |
23 |
assignBool(options::stringFMF, option, true); |
9280 |
23 |
break; |
9281 |
|
case 1007:// --no-strings-fmf |
9282 |
|
assignBool(options::stringFMF, option, false); |
9283 |
|
break; |
9284 |
|
case 1008: // --strings-guess-model |
9285 |
|
assignBool(options::stringGuessModel, option, true); |
9286 |
|
break; |
9287 |
|
case 1009:// --no-strings-guess-model |
9288 |
|
assignBool(options::stringGuessModel, option, false); |
9289 |
|
break; |
9290 |
|
case 1010: // --strings-infer-as-lemmas |
9291 |
|
assignBool(options::stringInferAsLemmas, option, true); |
9292 |
|
break; |
9293 |
|
case 1011:// --no-strings-infer-as-lemmas |
9294 |
|
assignBool(options::stringInferAsLemmas, option, false); |
9295 |
|
break; |
9296 |
|
case 1012: // --strings-infer-sym |
9297 |
|
assignBool(options::stringInferSym, option, true); |
9298 |
|
break; |
9299 |
|
case 1013:// --no-strings-infer-sym |
9300 |
|
assignBool(options::stringInferSym, option, false); |
9301 |
|
break; |
9302 |
|
case 1014: // --strings-inm |
9303 |
|
assignBool(options::stringIgnNegMembership, option, true); |
9304 |
|
break; |
9305 |
|
case 1015:// --no-strings-inm |
9306 |
|
assignBool(options::stringIgnNegMembership, option, false); |
9307 |
|
break; |
9308 |
|
case 1016: // --strings-lazy-pp |
9309 |
|
assignBool(options::stringLazyPreproc, option, true); |
9310 |
|
break; |
9311 |
21 |
case 1017:// --no-strings-lazy-pp |
9312 |
21 |
assignBool(options::stringLazyPreproc, option, false); |
9313 |
21 |
break; |
9314 |
|
case 1018: // --strings-len-norm |
9315 |
|
assignBool(options::stringLenNorm, option, true); |
9316 |
|
break; |
9317 |
|
case 1019:// --no-strings-len-norm |
9318 |
|
assignBool(options::stringLenNorm, option, false); |
9319 |
|
break; |
9320 |
|
case 1020: // --strings-lprop-csp |
9321 |
|
assignBool(options::stringLenPropCsp, option, true); |
9322 |
|
break; |
9323 |
|
case 1021:// --no-strings-lprop-csp |
9324 |
|
assignBool(options::stringLenPropCsp, option, false); |
9325 |
|
break; |
9326 |
|
case 1022: // --strings-min-prefix-explain |
9327 |
|
assignBool(options::stringMinPrefixExplain, option, true); |
9328 |
|
break; |
9329 |
|
case 1023:// --no-strings-min-prefix-explain |
9330 |
|
assignBool(options::stringMinPrefixExplain, option, false); |
9331 |
|
break; |
9332 |
|
case 1024: // --strings-process-loop-mode=MODE |
9333 |
|
assign(options::stringProcessLoopMode, option, optionarg); |
9334 |
|
break; |
9335 |
|
case 1025: // --strings-rexplain-lemmas |
9336 |
|
assignBool(options::stringRExplainLemmas, option, true); |
9337 |
|
break; |
9338 |
|
case 1026:// --no-strings-rexplain-lemmas |
9339 |
|
assignBool(options::stringRExplainLemmas, option, false); |
9340 |
|
break; |
9341 |
|
case 1027: // --strings-unified-vspt |
9342 |
|
assignBool(options::stringUnifiedVSpt, option, true); |
9343 |
|
break; |
9344 |
|
case 1028:// --no-strings-unified-vspt |
9345 |
|
assignBool(options::stringUnifiedVSpt, option, false); |
9346 |
|
break; |
9347 |
|
case 1029: // --assign-function-values |
9348 |
|
assignBool(options::assignFunctionValues, option, true); |
9349 |
|
break; |
9350 |
|
case 1030:// --no-assign-function-values |
9351 |
|
assignBool(options::assignFunctionValues, option, false); |
9352 |
|
break; |
9353 |
|
case 1031: // --condense-function-values |
9354 |
|
assignBool(options::condenseFunctionValues, option, true); |
9355 |
|
break; |
9356 |
|
case 1032:// --no-condense-function-values |
9357 |
|
assignBool(options::condenseFunctionValues, option, false); |
9358 |
|
break; |
9359 |
|
case 1033: // --ee-mode=MODE |
9360 |
|
assign(options::eeMode, option, optionarg); |
9361 |
|
break; |
9362 |
|
case 1034: // --relevance-filter |
9363 |
|
assignBool(options::relevanceFilter, option, true); |
9364 |
|
break; |
9365 |
|
case 1035:// --no-relevance-filter |
9366 |
|
assignBool(options::relevanceFilter, option, false); |
9367 |
|
break; |
9368 |
|
case 1036: // --tc-mode=MODE |
9369 |
|
assign(options::tcMode, option, optionarg); |
9370 |
|
break; |
9371 |
5 |
case 1037: // --theoryof-mode=MODE |
9372 |
5 |
assign(options::theoryOfMode, option, optionarg); |
9373 |
5 |
break; |
9374 |
|
case 1038: // --symmetry-breaker |
9375 |
|
case 1039: // --uf-symmetry-breaker |
9376 |
|
assignBool(options::ufSymmetryBreaker, option, true); |
9377 |
|
break; |
9378 |
|
case 1040:// --no-symmetry-breaker |
9379 |
|
case 1041:// --no-uf-symmetry-breaker |
9380 |
|
assignBool(options::ufSymmetryBreaker, option, false); |
9381 |
|
break; |
9382 |
133 |
case 1042: // --uf-ho |
9383 |
133 |
assignBool(options::ufHo, option, true); |
9384 |
133 |
break; |
9385 |
|
case 1043:// --no-uf-ho |
9386 |
|
assignBool(options::ufHo, option, false); |
9387 |
|
break; |
9388 |
|
case 1044: // --uf-ho-ext |
9389 |
|
assignBool(options::ufHoExt, option, true); |
9390 |
|
break; |
9391 |
|
case 1045:// --no-uf-ho-ext |
9392 |
|
assignBool(options::ufHoExt, option, false); |
9393 |
|
break; |
9394 |
|
case 1046: // --uf-ss-abort-card=N |
9395 |
|
assign(options::ufssAbortCardinality, option, optionarg); |
9396 |
|
break; |
9397 |
|
case 1047: // --uf-ss-fair |
9398 |
|
assignBool(options::ufssFairness, option, true); |
9399 |
|
break; |
9400 |
|
case 1048:// --no-uf-ss-fair |
9401 |
|
assignBool(options::ufssFairness, option, false); |
9402 |
|
break; |
9403 |
4 |
case 1049: // --uf-ss-fair-monotone |
9404 |
4 |
assignBool(options::ufssFairnessMonotone, option, true); |
9405 |
4 |
break; |
9406 |
|
case 1050:// --no-uf-ss-fair-monotone |
9407 |
|
assignBool(options::ufssFairnessMonotone, option, false); |
9408 |
|
break; |
9409 |
|
case 1051: // --uf-ss-totality-limited=N |
9410 |
|
assign(options::ufssTotalityLimited, option, optionarg); |
9411 |
|
break; |
9412 |
|
case 1052: // --uf-ss-totality-sym-break |
9413 |
|
assignBool(options::ufssTotalitySymBreak, option, true); |
9414 |
|
break; |
9415 |
|
case 1053:// --no-uf-ss-totality-sym-break |
9416 |
|
assignBool(options::ufssTotalitySymBreak, option, false); |
9417 |
|
break; |
9418 |
7 |
case 1054: // --uf-ss=MODE |
9419 |
7 |
assign(options::ufssMode, option, optionarg); |
9420 |
7 |
break; |
9421 |
|
|
9422 |
|
case ':' : |
9423 |
|
// This can be a long or short option, and the way to get at the |
9424 |
|
// name of it is different. |
9425 |
|
throw OptionException(std::string("option `") + option |
9426 |
|
+ "' missing its required argument"); |
9427 |
|
|
9428 |
|
case '?': |
9429 |
|
default: |
9430 |
|
throw OptionException(std::string("can't understand option `") + option |
9431 |
|
+ "'" + suggestCommandLineOptions(option)); |
9432 |
|
} |
9433 |
14775 |
} |
9434 |
|
// clang-format on |
9435 |
|
|
9436 |
17823 |
Debug("options") << "got " << nonoptions->size() |
9437 |
5941 |
<< " non-option arguments." << std::endl; |
9438 |
5941 |
} |
9439 |
|
|
9440 |
|
// clang-format off |
9441 |
|
std::vector<std::vector<std::string> > Options::getOptions() const |
9442 |
|
{ |
9443 |
|
std::vector< std::vector<std::string> > opts; |
9444 |
|
|
9445 |
|
opts.push_back({"approx-branch-depth=N", std::to_string(arith().maxApproxDepth)}); |
9446 |
|
opts.push_back({"arith-brab", arith().brabTest ? "true" : "false"}); |
9447 |
|
opts.push_back({"arith-no-partial-fun", arith().arithNoPartialFun ? "true" : "false"}); |
9448 |
|
opts.push_back({"arith-prop-clauses=N", std::to_string(arith().arithPropAsLemmaLength)}); |
9449 |
|
{ std::stringstream ss; ss << arith().arithPropagationMode; opts.push_back({"arith-prop=MODE", ss.str()}); } |
9450 |
|
opts.push_back({"arith-rewrite-equalities", arith().arithRewriteEq ? "true" : "false"}); |
9451 |
|
opts.push_back({"collect-pivot-stats", arith().collectPivots ? "true" : "false"}); |
9452 |
|
opts.push_back({"cut-all-bounded", arith().doCutAllBounded ? "true" : "false"}); |
9453 |
|
opts.push_back({"dio-decomps", arith().exportDioDecompositions ? "true" : "false"}); |
9454 |
|
opts.push_back({"dio-repeat", arith().dioRepeat ? "true" : "false"}); |
9455 |
|
opts.push_back({"dio-solver", arith().arithDioSolver ? "true" : "false"}); |
9456 |
|
opts.push_back({"dio-turns=N", std::to_string(arith().dioSolverTurns)}); |
9457 |
|
{ std::stringstream ss; ss << arith().arithErrorSelectionRule; opts.push_back({"error-selection-rule=RULE", ss.str()}); } |
9458 |
|
opts.push_back({"fc-penalties", arith().havePenalties ? "true" : "false"}); |
9459 |
|
opts.push_back({"heuristic-pivots=N", std::to_string(arith().arithHeuristicPivots)}); |
9460 |
|
opts.push_back({"lemmas-on-replay-failure", arith().replayFailureLemma ? "true" : "false"}); |
9461 |
|
opts.push_back({"maxCutsInContext=N", std::to_string(arith().maxCutsInContext)}); |
9462 |
|
opts.push_back({"miplib-trick", arith().arithMLTrick ? "true" : "false"}); |
9463 |
|
opts.push_back({"miplib-trick-subs=N", std::to_string(arith().arithMLTrickSubstitutions)}); |
9464 |
|
opts.push_back({"new-prop", arith().newProp ? "true" : "false"}); |
9465 |
|
opts.push_back({"nl-cad", arith().nlCad ? "true" : "false"}); |
9466 |
|
opts.push_back({"nl-cad-initial", arith().nlCadUseInitial ? "true" : "false"}); |
9467 |
|
opts.push_back({"nl-ext-ent-conf", arith().nlExtEntailConflicts ? "true" : "false"}); |
9468 |
|
opts.push_back({"nl-ext-factor", arith().nlExtFactor ? "true" : "false"}); |
9469 |
|
opts.push_back({"nl-ext-inc-prec", arith().nlExtIncPrecision ? "true" : "false"}); |
9470 |
|
opts.push_back({"nl-ext-purify", arith().nlExtPurify ? "true" : "false"}); |
9471 |
|
opts.push_back({"nl-ext-rbound", arith().nlExtResBound ? "true" : "false"}); |
9472 |
|
opts.push_back({"nl-ext-rewrite", arith().nlExtRewrites ? "true" : "false"}); |
9473 |
|
opts.push_back({"nl-ext-split-zero", arith().nlExtSplitZero ? "true" : "false"}); |
9474 |
|
opts.push_back({"nl-ext-tf-taylor-deg=N", std::to_string(arith().nlExtTfTaylorDegree)}); |
9475 |
|
opts.push_back({"nl-ext-tf-tplanes", arith().nlExtTfTangentPlanes ? "true" : "false"}); |
9476 |
|
opts.push_back({"nl-ext-tplanes", arith().nlExtTangentPlanes ? "true" : "false"}); |
9477 |
|
opts.push_back({"nl-ext-tplanes-interleave", arith().nlExtTangentPlanesInterleave ? "true" : "false"}); |
9478 |
|
{ std::stringstream ss; ss << arith().nlExt; opts.push_back({"nl-ext=MODE", ss.str()}); } |
9479 |
|
opts.push_back({"nl-icp", arith().nlICP ? "true" : "false"}); |
9480 |
|
{ std::stringstream ss; ss << arith().nlRlvMode; opts.push_back({"nl-rlv=MODE", ss.str()}); } |
9481 |
|
opts.push_back({"pb-rewrites", arith().pbRewrites ? "true" : "false"}); |
9482 |
|
opts.push_back({"pivot-threshold=N", std::to_string(arith().arithPivotThreshold)}); |
9483 |
|
opts.push_back({"pp-assert-max-sub-size=N", std::to_string(arith().ppAssertMaxSubSize)}); |
9484 |
|
opts.push_back({"prop-row-length=N", std::to_string(arith().arithPropagateMaxLength)}); |
9485 |
|
opts.push_back({"replay-early-close-depth=N", std::to_string(arith().replayEarlyCloseDepths)}); |
9486 |
|
opts.push_back({"replay-failure-penalty=N", std::to_string(arith().replayFailurePenalty)}); |
9487 |
|
opts.push_back({"replay-lemma-reject-cut=N", std::to_string(arith().lemmaRejectCutSize)}); |
9488 |
|
opts.push_back({"replay-num-err-penalty=N", std::to_string(arith().replayNumericFailurePenalty)}); |
9489 |
|
opts.push_back({"replay-reject-cut=N", std::to_string(arith().replayRejectCutSize)}); |
9490 |
|
opts.push_back({"replay-soi-major-threshold-pen=N", std::to_string(arith().soiApproxMajorFailurePen)}); |
9491 |
|
opts.push_back({"replay-soi-major-threshold=T", std::to_string(arith().soiApproxMajorFailure)}); |
9492 |
|
opts.push_back({"replay-soi-minor-threshold-pen=N", std::to_string(arith().soiApproxMinorFailurePen)}); |
9493 |
|
opts.push_back({"replay-soi-minor-threshold=T", std::to_string(arith().soiApproxMinorFailure)}); |
9494 |
|
opts.push_back({"restrict-pivots", arith().restrictedPivots ? "true" : "false"}); |
9495 |
|
opts.push_back({"revert-arith-models-on-unsat", arith().revertArithModels ? "true" : "false"}); |
9496 |
|
opts.push_back({"rr-turns=N", std::to_string(arith().rrTurns)}); |
9497 |
|
opts.push_back({"se-solve-int", arith().trySolveIntStandardEffort ? "true" : "false"}); |
9498 |
|
opts.push_back({"simplex-check-period=N", std::to_string(arith().arithSimplexCheckPeriod)}); |
9499 |
|
opts.push_back({"soi-qe", arith().soiQuickExplain ? "true" : "false"}); |
9500 |
|
opts.push_back({"standard-effort-variable-order-pivots=N", std::to_string(arith().arithStandardCheckVarOrderPivots)}); |
9501 |
|
{ std::stringstream ss; ss << arith().arithUnateLemmaMode; opts.push_back({"unate-lemmas=MODE", ss.str()}); } |
9502 |
|
opts.push_back({"use-approx", arith().useApprox ? "true" : "false"}); |
9503 |
|
opts.push_back({"use-fcsimplex", arith().useFC ? "true" : "false"}); |
9504 |
|
opts.push_back({"use-soi", arith().useSOI ? "true" : "false"}); |
9505 |
|
opts.push_back({"arrays-config=N", std::to_string(arrays().arraysConfig)}); |
9506 |
|
opts.push_back({"arrays-eager-index", arrays().arraysEagerIndexSplitting ? "true" : "false"}); |
9507 |
|
opts.push_back({"arrays-eager-lemmas", arrays().arraysEagerLemmas ? "true" : "false"}); |
9508 |
|
opts.push_back({"arrays-exp", arrays().arraysExp ? "true" : "false"}); |
9509 |
|
opts.push_back({"arrays-model-based", arrays().arraysModelBased ? "true" : "false"}); |
9510 |
|
opts.push_back({"arrays-optimize-linear", arrays().arraysOptimizeLinear ? "true" : "false"}); |
9511 |
|
opts.push_back({"arrays-prop=N", std::to_string(arrays().arraysPropagate)}); |
9512 |
|
opts.push_back({"arrays-reduce-sharing", arrays().arraysReduceSharing ? "true" : "false"}); |
9513 |
|
opts.push_back({"arrays-weak-equiv", arrays().arraysWeakEquivalence ? "true" : "false"}); |
9514 |
|
{ std::stringstream ss; ss << base().inputLanguage; opts.push_back({"lang=LANG", ss.str()}); } |
9515 |
|
{ std::stringstream ss; ss << base().outputLanguage; opts.push_back({"output-lang=LANG", ss.str()}); } |
9516 |
|
opts.push_back({"parse-only", base().parseOnly ? "true" : "false"}); |
9517 |
|
opts.push_back({"preprocess-only", base().preprocessOnly ? "true" : "false"}); |
9518 |
|
opts.push_back({"print-success", base().printSuccess ? "true" : "false"}); |
9519 |
|
opts.push_back({"stats", base().statistics ? "true" : "false"}); |
9520 |
|
opts.push_back({"stats-all", base().statisticsAll ? "true" : "false"}); |
9521 |
|
opts.push_back({"stats-every-query", base().statisticsEveryQuery ? "true" : "false"}); |
9522 |
|
opts.push_back({"stats-expert", base().statisticsExpert ? "true" : "false"}); |
9523 |
|
opts.push_back({"verbosity=N", std::to_string(base().verbosity)}); |
9524 |
|
opts.push_back({"bitblast-aig", bv().bitvectorAig ? "true" : "false"}); |
9525 |
|
{ std::stringstream ss; ss << bv().bitblastMode; opts.push_back({"bitblast=MODE", ss.str()}); } |
9526 |
|
opts.push_back({"bitwise-eq", bv().bitwiseEq ? "true" : "false"}); |
9527 |
|
{ std::stringstream ss; ss << bv().boolToBitvector; opts.push_back({"bool-to-bv=MODE", ss.str()}); } |
9528 |
|
opts.push_back({"bv-abstraction", bv().bvAbstraction ? "true" : "false"}); |
9529 |
|
{ std::stringstream ss; ss << bv().bitvectorAigSimplifications; opts.push_back({"bv-aig-simp=COMMAND", ss.str()}); } |
9530 |
|
opts.push_back({"bv-alg-extf", bv().bvAlgExtf ? "true" : "false"}); |
9531 |
|
opts.push_back({"bv-algebraic-budget=N", std::to_string(bv().bitvectorAlgebraicBudget)}); |
9532 |
|
opts.push_back({"bv-algebraic-solver", bv().bitvectorAlgebraicSolver ? "true" : "false"}); |
9533 |
|
opts.push_back({"bv-assert-input", bv().bvAssertInput ? "true" : "false"}); |
9534 |
|
opts.push_back({"bv-eager-explanations", bv().bvEagerExplanations ? "true" : "false"}); |
9535 |
|
opts.push_back({"bv-eq-solver", bv().bitvectorEqualitySolver ? "true" : "false"}); |
9536 |
|
opts.push_back({"bv-extract-arith", bv().bvExtractArithRewrite ? "true" : "false"}); |
9537 |
|
opts.push_back({"bv-gauss-elim", bv().bvGaussElim ? "true" : "false"}); |
9538 |
|
opts.push_back({"bv-inequality-solver", bv().bitvectorInequalitySolver ? "true" : "false"}); |
9539 |
|
opts.push_back({"bv-intro-pow2", bv().bvIntroducePow2 ? "true" : "false"}); |
9540 |
|
opts.push_back({"bv-lazy-reduce-extf", bv().bvLazyReduceExtf ? "true" : "false"}); |
9541 |
|
opts.push_back({"bv-lazy-rewrite-extf", bv().bvLazyRewriteExtf ? "true" : "false"}); |
9542 |
|
opts.push_back({"bv-num-func=N", std::to_string(bv().bvNumFunc)}); |
9543 |
|
opts.push_back({"bv-print-consts-as-indexed-symbols", bv().bvPrintConstsAsIndexedSymbols ? "true" : "false"}); |
9544 |
|
opts.push_back({"bv-propagate", bv().bitvectorPropagate ? "true" : "false"}); |
9545 |
|
opts.push_back({"bv-quick-xplain", bv().bitvectorQuickXplain ? "true" : "false"}); |
9546 |
|
{ std::stringstream ss; ss << bv().bvSatSolver; opts.push_back({"bv-sat-solver=MODE", ss.str()}); } |
9547 |
|
opts.push_back({"bv-skolemize", bv().skolemizeArguments ? "true" : "false"}); |
9548 |
|
{ std::stringstream ss; ss << bv().bvSolver; opts.push_back({"bv-solver=MODE", ss.str()}); } |
9549 |
|
opts.push_back({"bv-to-bool", bv().bitvectorToBool ? "true" : "false"}); |
9550 |
|
opts.push_back({"cdt-bisimilar", datatypes().cdtBisimilar ? "true" : "false"}); |
9551 |
|
opts.push_back({"dt-binary-split", datatypes().dtBinarySplit ? "true" : "false"}); |
9552 |
|
opts.push_back({"dt-blast-splits", datatypes().dtBlastSplits ? "true" : "false"}); |
9553 |
|
opts.push_back({"dt-cyclic", datatypes().dtCyclic ? "true" : "false"}); |
9554 |
|
opts.push_back({"dt-force-assignment", datatypes().dtForceAssignment ? "true" : "false"}); |
9555 |
|
opts.push_back({"dt-infer-as-lemmas", datatypes().dtInferAsLemmas ? "true" : "false"}); |
9556 |
|
opts.push_back({"dt-nested-rec", datatypes().dtNestedRec ? "true" : "false"}); |
9557 |
|
opts.push_back({"dt-polite-optimize", datatypes().dtPoliteOptimize ? "true" : "false"}); |
9558 |
|
opts.push_back({"dt-rewrite-error-sel", datatypes().dtRewriteErrorSel ? "true" : "false"}); |
9559 |
|
opts.push_back({"dt-share-sel", datatypes().dtSharedSelectors ? "true" : "false"}); |
9560 |
|
opts.push_back({"sygus-abort-size=N", std::to_string(datatypes().sygusAbortSize)}); |
9561 |
|
opts.push_back({"sygus-fair-max", datatypes().sygusFairMax ? "true" : "false"}); |
9562 |
|
{ std::stringstream ss; ss << datatypes().sygusFair; opts.push_back({"sygus-fair=MODE", ss.str()}); } |
9563 |
|
opts.push_back({"sygus-sym-break", datatypes().sygusSymBreak ? "true" : "false"}); |
9564 |
|
opts.push_back({"sygus-sym-break-agg", datatypes().sygusSymBreakAgg ? "true" : "false"}); |
9565 |
|
opts.push_back({"sygus-sym-break-dynamic", datatypes().sygusSymBreakDynamic ? "true" : "false"}); |
9566 |
|
opts.push_back({"sygus-sym-break-lazy", datatypes().sygusSymBreakLazy ? "true" : "false"}); |
9567 |
|
opts.push_back({"sygus-sym-break-pbe", datatypes().sygusSymBreakPbe ? "true" : "false"}); |
9568 |
|
opts.push_back({"sygus-sym-break-rlv", datatypes().sygusSymBreakRlv ? "true" : "false"}); |
9569 |
|
opts.push_back({"decision-random-weight=N", std::to_string(decision().decisionRandomWeight)}); |
9570 |
|
{ std::stringstream ss; ss << decision().decisionThreshold; opts.push_back({"decision-threshold=N", ss.str()}); } |
9571 |
|
opts.push_back({"decision-use-weight", decision().decisionUseWeight ? "true" : "false"}); |
9572 |
|
{ std::stringstream ss; ss << decision().decisionWeightInternal; opts.push_back({"decision-weight-internal=HOW", ss.str()}); } |
9573 |
|
{ std::stringstream ss; ss << decision().decisionMode; opts.push_back({"decision=MODE", ss.str()}); } |
9574 |
|
opts.push_back({"dag-thresh=N", std::to_string(expr().defaultDagThresh)}); |
9575 |
|
opts.push_back({"expr-depth=N", std::to_string(expr().defaultExprDepth)}); |
9576 |
|
opts.push_back({"type-checking", expr().typeChecking ? "true" : "false"}); |
9577 |
|
opts.push_back({"fp-exp", fp().fpExp ? "true" : "false"}); |
9578 |
|
opts.push_back({"early-exit", driver().earlyExit ? "true" : "false"}); |
9579 |
|
opts.push_back({"help", driver().help ? "true" : "false"}); |
9580 |
|
opts.push_back({"interactive", driver().interactive ? "true" : "false"}); |
9581 |
|
opts.push_back({"interactive-prompt", driver().interactivePrompt ? "true" : "false"}); |
9582 |
|
opts.push_back({"seed=N", std::to_string(driver().seed)}); |
9583 |
|
opts.push_back({"segv-spin", driver().segvSpin ? "true" : "false"}); |
9584 |
|
opts.push_back({"tear-down-incremental=N", std::to_string(driver().tearDownIncremental)}); |
9585 |
|
opts.push_back({"version", driver().version ? "true" : "false"}); |
9586 |
|
opts.push_back({"filesystem-access", parser().filesystemAccess ? "true" : "false"}); |
9587 |
|
{ std::stringstream ss; ss << parser().forceLogicString; opts.push_back({"force-logic=LOGIC", ss.str()}); } |
9588 |
|
opts.push_back({"global-declarations", parser().globalDeclarations ? "true" : "false"}); |
9589 |
|
opts.push_back({"mmap", parser().memoryMap ? "true" : "false"}); |
9590 |
|
opts.push_back({"semantic-checks", parser().semanticChecks ? "true" : "false"}); |
9591 |
|
opts.push_back({"strict-parsing", parser().strictParsing ? "true" : "false"}); |
9592 |
|
opts.push_back({"flatten-ho-chains", printer().flattenHOChains ? "true" : "false"}); |
9593 |
|
{ std::stringstream ss; ss << printer().instFormatMode; opts.push_back({"inst-format=MODE", ss.str()}); } |
9594 |
|
{ std::stringstream ss; ss << printer().modelFormatMode; opts.push_back({"model-format=MODE", ss.str()}); } |
9595 |
|
opts.push_back({"print-inst-full", printer().printInstFull ? "true" : "false"}); |
9596 |
|
{ std::stringstream ss; ss << printer().printInstMode; opts.push_back({"print-inst=MODE", ss.str()}); } |
9597 |
|
opts.push_back({"proof-eager-checking", proof().proofEagerChecking ? "true" : "false"}); |
9598 |
|
{ std::stringstream ss; ss << proof().proofFormatMode; opts.push_back({"proof-format-mode=MODE", ss.str()}); } |
9599 |
|
{ std::stringstream ss; ss << proof().proofGranularityMode; opts.push_back({"proof-granularity=MODE", ss.str()}); } |
9600 |
|
opts.push_back({"proof-pedantic=N", std::to_string(proof().proofPedantic)}); |
9601 |
|
opts.push_back({"proof-print-conclusion", proof().proofPrintConclusion ? "true" : "false"}); |
9602 |
|
opts.push_back({"minisat-dump-dimacs", prop().minisatDumpDimacs ? "true" : "false"}); |
9603 |
|
opts.push_back({"minisat-elimination", prop().minisatUseElim ? "true" : "false"}); |
9604 |
|
opts.push_back({"random-freq=P", std::to_string(prop().satRandomFreq)}); |
9605 |
|
opts.push_back({"random-seed=S", std::to_string(prop().satRandomSeed)}); |
9606 |
|
opts.push_back({"refine-conflicts", prop().sat_refine_conflicts ? "true" : "false"}); |
9607 |
|
opts.push_back({"restart-int-base=N", std::to_string(prop().satRestartFirst)}); |
9608 |
|
opts.push_back({"restart-int-inc=F", std::to_string(prop().satRestartInc)}); |
9609 |
|
opts.push_back({"ag-miniscope-quant", quantifiers().aggressiveMiniscopeQuant ? "true" : "false"}); |
9610 |
|
{ std::stringstream ss; ss << quantifiers().cegisSample; opts.push_back({"cegis-sample=MODE", ss.str()}); } |
9611 |
|
opts.push_back({"cegqi", quantifiers().cegqi ? "true" : "false"}); |
9612 |
|
opts.push_back({"cegqi-all", quantifiers().cegqiAll ? "true" : "false"}); |
9613 |
|
opts.push_back({"cegqi-bv", quantifiers().cegqiBv ? "true" : "false"}); |
9614 |
|
opts.push_back({"cegqi-bv-concat-inv", quantifiers().cegqiBvConcInv ? "true" : "false"}); |
9615 |
|
{ std::stringstream ss; ss << quantifiers().cegqiBvIneqMode; opts.push_back({"cegqi-bv-ineq=MODE", ss.str()}); } |
9616 |
|
opts.push_back({"cegqi-bv-interleave-value", quantifiers().cegqiBvInterleaveValue ? "true" : "false"}); |
9617 |
|
opts.push_back({"cegqi-bv-linear", quantifiers().cegqiBvLinearize ? "true" : "false"}); |
9618 |
|
opts.push_back({"cegqi-bv-rm-extract", quantifiers().cegqiBvRmExtract ? "true" : "false"}); |
9619 |
|
opts.push_back({"cegqi-bv-solve-nl", quantifiers().cegqiBvSolveNl ? "true" : "false"}); |
9620 |
|
opts.push_back({"cegqi-full", quantifiers().cegqiFullEffort ? "true" : "false"}); |
9621 |
|
opts.push_back({"cegqi-innermost", quantifiers().cegqiInnermost ? "true" : "false"}); |
9622 |
|
opts.push_back({"cegqi-midpoint", quantifiers().cegqiMidpoint ? "true" : "false"}); |
9623 |
|
opts.push_back({"cegqi-min-bounds", quantifiers().cegqiMinBounds ? "true" : "false"}); |
9624 |
|
opts.push_back({"cegqi-model", quantifiers().cegqiModel ? "true" : "false"}); |
9625 |
|
opts.push_back({"cegqi-multi-inst", quantifiers().cegqiMultiInst ? "true" : "false"}); |
9626 |
|
opts.push_back({"cegqi-nested-qe", quantifiers().cegqiNestedQE ? "true" : "false"}); |
9627 |
|
opts.push_back({"cegqi-nopt", quantifiers().cegqiNopt ? "true" : "false"}); |
9628 |
|
opts.push_back({"cegqi-repeat-lit", quantifiers().cegqiRepeatLit ? "true" : "false"}); |
9629 |
|
opts.push_back({"cegqi-round-up-lia", quantifiers().cegqiRoundUpLowerLia ? "true" : "false"}); |
9630 |
|
opts.push_back({"cegqi-sat", quantifiers().cegqiSat ? "true" : "false"}); |
9631 |
|
opts.push_back({"cegqi-use-inf-int", quantifiers().cegqiUseInfInt ? "true" : "false"}); |
9632 |
|
opts.push_back({"cegqi-use-inf-real", quantifiers().cegqiUseInfReal ? "true" : "false"}); |
9633 |
|
opts.push_back({"cond-var-split-agg-quant", quantifiers().condVarSplitQuantAgg ? "true" : "false"}); |
9634 |
|
opts.push_back({"cond-var-split-quant", quantifiers().condVarSplitQuant ? "true" : "false"}); |
9635 |
|
opts.push_back({"conjecture-filter-active-terms", quantifiers().conjectureFilterActiveTerms ? "true" : "false"}); |
9636 |
|
opts.push_back({"conjecture-filter-canonical", quantifiers().conjectureFilterCanonical ? "true" : "false"}); |
9637 |
|
opts.push_back({"conjecture-filter-model", quantifiers().conjectureFilterModel ? "true" : "false"}); |
9638 |
|
opts.push_back({"conjecture-gen", quantifiers().conjectureGen ? "true" : "false"}); |
9639 |
|
opts.push_back({"conjecture-gen-gt-enum=N", std::to_string(quantifiers().conjectureGenGtEnum)}); |
9640 |
|
opts.push_back({"conjecture-gen-max-depth=N", std::to_string(quantifiers().conjectureGenMaxDepth)}); |
9641 |
|
opts.push_back({"conjecture-gen-per-round=N", std::to_string(quantifiers().conjectureGenPerRound)}); |
9642 |
|
opts.push_back({"conjecture-gen-uee-intro", quantifiers().conjectureUeeIntro ? "true" : "false"}); |
9643 |
|
opts.push_back({"conjecture-no-filter", quantifiers().conjectureNoFilter ? "true" : "false"}); |
9644 |
|
opts.push_back({"debug-inst", quantifiers().debugInst ? "true" : "false"}); |
9645 |
|
opts.push_back({"debug-sygus", quantifiers().debugSygus ? "true" : "false"}); |
9646 |
|
opts.push_back({"dt-stc-ind", quantifiers().dtStcInduction ? "true" : "false"}); |
9647 |
|
opts.push_back({"dt-var-exp-quant", quantifiers().dtVarExpandQuant ? "true" : "false"}); |
9648 |
|
opts.push_back({"e-matching", quantifiers().eMatching ? "true" : "false"}); |
9649 |
|
opts.push_back({"elim-taut-quant", quantifiers().elimTautQuant ? "true" : "false"}); |
9650 |
|
opts.push_back({"ext-rewrite-quant", quantifiers().extRewriteQuant ? "true" : "false"}); |
9651 |
|
opts.push_back({"finite-model-find", quantifiers().finiteModelFind ? "true" : "false"}); |
9652 |
|
opts.push_back({"fmf-bound", quantifiers().fmfBound ? "true" : "false"}); |
9653 |
|
opts.push_back({"fmf-bound-int", quantifiers().fmfBoundInt ? "true" : "false"}); |
9654 |
|
opts.push_back({"fmf-bound-lazy", quantifiers().fmfBoundLazy ? "true" : "false"}); |
9655 |
|
opts.push_back({"fmf-fmc-simple", quantifiers().fmfFmcSimple ? "true" : "false"}); |
9656 |
|
opts.push_back({"fmf-fresh-dc", quantifiers().fmfFreshDistConst ? "true" : "false"}); |
9657 |
|
opts.push_back({"fmf-fun", quantifiers().fmfFunWellDefined ? "true" : "false"}); |
9658 |
|
opts.push_back({"fmf-fun-rlv", quantifiers().fmfFunWellDefinedRelevant ? "true" : "false"}); |
9659 |
|
opts.push_back({"fmf-inst-engine", quantifiers().fmfInstEngine ? "true" : "false"}); |
9660 |
|
opts.push_back({"fmf-type-completion-thresh=N", std::to_string(quantifiers().fmfTypeCompletionThresh)}); |
9661 |
|
opts.push_back({"fs-interleave", quantifiers().fullSaturateInterleave ? "true" : "false"}); |
9662 |
|
opts.push_back({"fs-stratify", quantifiers().fullSaturateStratify ? "true" : "false"}); |
9663 |
|
opts.push_back({"fs-sum", quantifiers().fullSaturateSum ? "true" : "false"}); |
9664 |
|
opts.push_back({"full-saturate-quant", quantifiers().fullSaturateQuant ? "true" : "false"}); |
9665 |
|
opts.push_back({"full-saturate-quant-limit=N", std::to_string(quantifiers().fullSaturateLimit)}); |
9666 |
|
opts.push_back({"full-saturate-quant-rd", quantifiers().fullSaturateQuantRd ? "true" : "false"}); |
9667 |
|
opts.push_back({"global-negate", quantifiers().globalNegate ? "true" : "false"}); |
9668 |
|
opts.push_back({"ho-elim", quantifiers().hoElim ? "true" : "false"}); |
9669 |
|
opts.push_back({"ho-elim-store-ax", quantifiers().hoElimStoreAx ? "true" : "false"}); |
9670 |
|
opts.push_back({"ho-matching", quantifiers().hoMatching ? "true" : "false"}); |
9671 |
|
opts.push_back({"ho-matching-var-priority", quantifiers().hoMatchingVarArgPriority ? "true" : "false"}); |
9672 |
|
opts.push_back({"ho-merge-term-db", quantifiers().hoMergeTermDb ? "true" : "false"}); |
9673 |
|
opts.push_back({"increment-triggers", quantifiers().incrementTriggers ? "true" : "false"}); |
9674 |
|
opts.push_back({"inst-level-input-only", quantifiers().instLevelInputOnly ? "true" : "false"}); |
9675 |
|
opts.push_back({"inst-max-level=N", std::to_string(quantifiers().instMaxLevel)}); |
9676 |
|
opts.push_back({"inst-no-entail", quantifiers().instNoEntail ? "true" : "false"}); |
9677 |
|
opts.push_back({"inst-when-phase=N", std::to_string(quantifiers().instWhenPhase)}); |
9678 |
|
opts.push_back({"inst-when-strict-interleave", quantifiers().instWhenStrictInterleave ? "true" : "false"}); |
9679 |
|
opts.push_back({"inst-when-tc-first", quantifiers().instWhenTcFirst ? "true" : "false"}); |
9680 |
|
{ std::stringstream ss; ss << quantifiers().instWhenMode; opts.push_back({"inst-when=MODE", ss.str()}); } |
9681 |
|
opts.push_back({"int-wf-ind", quantifiers().intWfInduction ? "true" : "false"}); |
9682 |
|
opts.push_back({"ite-dtt-split-quant", quantifiers().iteDtTesterSplitQuant ? "true" : "false"}); |
9683 |
|
{ std::stringstream ss; ss << quantifiers().iteLiftQuant; opts.push_back({"ite-lift-quant=MODE", ss.str()}); } |
9684 |
|
{ std::stringstream ss; ss << quantifiers().literalMatchMode; opts.push_back({"literal-matching=MODE", ss.str()}); } |
9685 |
|
opts.push_back({"macros-quant", quantifiers().macrosQuant ? "true" : "false"}); |
9686 |
|
{ std::stringstream ss; ss << quantifiers().macrosQuantMode; opts.push_back({"macros-quant-mode=MODE", ss.str()}); } |
9687 |
|
opts.push_back({"mbqi-interleave", quantifiers().mbqiInterleave ? "true" : "false"}); |
9688 |
|
opts.push_back({"mbqi-one-inst-per-round", quantifiers().fmfOneInstPerRound ? "true" : "false"}); |
9689 |
|
{ std::stringstream ss; ss << quantifiers().mbqiMode; opts.push_back({"mbqi=MODE", ss.str()}); } |
9690 |
|
opts.push_back({"miniscope-quant", quantifiers().miniscopeQuant ? "true" : "false"}); |
9691 |
|
opts.push_back({"miniscope-quant-fv", quantifiers().miniscopeQuantFreeVar ? "true" : "false"}); |
9692 |
|
opts.push_back({"multi-trigger-cache", quantifiers().multiTriggerCache ? "true" : "false"}); |
9693 |
|
opts.push_back({"multi-trigger-linear", quantifiers().multiTriggerLinear ? "true" : "false"}); |
9694 |
|
opts.push_back({"multi-trigger-priority", quantifiers().multiTriggerPriority ? "true" : "false"}); |
9695 |
|
opts.push_back({"multi-trigger-when-single", quantifiers().multiTriggerWhenSingle ? "true" : "false"}); |
9696 |
|
opts.push_back({"partial-triggers", quantifiers().partialTriggers ? "true" : "false"}); |
9697 |
|
opts.push_back({"pool-inst", quantifiers().poolInst ? "true" : "false"}); |
9698 |
|
opts.push_back({"pre-skolem-quant", quantifiers().preSkolemQuant ? "true" : "false"}); |
9699 |
|
opts.push_back({"pre-skolem-quant-agg", quantifiers().preSkolemQuantAgg ? "true" : "false"}); |
9700 |
|
opts.push_back({"pre-skolem-quant-nested", quantifiers().preSkolemQuantNested ? "true" : "false"}); |
9701 |
|
opts.push_back({"prenex-quant-user", quantifiers().prenexQuantUser ? "true" : "false"}); |
9702 |
|
{ std::stringstream ss; ss << quantifiers().prenexQuant; opts.push_back({"prenex-quant=MODE", ss.str()}); } |
9703 |
|
opts.push_back({"purify-triggers", quantifiers().purifyTriggers ? "true" : "false"}); |
9704 |
|
opts.push_back({"qcf-all-conflict", quantifiers().qcfAllConflict ? "true" : "false"}); |
9705 |
|
opts.push_back({"qcf-eager-check-rd", quantifiers().qcfEagerCheckRd ? "true" : "false"}); |
9706 |
|
opts.push_back({"qcf-eager-test", quantifiers().qcfEagerTest ? "true" : "false"}); |
9707 |
|
opts.push_back({"qcf-nested-conflict", quantifiers().qcfNestedConflict ? "true" : "false"}); |
9708 |
|
opts.push_back({"qcf-skip-rd", quantifiers().qcfSkipRd ? "true" : "false"}); |
9709 |
|
opts.push_back({"qcf-tconstraint", quantifiers().qcfTConstraint ? "true" : "false"}); |
9710 |
|
opts.push_back({"qcf-vo-exp", quantifiers().qcfVoExp ? "true" : "false"}); |
9711 |
|
opts.push_back({"quant-alpha-equiv", quantifiers().quantAlphaEquiv ? "true" : "false"}); |
9712 |
|
opts.push_back({"quant-cf", quantifiers().quantConflictFind ? "true" : "false"}); |
9713 |
|
{ std::stringstream ss; ss << quantifiers().qcfMode; opts.push_back({"quant-cf-mode=MODE", ss.str()}); } |
9714 |
|
{ std::stringstream ss; ss << quantifiers().qcfWhenMode; opts.push_back({"quant-cf-when=MODE", ss.str()}); } |
9715 |
|
{ std::stringstream ss; ss << quantifiers().quantDynamicSplit; opts.push_back({"quant-dsplit-mode=MODE", ss.str()}); } |
9716 |
|
opts.push_back({"quant-fun-wd", quantifiers().quantFunWellDefined ? "true" : "false"}); |
9717 |
|
opts.push_back({"quant-ind", quantifiers().quantInduction ? "true" : "false"}); |
9718 |
|
{ std::stringstream ss; ss << quantifiers().quantRepMode; opts.push_back({"quant-rep-mode=MODE", ss.str()}); } |
9719 |
|
opts.push_back({"quant-split", quantifiers().quantSplit ? "true" : "false"}); |
9720 |
|
opts.push_back({"register-quant-body-terms", quantifiers().registerQuantBodyTerms ? "true" : "false"}); |
9721 |
|
opts.push_back({"relational-triggers", quantifiers().relationalTriggers ? "true" : "false"}); |
9722 |
|
opts.push_back({"relevant-triggers", quantifiers().relevantTriggers ? "true" : "false"}); |
9723 |
|
opts.push_back({"strict-triggers", quantifiers().strictTriggers ? "true" : "false"}); |
9724 |
|
opts.push_back({"sygus", quantifiers().sygus ? "true" : "false"}); |
9725 |
|
opts.push_back({"sygus-active-gen-cfactor=N", std::to_string(quantifiers().sygusActiveGenEnumConsts)}); |
9726 |
|
{ std::stringstream ss; ss << quantifiers().sygusActiveGenMode; opts.push_back({"sygus-active-gen=MODE", ss.str()}); } |
9727 |
|
opts.push_back({"sygus-add-const-grammar", quantifiers().sygusAddConstGrammar ? "true" : "false"}); |
9728 |
|
opts.push_back({"sygus-arg-relevant", quantifiers().sygusArgRelevant ? "true" : "false"}); |
9729 |
|
opts.push_back({"sygus-auto-unfold", quantifiers().sygusInvAutoUnfold ? "true" : "false"}); |
9730 |
|
opts.push_back({"sygus-bool-ite-return-const", quantifiers().sygusBoolIteReturnConst ? "true" : "false"}); |
9731 |
|
opts.push_back({"sygus-core-connective", quantifiers().sygusCoreConnective ? "true" : "false"}); |
9732 |
|
opts.push_back({"sygus-crepair-abort", quantifiers().sygusConstRepairAbort ? "true" : "false"}); |
9733 |
|
opts.push_back({"sygus-eval-opt", quantifiers().sygusEvalOpt ? "true" : "false"}); |
9734 |
|
opts.push_back({"sygus-eval-unfold", quantifiers().sygusEvalUnfold ? "true" : "false"}); |
9735 |
|
opts.push_back({"sygus-eval-unfold-bool", quantifiers().sygusEvalUnfoldBool ? "true" : "false"}); |
9736 |
|
opts.push_back({"sygus-expr-miner-check-timeout=N", std::to_string(quantifiers().sygusExprMinerCheckTimeout)}); |
9737 |
|
opts.push_back({"sygus-ext-rew", quantifiers().sygusExtRew ? "true" : "false"}); |
9738 |
|
opts.push_back({"sygus-filter-sol-rev", quantifiers().sygusFilterSolRevSubsume ? "true" : "false"}); |
9739 |
|
{ std::stringstream ss; ss << quantifiers().sygusFilterSolMode; opts.push_back({"sygus-filter-sol=MODE", ss.str()}); } |
9740 |
|
{ std::stringstream ss; ss << quantifiers().sygusGrammarConsMode; opts.push_back({"sygus-grammar-cons=MODE", ss.str()}); } |
9741 |
|
opts.push_back({"sygus-grammar-norm", quantifiers().sygusGrammarNorm ? "true" : "false"}); |
9742 |
|
opts.push_back({"sygus-inference", quantifiers().sygusInference ? "true" : "false"}); |
9743 |
|
opts.push_back({"sygus-inst", quantifiers().sygusInst ? "true" : "false"}); |
9744 |
|
{ std::stringstream ss; ss << quantifiers().sygusInstMode; opts.push_back({"sygus-inst-mode=MODE", ss.str()}); } |
9745 |
|
{ std::stringstream ss; ss << quantifiers().sygusInstScope; opts.push_back({"sygus-inst-scope=MODE", ss.str()}); } |
9746 |
|
{ std::stringstream ss; ss << quantifiers().sygusInstTermSel; opts.push_back({"sygus-inst-term-sel=MODE", ss.str()}); } |
9747 |
|
opts.push_back({"sygus-inv-templ-when-sg", quantifiers().sygusInvTemplWhenSyntax ? "true" : "false"}); |
9748 |
|
{ std::stringstream ss; ss << quantifiers().sygusInvTemplMode; opts.push_back({"sygus-inv-templ=MODE", ss.str()}); } |
9749 |
|
opts.push_back({"sygus-min-grammar", quantifiers().sygusMinGrammar ? "true" : "false"}); |
9750 |
|
opts.push_back({"sygus-pbe", quantifiers().sygusUnifPbe ? "true" : "false"}); |
9751 |
|
opts.push_back({"sygus-pbe-multi-fair", quantifiers().sygusPbeMultiFair ? "true" : "false"}); |
9752 |
|
opts.push_back({"sygus-pbe-multi-fair-diff=N", std::to_string(quantifiers().sygusPbeMultiFairDiff)}); |
9753 |
|
opts.push_back({"sygus-qe-preproc", quantifiers().sygusQePreproc ? "true" : "false"}); |
9754 |
|
opts.push_back({"sygus-query-gen", quantifiers().sygusQueryGen ? "true" : "false"}); |
9755 |
|
opts.push_back({"sygus-query-gen-check", quantifiers().sygusQueryGenCheck ? "true" : "false"}); |
9756 |
|
{ std::stringstream ss; ss << quantifiers().sygusQueryGenDumpFiles; opts.push_back({"sygus-query-gen-dump-files=MODE", ss.str()}); } |
9757 |
|
opts.push_back({"sygus-query-gen-thresh=N", std::to_string(quantifiers().sygusQueryGenThresh)}); |
9758 |
|
opts.push_back({"sygus-rec-fun", quantifiers().sygusRecFun ? "true" : "false"}); |
9759 |
|
opts.push_back({"sygus-rec-fun-eval-limit=N", std::to_string(quantifiers().sygusRecFunEvalLimit)}); |
9760 |
|
opts.push_back({"sygus-repair-const", quantifiers().sygusRepairConst ? "true" : "false"}); |
9761 |
|
opts.push_back({"sygus-repair-const-timeout=N", std::to_string(quantifiers().sygusRepairConstTimeout)}); |
9762 |
|
opts.push_back({"sygus-rr", quantifiers().sygusRew ? "true" : "false"}); |
9763 |
|
opts.push_back({"sygus-rr-synth", quantifiers().sygusRewSynth ? "true" : "false"}); |
9764 |
|
opts.push_back({"sygus-rr-synth-accel", quantifiers().sygusRewSynthAccel ? "true" : "false"}); |
9765 |
|
opts.push_back({"sygus-rr-synth-check", quantifiers().sygusRewSynthCheck ? "true" : "false"}); |
9766 |
|
opts.push_back({"sygus-rr-synth-filter-cong", quantifiers().sygusRewSynthFilterCong ? "true" : "false"}); |
9767 |
|
opts.push_back({"sygus-rr-synth-filter-match", quantifiers().sygusRewSynthFilterMatch ? "true" : "false"}); |
9768 |
|
opts.push_back({"sygus-rr-synth-filter-nl", quantifiers().sygusRewSynthFilterNonLinear ? "true" : "false"}); |
9769 |
|
opts.push_back({"sygus-rr-synth-filter-order", quantifiers().sygusRewSynthFilterOrder ? "true" : "false"}); |
9770 |
|
opts.push_back({"sygus-rr-synth-input", quantifiers().sygusRewSynthInput ? "true" : "false"}); |
9771 |
|
opts.push_back({"sygus-rr-synth-input-nvars=N", std::to_string(quantifiers().sygusRewSynthInputNVars)}); |
9772 |
|
opts.push_back({"sygus-rr-synth-input-use-bool", quantifiers().sygusRewSynthInputUseBool ? "true" : "false"}); |
9773 |
|
opts.push_back({"sygus-rr-synth-rec", quantifiers().sygusRewSynthRec ? "true" : "false"}); |
9774 |
|
opts.push_back({"sygus-rr-verify", quantifiers().sygusRewVerify ? "true" : "false"}); |
9775 |
|
opts.push_back({"sygus-rr-verify-abort", quantifiers().sygusRewVerifyAbort ? "true" : "false"}); |
9776 |
|
opts.push_back({"sygus-sample-fp-uniform", quantifiers().sygusSampleFpUniform ? "true" : "false"}); |
9777 |
|
opts.push_back({"sygus-sample-grammar", quantifiers().sygusSampleGrammar ? "true" : "false"}); |
9778 |
|
opts.push_back({"sygus-samples=N", std::to_string(quantifiers().sygusSamples)}); |
9779 |
|
opts.push_back({"sygus-si-abort", quantifiers().cegqiSingleInvAbort ? "true" : "false"}); |
9780 |
|
opts.push_back({"sygus-si-partial", quantifiers().cegqiSingleInvPartial ? "true" : "false"}); |
9781 |
|
opts.push_back({"sygus-si-rcons-limit=N", std::to_string(quantifiers().cegqiSingleInvReconstructLimit)}); |
9782 |
|
{ std::stringstream ss; ss << quantifiers().cegqiSingleInvReconstruct; opts.push_back({"sygus-si-rcons=MODE", ss.str()}); } |
9783 |
|
opts.push_back({"sygus-si-reconstruct-const", quantifiers().cegqiSingleInvReconstructConst ? "true" : "false"}); |
9784 |
|
{ std::stringstream ss; ss << quantifiers().cegqiSingleInvMode; opts.push_back({"sygus-si=MODE", ss.str()}); } |
9785 |
|
opts.push_back({"sygus-stream", quantifiers().sygusStream ? "true" : "false"}); |
9786 |
|
opts.push_back({"sygus-templ-embed-grammar", quantifiers().sygusTemplEmbedGrammar ? "true" : "false"}); |
9787 |
|
opts.push_back({"sygus-unif-cond-independent-no-repeat-sol", quantifiers().sygusUnifCondIndNoRepeatSol ? "true" : "false"}); |
9788 |
|
{ std::stringstream ss; ss << quantifiers().sygusUnifPi; opts.push_back({"sygus-unif-pi=MODE", ss.str()}); } |
9789 |
|
opts.push_back({"sygus-unif-shuffle-cond", quantifiers().sygusUnifShuffleCond ? "true" : "false"}); |
9790 |
|
opts.push_back({"term-db-cd", quantifiers().termDbCd ? "true" : "false"}); |
9791 |
|
{ std::stringstream ss; ss << quantifiers().termDbMode; opts.push_back({"term-db-mode=MODE", ss.str()}); } |
9792 |
|
{ std::stringstream ss; ss << quantifiers().triggerActiveSelMode; opts.push_back({"trigger-active-sel=MODE", ss.str()}); } |
9793 |
|
{ std::stringstream ss; ss << quantifiers().triggerSelMode; opts.push_back({"trigger-sel=MODE", ss.str()}); } |
9794 |
|
{ std::stringstream ss; ss << quantifiers().userPatternsQuant; opts.push_back({"user-pat=MODE", ss.str()}); } |
9795 |
|
opts.push_back({"var-elim-quant", quantifiers().varElimQuant ? "true" : "false"}); |
9796 |
|
opts.push_back({"var-ineq-elim-quant", quantifiers().varIneqElimQuant ? "true" : "false"}); |
9797 |
|
opts.push_back({"rlimit-per=N", std::to_string(resman().perCallResourceLimit)}); |
9798 |
|
opts.push_back({"rlimit=N", std::to_string(resman().cumulativeResourceLimit)}); |
9799 |
|
opts.push_back({"tlimit-per=MS", std::to_string(resman().perCallMillisecondLimit)}); |
9800 |
|
opts.push_back({"tlimit=MS", std::to_string(resman().cumulativeMillisecondLimit)}); |
9801 |
|
opts.push_back({"sep-check-neg", sep().sepCheckNeg ? "true" : "false"}); |
9802 |
|
opts.push_back({"sep-child-refine", sep().sepChildRefine ? "true" : "false"}); |
9803 |
|
opts.push_back({"sep-deq-c", sep().sepDisequalC ? "true" : "false"}); |
9804 |
|
opts.push_back({"sep-exp", sep().sepExp ? "true" : "false"}); |
9805 |
|
opts.push_back({"sep-min-refine", sep().sepMinimalRefine ? "true" : "false"}); |
9806 |
|
opts.push_back({"sep-pre-skolem-emp", sep().sepPreSkolemEmp ? "true" : "false"}); |
9807 |
|
opts.push_back({"sets-ext", sets().setsExt ? "true" : "false"}); |
9808 |
|
opts.push_back({"sets-infer-as-lemmas", sets().setsInferAsLemmas ? "true" : "false"}); |
9809 |
|
opts.push_back({"sets-proxy-lemmas", sets().setsProxyLemmas ? "true" : "false"}); |
9810 |
|
opts.push_back({"abstract-values", smt().abstractValues ? "true" : "false"}); |
9811 |
|
opts.push_back({"ackermann", smt().ackermann ? "true" : "false"}); |
9812 |
|
{ std::stringstream ss; ss << smt().blockModelsMode; opts.push_back({"block-models=MODE", ss.str()}); } |
9813 |
|
opts.push_back({"bvand-integer-granularity=N", std::to_string(smt().BVAndIntegerGranularity)}); |
9814 |
|
opts.push_back({"check-abducts", smt().checkAbducts ? "true" : "false"}); |
9815 |
|
opts.push_back({"check-interpols", smt().checkInterpols ? "true" : "false"}); |
9816 |
|
opts.push_back({"check-models", smt().checkModels ? "true" : "false"}); |
9817 |
|
opts.push_back({"check-proofs", smt().checkProofs ? "true" : "false"}); |
9818 |
|
opts.push_back({"check-synth-sol", smt().checkSynthSol ? "true" : "false"}); |
9819 |
|
opts.push_back({"check-unsat-cores", smt().checkUnsatCores ? "true" : "false"}); |
9820 |
|
opts.push_back({"debug-check-models", smt().debugCheckModels ? "true" : "false"}); |
9821 |
|
{ std::stringstream ss; ss << smt().diagnosticChannelName; opts.push_back({"diagnostic-output-channel=CHANNEL", ss.str()}); } |
9822 |
|
opts.push_back({"dump-instantiations", smt().dumpInstantiations ? "true" : "false"}); |
9823 |
|
opts.push_back({"dump-models", smt().dumpModels ? "true" : "false"}); |
9824 |
|
opts.push_back({"dump-proofs", smt().dumpProofs ? "true" : "false"}); |
9825 |
|
{ std::stringstream ss; ss << smt().dumpToFileName; opts.push_back({"dump-to=FILE", ss.str()}); } |
9826 |
|
opts.push_back({"dump-unsat-cores", smt().dumpUnsatCores ? "true" : "false"}); |
9827 |
|
opts.push_back({"dump-unsat-cores-full", smt().dumpUnsatCoresFull ? "true" : "false"}); |
9828 |
|
{ std::stringstream ss; ss << smt().dumpModeString; opts.push_back({"dump=MODE", ss.str()}); } |
9829 |
|
opts.push_back({"early-ite-removal", smt().earlyIteRemoval ? "true" : "false"}); |
9830 |
|
opts.push_back({"expand-definitions", smt().expandDefinitions ? "true" : "false"}); |
9831 |
|
opts.push_back({"ext-rew-prep", smt().extRewPrep ? "true" : "false"}); |
9832 |
|
opts.push_back({"ext-rew-prep-agg", smt().extRewPrepAgg ? "true" : "false"}); |
9833 |
|
opts.push_back({"force-no-limit-cpu-while-dump", smt().forceNoLimitCpuWhileDump ? "true" : "false"}); |
9834 |
|
opts.push_back({"foreign-theory-rewrite", smt().foreignTheoryRewrite ? "true" : "false"}); |
9835 |
|
{ std::stringstream ss; ss << smt().iandMode; opts.push_back({"iand-mode=mode", ss.str()}); } |
9836 |
|
opts.push_back({"incremental", smt().incrementalSolving ? "true" : "false"}); |
9837 |
|
opts.push_back({"interactive-mode", smt().interactiveMode ? "true" : "false"}); |
9838 |
|
opts.push_back({"ite-simp", smt().doITESimp ? "true" : "false"}); |
9839 |
|
{ std::stringstream ss; ss << smt().modelCoresMode; opts.push_back({"model-cores=MODE", ss.str()}); } |
9840 |
|
{ std::stringstream ss; ss << smt().modelUninterpPrint; opts.push_back({"model-u-print=MODE", ss.str()}); } |
9841 |
|
opts.push_back({"model-witness-value", smt().modelWitnessValue ? "true" : "false"}); |
9842 |
|
opts.push_back({"on-repeat-ite-simp", smt().doITESimpOnRepeat ? "true" : "false"}); |
9843 |
|
opts.push_back({"produce-abducts", smt().produceAbducts ? "true" : "false"}); |
9844 |
|
opts.push_back({"produce-assertions", smt().produceAssertions ? "true" : "false"}); |
9845 |
|
opts.push_back({"produce-assignments", smt().produceAssignments ? "true" : "false"}); |
9846 |
|
{ std::stringstream ss; ss << smt().produceInterpols; opts.push_back({"produce-interpols=MODE", ss.str()}); } |
9847 |
|
opts.push_back({"produce-models", smt().produceModels ? "true" : "false"}); |
9848 |
|
opts.push_back({"produce-proofs", smt().produceProofs ? "true" : "false"}); |
9849 |
|
opts.push_back({"produce-unsat-assumptions", smt().unsatAssumptions ? "true" : "false"}); |
9850 |
|
opts.push_back({"produce-unsat-cores", smt().unsatCores ? "true" : "false"}); |
9851 |
|
{ std::stringstream ss; ss << smt().regularChannelName; opts.push_back({"regular-output-channel=CHANNEL", ss.str()}); } |
9852 |
|
opts.push_back({"repeat-simp", smt().repeatSimp ? "true" : "false"}); |
9853 |
|
opts.push_back({"simp-ite-compress", smt().compressItes ? "true" : "false"}); |
9854 |
|
opts.push_back({"simp-ite-hunt-zombies=N", std::to_string(smt().zombieHuntThreshold)}); |
9855 |
|
opts.push_back({"simp-with-care", smt().simplifyWithCareEnabled ? "true" : "false"}); |
9856 |
|
{ std::stringstream ss; ss << smt().simplificationMode; opts.push_back({"simplification=MODE", ss.str()}); } |
9857 |
|
{ std::stringstream ss; ss << smt().solveBVAsInt; opts.push_back({"solve-bv-as-int=MODE", ss.str()}); } |
9858 |
|
opts.push_back({"solve-int-as-bv=N", std::to_string(smt().solveIntAsBV)}); |
9859 |
|
opts.push_back({"solve-real-as-int", smt().solveRealAsInt ? "true" : "false"}); |
9860 |
|
opts.push_back({"sort-inference", smt().sortInference ? "true" : "false"}); |
9861 |
|
opts.push_back({"static-learning", smt().doStaticLearning ? "true" : "false"}); |
9862 |
|
{ std::stringstream ss; ss << smt().sygusOut; opts.push_back({"sygus-out=MODE", ss.str()}); } |
9863 |
|
opts.push_back({"sygus-print-callbacks", smt().sygusPrintCallbacks ? "true" : "false"}); |
9864 |
|
opts.push_back({"unconstrained-simp", smt().unconstrainedSimp ? "true" : "false"}); |
9865 |
|
{ std::stringstream ss; ss << smt().unsatCoresMode; opts.push_back({"unsat-cores-mode=MODE", ss.str()}); } |
9866 |
|
opts.push_back({"re-elim", strings().regExpElim ? "true" : "false"}); |
9867 |
|
opts.push_back({"re-elim-agg", strings().regExpElimAgg ? "true" : "false"}); |
9868 |
|
{ std::stringstream ss; ss << strings().stringRegExpInterMode; opts.push_back({"re-inter-mode=MODE", ss.str()}); } |
9869 |
|
opts.push_back({"strings-check-entail-len", strings().stringCheckEntailLen ? "true" : "false"}); |
9870 |
|
opts.push_back({"strings-eager", strings().stringEager ? "true" : "false"}); |
9871 |
|
opts.push_back({"strings-eager-eval", strings().stringEagerEval ? "true" : "false"}); |
9872 |
|
opts.push_back({"strings-eager-len", strings().stringEagerLen ? "true" : "false"}); |
9873 |
|
opts.push_back({"strings-exp", strings().stringExp ? "true" : "false"}); |
9874 |
|
opts.push_back({"strings-ff", strings().stringFlatForms ? "true" : "false"}); |
9875 |
|
opts.push_back({"strings-fmf", strings().stringFMF ? "true" : "false"}); |
9876 |
|
opts.push_back({"strings-guess-model", strings().stringGuessModel ? "true" : "false"}); |
9877 |
|
opts.push_back({"strings-infer-as-lemmas", strings().stringInferAsLemmas ? "true" : "false"}); |
9878 |
|
opts.push_back({"strings-infer-sym", strings().stringInferSym ? "true" : "false"}); |
9879 |
|
opts.push_back({"strings-inm", strings().stringIgnNegMembership ? "true" : "false"}); |
9880 |
|
opts.push_back({"strings-lazy-pp", strings().stringLazyPreproc ? "true" : "false"}); |
9881 |
|
opts.push_back({"strings-len-norm", strings().stringLenNorm ? "true" : "false"}); |
9882 |
|
opts.push_back({"strings-lprop-csp", strings().stringLenPropCsp ? "true" : "false"}); |
9883 |
|
opts.push_back({"strings-min-prefix-explain", strings().stringMinPrefixExplain ? "true" : "false"}); |
9884 |
|
{ std::stringstream ss; ss << strings().stringProcessLoopMode; opts.push_back({"strings-process-loop-mode=MODE", ss.str()}); } |
9885 |
|
opts.push_back({"strings-rexplain-lemmas", strings().stringRExplainLemmas ? "true" : "false"}); |
9886 |
|
opts.push_back({"strings-unified-vspt", strings().stringUnifiedVSpt ? "true" : "false"}); |
9887 |
|
opts.push_back({"assign-function-values", theory().assignFunctionValues ? "true" : "false"}); |
9888 |
|
opts.push_back({"condense-function-values", theory().condenseFunctionValues ? "true" : "false"}); |
9889 |
|
{ std::stringstream ss; ss << theory().eeMode; opts.push_back({"ee-mode=MODE", ss.str()}); } |
9890 |
|
opts.push_back({"relevance-filter", theory().relevanceFilter ? "true" : "false"}); |
9891 |
|
{ std::stringstream ss; ss << theory().tcMode; opts.push_back({"tc-mode=MODE", ss.str()}); } |
9892 |
|
{ std::stringstream ss; ss << theory().theoryOfMode; opts.push_back({"theoryof-mode=MODE", ss.str()}); } |
9893 |
|
opts.push_back({"symmetry-breaker", uf().ufSymmetryBreaker ? "true" : "false"}); |
9894 |
|
opts.push_back({"uf-ho", uf().ufHo ? "true" : "false"}); |
9895 |
|
opts.push_back({"uf-ho-ext", uf().ufHoExt ? "true" : "false"}); |
9896 |
|
opts.push_back({"uf-ss-abort-card=N", std::to_string(uf().ufssAbortCardinality)}); |
9897 |
|
opts.push_back({"uf-ss-fair", uf().ufssFairness ? "true" : "false"}); |
9898 |
|
opts.push_back({"uf-ss-fair-monotone", uf().ufssFairnessMonotone ? "true" : "false"}); |
9899 |
|
opts.push_back({"uf-ss-totality-limited=N", std::to_string(uf().ufssTotalityLimited)}); |
9900 |
|
opts.push_back({"uf-ss-totality-sym-break", uf().ufssTotalitySymBreak ? "true" : "false"}); |
9901 |
|
{ std::stringstream ss; ss << uf().ufssMode; opts.push_back({"uf-ss=MODE", ss.str()}); } |
9902 |
|
|
9903 |
|
return opts; |
9904 |
|
} |
9905 |
|
// clang-format on |
9906 |
|
|
9907 |
9279 |
void Options::setOption(const std::string& key, const std::string& optionarg) |
9908 |
|
{ |
9909 |
18558 |
Trace("options") << "setOption(" << key << ", " << optionarg << ")" |
9910 |
9279 |
<< std::endl; |
9911 |
|
// first update this object |
9912 |
9279 |
setOptionInternal(key, optionarg); |
9913 |
|
// then, notify the provided listener |
9914 |
9277 |
if (d_olisten != nullptr) |
9915 |
|
{ |
9916 |
9277 |
d_olisten->notifySetOption(key); |
9917 |
|
} |
9918 |
9277 |
} |
9919 |
|
|
9920 |
|
// clang-format off |
9921 |
9279 |
void Options::setOptionInternal(const std::string& key, |
9922 |
|
const std::string& optionarg) |
9923 |
|
{ |
9924 |
9279 |
options::OptionsHandler* handler = d_handler; |
9925 |
9279 |
if(key == "approx-branch-depth") { |
9926 |
|
assign(options::maxApproxDepth, key, optionarg); |
9927 |
|
return; |
9928 |
|
} |
9929 |
9279 |
if(key == "arith-brab") { |
9930 |
|
assignBool(options::brabTest, key, optionarg == "true"); |
9931 |
|
return; |
9932 |
|
} |
9933 |
9279 |
if(key == "arith-no-partial-fun") { |
9934 |
3 |
assignBool(options::arithNoPartialFun, key, optionarg == "true"); |
9935 |
3 |
return; |
9936 |
|
} |
9937 |
9276 |
if(key == "arith-prop-clauses") { |
9938 |
|
assign(options::arithPropAsLemmaLength, key, optionarg); |
9939 |
|
return; |
9940 |
|
} |
9941 |
9276 |
if(key == "arith-prop") { |
9942 |
|
assign(options::arithPropagationMode, key, optionarg); |
9943 |
|
return; |
9944 |
|
} |
9945 |
9276 |
if(key == "arith-rewrite-equalities") { |
9946 |
5 |
assignBool(options::arithRewriteEq, key, optionarg == "true"); |
9947 |
5 |
return; |
9948 |
|
} |
9949 |
9271 |
if(key == "collect-pivot-stats") { |
9950 |
|
assignBool(options::collectPivots, key, optionarg == "true"); |
9951 |
|
return; |
9952 |
|
} |
9953 |
9271 |
if(key == "cut-all-bounded") { |
9954 |
|
assignBool(options::doCutAllBounded, key, optionarg == "true"); |
9955 |
|
return; |
9956 |
|
} |
9957 |
9271 |
if(key == "dio-decomps") { |
9958 |
|
assignBool(options::exportDioDecompositions, key, optionarg == "true"); |
9959 |
|
return; |
9960 |
|
} |
9961 |
9271 |
if(key == "dio-repeat") { |
9962 |
|
assignBool(options::dioRepeat, key, optionarg == "true"); |
9963 |
|
return; |
9964 |
|
} |
9965 |
9271 |
if(key == "dio-solver") { |
9966 |
|
assignBool(options::arithDioSolver, key, optionarg == "true"); |
9967 |
|
return; |
9968 |
|
} |
9969 |
9271 |
if(key == "dio-turns") { |
9970 |
|
assign(options::dioSolverTurns, key, optionarg); |
9971 |
|
return; |
9972 |
|
} |
9973 |
9271 |
if(key == "error-selection-rule") { |
9974 |
|
assign(options::arithErrorSelectionRule, key, optionarg); |
9975 |
|
return; |
9976 |
|
} |
9977 |
9271 |
if(key == "fc-penalties") { |
9978 |
|
assignBool(options::havePenalties, key, optionarg == "true"); |
9979 |
|
return; |
9980 |
|
} |
9981 |
9271 |
if(key == "heuristic-pivots") { |
9982 |
|
assign(options::arithHeuristicPivots, key, optionarg); |
9983 |
|
return; |
9984 |
|
} |
9985 |
9271 |
if(key == "lemmas-on-replay-failure") { |
9986 |
|
assignBool(options::replayFailureLemma, key, optionarg == "true"); |
9987 |
|
return; |
9988 |
|
} |
9989 |
9271 |
if(key == "maxCutsInContext") { |
9990 |
|
assign(options::maxCutsInContext, key, optionarg); |
9991 |
|
return; |
9992 |
|
} |
9993 |
9271 |
if(key == "miplib-trick") { |
9994 |
|
assignBool(options::arithMLTrick, key, optionarg == "true"); |
9995 |
|
return; |
9996 |
|
} |
9997 |
9271 |
if(key == "miplib-trick-subs") { |
9998 |
|
assign(options::arithMLTrickSubstitutions, key, optionarg); |
9999 |
|
return; |
10000 |
|
} |
10001 |
9271 |
if(key == "new-prop") { |
10002 |
|
assignBool(options::newProp, key, optionarg == "true"); |
10003 |
|
return; |
10004 |
|
} |
10005 |
9271 |
if(key == "nl-cad") { |
10006 |
|
assignBool(options::nlCad, key, optionarg == "true"); |
10007 |
|
return; |
10008 |
|
} |
10009 |
9271 |
if(key == "nl-cad-initial") { |
10010 |
|
assignBool(options::nlCadUseInitial, key, optionarg == "true"); |
10011 |
|
return; |
10012 |
|
} |
10013 |
9271 |
if(key == "nl-ext-ent-conf") { |
10014 |
|
assignBool(options::nlExtEntailConflicts, key, optionarg == "true"); |
10015 |
|
return; |
10016 |
|
} |
10017 |
9271 |
if(key == "nl-ext-factor") { |
10018 |
|
assignBool(options::nlExtFactor, key, optionarg == "true"); |
10019 |
|
return; |
10020 |
|
} |
10021 |
9271 |
if(key == "nl-ext-inc-prec") { |
10022 |
|
assignBool(options::nlExtIncPrecision, key, optionarg == "true"); |
10023 |
|
return; |
10024 |
|
} |
10025 |
9271 |
if(key == "nl-ext-purify") { |
10026 |
2 |
assignBool(options::nlExtPurify, key, optionarg == "true"); |
10027 |
2 |
return; |
10028 |
|
} |
10029 |
9269 |
if(key == "nl-ext-rbound") { |
10030 |
|
assignBool(options::nlExtResBound, key, optionarg == "true"); |
10031 |
|
return; |
10032 |
|
} |
10033 |
9269 |
if(key == "nl-ext-rewrite") { |
10034 |
|
assignBool(options::nlExtRewrites, key, optionarg == "true"); |
10035 |
|
return; |
10036 |
|
} |
10037 |
9269 |
if(key == "nl-ext-split-zero") { |
10038 |
|
assignBool(options::nlExtSplitZero, key, optionarg == "true"); |
10039 |
|
return; |
10040 |
|
} |
10041 |
9269 |
if(key == "nl-ext-tf-taylor-deg") { |
10042 |
|
assign(options::nlExtTfTaylorDegree, key, optionarg); |
10043 |
|
return; |
10044 |
|
} |
10045 |
9269 |
if(key == "nl-ext-tf-tplanes") { |
10046 |
|
assignBool(options::nlExtTfTangentPlanes, key, optionarg == "true"); |
10047 |
|
return; |
10048 |
|
} |
10049 |
9269 |
if(key == "nl-ext-tplanes") { |
10050 |
|
assignBool(options::nlExtTangentPlanes, key, optionarg == "true"); |
10051 |
|
return; |
10052 |
|
} |
10053 |
9269 |
if(key == "nl-ext-tplanes-interleave") { |
10054 |
|
assignBool(options::nlExtTangentPlanesInterleave, key, optionarg == "true"); |
10055 |
|
return; |
10056 |
|
} |
10057 |
9269 |
if(key == "nl-ext") { |
10058 |
|
assign(options::nlExt, key, optionarg); |
10059 |
|
return; |
10060 |
|
} |
10061 |
9269 |
if(key == "nl-icp") { |
10062 |
|
assignBool(options::nlICP, key, optionarg == "true"); |
10063 |
|
return; |
10064 |
|
} |
10065 |
9269 |
if(key == "nl-rlv") { |
10066 |
|
assign(options::nlRlvMode, key, optionarg); |
10067 |
|
return; |
10068 |
|
} |
10069 |
9269 |
if(key == "pb-rewrites") { |
10070 |
|
assignBool(options::pbRewrites, key, optionarg == "true"); |
10071 |
|
return; |
10072 |
|
} |
10073 |
9269 |
if(key == "pivot-threshold") { |
10074 |
|
assign(options::arithPivotThreshold, key, optionarg); |
10075 |
|
return; |
10076 |
|
} |
10077 |
9269 |
if(key == "pp-assert-max-sub-size") { |
10078 |
|
assign(options::ppAssertMaxSubSize, key, optionarg); |
10079 |
|
return; |
10080 |
|
} |
10081 |
9269 |
if(key == "prop-row-length") { |
10082 |
|
assign(options::arithPropagateMaxLength, key, optionarg); |
10083 |
|
return; |
10084 |
|
} |
10085 |
9269 |
if(key == "replay-early-close-depth") { |
10086 |
|
assign(options::replayEarlyCloseDepths, key, optionarg); |
10087 |
|
return; |
10088 |
|
} |
10089 |
9269 |
if(key == "replay-failure-penalty") { |
10090 |
|
assign(options::replayFailurePenalty, key, optionarg); |
10091 |
|
return; |
10092 |
|
} |
10093 |
9269 |
if(key == "replay-lemma-reject-cut") { |
10094 |
|
assign(options::lemmaRejectCutSize, key, optionarg); |
10095 |
|
return; |
10096 |
|
} |
10097 |
9269 |
if(key == "replay-num-err-penalty") { |
10098 |
|
assign(options::replayNumericFailurePenalty, key, optionarg); |
10099 |
|
return; |
10100 |
|
} |
10101 |
9269 |
if(key == "replay-reject-cut") { |
10102 |
|
assign(options::replayRejectCutSize, key, optionarg); |
10103 |
|
return; |
10104 |
|
} |
10105 |
9269 |
if(key == "replay-soi-major-threshold-pen") { |
10106 |
|
assign(options::soiApproxMajorFailurePen, key, optionarg); |
10107 |
|
return; |
10108 |
|
} |
10109 |
9269 |
if(key == "replay-soi-major-threshold") { |
10110 |
|
assign(options::soiApproxMajorFailure, key, optionarg); |
10111 |
|
return; |
10112 |
|
} |
10113 |
9269 |
if(key == "replay-soi-minor-threshold-pen") { |
10114 |
|
assign(options::soiApproxMinorFailurePen, key, optionarg); |
10115 |
|
return; |
10116 |
|
} |
10117 |
9269 |
if(key == "replay-soi-minor-threshold") { |
10118 |
|
assign(options::soiApproxMinorFailure, key, optionarg); |
10119 |
|
return; |
10120 |
|
} |
10121 |
9269 |
if(key == "restrict-pivots") { |
10122 |
|
assignBool(options::restrictedPivots, key, optionarg == "true"); |
10123 |
|
return; |
10124 |
|
} |
10125 |
9269 |
if(key == "revert-arith-models-on-unsat") { |
10126 |
|
assignBool(options::revertArithModels, key, optionarg == "true"); |
10127 |
|
return; |
10128 |
|
} |
10129 |
9269 |
if(key == "rr-turns") { |
10130 |
|
assign(options::rrTurns, key, optionarg); |
10131 |
|
return; |
10132 |
|
} |
10133 |
9269 |
if(key == "se-solve-int") { |
10134 |
|
assignBool(options::trySolveIntStandardEffort, key, optionarg == "true"); |
10135 |
|
return; |
10136 |
|
} |
10137 |
9269 |
if(key == "simplex-check-period") { |
10138 |
|
assign(options::arithSimplexCheckPeriod, key, optionarg); |
10139 |
|
return; |
10140 |
|
} |
10141 |
9269 |
if(key == "soi-qe") { |
10142 |
|
assignBool(options::soiQuickExplain, key, optionarg == "true"); |
10143 |
|
return; |
10144 |
|
} |
10145 |
9269 |
if(key == "standard-effort-variable-order-pivots") { |
10146 |
|
assign(options::arithStandardCheckVarOrderPivots, key, optionarg); |
10147 |
|
return; |
10148 |
|
} |
10149 |
9269 |
if(key == "unate-lemmas") { |
10150 |
|
assign(options::arithUnateLemmaMode, key, optionarg); |
10151 |
|
return; |
10152 |
|
} |
10153 |
9269 |
if(key == "use-approx") { |
10154 |
|
assignBool(options::useApprox, key, optionarg == "true"); |
10155 |
|
return; |
10156 |
|
} |
10157 |
9269 |
if(key == "use-fcsimplex") { |
10158 |
|
assignBool(options::useFC, key, optionarg == "true"); |
10159 |
|
return; |
10160 |
|
} |
10161 |
9269 |
if(key == "use-soi") { |
10162 |
|
assignBool(options::useSOI, key, optionarg == "true"); |
10163 |
|
return; |
10164 |
|
} |
10165 |
9269 |
if(key == "arrays-config") { |
10166 |
|
assign(options::arraysConfig, key, optionarg); |
10167 |
|
return; |
10168 |
|
} |
10169 |
9269 |
if(key == "arrays-eager-index") { |
10170 |
|
assignBool(options::arraysEagerIndexSplitting, key, optionarg == "true"); |
10171 |
|
return; |
10172 |
|
} |
10173 |
9269 |
if(key == "arrays-eager-lemmas") { |
10174 |
|
assignBool(options::arraysEagerLemmas, key, optionarg == "true"); |
10175 |
|
return; |
10176 |
|
} |
10177 |
9269 |
if(key == "arrays-exp") { |
10178 |
7 |
assignBool(options::arraysExp, key, optionarg == "true"); |
10179 |
7 |
return; |
10180 |
|
} |
10181 |
9262 |
if(key == "arrays-model-based") { |
10182 |
|
assignBool(options::arraysModelBased, key, optionarg == "true"); |
10183 |
|
return; |
10184 |
|
} |
10185 |
9262 |
if(key == "arrays-optimize-linear") { |
10186 |
|
assignBool(options::arraysOptimizeLinear, key, optionarg == "true"); |
10187 |
|
return; |
10188 |
|
} |
10189 |
9262 |
if(key == "arrays-prop") { |
10190 |
|
assign(options::arraysPropagate, key, optionarg); |
10191 |
|
return; |
10192 |
|
} |
10193 |
9262 |
if(key == "arrays-reduce-sharing") { |
10194 |
|
assignBool(options::arraysReduceSharing, key, optionarg == "true"); |
10195 |
|
return; |
10196 |
|
} |
10197 |
9262 |
if(key == "arrays-weak-equiv") { |
10198 |
|
assignBool(options::arraysWeakEquivalence, key, optionarg == "true"); |
10199 |
|
return; |
10200 |
|
} |
10201 |
9262 |
if(key == "debug") { |
10202 |
|
handler->enableDebugTag("debug", optionarg); |
10203 |
|
return; |
10204 |
|
} |
10205 |
9262 |
if(key == "input-language" || key == "lang") { |
10206 |
276 |
assign(options::inputLanguage, key, optionarg); |
10207 |
276 |
return; |
10208 |
|
} |
10209 |
8986 |
if(key == "output-lang" || key == "output-language") { |
10210 |
25 |
assign(options::outputLanguage, key, optionarg); |
10211 |
25 |
return; |
10212 |
|
} |
10213 |
8961 |
if(key == "parse-only") { |
10214 |
|
assignBool(options::parseOnly, key, optionarg == "true"); |
10215 |
|
return; |
10216 |
|
} |
10217 |
8961 |
if(key == "preprocess-only") { |
10218 |
|
assignBool(options::preprocessOnly, key, optionarg == "true"); |
10219 |
|
return; |
10220 |
|
} |
10221 |
8961 |
if(key == "print-success") { |
10222 |
27 |
assignBool(options::printSuccess, key, optionarg == "true"); |
10223 |
27 |
return; |
10224 |
|
} |
10225 |
8934 |
if(key == "quiet") { |
10226 |
4 |
handler->decreaseVerbosity("quiet"); |
10227 |
4 |
return; |
10228 |
|
} |
10229 |
8930 |
if(key == "stats") { |
10230 |
|
assignBool(options::statistics, key, optionarg == "true"); |
10231 |
|
return; |
10232 |
|
} |
10233 |
8930 |
if(key == "stats-all") { |
10234 |
|
assignBool(options::statisticsAll, key, optionarg == "true"); |
10235 |
|
return; |
10236 |
|
} |
10237 |
8930 |
if(key == "stats-every-query") { |
10238 |
|
assignBool(options::statisticsEveryQuery, key, optionarg == "true"); |
10239 |
|
return; |
10240 |
|
} |
10241 |
8930 |
if(key == "stats-expert") { |
10242 |
|
assignBool(options::statisticsExpert, key, optionarg == "true"); |
10243 |
|
return; |
10244 |
|
} |
10245 |
8930 |
if(key == "trace") { |
10246 |
|
handler->enableTraceTag("trace", optionarg); |
10247 |
|
return; |
10248 |
|
} |
10249 |
8930 |
if(key == "verbose") { |
10250 |
|
handler->increaseVerbosity("verbose"); |
10251 |
|
return; |
10252 |
|
} |
10253 |
8930 |
if(key == "verbosity") { |
10254 |
|
assign(options::verbosity, key, optionarg); |
10255 |
|
return; |
10256 |
|
} |
10257 |
8930 |
if(key == "bitblast-aig") { |
10258 |
|
assignBool(options::bitvectorAig, key, optionarg == "true"); |
10259 |
|
return; |
10260 |
|
} |
10261 |
8930 |
if(key == "bitblast") { |
10262 |
2 |
assign(options::bitblastMode, key, optionarg); |
10263 |
2 |
return; |
10264 |
|
} |
10265 |
8928 |
if(key == "bitwise-eq") { |
10266 |
|
assignBool(options::bitwiseEq, key, optionarg == "true"); |
10267 |
|
return; |
10268 |
|
} |
10269 |
8928 |
if(key == "bool-to-bv") { |
10270 |
|
assign(options::boolToBitvector, key, optionarg); |
10271 |
|
return; |
10272 |
|
} |
10273 |
8928 |
if(key == "bv-abstraction") { |
10274 |
|
assignBool(options::bvAbstraction, key, optionarg == "true"); |
10275 |
|
return; |
10276 |
|
} |
10277 |
8928 |
if(key == "bv-aig-simp") { |
10278 |
|
assign(options::bitvectorAigSimplifications, key, optionarg); |
10279 |
|
return; |
10280 |
|
} |
10281 |
8928 |
if(key == "bv-alg-extf") { |
10282 |
|
assignBool(options::bvAlgExtf, key, optionarg == "true"); |
10283 |
|
return; |
10284 |
|
} |
10285 |
8928 |
if(key == "bv-algebraic-budget") { |
10286 |
|
assign(options::bitvectorAlgebraicBudget, key, optionarg); |
10287 |
|
return; |
10288 |
|
} |
10289 |
8928 |
if(key == "bv-algebraic-solver") { |
10290 |
|
assignBool(options::bitvectorAlgebraicSolver, key, optionarg == "true"); |
10291 |
|
return; |
10292 |
|
} |
10293 |
8928 |
if(key == "bv-assert-input") { |
10294 |
|
assignBool(options::bvAssertInput, key, optionarg == "true"); |
10295 |
|
return; |
10296 |
|
} |
10297 |
8928 |
if(key == "bv-eager-explanations") { |
10298 |
|
assignBool(options::bvEagerExplanations, key, optionarg == "true"); |
10299 |
|
return; |
10300 |
|
} |
10301 |
8928 |
if(key == "bv-eq-solver") { |
10302 |
|
assignBool(options::bitvectorEqualitySolver, key, optionarg == "true"); |
10303 |
|
return; |
10304 |
|
} |
10305 |
8928 |
if(key == "bv-extract-arith") { |
10306 |
|
assignBool(options::bvExtractArithRewrite, key, optionarg == "true"); |
10307 |
|
return; |
10308 |
|
} |
10309 |
8928 |
if(key == "bv-gauss-elim") { |
10310 |
|
assignBool(options::bvGaussElim, key, optionarg == "true"); |
10311 |
|
return; |
10312 |
|
} |
10313 |
8928 |
if(key == "bv-inequality-solver") { |
10314 |
|
assignBool(options::bitvectorInequalitySolver, key, optionarg == "true"); |
10315 |
|
return; |
10316 |
|
} |
10317 |
8928 |
if(key == "bv-intro-pow2") { |
10318 |
|
assignBool(options::bvIntroducePow2, key, optionarg == "true"); |
10319 |
|
return; |
10320 |
|
} |
10321 |
8928 |
if(key == "bv-lazy-reduce-extf") { |
10322 |
|
assignBool(options::bvLazyReduceExtf, key, optionarg == "true"); |
10323 |
|
return; |
10324 |
|
} |
10325 |
8928 |
if(key == "bv-lazy-rewrite-extf") { |
10326 |
|
assignBool(options::bvLazyRewriteExtf, key, optionarg == "true"); |
10327 |
|
return; |
10328 |
|
} |
10329 |
8928 |
if(key == "bv-num-func") { |
10330 |
|
assign(options::bvNumFunc, key, optionarg); |
10331 |
|
return; |
10332 |
|
} |
10333 |
8928 |
if(key == "bv-print-consts-as-indexed-symbols") { |
10334 |
|
assignBool(options::bvPrintConstsAsIndexedSymbols, key, optionarg == "true"); |
10335 |
|
return; |
10336 |
|
} |
10337 |
8928 |
if(key == "bv-propagate") { |
10338 |
|
assignBool(options::bitvectorPropagate, key, optionarg == "true"); |
10339 |
|
return; |
10340 |
|
} |
10341 |
8928 |
if(key == "bv-quick-xplain") { |
10342 |
|
assignBool(options::bitvectorQuickXplain, key, optionarg == "true"); |
10343 |
|
return; |
10344 |
|
} |
10345 |
8928 |
if(key == "bv-sat-solver") { |
10346 |
6 |
assign(options::bvSatSolver, key, optionarg); |
10347 |
2 |
return; |
10348 |
|
} |
10349 |
8924 |
if(key == "bv-skolemize") { |
10350 |
|
assignBool(options::skolemizeArguments, key, optionarg == "true"); |
10351 |
|
return; |
10352 |
|
} |
10353 |
8924 |
if(key == "bv-solver") { |
10354 |
|
assign(options::bvSolver, key, optionarg); |
10355 |
|
return; |
10356 |
|
} |
10357 |
8924 |
if(key == "bv-to-bool") { |
10358 |
|
assignBool(options::bitvectorToBool, key, optionarg == "true"); |
10359 |
|
return; |
10360 |
|
} |
10361 |
8924 |
if(key == "cdt-bisimilar") { |
10362 |
|
assignBool(options::cdtBisimilar, key, optionarg == "true"); |
10363 |
|
return; |
10364 |
|
} |
10365 |
8924 |
if(key == "dt-binary-split") { |
10366 |
|
assignBool(options::dtBinarySplit, key, optionarg == "true"); |
10367 |
|
return; |
10368 |
|
} |
10369 |
8924 |
if(key == "dt-blast-splits") { |
10370 |
|
assignBool(options::dtBlastSplits, key, optionarg == "true"); |
10371 |
|
return; |
10372 |
|
} |
10373 |
8924 |
if(key == "dt-cyclic") { |
10374 |
|
assignBool(options::dtCyclic, key, optionarg == "true"); |
10375 |
|
return; |
10376 |
|
} |
10377 |
8924 |
if(key == "dt-force-assignment") { |
10378 |
|
assignBool(options::dtForceAssignment, key, optionarg == "true"); |
10379 |
|
return; |
10380 |
|
} |
10381 |
8924 |
if(key == "dt-infer-as-lemmas") { |
10382 |
|
assignBool(options::dtInferAsLemmas, key, optionarg == "true"); |
10383 |
|
return; |
10384 |
|
} |
10385 |
8924 |
if(key == "dt-nested-rec") { |
10386 |
|
assignBool(options::dtNestedRec, key, optionarg == "true"); |
10387 |
|
return; |
10388 |
|
} |
10389 |
8924 |
if(key == "dt-polite-optimize") { |
10390 |
|
assignBool(options::dtPoliteOptimize, key, optionarg == "true"); |
10391 |
|
return; |
10392 |
|
} |
10393 |
8924 |
if(key == "dt-rewrite-error-sel") { |
10394 |
|
assignBool(options::dtRewriteErrorSel, key, optionarg == "true"); |
10395 |
|
return; |
10396 |
|
} |
10397 |
8924 |
if(key == "dt-share-sel") { |
10398 |
|
assignBool(options::dtSharedSelectors, key, optionarg == "true"); |
10399 |
|
return; |
10400 |
|
} |
10401 |
8924 |
if(key == "sygus-abort-size") { |
10402 |
|
assign(options::sygusAbortSize, key, optionarg); |
10403 |
|
return; |
10404 |
|
} |
10405 |
8924 |
if(key == "sygus-fair-max") { |
10406 |
|
assignBool(options::sygusFairMax, key, optionarg == "true"); |
10407 |
|
return; |
10408 |
|
} |
10409 |
8924 |
if(key == "sygus-fair") { |
10410 |
|
assign(options::sygusFair, key, optionarg); |
10411 |
|
return; |
10412 |
|
} |
10413 |
8924 |
if(key == "sygus-sym-break") { |
10414 |
2 |
assignBool(options::sygusSymBreak, key, optionarg == "true"); |
10415 |
2 |
return; |
10416 |
|
} |
10417 |
8922 |
if(key == "sygus-sym-break-agg") { |
10418 |
|
assignBool(options::sygusSymBreakAgg, key, optionarg == "true"); |
10419 |
|
return; |
10420 |
|
} |
10421 |
8922 |
if(key == "sygus-sym-break-dynamic") { |
10422 |
|
assignBool(options::sygusSymBreakDynamic, key, optionarg == "true"); |
10423 |
|
return; |
10424 |
|
} |
10425 |
8922 |
if(key == "sygus-sym-break-lazy") { |
10426 |
2 |
assignBool(options::sygusSymBreakLazy, key, optionarg == "true"); |
10427 |
2 |
return; |
10428 |
|
} |
10429 |
8920 |
if(key == "sygus-sym-break-pbe") { |
10430 |
|
assignBool(options::sygusSymBreakPbe, key, optionarg == "true"); |
10431 |
|
return; |
10432 |
|
} |
10433 |
8920 |
if(key == "sygus-sym-break-rlv") { |
10434 |
2 |
assignBool(options::sygusSymBreakRlv, key, optionarg == "true"); |
10435 |
2 |
return; |
10436 |
|
} |
10437 |
8918 |
if(key == "decision-random-weight") { |
10438 |
|
assign(options::decisionRandomWeight, key, optionarg); |
10439 |
|
return; |
10440 |
|
} |
10441 |
8918 |
if(key == "decision-threshold") { |
10442 |
|
assign(options::decisionThreshold, key, optionarg); |
10443 |
|
return; |
10444 |
|
} |
10445 |
8918 |
if(key == "decision-use-weight") { |
10446 |
|
assignBool(options::decisionUseWeight, key, optionarg == "true"); |
10447 |
|
return; |
10448 |
|
} |
10449 |
8918 |
if(key == "decision-weight-internal") { |
10450 |
|
assign(options::decisionWeightInternal, key, optionarg); |
10451 |
|
return; |
10452 |
|
} |
10453 |
8918 |
if(key == "decision" || key == "decision-mode") { |
10454 |
|
assign(options::decisionMode, key, optionarg); |
10455 |
|
return; |
10456 |
|
} |
10457 |
8918 |
if(key == "dag-thresh") { |
10458 |
1 |
assign(options::defaultDagThresh, key, optionarg); |
10459 |
1 |
return; |
10460 |
|
} |
10461 |
8917 |
if(key == "expr-depth") { |
10462 |
|
assign(options::defaultExprDepth, key, optionarg); |
10463 |
|
return; |
10464 |
|
} |
10465 |
8917 |
if(key == "type-checking") { |
10466 |
|
assignBool(options::typeChecking, key, optionarg == "true"); |
10467 |
|
return; |
10468 |
|
} |
10469 |
8917 |
if(key == "fp-exp") { |
10470 |
|
assignBool(options::fpExp, key, optionarg == "true"); |
10471 |
|
return; |
10472 |
|
} |
10473 |
8917 |
if(key == "copyright") { |
10474 |
|
handler->copyright("copyright"); |
10475 |
|
return; |
10476 |
|
} |
10477 |
8917 |
if(key == "early-exit") { |
10478 |
|
assignBool(options::earlyExit, key, optionarg == "true"); |
10479 |
|
return; |
10480 |
|
} |
10481 |
8917 |
if(key == "help") { |
10482 |
|
assignBool(options::help, key, optionarg == "true"); |
10483 |
|
return; |
10484 |
|
} |
10485 |
8917 |
if(key == "interactive") { |
10486 |
|
assignBool(options::interactive, key, optionarg == "true"); |
10487 |
|
return; |
10488 |
|
} |
10489 |
8917 |
if(key == "interactive-prompt") { |
10490 |
|
assignBool(options::interactivePrompt, key, optionarg == "true"); |
10491 |
|
return; |
10492 |
|
} |
10493 |
8917 |
if(key == "seed") { |
10494 |
|
assign(options::seed, key, optionarg); |
10495 |
|
return; |
10496 |
|
} |
10497 |
8917 |
if(key == "segv-spin") { |
10498 |
|
assignBool(options::segvSpin, key, optionarg == "true"); |
10499 |
|
return; |
10500 |
|
} |
10501 |
8917 |
if(key == "show-config") { |
10502 |
|
handler->showConfiguration("show-config"); |
10503 |
|
return; |
10504 |
|
} |
10505 |
8917 |
if(key == "show-debug-tags") { |
10506 |
|
handler->showDebugTags("show-debug-tags"); |
10507 |
|
return; |
10508 |
|
} |
10509 |
8917 |
if(key == "show-trace-tags") { |
10510 |
|
handler->showTraceTags("show-trace-tags"); |
10511 |
|
return; |
10512 |
|
} |
10513 |
8917 |
if(key == "tear-down-incremental") { |
10514 |
|
assign(options::tearDownIncremental, key, optionarg); |
10515 |
|
return; |
10516 |
|
} |
10517 |
8917 |
if(key == "version") { |
10518 |
|
assignBool(options::version, key, optionarg == "true"); |
10519 |
|
return; |
10520 |
|
} |
10521 |
8917 |
if(key == "filesystem-access") { |
10522 |
|
assignBool(options::filesystemAccess, key, optionarg == "true"); |
10523 |
|
return; |
10524 |
|
} |
10525 |
8917 |
if(key == "force-logic") { |
10526 |
|
assign(options::forceLogicString, key, optionarg); |
10527 |
|
return; |
10528 |
|
} |
10529 |
8917 |
if(key == "global-declarations") { |
10530 |
17 |
assignBool(options::globalDeclarations, key, optionarg == "true"); |
10531 |
17 |
return; |
10532 |
|
} |
10533 |
8900 |
if(key == "mmap") { |
10534 |
|
assignBool(options::memoryMap, key, optionarg == "true"); |
10535 |
|
return; |
10536 |
|
} |
10537 |
8900 |
if(key == "semantic-checks") { |
10538 |
|
assignBool(options::semanticChecks, key, optionarg == "true"); |
10539 |
|
return; |
10540 |
|
} |
10541 |
8900 |
if(key == "strict-parsing") { |
10542 |
|
assignBool(options::strictParsing, key, optionarg == "true"); |
10543 |
|
return; |
10544 |
|
} |
10545 |
8900 |
if(key == "flatten-ho-chains") { |
10546 |
|
assignBool(options::flattenHOChains, key, optionarg == "true"); |
10547 |
|
return; |
10548 |
|
} |
10549 |
8900 |
if(key == "inst-format") { |
10550 |
|
assign(options::instFormatMode, key, optionarg); |
10551 |
|
return; |
10552 |
|
} |
10553 |
8900 |
if(key == "model-format") { |
10554 |
|
assign(options::modelFormatMode, key, optionarg); |
10555 |
|
return; |
10556 |
|
} |
10557 |
8900 |
if(key == "print-inst-full") { |
10558 |
|
assignBool(options::printInstFull, key, optionarg == "true"); |
10559 |
|
return; |
10560 |
|
} |
10561 |
8900 |
if(key == "print-inst") { |
10562 |
|
assign(options::printInstMode, key, optionarg); |
10563 |
|
return; |
10564 |
|
} |
10565 |
8900 |
if(key == "proof-eager-checking") { |
10566 |
|
assignBool(options::proofEagerChecking, key, optionarg == "true"); |
10567 |
|
return; |
10568 |
|
} |
10569 |
8900 |
if(key == "proof-format-mode") { |
10570 |
|
assign(options::proofFormatMode, key, optionarg); |
10571 |
|
return; |
10572 |
|
} |
10573 |
8900 |
if(key == "proof-granularity") { |
10574 |
|
assign(options::proofGranularityMode, key, optionarg); |
10575 |
|
return; |
10576 |
|
} |
10577 |
8900 |
if(key == "proof-pedantic") { |
10578 |
|
assign(options::proofPedantic, key, optionarg); |
10579 |
|
return; |
10580 |
|
} |
10581 |
8900 |
if(key == "proof-print-conclusion") { |
10582 |
|
assignBool(options::proofPrintConclusion, key, optionarg == "true"); |
10583 |
|
return; |
10584 |
|
} |
10585 |
8900 |
if(key == "minisat-dump-dimacs") { |
10586 |
|
assignBool(options::minisatDumpDimacs, key, optionarg == "true"); |
10587 |
|
return; |
10588 |
|
} |
10589 |
8900 |
if(key == "minisat-elimination") { |
10590 |
|
assignBool(options::minisatUseElim, key, optionarg == "true"); |
10591 |
|
return; |
10592 |
|
} |
10593 |
8900 |
if(key == "random-freq" || key == "random-frequency") { |
10594 |
|
assign(options::satRandomFreq, key, optionarg); |
10595 |
|
return; |
10596 |
|
} |
10597 |
8900 |
if(key == "random-seed") { |
10598 |
|
assign(options::satRandomSeed, key, optionarg); |
10599 |
|
return; |
10600 |
|
} |
10601 |
8900 |
if(key == "refine-conflicts") { |
10602 |
|
assignBool(options::sat_refine_conflicts, key, optionarg == "true"); |
10603 |
|
return; |
10604 |
|
} |
10605 |
8900 |
if(key == "restart-int-base") { |
10606 |
|
assign(options::satRestartFirst, key, optionarg); |
10607 |
|
return; |
10608 |
|
} |
10609 |
8900 |
if(key == "restart-int-inc") { |
10610 |
|
assign(options::satRestartInc, key, optionarg); |
10611 |
|
return; |
10612 |
|
} |
10613 |
8900 |
if(key == "ag-miniscope-quant") { |
10614 |
4 |
assignBool(options::aggressiveMiniscopeQuant, key, optionarg == "true"); |
10615 |
4 |
return; |
10616 |
|
} |
10617 |
8896 |
if(key == "cegis-sample") { |
10618 |
|
assign(options::cegisSample, key, optionarg); |
10619 |
|
return; |
10620 |
|
} |
10621 |
8896 |
if(key == "cegqi") { |
10622 |
|
assignBool(options::cegqi, key, optionarg == "true"); |
10623 |
|
return; |
10624 |
|
} |
10625 |
8896 |
if(key == "cegqi-all") { |
10626 |
3 |
assignBool(options::cegqiAll, key, optionarg == "true"); |
10627 |
3 |
return; |
10628 |
|
} |
10629 |
8893 |
if(key == "cegqi-bv") { |
10630 |
|
assignBool(options::cegqiBv, key, optionarg == "true"); |
10631 |
|
return; |
10632 |
|
} |
10633 |
8893 |
if(key == "cegqi-bv-concat-inv") { |
10634 |
|
assignBool(options::cegqiBvConcInv, key, optionarg == "true"); |
10635 |
|
return; |
10636 |
|
} |
10637 |
8893 |
if(key == "cegqi-bv-ineq") { |
10638 |
|
assign(options::cegqiBvIneqMode, key, optionarg); |
10639 |
|
return; |
10640 |
|
} |
10641 |
8893 |
if(key == "cegqi-bv-interleave-value") { |
10642 |
|
assignBool(options::cegqiBvInterleaveValue, key, optionarg == "true"); |
10643 |
|
return; |
10644 |
|
} |
10645 |
8893 |
if(key == "cegqi-bv-linear") { |
10646 |
|
assignBool(options::cegqiBvLinearize, key, optionarg == "true"); |
10647 |
|
return; |
10648 |
|
} |
10649 |
8893 |
if(key == "cegqi-bv-rm-extract") { |
10650 |
|
assignBool(options::cegqiBvRmExtract, key, optionarg == "true"); |
10651 |
|
return; |
10652 |
|
} |
10653 |
8893 |
if(key == "cegqi-bv-solve-nl") { |
10654 |
|
assignBool(options::cegqiBvSolveNl, key, optionarg == "true"); |
10655 |
|
return; |
10656 |
|
} |
10657 |
8893 |
if(key == "cegqi-full") { |
10658 |
512 |
assignBool(options::cegqiFullEffort, key, optionarg == "true"); |
10659 |
512 |
return; |
10660 |
|
} |
10661 |
8381 |
if(key == "cegqi-innermost") { |
10662 |
|
assignBool(options::cegqiInnermost, key, optionarg == "true"); |
10663 |
|
return; |
10664 |
|
} |
10665 |
8381 |
if(key == "cegqi-midpoint") { |
10666 |
|
assignBool(options::cegqiMidpoint, key, optionarg == "true"); |
10667 |
|
return; |
10668 |
|
} |
10669 |
8381 |
if(key == "cegqi-min-bounds") { |
10670 |
|
assignBool(options::cegqiMinBounds, key, optionarg == "true"); |
10671 |
|
return; |
10672 |
|
} |
10673 |
8381 |
if(key == "cegqi-model") { |
10674 |
|
assignBool(options::cegqiModel, key, optionarg == "true"); |
10675 |
|
return; |
10676 |
|
} |
10677 |
8381 |
if(key == "cegqi-multi-inst") { |
10678 |
|
assignBool(options::cegqiMultiInst, key, optionarg == "true"); |
10679 |
|
return; |
10680 |
|
} |
10681 |
8381 |
if(key == "cegqi-nested-qe") { |
10682 |
12 |
assignBool(options::cegqiNestedQE, key, optionarg == "true"); |
10683 |
12 |
return; |
10684 |
|
} |
10685 |
8369 |
if(key == "cegqi-nopt") { |
10686 |
|
assignBool(options::cegqiNopt, key, optionarg == "true"); |
10687 |
|
return; |
10688 |
|
} |
10689 |
8369 |
if(key == "cegqi-repeat-lit") { |
10690 |
|
assignBool(options::cegqiRepeatLit, key, optionarg == "true"); |
10691 |
|
return; |
10692 |
|
} |
10693 |
8369 |
if(key == "cegqi-round-up-lia") { |
10694 |
|
assignBool(options::cegqiRoundUpLowerLia, key, optionarg == "true"); |
10695 |
|
return; |
10696 |
|
} |
10697 |
8369 |
if(key == "cegqi-sat") { |
10698 |
|
assignBool(options::cegqiSat, key, optionarg == "true"); |
10699 |
|
return; |
10700 |
|
} |
10701 |
8369 |
if(key == "cegqi-use-inf-int") { |
10702 |
3 |
assignBool(options::cegqiUseInfInt, key, optionarg == "true"); |
10703 |
3 |
return; |
10704 |
|
} |
10705 |
8366 |
if(key == "cegqi-use-inf-real") { |
10706 |
3 |
assignBool(options::cegqiUseInfReal, key, optionarg == "true"); |
10707 |
3 |
return; |
10708 |
|
} |
10709 |
8363 |
if(key == "cond-var-split-agg-quant") { |
10710 |
|
assignBool(options::condVarSplitQuantAgg, key, optionarg == "true"); |
10711 |
|
return; |
10712 |
|
} |
10713 |
8363 |
if(key == "cond-var-split-quant") { |
10714 |
|
assignBool(options::condVarSplitQuant, key, optionarg == "true"); |
10715 |
|
return; |
10716 |
|
} |
10717 |
8363 |
if(key == "conjecture-filter-active-terms") { |
10718 |
|
assignBool(options::conjectureFilterActiveTerms, key, optionarg == "true"); |
10719 |
|
return; |
10720 |
|
} |
10721 |
8363 |
if(key == "conjecture-filter-canonical") { |
10722 |
|
assignBool(options::conjectureFilterCanonical, key, optionarg == "true"); |
10723 |
|
return; |
10724 |
|
} |
10725 |
8363 |
if(key == "conjecture-filter-model") { |
10726 |
2 |
assignBool(options::conjectureFilterModel, key, optionarg == "true"); |
10727 |
2 |
return; |
10728 |
|
} |
10729 |
8361 |
if(key == "conjecture-gen") { |
10730 |
4 |
assignBool(options::conjectureGen, key, optionarg == "true"); |
10731 |
4 |
return; |
10732 |
|
} |
10733 |
8357 |
if(key == "conjecture-gen-gt-enum") { |
10734 |
|
assign(options::conjectureGenGtEnum, key, optionarg); |
10735 |
|
return; |
10736 |
|
} |
10737 |
8357 |
if(key == "conjecture-gen-max-depth") { |
10738 |
|
assign(options::conjectureGenMaxDepth, key, optionarg); |
10739 |
|
return; |
10740 |
|
} |
10741 |
8357 |
if(key == "conjecture-gen-per-round") { |
10742 |
|
assign(options::conjectureGenPerRound, key, optionarg); |
10743 |
|
return; |
10744 |
|
} |
10745 |
8357 |
if(key == "conjecture-gen-uee-intro") { |
10746 |
|
assignBool(options::conjectureUeeIntro, key, optionarg == "true"); |
10747 |
|
return; |
10748 |
|
} |
10749 |
8357 |
if(key == "conjecture-no-filter") { |
10750 |
2 |
assignBool(options::conjectureNoFilter, key, optionarg == "true"); |
10751 |
2 |
return; |
10752 |
|
} |
10753 |
8355 |
if(key == "debug-inst") { |
10754 |
|
assignBool(options::debugInst, key, optionarg == "true"); |
10755 |
|
return; |
10756 |
|
} |
10757 |
8355 |
if(key == "debug-sygus") { |
10758 |
|
assignBool(options::debugSygus, key, optionarg == "true"); |
10759 |
|
return; |
10760 |
|
} |
10761 |
8355 |
if(key == "dt-stc-ind") { |
10762 |
|
assignBool(options::dtStcInduction, key, optionarg == "true"); |
10763 |
|
return; |
10764 |
|
} |
10765 |
8355 |
if(key == "dt-var-exp-quant") { |
10766 |
|
assignBool(options::dtVarExpandQuant, key, optionarg == "true"); |
10767 |
|
return; |
10768 |
|
} |
10769 |
8355 |
if(key == "e-matching") { |
10770 |
1 |
assignBool(options::eMatching, key, optionarg == "true"); |
10771 |
1 |
return; |
10772 |
|
} |
10773 |
8354 |
if(key == "elim-taut-quant") { |
10774 |
|
assignBool(options::elimTautQuant, key, optionarg == "true"); |
10775 |
|
return; |
10776 |
|
} |
10777 |
8354 |
if(key == "ext-rewrite-quant") { |
10778 |
2 |
assignBool(options::extRewriteQuant, key, optionarg == "true"); |
10779 |
2 |
return; |
10780 |
|
} |
10781 |
8352 |
if(key == "finite-model-find") { |
10782 |
13 |
assignBool(options::finiteModelFind, key, optionarg == "true"); |
10783 |
13 |
return; |
10784 |
|
} |
10785 |
8339 |
if(key == "fmf-bound") { |
10786 |
8 |
assignBool(options::fmfBound, key, optionarg == "true"); |
10787 |
8 |
return; |
10788 |
|
} |
10789 |
8331 |
if(key == "fmf-bound-int") { |
10790 |
6 |
assignBool(options::fmfBoundInt, key, optionarg == "true"); |
10791 |
6 |
return; |
10792 |
|
} |
10793 |
8325 |
if(key == "fmf-bound-lazy") { |
10794 |
|
assignBool(options::fmfBoundLazy, key, optionarg == "true"); |
10795 |
|
return; |
10796 |
|
} |
10797 |
8325 |
if(key == "fmf-fmc-simple") { |
10798 |
|
assignBool(options::fmfFmcSimple, key, optionarg == "true"); |
10799 |
|
return; |
10800 |
|
} |
10801 |
8325 |
if(key == "fmf-fresh-dc") { |
10802 |
|
assignBool(options::fmfFreshDistConst, key, optionarg == "true"); |
10803 |
|
return; |
10804 |
|
} |
10805 |
8325 |
if(key == "fmf-fun") { |
10806 |
12 |
assignBool(options::fmfFunWellDefined, key, optionarg == "true"); |
10807 |
12 |
return; |
10808 |
|
} |
10809 |
8313 |
if(key == "fmf-fun-rlv") { |
10810 |
|
assignBool(options::fmfFunWellDefinedRelevant, key, optionarg == "true"); |
10811 |
|
return; |
10812 |
|
} |
10813 |
8313 |
if(key == "fmf-inst-engine") { |
10814 |
|
assignBool(options::fmfInstEngine, key, optionarg == "true"); |
10815 |
|
return; |
10816 |
|
} |
10817 |
8313 |
if(key == "fmf-type-completion-thresh") { |
10818 |
|
assign(options::fmfTypeCompletionThresh, key, optionarg); |
10819 |
|
return; |
10820 |
|
} |
10821 |
8313 |
if(key == "fs-interleave") { |
10822 |
|
assignBool(options::fullSaturateInterleave, key, optionarg == "true"); |
10823 |
|
return; |
10824 |
|
} |
10825 |
8313 |
if(key == "fs-stratify") { |
10826 |
|
assignBool(options::fullSaturateStratify, key, optionarg == "true"); |
10827 |
|
return; |
10828 |
|
} |
10829 |
8313 |
if(key == "fs-sum") { |
10830 |
|
assignBool(options::fullSaturateSum, key, optionarg == "true"); |
10831 |
|
return; |
10832 |
|
} |
10833 |
8313 |
if(key == "full-saturate-quant") { |
10834 |
|
assignBool(options::fullSaturateQuant, key, optionarg == "true"); |
10835 |
|
return; |
10836 |
|
} |
10837 |
8313 |
if(key == "full-saturate-quant-limit") { |
10838 |
|
assign(options::fullSaturateLimit, key, optionarg); |
10839 |
|
return; |
10840 |
|
} |
10841 |
8313 |
if(key == "full-saturate-quant-rd") { |
10842 |
|
assignBool(options::fullSaturateQuantRd, key, optionarg == "true"); |
10843 |
|
return; |
10844 |
|
} |
10845 |
8313 |
if(key == "global-negate") { |
10846 |
2 |
assignBool(options::globalNegate, key, optionarg == "true"); |
10847 |
2 |
return; |
10848 |
|
} |
10849 |
8311 |
if(key == "ho-elim") { |
10850 |
|
assignBool(options::hoElim, key, optionarg == "true"); |
10851 |
|
return; |
10852 |
|
} |
10853 |
8311 |
if(key == "ho-elim-store-ax") { |
10854 |
|
assignBool(options::hoElimStoreAx, key, optionarg == "true"); |
10855 |
|
return; |
10856 |
|
} |
10857 |
8311 |
if(key == "ho-matching") { |
10858 |
|
assignBool(options::hoMatching, key, optionarg == "true"); |
10859 |
|
return; |
10860 |
|
} |
10861 |
8311 |
if(key == "ho-matching-var-priority") { |
10862 |
|
assignBool(options::hoMatchingVarArgPriority, key, optionarg == "true"); |
10863 |
|
return; |
10864 |
|
} |
10865 |
8311 |
if(key == "ho-merge-term-db") { |
10866 |
|
assignBool(options::hoMergeTermDb, key, optionarg == "true"); |
10867 |
|
return; |
10868 |
|
} |
10869 |
8311 |
if(key == "increment-triggers") { |
10870 |
|
assignBool(options::incrementTriggers, key, optionarg == "true"); |
10871 |
|
return; |
10872 |
|
} |
10873 |
8311 |
if(key == "inst-level-input-only") { |
10874 |
|
assignBool(options::instLevelInputOnly, key, optionarg == "true"); |
10875 |
|
return; |
10876 |
|
} |
10877 |
8311 |
if(key == "inst-max-level") { |
10878 |
|
assign(options::instMaxLevel, key, optionarg); |
10879 |
|
return; |
10880 |
|
} |
10881 |
8311 |
if(key == "inst-no-entail") { |
10882 |
|
assignBool(options::instNoEntail, key, optionarg == "true"); |
10883 |
|
return; |
10884 |
|
} |
10885 |
8311 |
if(key == "inst-when-phase") { |
10886 |
|
assign(options::instWhenPhase, key, optionarg); |
10887 |
|
return; |
10888 |
|
} |
10889 |
8311 |
if(key == "inst-when-strict-interleave") { |
10890 |
|
assignBool(options::instWhenStrictInterleave, key, optionarg == "true"); |
10891 |
|
return; |
10892 |
|
} |
10893 |
8311 |
if(key == "inst-when-tc-first") { |
10894 |
|
assignBool(options::instWhenTcFirst, key, optionarg == "true"); |
10895 |
|
return; |
10896 |
|
} |
10897 |
8311 |
if(key == "inst-when") { |
10898 |
|
assign(options::instWhenMode, key, optionarg); |
10899 |
|
return; |
10900 |
|
} |
10901 |
8311 |
if(key == "int-wf-ind") { |
10902 |
2 |
assignBool(options::intWfInduction, key, optionarg == "true"); |
10903 |
2 |
return; |
10904 |
|
} |
10905 |
8309 |
if(key == "ite-dtt-split-quant") { |
10906 |
|
assignBool(options::iteDtTesterSplitQuant, key, optionarg == "true"); |
10907 |
|
return; |
10908 |
|
} |
10909 |
8309 |
if(key == "ite-lift-quant") { |
10910 |
|
assign(options::iteLiftQuant, key, optionarg); |
10911 |
|
return; |
10912 |
|
} |
10913 |
8309 |
if(key == "literal-matching") { |
10914 |
|
assign(options::literalMatchMode, key, optionarg); |
10915 |
|
return; |
10916 |
|
} |
10917 |
8309 |
if(key == "macros-quant") { |
10918 |
|
assignBool(options::macrosQuant, key, optionarg == "true"); |
10919 |
|
return; |
10920 |
|
} |
10921 |
8309 |
if(key == "macros-quant-mode") { |
10922 |
|
assign(options::macrosQuantMode, key, optionarg); |
10923 |
|
return; |
10924 |
|
} |
10925 |
8309 |
if(key == "mbqi-interleave") { |
10926 |
|
assignBool(options::mbqiInterleave, key, optionarg == "true"); |
10927 |
|
return; |
10928 |
|
} |
10929 |
8309 |
if(key == "mbqi-one-inst-per-round") { |
10930 |
|
assignBool(options::fmfOneInstPerRound, key, optionarg == "true"); |
10931 |
|
return; |
10932 |
|
} |
10933 |
8309 |
if(key == "mbqi") { |
10934 |
|
assign(options::mbqiMode, key, optionarg); |
10935 |
|
return; |
10936 |
|
} |
10937 |
8309 |
if(key == "miniscope-quant") { |
10938 |
128 |
assignBool(options::miniscopeQuant, key, optionarg == "true"); |
10939 |
128 |
return; |
10940 |
|
} |
10941 |
8181 |
if(key == "miniscope-quant-fv") { |
10942 |
126 |
assignBool(options::miniscopeQuantFreeVar, key, optionarg == "true"); |
10943 |
126 |
return; |
10944 |
|
} |
10945 |
8055 |
if(key == "multi-trigger-cache") { |
10946 |
|
assignBool(options::multiTriggerCache, key, optionarg == "true"); |
10947 |
|
return; |
10948 |
|
} |
10949 |
8055 |
if(key == "multi-trigger-linear") { |
10950 |
|
assignBool(options::multiTriggerLinear, key, optionarg == "true"); |
10951 |
|
return; |
10952 |
|
} |
10953 |
8055 |
if(key == "multi-trigger-priority") { |
10954 |
|
assignBool(options::multiTriggerPriority, key, optionarg == "true"); |
10955 |
|
return; |
10956 |
|
} |
10957 |
8055 |
if(key == "multi-trigger-when-single") { |
10958 |
|
assignBool(options::multiTriggerWhenSingle, key, optionarg == "true"); |
10959 |
|
return; |
10960 |
|
} |
10961 |
8055 |
if(key == "partial-triggers") { |
10962 |
|
assignBool(options::partialTriggers, key, optionarg == "true"); |
10963 |
|
return; |
10964 |
|
} |
10965 |
8055 |
if(key == "pool-inst") { |
10966 |
|
assignBool(options::poolInst, key, optionarg == "true"); |
10967 |
|
return; |
10968 |
|
} |
10969 |
8055 |
if(key == "pre-skolem-quant") { |
10970 |
2 |
assignBool(options::preSkolemQuant, key, optionarg == "true"); |
10971 |
2 |
return; |
10972 |
|
} |
10973 |
8053 |
if(key == "pre-skolem-quant-agg") { |
10974 |
|
assignBool(options::preSkolemQuantAgg, key, optionarg == "true"); |
10975 |
|
return; |
10976 |
|
} |
10977 |
8053 |
if(key == "pre-skolem-quant-nested") { |
10978 |
2 |
assignBool(options::preSkolemQuantNested, key, optionarg == "true"); |
10979 |
2 |
return; |
10980 |
|
} |
10981 |
8051 |
if(key == "prenex-quant-user") { |
10982 |
|
assignBool(options::prenexQuantUser, key, optionarg == "true"); |
10983 |
|
return; |
10984 |
|
} |
10985 |
8051 |
if(key == "prenex-quant") { |
10986 |
|
assign(options::prenexQuant, key, optionarg); |
10987 |
|
return; |
10988 |
|
} |
10989 |
8051 |
if(key == "purify-triggers") { |
10990 |
|
assignBool(options::purifyTriggers, key, optionarg == "true"); |
10991 |
|
return; |
10992 |
|
} |
10993 |
8051 |
if(key == "qcf-all-conflict") { |
10994 |
|
assignBool(options::qcfAllConflict, key, optionarg == "true"); |
10995 |
|
return; |
10996 |
|
} |
10997 |
8051 |
if(key == "qcf-eager-check-rd") { |
10998 |
|
assignBool(options::qcfEagerCheckRd, key, optionarg == "true"); |
10999 |
|
return; |
11000 |
|
} |
11001 |
8051 |
if(key == "qcf-eager-test") { |
11002 |
|
assignBool(options::qcfEagerTest, key, optionarg == "true"); |
11003 |
|
return; |
11004 |
|
} |
11005 |
8051 |
if(key == "qcf-nested-conflict") { |
11006 |
|
assignBool(options::qcfNestedConflict, key, optionarg == "true"); |
11007 |
|
return; |
11008 |
|
} |
11009 |
8051 |
if(key == "qcf-skip-rd") { |
11010 |
|
assignBool(options::qcfSkipRd, key, optionarg == "true"); |
11011 |
|
return; |
11012 |
|
} |
11013 |
8051 |
if(key == "qcf-tconstraint") { |
11014 |
|
assignBool(options::qcfTConstraint, key, optionarg == "true"); |
11015 |
|
return; |
11016 |
|
} |
11017 |
8051 |
if(key == "qcf-vo-exp") { |
11018 |
|
assignBool(options::qcfVoExp, key, optionarg == "true"); |
11019 |
|
return; |
11020 |
|
} |
11021 |
8051 |
if(key == "quant-alpha-equiv") { |
11022 |
|
assignBool(options::quantAlphaEquiv, key, optionarg == "true"); |
11023 |
|
return; |
11024 |
|
} |
11025 |
8051 |
if(key == "quant-cf") { |
11026 |
|
assignBool(options::quantConflictFind, key, optionarg == "true"); |
11027 |
|
return; |
11028 |
|
} |
11029 |
8051 |
if(key == "quant-cf-mode") { |
11030 |
|
assign(options::qcfMode, key, optionarg); |
11031 |
|
return; |
11032 |
|
} |
11033 |
8051 |
if(key == "quant-cf-when") { |
11034 |
|
assign(options::qcfWhenMode, key, optionarg); |
11035 |
|
return; |
11036 |
|
} |
11037 |
8051 |
if(key == "quant-dsplit-mode") { |
11038 |
|
assign(options::quantDynamicSplit, key, optionarg); |
11039 |
|
return; |
11040 |
|
} |
11041 |
8051 |
if(key == "quant-fun-wd") { |
11042 |
|
assignBool(options::quantFunWellDefined, key, optionarg == "true"); |
11043 |
|
return; |
11044 |
|
} |
11045 |
8051 |
if(key == "quant-ind") { |
11046 |
2 |
assignBool(options::quantInduction, key, optionarg == "true"); |
11047 |
2 |
return; |
11048 |
|
} |
11049 |
8049 |
if(key == "quant-rep-mode") { |
11050 |
|
assign(options::quantRepMode, key, optionarg); |
11051 |
|
return; |
11052 |
|
} |
11053 |
8049 |
if(key == "quant-split") { |
11054 |
126 |
assignBool(options::quantSplit, key, optionarg == "true"); |
11055 |
126 |
return; |
11056 |
|
} |
11057 |
7923 |
if(key == "register-quant-body-terms") { |
11058 |
|
assignBool(options::registerQuantBodyTerms, key, optionarg == "true"); |
11059 |
|
return; |
11060 |
|
} |
11061 |
7923 |
if(key == "relational-triggers") { |
11062 |
|
assignBool(options::relationalTriggers, key, optionarg == "true"); |
11063 |
|
return; |
11064 |
|
} |
11065 |
7923 |
if(key == "relevant-triggers") { |
11066 |
|
assignBool(options::relevantTriggers, key, optionarg == "true"); |
11067 |
|
return; |
11068 |
|
} |
11069 |
7923 |
if(key == "strict-triggers") { |
11070 |
|
assignBool(options::strictTriggers, key, optionarg == "true"); |
11071 |
|
return; |
11072 |
|
} |
11073 |
7923 |
if(key == "sygus") { |
11074 |
|
assignBool(options::sygus, key, optionarg == "true"); |
11075 |
|
return; |
11076 |
|
} |
11077 |
7923 |
if(key == "sygus-active-gen-cfactor") { |
11078 |
|
assign(options::sygusActiveGenEnumConsts, key, optionarg); |
11079 |
|
return; |
11080 |
|
} |
11081 |
7923 |
if(key == "sygus-active-gen") { |
11082 |
1 |
assign(options::sygusActiveGenMode, key, optionarg); |
11083 |
1 |
return; |
11084 |
|
} |
11085 |
7922 |
if(key == "sygus-add-const-grammar") { |
11086 |
|
assignBool(options::sygusAddConstGrammar, key, optionarg == "true"); |
11087 |
|
return; |
11088 |
|
} |
11089 |
7922 |
if(key == "sygus-arg-relevant") { |
11090 |
|
assignBool(options::sygusArgRelevant, key, optionarg == "true"); |
11091 |
|
return; |
11092 |
|
} |
11093 |
7922 |
if(key == "sygus-auto-unfold") { |
11094 |
|
assignBool(options::sygusInvAutoUnfold, key, optionarg == "true"); |
11095 |
|
return; |
11096 |
|
} |
11097 |
7922 |
if(key == "sygus-bool-ite-return-const") { |
11098 |
|
assignBool(options::sygusBoolIteReturnConst, key, optionarg == "true"); |
11099 |
|
return; |
11100 |
|
} |
11101 |
7922 |
if(key == "sygus-core-connective") { |
11102 |
|
assignBool(options::sygusCoreConnective, key, optionarg == "true"); |
11103 |
|
return; |
11104 |
|
} |
11105 |
7922 |
if(key == "sygus-crepair-abort") { |
11106 |
|
assignBool(options::sygusConstRepairAbort, key, optionarg == "true"); |
11107 |
|
return; |
11108 |
|
} |
11109 |
7922 |
if(key == "sygus-eval-opt") { |
11110 |
|
assignBool(options::sygusEvalOpt, key, optionarg == "true"); |
11111 |
|
return; |
11112 |
|
} |
11113 |
7922 |
if(key == "sygus-eval-unfold") { |
11114 |
|
assignBool(options::sygusEvalUnfold, key, optionarg == "true"); |
11115 |
|
return; |
11116 |
|
} |
11117 |
7922 |
if(key == "sygus-eval-unfold-bool") { |
11118 |
|
assignBool(options::sygusEvalUnfoldBool, key, optionarg == "true"); |
11119 |
|
return; |
11120 |
|
} |
11121 |
7922 |
if(key == "sygus-expr-miner-check-timeout") { |
11122 |
|
assign(options::sygusExprMinerCheckTimeout, key, optionarg); |
11123 |
|
return; |
11124 |
|
} |
11125 |
7922 |
if(key == "sygus-ext-rew") { |
11126 |
2 |
assignBool(options::sygusExtRew, key, optionarg == "true"); |
11127 |
2 |
return; |
11128 |
|
} |
11129 |
7920 |
if(key == "sygus-filter-sol-rev") { |
11130 |
|
assignBool(options::sygusFilterSolRevSubsume, key, optionarg == "true"); |
11131 |
|
return; |
11132 |
|
} |
11133 |
7920 |
if(key == "sygus-filter-sol") { |
11134 |
|
assign(options::sygusFilterSolMode, key, optionarg); |
11135 |
|
return; |
11136 |
|
} |
11137 |
7920 |
if(key == "sygus-grammar-cons") { |
11138 |
|
assign(options::sygusGrammarConsMode, key, optionarg); |
11139 |
|
return; |
11140 |
|
} |
11141 |
7920 |
if(key == "sygus-grammar-norm") { |
11142 |
|
assignBool(options::sygusGrammarNorm, key, optionarg == "true"); |
11143 |
|
return; |
11144 |
|
} |
11145 |
7920 |
if(key == "sygus-inference") { |
11146 |
14 |
assignBool(options::sygusInference, key, optionarg == "true"); |
11147 |
14 |
return; |
11148 |
|
} |
11149 |
7906 |
if(key == "sygus-inst") { |
11150 |
4 |
assignBool(options::sygusInst, key, optionarg == "true"); |
11151 |
4 |
return; |
11152 |
|
} |
11153 |
7902 |
if(key == "sygus-inst-mode") { |
11154 |
|
assign(options::sygusInstMode, key, optionarg); |
11155 |
|
return; |
11156 |
|
} |
11157 |
7902 |
if(key == "sygus-inst-scope") { |
11158 |
|
assign(options::sygusInstScope, key, optionarg); |
11159 |
|
return; |
11160 |
|
} |
11161 |
7902 |
if(key == "sygus-inst-term-sel") { |
11162 |
|
assign(options::sygusInstTermSel, key, optionarg); |
11163 |
|
return; |
11164 |
|
} |
11165 |
7902 |
if(key == "sygus-inv-templ-when-sg") { |
11166 |
|
assignBool(options::sygusInvTemplWhenSyntax, key, optionarg == "true"); |
11167 |
|
return; |
11168 |
|
} |
11169 |
7902 |
if(key == "sygus-inv-templ") { |
11170 |
|
assign(options::sygusInvTemplMode, key, optionarg); |
11171 |
|
return; |
11172 |
|
} |
11173 |
7902 |
if(key == "sygus-min-grammar") { |
11174 |
|
assignBool(options::sygusMinGrammar, key, optionarg == "true"); |
11175 |
|
return; |
11176 |
|
} |
11177 |
7902 |
if(key == "sygus-pbe") { |
11178 |
|
assignBool(options::sygusUnifPbe, key, optionarg == "true"); |
11179 |
|
return; |
11180 |
|
} |
11181 |
7902 |
if(key == "sygus-pbe-multi-fair") { |
11182 |
|
assignBool(options::sygusPbeMultiFair, key, optionarg == "true"); |
11183 |
|
return; |
11184 |
|
} |
11185 |
7902 |
if(key == "sygus-pbe-multi-fair-diff") { |
11186 |
|
assign(options::sygusPbeMultiFairDiff, key, optionarg); |
11187 |
|
return; |
11188 |
|
} |
11189 |
7902 |
if(key == "sygus-qe-preproc") { |
11190 |
|
assignBool(options::sygusQePreproc, key, optionarg == "true"); |
11191 |
|
return; |
11192 |
|
} |
11193 |
7902 |
if(key == "sygus-query-gen") { |
11194 |
|
assignBool(options::sygusQueryGen, key, optionarg == "true"); |
11195 |
|
return; |
11196 |
|
} |
11197 |
7902 |
if(key == "sygus-query-gen-check") { |
11198 |
|
assignBool(options::sygusQueryGenCheck, key, optionarg == "true"); |
11199 |
|
return; |
11200 |
|
} |
11201 |
7902 |
if(key == "sygus-query-gen-dump-files") { |
11202 |
|
assign(options::sygusQueryGenDumpFiles, key, optionarg); |
11203 |
|
return; |
11204 |
|
} |
11205 |
7902 |
if(key == "sygus-query-gen-thresh") { |
11206 |
|
assign(options::sygusQueryGenThresh, key, optionarg); |
11207 |
|
return; |
11208 |
|
} |
11209 |
7902 |
if(key == "sygus-rec-fun") { |
11210 |
2 |
assignBool(options::sygusRecFun, key, optionarg == "true"); |
11211 |
2 |
return; |
11212 |
|
} |
11213 |
7900 |
if(key == "sygus-rec-fun-eval-limit") { |
11214 |
|
assign(options::sygusRecFunEvalLimit, key, optionarg); |
11215 |
|
return; |
11216 |
|
} |
11217 |
7900 |
if(key == "sygus-repair-const") { |
11218 |
|
assignBool(options::sygusRepairConst, key, optionarg == "true"); |
11219 |
|
return; |
11220 |
|
} |
11221 |
7900 |
if(key == "sygus-repair-const-timeout") { |
11222 |
|
assign(options::sygusRepairConstTimeout, key, optionarg); |
11223 |
|
return; |
11224 |
|
} |
11225 |
7900 |
if(key == "sygus-rr") { |
11226 |
|
assignBool(options::sygusRew, key, optionarg == "true"); |
11227 |
|
return; |
11228 |
|
} |
11229 |
7900 |
if(key == "sygus-rr-synth") { |
11230 |
|
assignBool(options::sygusRewSynth, key, optionarg == "true"); |
11231 |
|
return; |
11232 |
|
} |
11233 |
7900 |
if(key == "sygus-rr-synth-accel") { |
11234 |
|
assignBool(options::sygusRewSynthAccel, key, optionarg == "true"); |
11235 |
|
return; |
11236 |
|
} |
11237 |
7900 |
if(key == "sygus-rr-synth-check") { |
11238 |
|
assignBool(options::sygusRewSynthCheck, key, optionarg == "true"); |
11239 |
|
return; |
11240 |
|
} |
11241 |
7900 |
if(key == "sygus-rr-synth-filter-cong") { |
11242 |
|
assignBool(options::sygusRewSynthFilterCong, key, optionarg == "true"); |
11243 |
|
return; |
11244 |
|
} |
11245 |
7900 |
if(key == "sygus-rr-synth-filter-match") { |
11246 |
|
assignBool(options::sygusRewSynthFilterMatch, key, optionarg == "true"); |
11247 |
|
return; |
11248 |
|
} |
11249 |
7900 |
if(key == "sygus-rr-synth-filter-nl") { |
11250 |
|
assignBool(options::sygusRewSynthFilterNonLinear, key, optionarg == "true"); |
11251 |
|
return; |
11252 |
|
} |
11253 |
7900 |
if(key == "sygus-rr-synth-filter-order") { |
11254 |
|
assignBool(options::sygusRewSynthFilterOrder, key, optionarg == "true"); |
11255 |
|
return; |
11256 |
|
} |
11257 |
7900 |
if(key == "sygus-rr-synth-input") { |
11258 |
247 |
assignBool(options::sygusRewSynthInput, key, optionarg == "true"); |
11259 |
247 |
return; |
11260 |
|
} |
11261 |
7653 |
if(key == "sygus-rr-synth-input-nvars") { |
11262 |
|
assign(options::sygusRewSynthInputNVars, key, optionarg); |
11263 |
|
return; |
11264 |
|
} |
11265 |
7653 |
if(key == "sygus-rr-synth-input-use-bool") { |
11266 |
|
assignBool(options::sygusRewSynthInputUseBool, key, optionarg == "true"); |
11267 |
|
return; |
11268 |
|
} |
11269 |
7653 |
if(key == "sygus-rr-synth-rec") { |
11270 |
|
assignBool(options::sygusRewSynthRec, key, optionarg == "true"); |
11271 |
|
return; |
11272 |
|
} |
11273 |
7653 |
if(key == "sygus-rr-verify") { |
11274 |
|
assignBool(options::sygusRewVerify, key, optionarg == "true"); |
11275 |
|
return; |
11276 |
|
} |
11277 |
7653 |
if(key == "sygus-rr-verify-abort") { |
11278 |
|
assignBool(options::sygusRewVerifyAbort, key, optionarg == "true"); |
11279 |
|
return; |
11280 |
|
} |
11281 |
7653 |
if(key == "sygus-sample-fp-uniform") { |
11282 |
|
assignBool(options::sygusSampleFpUniform, key, optionarg == "true"); |
11283 |
|
return; |
11284 |
|
} |
11285 |
7653 |
if(key == "sygus-sample-grammar") { |
11286 |
|
assignBool(options::sygusSampleGrammar, key, optionarg == "true"); |
11287 |
|
return; |
11288 |
|
} |
11289 |
7653 |
if(key == "sygus-samples") { |
11290 |
|
assign(options::sygusSamples, key, optionarg); |
11291 |
|
return; |
11292 |
|
} |
11293 |
7653 |
if(key == "sygus-si-abort") { |
11294 |
|
assignBool(options::cegqiSingleInvAbort, key, optionarg == "true"); |
11295 |
|
return; |
11296 |
|
} |
11297 |
7653 |
if(key == "sygus-si-partial") { |
11298 |
|
assignBool(options::cegqiSingleInvPartial, key, optionarg == "true"); |
11299 |
|
return; |
11300 |
|
} |
11301 |
7653 |
if(key == "sygus-si-rcons-limit") { |
11302 |
|
assign(options::cegqiSingleInvReconstructLimit, key, optionarg); |
11303 |
|
return; |
11304 |
|
} |
11305 |
7653 |
if(key == "sygus-si-rcons") { |
11306 |
|
assign(options::cegqiSingleInvReconstruct, key, optionarg); |
11307 |
|
return; |
11308 |
|
} |
11309 |
7653 |
if(key == "sygus-si-reconstruct-const") { |
11310 |
|
assignBool(options::cegqiSingleInvReconstructConst, key, optionarg == "true"); |
11311 |
|
return; |
11312 |
|
} |
11313 |
7653 |
if(key == "sygus-si") { |
11314 |
|
assign(options::cegqiSingleInvMode, key, optionarg); |
11315 |
|
return; |
11316 |
|
} |
11317 |
7653 |
if(key == "sygus-stream") { |
11318 |
|
assignBool(options::sygusStream, key, optionarg == "true"); |
11319 |
|
return; |
11320 |
|
} |
11321 |
7653 |
if(key == "sygus-templ-embed-grammar") { |
11322 |
|
assignBool(options::sygusTemplEmbedGrammar, key, optionarg == "true"); |
11323 |
|
return; |
11324 |
|
} |
11325 |
7653 |
if(key == "sygus-unif-cond-independent-no-repeat-sol") { |
11326 |
|
assignBool(options::sygusUnifCondIndNoRepeatSol, key, optionarg == "true"); |
11327 |
|
return; |
11328 |
|
} |
11329 |
7653 |
if(key == "sygus-unif-pi") { |
11330 |
|
assign(options::sygusUnifPi, key, optionarg); |
11331 |
|
return; |
11332 |
|
} |
11333 |
7653 |
if(key == "sygus-unif-shuffle-cond") { |
11334 |
|
assignBool(options::sygusUnifShuffleCond, key, optionarg == "true"); |
11335 |
|
return; |
11336 |
|
} |
11337 |
7653 |
if(key == "term-db-cd") { |
11338 |
|
assignBool(options::termDbCd, key, optionarg == "true"); |
11339 |
|
return; |
11340 |
|
} |
11341 |
7653 |
if(key == "term-db-mode") { |
11342 |
|
assign(options::termDbMode, key, optionarg); |
11343 |
|
return; |
11344 |
|
} |
11345 |
7653 |
if(key == "trigger-active-sel") { |
11346 |
|
assign(options::triggerActiveSelMode, key, optionarg); |
11347 |
|
return; |
11348 |
|
} |
11349 |
7653 |
if(key == "trigger-sel") { |
11350 |
|
assign(options::triggerSelMode, key, optionarg); |
11351 |
|
return; |
11352 |
|
} |
11353 |
7653 |
if(key == "user-pat") { |
11354 |
|
assign(options::userPatternsQuant, key, optionarg); |
11355 |
|
return; |
11356 |
|
} |
11357 |
7653 |
if(key == "var-elim-quant") { |
11358 |
|
assignBool(options::varElimQuant, key, optionarg == "true"); |
11359 |
|
return; |
11360 |
|
} |
11361 |
7653 |
if(key == "var-ineq-elim-quant") { |
11362 |
5 |
assignBool(options::varIneqElimQuant, key, optionarg == "true"); |
11363 |
5 |
return; |
11364 |
|
} |
11365 |
7648 |
if(key == "reproducible-resource-limit" || key == "rlimit-per") { |
11366 |
|
assign(options::perCallResourceLimit, key, optionarg); |
11367 |
|
return; |
11368 |
|
} |
11369 |
7648 |
if(key == "rlimit") { |
11370 |
|
assign(options::cumulativeResourceLimit, key, optionarg); |
11371 |
|
return; |
11372 |
|
} |
11373 |
7648 |
if(key == "rweight") { |
11374 |
|
handler->setResourceWeight("rweight", optionarg); |
11375 |
|
return; |
11376 |
|
} |
11377 |
7648 |
if(key == "tlimit-per") { |
11378 |
|
assign(options::perCallMillisecondLimit, key, optionarg); |
11379 |
|
return; |
11380 |
|
} |
11381 |
7648 |
if(key == "tlimit") { |
11382 |
|
assign(options::cumulativeMillisecondLimit, key, optionarg); |
11383 |
|
return; |
11384 |
|
} |
11385 |
7648 |
if(key == "sep-check-neg") { |
11386 |
|
assignBool(options::sepCheckNeg, key, optionarg == "true"); |
11387 |
|
return; |
11388 |
|
} |
11389 |
7648 |
if(key == "sep-child-refine") { |
11390 |
|
assignBool(options::sepChildRefine, key, optionarg == "true"); |
11391 |
|
return; |
11392 |
|
} |
11393 |
7648 |
if(key == "sep-deq-c") { |
11394 |
|
assignBool(options::sepDisequalC, key, optionarg == "true"); |
11395 |
|
return; |
11396 |
|
} |
11397 |
7648 |
if(key == "sep-exp") { |
11398 |
|
assignBool(options::sepExp, key, optionarg == "true"); |
11399 |
|
return; |
11400 |
|
} |
11401 |
7648 |
if(key == "sep-min-refine") { |
11402 |
|
assignBool(options::sepMinimalRefine, key, optionarg == "true"); |
11403 |
|
return; |
11404 |
|
} |
11405 |
7648 |
if(key == "sep-pre-skolem-emp") { |
11406 |
|
assignBool(options::sepPreSkolemEmp, key, optionarg == "true"); |
11407 |
|
return; |
11408 |
|
} |
11409 |
7648 |
if(key == "sets-ext") { |
11410 |
84 |
assignBool(options::setsExt, key, optionarg == "true"); |
11411 |
84 |
return; |
11412 |
|
} |
11413 |
7564 |
if(key == "sets-infer-as-lemmas") { |
11414 |
|
assignBool(options::setsInferAsLemmas, key, optionarg == "true"); |
11415 |
|
return; |
11416 |
|
} |
11417 |
7564 |
if(key == "sets-proxy-lemmas") { |
11418 |
|
assignBool(options::setsProxyLemmas, key, optionarg == "true"); |
11419 |
|
return; |
11420 |
|
} |
11421 |
7564 |
if(key == "abstract-values") { |
11422 |
|
assignBool(options::abstractValues, key, optionarg == "true"); |
11423 |
|
return; |
11424 |
|
} |
11425 |
7564 |
if(key == "ackermann") { |
11426 |
|
assignBool(options::ackermann, key, optionarg == "true"); |
11427 |
|
return; |
11428 |
|
} |
11429 |
7564 |
if(key == "block-models") { |
11430 |
14 |
assign(options::blockModelsMode, key, optionarg); |
11431 |
14 |
return; |
11432 |
|
} |
11433 |
7550 |
if(key == "bvand-integer-granularity") { |
11434 |
|
assign(options::BVAndIntegerGranularity, key, optionarg); |
11435 |
|
return; |
11436 |
|
} |
11437 |
7550 |
if(key == "check-abducts") { |
11438 |
|
assignBool(options::checkAbducts, key, optionarg == "true"); |
11439 |
|
return; |
11440 |
|
} |
11441 |
7550 |
if(key == "check-interpols") { |
11442 |
|
assignBool(options::checkInterpols, key, optionarg == "true"); |
11443 |
|
return; |
11444 |
|
} |
11445 |
7550 |
if(key == "check-models") { |
11446 |
9 |
assignBool(options::checkModels, key, optionarg == "true"); |
11447 |
9 |
return; |
11448 |
|
} |
11449 |
7541 |
if(key == "check-proofs") { |
11450 |
|
assignBool(options::checkProofs, key, optionarg == "true"); |
11451 |
|
return; |
11452 |
|
} |
11453 |
7541 |
if(key == "check-synth-sol") { |
11454 |
|
assignBool(options::checkSynthSol, key, optionarg == "true"); |
11455 |
|
return; |
11456 |
|
} |
11457 |
7541 |
if(key == "check-unsat-cores") { |
11458 |
4 |
assignBool(options::checkUnsatCores, key, optionarg == "true"); |
11459 |
4 |
return; |
11460 |
|
} |
11461 |
7537 |
if(key == "debug-check-models") { |
11462 |
|
assignBool(options::debugCheckModels, key, optionarg == "true"); |
11463 |
|
return; |
11464 |
|
} |
11465 |
7537 |
if(key == "diagnostic-output-channel") { |
11466 |
|
assign(options::diagnosticChannelName, key, optionarg); |
11467 |
|
return; |
11468 |
|
} |
11469 |
7537 |
if(key == "dump-instantiations") { |
11470 |
|
assignBool(options::dumpInstantiations, key, optionarg == "true"); |
11471 |
|
return; |
11472 |
|
} |
11473 |
7537 |
if(key == "dump-models") { |
11474 |
|
assignBool(options::dumpModels, key, optionarg == "true"); |
11475 |
|
return; |
11476 |
|
} |
11477 |
7537 |
if(key == "dump-proofs") { |
11478 |
|
assignBool(options::dumpProofs, key, optionarg == "true"); |
11479 |
|
return; |
11480 |
|
} |
11481 |
7537 |
if(key == "dump-to") { |
11482 |
|
assign(options::dumpToFileName, key, optionarg); |
11483 |
|
return; |
11484 |
|
} |
11485 |
7537 |
if(key == "dump-unsat-cores") { |
11486 |
|
assignBool(options::dumpUnsatCores, key, optionarg == "true"); |
11487 |
|
return; |
11488 |
|
} |
11489 |
7537 |
if(key == "dump-unsat-cores-full") { |
11490 |
|
assignBool(options::dumpUnsatCoresFull, key, optionarg == "true"); |
11491 |
|
return; |
11492 |
|
} |
11493 |
7537 |
if(key == "dump") { |
11494 |
|
assign(options::dumpModeString, key, optionarg); |
11495 |
|
return; |
11496 |
|
} |
11497 |
7537 |
if(key == "early-ite-removal") { |
11498 |
|
assignBool(options::earlyIteRemoval, key, optionarg == "true"); |
11499 |
|
return; |
11500 |
|
} |
11501 |
7537 |
if(key == "expand-definitions") { |
11502 |
|
assignBool(options::expandDefinitions, key, optionarg == "true"); |
11503 |
|
return; |
11504 |
|
} |
11505 |
7537 |
if(key == "ext-rew-prep") { |
11506 |
2 |
assignBool(options::extRewPrep, key, optionarg == "true"); |
11507 |
2 |
return; |
11508 |
|
} |
11509 |
7535 |
if(key == "ext-rew-prep-agg") { |
11510 |
|
assignBool(options::extRewPrepAgg, key, optionarg == "true"); |
11511 |
|
return; |
11512 |
|
} |
11513 |
7535 |
if(key == "force-no-limit-cpu-while-dump") { |
11514 |
|
assignBool(options::forceNoLimitCpuWhileDump, key, optionarg == "true"); |
11515 |
|
return; |
11516 |
|
} |
11517 |
7535 |
if(key == "foreign-theory-rewrite") { |
11518 |
|
assignBool(options::foreignTheoryRewrite, key, optionarg == "true"); |
11519 |
|
return; |
11520 |
|
} |
11521 |
7535 |
if(key == "iand-mode") { |
11522 |
|
assign(options::iandMode, key, optionarg); |
11523 |
|
return; |
11524 |
|
} |
11525 |
7535 |
if(key == "incremental") { |
11526 |
6399 |
assignBool(options::incrementalSolving, key, optionarg == "true"); |
11527 |
6399 |
return; |
11528 |
|
} |
11529 |
1136 |
if(key == "interactive-mode") { |
11530 |
2 |
assignBool(options::interactiveMode, key, optionarg == "true"); |
11531 |
2 |
return; |
11532 |
|
} |
11533 |
1134 |
if(key == "ite-simp") { |
11534 |
3 |
assignBool(options::doITESimp, key, optionarg == "true"); |
11535 |
3 |
return; |
11536 |
|
} |
11537 |
1131 |
if(key == "model-cores") { |
11538 |
|
assign(options::modelCoresMode, key, optionarg); |
11539 |
|
return; |
11540 |
|
} |
11541 |
1131 |
if(key == "model-u-print" || key == "model-uninterp-print") { |
11542 |
|
assign(options::modelUninterpPrint, key, optionarg); |
11543 |
|
return; |
11544 |
|
} |
11545 |
1131 |
if(key == "model-witness-value") { |
11546 |
|
assignBool(options::modelWitnessValue, key, optionarg == "true"); |
11547 |
|
return; |
11548 |
|
} |
11549 |
1131 |
if(key == "on-repeat-ite-simp") { |
11550 |
|
assignBool(options::doITESimpOnRepeat, key, optionarg == "true"); |
11551 |
|
return; |
11552 |
|
} |
11553 |
1131 |
if(key == "produce-abducts") { |
11554 |
9 |
assignBool(options::produceAbducts, key, optionarg == "true"); |
11555 |
9 |
return; |
11556 |
|
} |
11557 |
1122 |
if(key == "produce-assertions") { |
11558 |
18 |
assignBool(options::produceAssertions, key, optionarg == "true"); |
11559 |
18 |
return; |
11560 |
|
} |
11561 |
1104 |
if(key == "produce-assignments") { |
11562 |
4 |
assignBool(options::produceAssignments, key, optionarg == "true"); |
11563 |
4 |
return; |
11564 |
|
} |
11565 |
1100 |
if(key == "produce-interpols") { |
11566 |
3 |
assign(options::produceInterpols, key, optionarg); |
11567 |
3 |
return; |
11568 |
|
} |
11569 |
1097 |
if(key == "produce-models") { |
11570 |
745 |
assignBool(options::produceModels, key, optionarg == "true"); |
11571 |
745 |
return; |
11572 |
|
} |
11573 |
352 |
if(key == "produce-proofs") { |
11574 |
2 |
assignBool(options::produceProofs, key, optionarg == "true"); |
11575 |
2 |
return; |
11576 |
|
} |
11577 |
350 |
if(key == "produce-unsat-assumptions") { |
11578 |
15 |
assignBool(options::unsatAssumptions, key, optionarg == "true"); |
11579 |
15 |
return; |
11580 |
|
} |
11581 |
335 |
if(key == "produce-unsat-cores") { |
11582 |
15 |
assignBool(options::unsatCores, key, optionarg == "true"); |
11583 |
15 |
return; |
11584 |
|
} |
11585 |
320 |
if(key == "regular-output-channel") { |
11586 |
|
assign(options::regularChannelName, key, optionarg); |
11587 |
|
return; |
11588 |
|
} |
11589 |
320 |
if(key == "repeat-simp") { |
11590 |
|
assignBool(options::repeatSimp, key, optionarg == "true"); |
11591 |
|
return; |
11592 |
|
} |
11593 |
320 |
if(key == "simp-ite-compress") { |
11594 |
3 |
assignBool(options::compressItes, key, optionarg == "true"); |
11595 |
3 |
return; |
11596 |
|
} |
11597 |
317 |
if(key == "simp-ite-hunt-zombies") { |
11598 |
|
assign(options::zombieHuntThreshold, key, optionarg); |
11599 |
|
return; |
11600 |
|
} |
11601 |
317 |
if(key == "simp-with-care") { |
11602 |
|
assignBool(options::simplifyWithCareEnabled, key, optionarg == "true"); |
11603 |
|
return; |
11604 |
|
} |
11605 |
317 |
if(key == "simplification" || key == "simplification-mode") { |
11606 |
1 |
assign(options::simplificationMode, key, optionarg); |
11607 |
1 |
return; |
11608 |
|
} |
11609 |
316 |
if(key == "solve-bv-as-int") { |
11610 |
14 |
assign(options::solveBVAsInt, key, optionarg); |
11611 |
14 |
return; |
11612 |
|
} |
11613 |
302 |
if(key == "solve-int-as-bv") { |
11614 |
4 |
assign(options::solveIntAsBV, key, optionarg); |
11615 |
4 |
return; |
11616 |
|
} |
11617 |
298 |
if(key == "solve-real-as-int") { |
11618 |
|
assignBool(options::solveRealAsInt, key, optionarg == "true"); |
11619 |
|
return; |
11620 |
|
} |
11621 |
298 |
if(key == "sort-inference") { |
11622 |
6 |
assignBool(options::sortInference, key, optionarg == "true"); |
11623 |
6 |
return; |
11624 |
|
} |
11625 |
292 |
if(key == "static-learning") { |
11626 |
|
assignBool(options::doStaticLearning, key, optionarg == "true"); |
11627 |
|
return; |
11628 |
|
} |
11629 |
292 |
if(key == "sygus-out") { |
11630 |
|
assign(options::sygusOut, key, optionarg); |
11631 |
|
return; |
11632 |
|
} |
11633 |
292 |
if(key == "sygus-print-callbacks") { |
11634 |
|
assignBool(options::sygusPrintCallbacks, key, optionarg == "true"); |
11635 |
|
return; |
11636 |
|
} |
11637 |
292 |
if(key == "unconstrained-simp") { |
11638 |
|
assignBool(options::unconstrainedSimp, key, optionarg == "true"); |
11639 |
|
return; |
11640 |
|
} |
11641 |
292 |
if(key == "unsat-cores-mode") { |
11642 |
|
assign(options::unsatCoresMode, key, optionarg); |
11643 |
|
return; |
11644 |
|
} |
11645 |
292 |
if(key == "re-elim") { |
11646 |
14 |
assignBool(options::regExpElim, key, optionarg == "true"); |
11647 |
14 |
return; |
11648 |
|
} |
11649 |
278 |
if(key == "re-elim-agg") { |
11650 |
6 |
assignBool(options::regExpElimAgg, key, optionarg == "true"); |
11651 |
6 |
return; |
11652 |
|
} |
11653 |
272 |
if(key == "re-inter-mode") { |
11654 |
|
assign(options::stringRegExpInterMode, key, optionarg); |
11655 |
|
return; |
11656 |
|
} |
11657 |
272 |
if(key == "strings-check-entail-len") { |
11658 |
|
assignBool(options::stringCheckEntailLen, key, optionarg == "true"); |
11659 |
|
return; |
11660 |
|
} |
11661 |
272 |
if(key == "strings-eager") { |
11662 |
|
assignBool(options::stringEager, key, optionarg == "true"); |
11663 |
|
return; |
11664 |
|
} |
11665 |
272 |
if(key == "strings-eager-eval") { |
11666 |
|
assignBool(options::stringEagerEval, key, optionarg == "true"); |
11667 |
|
return; |
11668 |
|
} |
11669 |
272 |
if(key == "strings-eager-len") { |
11670 |
|
assignBool(options::stringEagerLen, key, optionarg == "true"); |
11671 |
|
return; |
11672 |
|
} |
11673 |
272 |
if(key == "strings-exp") { |
11674 |
219 |
assignBool(options::stringExp, key, optionarg == "true"); |
11675 |
219 |
return; |
11676 |
|
} |
11677 |
53 |
if(key == "strings-ff") { |
11678 |
|
assignBool(options::stringFlatForms, key, optionarg == "true"); |
11679 |
|
return; |
11680 |
|
} |
11681 |
53 |
if(key == "strings-fmf") { |
11682 |
24 |
assignBool(options::stringFMF, key, optionarg == "true"); |
11683 |
24 |
return; |
11684 |
|
} |
11685 |
29 |
if(key == "strings-guess-model") { |
11686 |
|
assignBool(options::stringGuessModel, key, optionarg == "true"); |
11687 |
|
return; |
11688 |
|
} |
11689 |
29 |
if(key == "strings-infer-as-lemmas") { |
11690 |
|
assignBool(options::stringInferAsLemmas, key, optionarg == "true"); |
11691 |
|
return; |
11692 |
|
} |
11693 |
29 |
if(key == "strings-infer-sym") { |
11694 |
|
assignBool(options::stringInferSym, key, optionarg == "true"); |
11695 |
|
return; |
11696 |
|
} |
11697 |
29 |
if(key == "strings-inm") { |
11698 |
2 |
assignBool(options::stringIgnNegMembership, key, optionarg == "true"); |
11699 |
2 |
return; |
11700 |
|
} |
11701 |
27 |
if(key == "strings-lazy-pp") { |
11702 |
7 |
assignBool(options::stringLazyPreproc, key, optionarg == "true"); |
11703 |
7 |
return; |
11704 |
|
} |
11705 |
20 |
if(key == "strings-len-norm") { |
11706 |
|
assignBool(options::stringLenNorm, key, optionarg == "true"); |
11707 |
|
return; |
11708 |
|
} |
11709 |
20 |
if(key == "strings-lprop-csp") { |
11710 |
|
assignBool(options::stringLenPropCsp, key, optionarg == "true"); |
11711 |
|
return; |
11712 |
|
} |
11713 |
20 |
if(key == "strings-min-prefix-explain") { |
11714 |
|
assignBool(options::stringMinPrefixExplain, key, optionarg == "true"); |
11715 |
|
return; |
11716 |
|
} |
11717 |
20 |
if(key == "strings-process-loop-mode") { |
11718 |
|
assign(options::stringProcessLoopMode, key, optionarg); |
11719 |
|
return; |
11720 |
|
} |
11721 |
20 |
if(key == "strings-rexplain-lemmas") { |
11722 |
|
assignBool(options::stringRExplainLemmas, key, optionarg == "true"); |
11723 |
|
return; |
11724 |
|
} |
11725 |
20 |
if(key == "strings-unified-vspt") { |
11726 |
|
assignBool(options::stringUnifiedVSpt, key, optionarg == "true"); |
11727 |
|
return; |
11728 |
|
} |
11729 |
20 |
if(key == "assign-function-values") { |
11730 |
2 |
assignBool(options::assignFunctionValues, key, optionarg == "true"); |
11731 |
2 |
return; |
11732 |
|
} |
11733 |
18 |
if(key == "condense-function-values") { |
11734 |
|
assignBool(options::condenseFunctionValues, key, optionarg == "true"); |
11735 |
|
return; |
11736 |
|
} |
11737 |
18 |
if(key == "ee-mode") { |
11738 |
|
assign(options::eeMode, key, optionarg); |
11739 |
|
return; |
11740 |
|
} |
11741 |
18 |
if(key == "relevance-filter") { |
11742 |
|
assignBool(options::relevanceFilter, key, optionarg == "true"); |
11743 |
|
return; |
11744 |
|
} |
11745 |
18 |
if(key == "tc-mode") { |
11746 |
|
assign(options::tcMode, key, optionarg); |
11747 |
|
return; |
11748 |
|
} |
11749 |
18 |
if(key == "theoryof-mode") { |
11750 |
|
assign(options::theoryOfMode, key, optionarg); |
11751 |
|
return; |
11752 |
|
} |
11753 |
18 |
if(key == "symmetry-breaker" || key == "uf-symmetry-breaker") { |
11754 |
|
assignBool(options::ufSymmetryBreaker, key, optionarg == "true"); |
11755 |
|
return; |
11756 |
|
} |
11757 |
18 |
if(key == "uf-ho") { |
11758 |
18 |
assignBool(options::ufHo, key, optionarg == "true"); |
11759 |
18 |
return; |
11760 |
|
} |
11761 |
|
if(key == "uf-ho-ext") { |
11762 |
|
assignBool(options::ufHoExt, key, optionarg == "true"); |
11763 |
|
return; |
11764 |
|
} |
11765 |
|
if(key == "uf-ss-abort-card") { |
11766 |
|
assign(options::ufssAbortCardinality, key, optionarg); |
11767 |
|
return; |
11768 |
|
} |
11769 |
|
if(key == "uf-ss-fair") { |
11770 |
|
assignBool(options::ufssFairness, key, optionarg == "true"); |
11771 |
|
return; |
11772 |
|
} |
11773 |
|
if(key == "uf-ss-fair-monotone") { |
11774 |
|
assignBool(options::ufssFairnessMonotone, key, optionarg == "true"); |
11775 |
|
return; |
11776 |
|
} |
11777 |
|
if(key == "uf-ss-totality-limited") { |
11778 |
|
assign(options::ufssTotalityLimited, key, optionarg); |
11779 |
|
return; |
11780 |
|
} |
11781 |
|
if(key == "uf-ss-totality-sym-break") { |
11782 |
|
assignBool(options::ufssTotalitySymBreak, key, optionarg == "true"); |
11783 |
|
return; |
11784 |
|
} |
11785 |
|
if(key == "uf-ss") { |
11786 |
|
assign(options::ufssMode, key, optionarg); |
11787 |
|
return; |
11788 |
|
} |
11789 |
|
throw UnrecognizedOptionException(key); |
11790 |
|
} |
11791 |
|
// clang-format on |
11792 |
|
|
11793 |
|
// clang-format off |
11794 |
29 |
std::string Options::getOption(const std::string& key) const |
11795 |
|
{ |
11796 |
29 |
Trace("options") << "Options::getOption(" << key << ")" << std::endl; |
11797 |
29 |
if (key == "approx-branch-depth") { |
11798 |
|
return std::to_string((*this)[options::maxApproxDepth]); |
11799 |
|
} |
11800 |
29 |
if (key == "arith-brab") { |
11801 |
|
return (*this)[options::brabTest] ? "true" : "false"; |
11802 |
|
} |
11803 |
29 |
if (key == "arith-no-partial-fun") { |
11804 |
|
return (*this)[options::arithNoPartialFun] ? "true" : "false"; |
11805 |
|
} |
11806 |
29 |
if (key == "arith-prop-clauses") { |
11807 |
|
return std::to_string((*this)[options::arithPropAsLemmaLength]); |
11808 |
|
} |
11809 |
29 |
if (key == "arith-prop") { |
11810 |
|
std::stringstream ss; |
11811 |
|
ss << (*this)[options::arithPropagationMode]; |
11812 |
|
return ss.str(); |
11813 |
|
} |
11814 |
29 |
if (key == "arith-rewrite-equalities") { |
11815 |
|
return (*this)[options::arithRewriteEq] ? "true" : "false"; |
11816 |
|
} |
11817 |
29 |
if (key == "collect-pivot-stats") { |
11818 |
|
return (*this)[options::collectPivots] ? "true" : "false"; |
11819 |
|
} |
11820 |
29 |
if (key == "cut-all-bounded") { |
11821 |
|
return (*this)[options::doCutAllBounded] ? "true" : "false"; |
11822 |
|
} |
11823 |
29 |
if (key == "dio-decomps") { |
11824 |
|
return (*this)[options::exportDioDecompositions] ? "true" : "false"; |
11825 |
|
} |
11826 |
29 |
if (key == "dio-repeat") { |
11827 |
|
return (*this)[options::dioRepeat] ? "true" : "false"; |
11828 |
|
} |
11829 |
29 |
if (key == "dio-solver") { |
11830 |
|
return (*this)[options::arithDioSolver] ? "true" : "false"; |
11831 |
|
} |
11832 |
29 |
if (key == "dio-turns") { |
11833 |
|
return std::to_string((*this)[options::dioSolverTurns]); |
11834 |
|
} |
11835 |
29 |
if (key == "error-selection-rule") { |
11836 |
|
std::stringstream ss; |
11837 |
|
ss << (*this)[options::arithErrorSelectionRule]; |
11838 |
|
return ss.str(); |
11839 |
|
} |
11840 |
29 |
if (key == "fc-penalties") { |
11841 |
|
return (*this)[options::havePenalties] ? "true" : "false"; |
11842 |
|
} |
11843 |
29 |
if (key == "heuristic-pivots") { |
11844 |
|
return std::to_string((*this)[options::arithHeuristicPivots]); |
11845 |
|
} |
11846 |
29 |
if (key == "lemmas-on-replay-failure") { |
11847 |
|
return (*this)[options::replayFailureLemma] ? "true" : "false"; |
11848 |
|
} |
11849 |
29 |
if (key == "maxCutsInContext") { |
11850 |
|
return std::to_string((*this)[options::maxCutsInContext]); |
11851 |
|
} |
11852 |
29 |
if (key == "miplib-trick") { |
11853 |
|
return (*this)[options::arithMLTrick] ? "true" : "false"; |
11854 |
|
} |
11855 |
29 |
if (key == "miplib-trick-subs") { |
11856 |
|
return std::to_string((*this)[options::arithMLTrickSubstitutions]); |
11857 |
|
} |
11858 |
29 |
if (key == "new-prop") { |
11859 |
|
return (*this)[options::newProp] ? "true" : "false"; |
11860 |
|
} |
11861 |
29 |
if (key == "nl-cad") { |
11862 |
|
return (*this)[options::nlCad] ? "true" : "false"; |
11863 |
|
} |
11864 |
29 |
if (key == "nl-cad-initial") { |
11865 |
|
return (*this)[options::nlCadUseInitial] ? "true" : "false"; |
11866 |
|
} |
11867 |
29 |
if (key == "nl-ext-ent-conf") { |
11868 |
|
return (*this)[options::nlExtEntailConflicts] ? "true" : "false"; |
11869 |
|
} |
11870 |
29 |
if (key == "nl-ext-factor") { |
11871 |
|
return (*this)[options::nlExtFactor] ? "true" : "false"; |
11872 |
|
} |
11873 |
29 |
if (key == "nl-ext-inc-prec") { |
11874 |
|
return (*this)[options::nlExtIncPrecision] ? "true" : "false"; |
11875 |
|
} |
11876 |
29 |
if (key == "nl-ext-purify") { |
11877 |
|
return (*this)[options::nlExtPurify] ? "true" : "false"; |
11878 |
|
} |
11879 |
29 |
if (key == "nl-ext-rbound") { |
11880 |
|
return (*this)[options::nlExtResBound] ? "true" : "false"; |
11881 |
|
} |
11882 |
29 |
if (key == "nl-ext-rewrite") { |
11883 |
|
return (*this)[options::nlExtRewrites] ? "true" : "false"; |
11884 |
|
} |
11885 |
29 |
if (key == "nl-ext-split-zero") { |
11886 |
|
return (*this)[options::nlExtSplitZero] ? "true" : "false"; |
11887 |
|
} |
11888 |
29 |
if (key == "nl-ext-tf-taylor-deg") { |
11889 |
|
return std::to_string((*this)[options::nlExtTfTaylorDegree]); |
11890 |
|
} |
11891 |
29 |
if (key == "nl-ext-tf-tplanes") { |
11892 |
|
return (*this)[options::nlExtTfTangentPlanes] ? "true" : "false"; |
11893 |
|
} |
11894 |
29 |
if (key == "nl-ext-tplanes") { |
11895 |
|
return (*this)[options::nlExtTangentPlanes] ? "true" : "false"; |
11896 |
|
} |
11897 |
29 |
if (key == "nl-ext-tplanes-interleave") { |
11898 |
|
return (*this)[options::nlExtTangentPlanesInterleave] ? "true" : "false"; |
11899 |
|
} |
11900 |
29 |
if (key == "nl-ext") { |
11901 |
|
std::stringstream ss; |
11902 |
|
ss << (*this)[options::nlExt]; |
11903 |
|
return ss.str(); |
11904 |
|
} |
11905 |
29 |
if (key == "nl-icp") { |
11906 |
|
return (*this)[options::nlICP] ? "true" : "false"; |
11907 |
|
} |
11908 |
29 |
if (key == "nl-rlv") { |
11909 |
|
std::stringstream ss; |
11910 |
|
ss << (*this)[options::nlRlvMode]; |
11911 |
|
return ss.str(); |
11912 |
|
} |
11913 |
29 |
if (key == "pb-rewrites") { |
11914 |
|
return (*this)[options::pbRewrites] ? "true" : "false"; |
11915 |
|
} |
11916 |
29 |
if (key == "pivot-threshold") { |
11917 |
|
return std::to_string((*this)[options::arithPivotThreshold]); |
11918 |
|
} |
11919 |
29 |
if (key == "pp-assert-max-sub-size") { |
11920 |
|
return std::to_string((*this)[options::ppAssertMaxSubSize]); |
11921 |
|
} |
11922 |
29 |
if (key == "prop-row-length") { |
11923 |
|
return std::to_string((*this)[options::arithPropagateMaxLength]); |
11924 |
|
} |
11925 |
29 |
if (key == "replay-early-close-depth") { |
11926 |
|
return std::to_string((*this)[options::replayEarlyCloseDepths]); |
11927 |
|
} |
11928 |
29 |
if (key == "replay-failure-penalty") { |
11929 |
|
return std::to_string((*this)[options::replayFailurePenalty]); |
11930 |
|
} |
11931 |
29 |
if (key == "replay-lemma-reject-cut") { |
11932 |
|
return std::to_string((*this)[options::lemmaRejectCutSize]); |
11933 |
|
} |
11934 |
29 |
if (key == "replay-num-err-penalty") { |
11935 |
|
return std::to_string((*this)[options::replayNumericFailurePenalty]); |
11936 |
|
} |
11937 |
29 |
if (key == "replay-reject-cut") { |
11938 |
|
return std::to_string((*this)[options::replayRejectCutSize]); |
11939 |
|
} |
11940 |
29 |
if (key == "replay-soi-major-threshold-pen") { |
11941 |
|
return std::to_string((*this)[options::soiApproxMajorFailurePen]); |
11942 |
|
} |
11943 |
29 |
if (key == "replay-soi-major-threshold") { |
11944 |
|
return std::to_string((*this)[options::soiApproxMajorFailure]); |
11945 |
|
} |
11946 |
29 |
if (key == "replay-soi-minor-threshold-pen") { |
11947 |
|
return std::to_string((*this)[options::soiApproxMinorFailurePen]); |
11948 |
|
} |
11949 |
29 |
if (key == "replay-soi-minor-threshold") { |
11950 |
|
return std::to_string((*this)[options::soiApproxMinorFailure]); |
11951 |
|
} |
11952 |
29 |
if (key == "restrict-pivots") { |
11953 |
|
return (*this)[options::restrictedPivots] ? "true" : "false"; |
11954 |
|
} |
11955 |
29 |
if (key == "revert-arith-models-on-unsat") { |
11956 |
|
return (*this)[options::revertArithModels] ? "true" : "false"; |
11957 |
|
} |
11958 |
29 |
if (key == "rr-turns") { |
11959 |
|
return std::to_string((*this)[options::rrTurns]); |
11960 |
|
} |
11961 |
29 |
if (key == "se-solve-int") { |
11962 |
|
return (*this)[options::trySolveIntStandardEffort] ? "true" : "false"; |
11963 |
|
} |
11964 |
29 |
if (key == "simplex-check-period") { |
11965 |
|
return std::to_string((*this)[options::arithSimplexCheckPeriod]); |
11966 |
|
} |
11967 |
29 |
if (key == "soi-qe") { |
11968 |
|
return (*this)[options::soiQuickExplain] ? "true" : "false"; |
11969 |
|
} |
11970 |
29 |
if (key == "standard-effort-variable-order-pivots") { |
11971 |
|
return std::to_string((*this)[options::arithStandardCheckVarOrderPivots]); |
11972 |
|
} |
11973 |
29 |
if (key == "unate-lemmas") { |
11974 |
|
std::stringstream ss; |
11975 |
|
ss << (*this)[options::arithUnateLemmaMode]; |
11976 |
|
return ss.str(); |
11977 |
|
} |
11978 |
29 |
if (key == "use-approx") { |
11979 |
|
return (*this)[options::useApprox] ? "true" : "false"; |
11980 |
|
} |
11981 |
29 |
if (key == "use-fcsimplex") { |
11982 |
|
return (*this)[options::useFC] ? "true" : "false"; |
11983 |
|
} |
11984 |
29 |
if (key == "use-soi") { |
11985 |
|
return (*this)[options::useSOI] ? "true" : "false"; |
11986 |
|
} |
11987 |
29 |
if (key == "arrays-config") { |
11988 |
|
return std::to_string((*this)[options::arraysConfig]); |
11989 |
|
} |
11990 |
29 |
if (key == "arrays-eager-index") { |
11991 |
|
return (*this)[options::arraysEagerIndexSplitting] ? "true" : "false"; |
11992 |
|
} |
11993 |
29 |
if (key == "arrays-eager-lemmas") { |
11994 |
|
return (*this)[options::arraysEagerLemmas] ? "true" : "false"; |
11995 |
|
} |
11996 |
29 |
if (key == "arrays-exp") { |
11997 |
17 |
return (*this)[options::arraysExp] ? "true" : "false"; |
11998 |
|
} |
11999 |
12 |
if (key == "arrays-model-based") { |
12000 |
|
return (*this)[options::arraysModelBased] ? "true" : "false"; |
12001 |
|
} |
12002 |
12 |
if (key == "arrays-optimize-linear") { |
12003 |
|
return (*this)[options::arraysOptimizeLinear] ? "true" : "false"; |
12004 |
|
} |
12005 |
12 |
if (key == "arrays-prop") { |
12006 |
|
return std::to_string((*this)[options::arraysPropagate]); |
12007 |
|
} |
12008 |
12 |
if (key == "arrays-reduce-sharing") { |
12009 |
|
return (*this)[options::arraysReduceSharing] ? "true" : "false"; |
12010 |
|
} |
12011 |
12 |
if (key == "arrays-weak-equiv") { |
12012 |
|
return (*this)[options::arraysWeakEquivalence] ? "true" : "false"; |
12013 |
|
} |
12014 |
12 |
if (key == "input-language" || key == "lang") { |
12015 |
2 |
std::stringstream ss; |
12016 |
1 |
ss << (*this)[options::inputLanguage]; |
12017 |
1 |
return ss.str(); |
12018 |
|
} |
12019 |
11 |
if (key == "output-lang" || key == "output-language") { |
12020 |
|
std::stringstream ss; |
12021 |
|
ss << (*this)[options::outputLanguage]; |
12022 |
|
return ss.str(); |
12023 |
|
} |
12024 |
11 |
if (key == "parse-only") { |
12025 |
|
return (*this)[options::parseOnly] ? "true" : "false"; |
12026 |
|
} |
12027 |
11 |
if (key == "preprocess-only") { |
12028 |
|
return (*this)[options::preprocessOnly] ? "true" : "false"; |
12029 |
|
} |
12030 |
11 |
if (key == "print-success") { |
12031 |
|
return (*this)[options::printSuccess] ? "true" : "false"; |
12032 |
|
} |
12033 |
11 |
if (key == "stats") { |
12034 |
|
return (*this)[options::statistics] ? "true" : "false"; |
12035 |
|
} |
12036 |
11 |
if (key == "stats-all") { |
12037 |
|
return (*this)[options::statisticsAll] ? "true" : "false"; |
12038 |
|
} |
12039 |
11 |
if (key == "stats-every-query") { |
12040 |
|
return (*this)[options::statisticsEveryQuery] ? "true" : "false"; |
12041 |
|
} |
12042 |
11 |
if (key == "stats-expert") { |
12043 |
|
return (*this)[options::statisticsExpert] ? "true" : "false"; |
12044 |
|
} |
12045 |
11 |
if (key == "verbosity") { |
12046 |
|
return std::to_string((*this)[options::verbosity]); |
12047 |
|
} |
12048 |
11 |
if (key == "bitblast-aig") { |
12049 |
|
return (*this)[options::bitvectorAig] ? "true" : "false"; |
12050 |
|
} |
12051 |
11 |
if (key == "bitblast") { |
12052 |
|
std::stringstream ss; |
12053 |
|
ss << (*this)[options::bitblastMode]; |
12054 |
|
return ss.str(); |
12055 |
|
} |
12056 |
11 |
if (key == "bitwise-eq") { |
12057 |
|
return (*this)[options::bitwiseEq] ? "true" : "false"; |
12058 |
|
} |
12059 |
11 |
if (key == "bool-to-bv") { |
12060 |
|
std::stringstream ss; |
12061 |
|
ss << (*this)[options::boolToBitvector]; |
12062 |
|
return ss.str(); |
12063 |
|
} |
12064 |
11 |
if (key == "bv-abstraction") { |
12065 |
|
return (*this)[options::bvAbstraction] ? "true" : "false"; |
12066 |
|
} |
12067 |
11 |
if (key == "bv-aig-simp") { |
12068 |
|
return (*this)[options::bitvectorAigSimplifications]; |
12069 |
|
} |
12070 |
11 |
if (key == "bv-alg-extf") { |
12071 |
|
return (*this)[options::bvAlgExtf] ? "true" : "false"; |
12072 |
|
} |
12073 |
11 |
if (key == "bv-algebraic-budget") { |
12074 |
|
return std::to_string((*this)[options::bitvectorAlgebraicBudget]); |
12075 |
|
} |
12076 |
11 |
if (key == "bv-algebraic-solver") { |
12077 |
|
return (*this)[options::bitvectorAlgebraicSolver] ? "true" : "false"; |
12078 |
|
} |
12079 |
11 |
if (key == "bv-assert-input") { |
12080 |
|
return (*this)[options::bvAssertInput] ? "true" : "false"; |
12081 |
|
} |
12082 |
11 |
if (key == "bv-eager-explanations") { |
12083 |
|
return (*this)[options::bvEagerExplanations] ? "true" : "false"; |
12084 |
|
} |
12085 |
11 |
if (key == "bv-eq-solver") { |
12086 |
|
return (*this)[options::bitvectorEqualitySolver] ? "true" : "false"; |
12087 |
|
} |
12088 |
11 |
if (key == "bv-extract-arith") { |
12089 |
|
return (*this)[options::bvExtractArithRewrite] ? "true" : "false"; |
12090 |
|
} |
12091 |
11 |
if (key == "bv-gauss-elim") { |
12092 |
|
return (*this)[options::bvGaussElim] ? "true" : "false"; |
12093 |
|
} |
12094 |
11 |
if (key == "bv-inequality-solver") { |
12095 |
|
return (*this)[options::bitvectorInequalitySolver] ? "true" : "false"; |
12096 |
|
} |
12097 |
11 |
if (key == "bv-intro-pow2") { |
12098 |
|
return (*this)[options::bvIntroducePow2] ? "true" : "false"; |
12099 |
|
} |
12100 |
11 |
if (key == "bv-lazy-reduce-extf") { |
12101 |
|
return (*this)[options::bvLazyReduceExtf] ? "true" : "false"; |
12102 |
|
} |
12103 |
11 |
if (key == "bv-lazy-rewrite-extf") { |
12104 |
|
return (*this)[options::bvLazyRewriteExtf] ? "true" : "false"; |
12105 |
|
} |
12106 |
11 |
if (key == "bv-num-func") { |
12107 |
|
return std::to_string((*this)[options::bvNumFunc]); |
12108 |
|
} |
12109 |
11 |
if (key == "bv-print-consts-as-indexed-symbols") { |
12110 |
|
return (*this)[options::bvPrintConstsAsIndexedSymbols] ? "true" : "false"; |
12111 |
|
} |
12112 |
11 |
if (key == "bv-propagate") { |
12113 |
|
return (*this)[options::bitvectorPropagate] ? "true" : "false"; |
12114 |
|
} |
12115 |
11 |
if (key == "bv-quick-xplain") { |
12116 |
|
return (*this)[options::bitvectorQuickXplain] ? "true" : "false"; |
12117 |
|
} |
12118 |
11 |
if (key == "bv-sat-solver") { |
12119 |
|
std::stringstream ss; |
12120 |
|
ss << (*this)[options::bvSatSolver]; |
12121 |
|
return ss.str(); |
12122 |
|
} |
12123 |
11 |
if (key == "bv-skolemize") { |
12124 |
|
return (*this)[options::skolemizeArguments] ? "true" : "false"; |
12125 |
|
} |
12126 |
11 |
if (key == "bv-solver") { |
12127 |
|
std::stringstream ss; |
12128 |
|
ss << (*this)[options::bvSolver]; |
12129 |
|
return ss.str(); |
12130 |
|
} |
12131 |
11 |
if (key == "bv-to-bool") { |
12132 |
|
return (*this)[options::bitvectorToBool] ? "true" : "false"; |
12133 |
|
} |
12134 |
11 |
if (key == "cdt-bisimilar") { |
12135 |
|
return (*this)[options::cdtBisimilar] ? "true" : "false"; |
12136 |
|
} |
12137 |
11 |
if (key == "dt-binary-split") { |
12138 |
|
return (*this)[options::dtBinarySplit] ? "true" : "false"; |
12139 |
|
} |
12140 |
11 |
if (key == "dt-blast-splits") { |
12141 |
|
return (*this)[options::dtBlastSplits] ? "true" : "false"; |
12142 |
|
} |
12143 |
11 |
if (key == "dt-cyclic") { |
12144 |
|
return (*this)[options::dtCyclic] ? "true" : "false"; |
12145 |
|
} |
12146 |
11 |
if (key == "dt-force-assignment") { |
12147 |
|
return (*this)[options::dtForceAssignment] ? "true" : "false"; |
12148 |
|
} |
12149 |
11 |
if (key == "dt-infer-as-lemmas") { |
12150 |
|
return (*this)[options::dtInferAsLemmas] ? "true" : "false"; |
12151 |
|
} |
12152 |
11 |
if (key == "dt-nested-rec") { |
12153 |
|
return (*this)[options::dtNestedRec] ? "true" : "false"; |
12154 |
|
} |
12155 |
11 |
if (key == "dt-polite-optimize") { |
12156 |
|
return (*this)[options::dtPoliteOptimize] ? "true" : "false"; |
12157 |
|
} |
12158 |
11 |
if (key == "dt-rewrite-error-sel") { |
12159 |
|
return (*this)[options::dtRewriteErrorSel] ? "true" : "false"; |
12160 |
|
} |
12161 |
11 |
if (key == "dt-share-sel") { |
12162 |
|
return (*this)[options::dtSharedSelectors] ? "true" : "false"; |
12163 |
|
} |
12164 |
11 |
if (key == "sygus-abort-size") { |
12165 |
|
return std::to_string((*this)[options::sygusAbortSize]); |
12166 |
|
} |
12167 |
11 |
if (key == "sygus-fair-max") { |
12168 |
|
return (*this)[options::sygusFairMax] ? "true" : "false"; |
12169 |
|
} |
12170 |
11 |
if (key == "sygus-fair") { |
12171 |
|
std::stringstream ss; |
12172 |
|
ss << (*this)[options::sygusFair]; |
12173 |
|
return ss.str(); |
12174 |
|
} |
12175 |
11 |
if (key == "sygus-sym-break") { |
12176 |
|
return (*this)[options::sygusSymBreak] ? "true" : "false"; |
12177 |
|
} |
12178 |
11 |
if (key == "sygus-sym-break-agg") { |
12179 |
|
return (*this)[options::sygusSymBreakAgg] ? "true" : "false"; |
12180 |
|
} |
12181 |
11 |
if (key == "sygus-sym-break-dynamic") { |
12182 |
|
return (*this)[options::sygusSymBreakDynamic] ? "true" : "false"; |
12183 |
|
} |
12184 |
11 |
if (key == "sygus-sym-break-lazy") { |
12185 |
|
return (*this)[options::sygusSymBreakLazy] ? "true" : "false"; |
12186 |
|
} |
12187 |
11 |
if (key == "sygus-sym-break-pbe") { |
12188 |
|
return (*this)[options::sygusSymBreakPbe] ? "true" : "false"; |
12189 |
|
} |
12190 |
11 |
if (key == "sygus-sym-break-rlv") { |
12191 |
|
return (*this)[options::sygusSymBreakRlv] ? "true" : "false"; |
12192 |
|
} |
12193 |
11 |
if (key == "decision-random-weight") { |
12194 |
|
return std::to_string((*this)[options::decisionRandomWeight]); |
12195 |
|
} |
12196 |
11 |
if (key == "decision-threshold") { |
12197 |
|
std::stringstream ss; |
12198 |
|
ss << (*this)[options::decisionThreshold]; |
12199 |
|
return ss.str(); |
12200 |
|
} |
12201 |
11 |
if (key == "decision-use-weight") { |
12202 |
|
return (*this)[options::decisionUseWeight] ? "true" : "false"; |
12203 |
|
} |
12204 |
11 |
if (key == "decision-weight-internal") { |
12205 |
|
std::stringstream ss; |
12206 |
|
ss << (*this)[options::decisionWeightInternal]; |
12207 |
|
return ss.str(); |
12208 |
|
} |
12209 |
11 |
if (key == "decision" || key == "decision-mode") { |
12210 |
|
std::stringstream ss; |
12211 |
|
ss << (*this)[options::decisionMode]; |
12212 |
|
return ss.str(); |
12213 |
|
} |
12214 |
11 |
if (key == "dag-thresh") { |
12215 |
1 |
return std::to_string((*this)[options::defaultDagThresh]); |
12216 |
|
} |
12217 |
10 |
if (key == "expr-depth") { |
12218 |
|
return std::to_string((*this)[options::defaultExprDepth]); |
12219 |
|
} |
12220 |
10 |
if (key == "type-checking") { |
12221 |
|
return (*this)[options::typeChecking] ? "true" : "false"; |
12222 |
|
} |
12223 |
10 |
if (key == "fp-exp") { |
12224 |
|
return (*this)[options::fpExp] ? "true" : "false"; |
12225 |
|
} |
12226 |
10 |
if (key == "early-exit") { |
12227 |
|
return (*this)[options::earlyExit] ? "true" : "false"; |
12228 |
|
} |
12229 |
10 |
if (key == "help") { |
12230 |
|
return (*this)[options::help] ? "true" : "false"; |
12231 |
|
} |
12232 |
10 |
if (key == "interactive") { |
12233 |
|
return (*this)[options::interactive] ? "true" : "false"; |
12234 |
|
} |
12235 |
10 |
if (key == "interactive-prompt") { |
12236 |
|
return (*this)[options::interactivePrompt] ? "true" : "false"; |
12237 |
|
} |
12238 |
10 |
if (key == "seed") { |
12239 |
|
return std::to_string((*this)[options::seed]); |
12240 |
|
} |
12241 |
10 |
if (key == "segv-spin") { |
12242 |
|
return (*this)[options::segvSpin] ? "true" : "false"; |
12243 |
|
} |
12244 |
10 |
if (key == "tear-down-incremental") { |
12245 |
|
return std::to_string((*this)[options::tearDownIncremental]); |
12246 |
|
} |
12247 |
10 |
if (key == "version") { |
12248 |
|
return (*this)[options::version] ? "true" : "false"; |
12249 |
|
} |
12250 |
10 |
if (key == "filesystem-access") { |
12251 |
|
return (*this)[options::filesystemAccess] ? "true" : "false"; |
12252 |
|
} |
12253 |
10 |
if (key == "force-logic") { |
12254 |
|
return (*this)[options::forceLogicString]; |
12255 |
|
} |
12256 |
10 |
if (key == "global-declarations") { |
12257 |
|
return (*this)[options::globalDeclarations] ? "true" : "false"; |
12258 |
|
} |
12259 |
10 |
if (key == "mmap") { |
12260 |
|
return (*this)[options::memoryMap] ? "true" : "false"; |
12261 |
|
} |
12262 |
10 |
if (key == "semantic-checks") { |
12263 |
|
return (*this)[options::semanticChecks] ? "true" : "false"; |
12264 |
|
} |
12265 |
10 |
if (key == "strict-parsing") { |
12266 |
|
return (*this)[options::strictParsing] ? "true" : "false"; |
12267 |
|
} |
12268 |
10 |
if (key == "flatten-ho-chains") { |
12269 |
|
return (*this)[options::flattenHOChains] ? "true" : "false"; |
12270 |
|
} |
12271 |
10 |
if (key == "inst-format") { |
12272 |
|
std::stringstream ss; |
12273 |
|
ss << (*this)[options::instFormatMode]; |
12274 |
|
return ss.str(); |
12275 |
|
} |
12276 |
10 |
if (key == "model-format") { |
12277 |
|
std::stringstream ss; |
12278 |
|
ss << (*this)[options::modelFormatMode]; |
12279 |
|
return ss.str(); |
12280 |
|
} |
12281 |
10 |
if (key == "print-inst-full") { |
12282 |
|
return (*this)[options::printInstFull] ? "true" : "false"; |
12283 |
|
} |
12284 |
10 |
if (key == "print-inst") { |
12285 |
|
std::stringstream ss; |
12286 |
|
ss << (*this)[options::printInstMode]; |
12287 |
|
return ss.str(); |
12288 |
|
} |
12289 |
10 |
if (key == "proof-eager-checking") { |
12290 |
|
return (*this)[options::proofEagerChecking] ? "true" : "false"; |
12291 |
|
} |
12292 |
10 |
if (key == "proof-format-mode") { |
12293 |
|
std::stringstream ss; |
12294 |
|
ss << (*this)[options::proofFormatMode]; |
12295 |
|
return ss.str(); |
12296 |
|
} |
12297 |
10 |
if (key == "proof-granularity") { |
12298 |
|
std::stringstream ss; |
12299 |
|
ss << (*this)[options::proofGranularityMode]; |
12300 |
|
return ss.str(); |
12301 |
|
} |
12302 |
10 |
if (key == "proof-pedantic") { |
12303 |
|
return std::to_string((*this)[options::proofPedantic]); |
12304 |
|
} |
12305 |
10 |
if (key == "proof-print-conclusion") { |
12306 |
|
return (*this)[options::proofPrintConclusion] ? "true" : "false"; |
12307 |
|
} |
12308 |
10 |
if (key == "minisat-dump-dimacs") { |
12309 |
|
return (*this)[options::minisatDumpDimacs] ? "true" : "false"; |
12310 |
|
} |
12311 |
10 |
if (key == "minisat-elimination") { |
12312 |
|
return (*this)[options::minisatUseElim] ? "true" : "false"; |
12313 |
|
} |
12314 |
10 |
if (key == "random-freq" || key == "random-frequency") { |
12315 |
|
return std::to_string((*this)[options::satRandomFreq]); |
12316 |
|
} |
12317 |
10 |
if (key == "random-seed") { |
12318 |
|
return std::to_string((*this)[options::satRandomSeed]); |
12319 |
|
} |
12320 |
10 |
if (key == "refine-conflicts") { |
12321 |
|
return (*this)[options::sat_refine_conflicts] ? "true" : "false"; |
12322 |
|
} |
12323 |
10 |
if (key == "restart-int-base") { |
12324 |
|
return std::to_string((*this)[options::satRestartFirst]); |
12325 |
|
} |
12326 |
10 |
if (key == "restart-int-inc") { |
12327 |
|
return std::to_string((*this)[options::satRestartInc]); |
12328 |
|
} |
12329 |
10 |
if (key == "ag-miniscope-quant") { |
12330 |
|
return (*this)[options::aggressiveMiniscopeQuant] ? "true" : "false"; |
12331 |
|
} |
12332 |
10 |
if (key == "cegis-sample") { |
12333 |
|
std::stringstream ss; |
12334 |
|
ss << (*this)[options::cegisSample]; |
12335 |
|
return ss.str(); |
12336 |
|
} |
12337 |
10 |
if (key == "cegqi") { |
12338 |
|
return (*this)[options::cegqi] ? "true" : "false"; |
12339 |
|
} |
12340 |
10 |
if (key == "cegqi-all") { |
12341 |
|
return (*this)[options::cegqiAll] ? "true" : "false"; |
12342 |
|
} |
12343 |
10 |
if (key == "cegqi-bv") { |
12344 |
|
return (*this)[options::cegqiBv] ? "true" : "false"; |
12345 |
|
} |
12346 |
10 |
if (key == "cegqi-bv-concat-inv") { |
12347 |
|
return (*this)[options::cegqiBvConcInv] ? "true" : "false"; |
12348 |
|
} |
12349 |
10 |
if (key == "cegqi-bv-ineq") { |
12350 |
|
std::stringstream ss; |
12351 |
|
ss << (*this)[options::cegqiBvIneqMode]; |
12352 |
|
return ss.str(); |
12353 |
|
} |
12354 |
10 |
if (key == "cegqi-bv-interleave-value") { |
12355 |
|
return (*this)[options::cegqiBvInterleaveValue] ? "true" : "false"; |
12356 |
|
} |
12357 |
10 |
if (key == "cegqi-bv-linear") { |
12358 |
|
return (*this)[options::cegqiBvLinearize] ? "true" : "false"; |
12359 |
|
} |
12360 |
10 |
if (key == "cegqi-bv-rm-extract") { |
12361 |
|
return (*this)[options::cegqiBvRmExtract] ? "true" : "false"; |
12362 |
|
} |
12363 |
10 |
if (key == "cegqi-bv-solve-nl") { |
12364 |
|
return (*this)[options::cegqiBvSolveNl] ? "true" : "false"; |
12365 |
|
} |
12366 |
10 |
if (key == "cegqi-full") { |
12367 |
|
return (*this)[options::cegqiFullEffort] ? "true" : "false"; |
12368 |
|
} |
12369 |
10 |
if (key == "cegqi-innermost") { |
12370 |
|
return (*this)[options::cegqiInnermost] ? "true" : "false"; |
12371 |
|
} |
12372 |
10 |
if (key == "cegqi-midpoint") { |
12373 |
|
return (*this)[options::cegqiMidpoint] ? "true" : "false"; |
12374 |
|
} |
12375 |
10 |
if (key == "cegqi-min-bounds") { |
12376 |
|
return (*this)[options::cegqiMinBounds] ? "true" : "false"; |
12377 |
|
} |
12378 |
10 |
if (key == "cegqi-model") { |
12379 |
|
return (*this)[options::cegqiModel] ? "true" : "false"; |
12380 |
|
} |
12381 |
10 |
if (key == "cegqi-multi-inst") { |
12382 |
|
return (*this)[options::cegqiMultiInst] ? "true" : "false"; |
12383 |
|
} |
12384 |
10 |
if (key == "cegqi-nested-qe") { |
12385 |
|
return (*this)[options::cegqiNestedQE] ? "true" : "false"; |
12386 |
|
} |
12387 |
10 |
if (key == "cegqi-nopt") { |
12388 |
|
return (*this)[options::cegqiNopt] ? "true" : "false"; |
12389 |
|
} |
12390 |
10 |
if (key == "cegqi-repeat-lit") { |
12391 |
|
return (*this)[options::cegqiRepeatLit] ? "true" : "false"; |
12392 |
|
} |
12393 |
10 |
if (key == "cegqi-round-up-lia") { |
12394 |
|
return (*this)[options::cegqiRoundUpLowerLia] ? "true" : "false"; |
12395 |
|
} |
12396 |
10 |
if (key == "cegqi-sat") { |
12397 |
|
return (*this)[options::cegqiSat] ? "true" : "false"; |
12398 |
|
} |
12399 |
10 |
if (key == "cegqi-use-inf-int") { |
12400 |
|
return (*this)[options::cegqiUseInfInt] ? "true" : "false"; |
12401 |
|
} |
12402 |
10 |
if (key == "cegqi-use-inf-real") { |
12403 |
|
return (*this)[options::cegqiUseInfReal] ? "true" : "false"; |
12404 |
|
} |
12405 |
10 |
if (key == "cond-var-split-agg-quant") { |
12406 |
|
return (*this)[options::condVarSplitQuantAgg] ? "true" : "false"; |
12407 |
|
} |
12408 |
10 |
if (key == "cond-var-split-quant") { |
12409 |
|
return (*this)[options::condVarSplitQuant] ? "true" : "false"; |
12410 |
|
} |
12411 |
10 |
if (key == "conjecture-filter-active-terms") { |
12412 |
|
return (*this)[options::conjectureFilterActiveTerms] ? "true" : "false"; |
12413 |
|
} |
12414 |
10 |
if (key == "conjecture-filter-canonical") { |
12415 |
|
return (*this)[options::conjectureFilterCanonical] ? "true" : "false"; |
12416 |
|
} |
12417 |
10 |
if (key == "conjecture-filter-model") { |
12418 |
|
return (*this)[options::conjectureFilterModel] ? "true" : "false"; |
12419 |
|
} |
12420 |
10 |
if (key == "conjecture-gen") { |
12421 |
|
return (*this)[options::conjectureGen] ? "true" : "false"; |
12422 |
|
} |
12423 |
10 |
if (key == "conjecture-gen-gt-enum") { |
12424 |
|
return std::to_string((*this)[options::conjectureGenGtEnum]); |
12425 |
|
} |
12426 |
10 |
if (key == "conjecture-gen-max-depth") { |
12427 |
|
return std::to_string((*this)[options::conjectureGenMaxDepth]); |
12428 |
|
} |
12429 |
10 |
if (key == "conjecture-gen-per-round") { |
12430 |
|
return std::to_string((*this)[options::conjectureGenPerRound]); |
12431 |
|
} |
12432 |
10 |
if (key == "conjecture-gen-uee-intro") { |
12433 |
|
return (*this)[options::conjectureUeeIntro] ? "true" : "false"; |
12434 |
|
} |
12435 |
10 |
if (key == "conjecture-no-filter") { |
12436 |
|
return (*this)[options::conjectureNoFilter] ? "true" : "false"; |
12437 |
|
} |
12438 |
10 |
if (key == "debug-inst") { |
12439 |
|
return (*this)[options::debugInst] ? "true" : "false"; |
12440 |
|
} |
12441 |
10 |
if (key == "debug-sygus") { |
12442 |
|
return (*this)[options::debugSygus] ? "true" : "false"; |
12443 |
|
} |
12444 |
10 |
if (key == "dt-stc-ind") { |
12445 |
|
return (*this)[options::dtStcInduction] ? "true" : "false"; |
12446 |
|
} |
12447 |
10 |
if (key == "dt-var-exp-quant") { |
12448 |
|
return (*this)[options::dtVarExpandQuant] ? "true" : "false"; |
12449 |
|
} |
12450 |
10 |
if (key == "e-matching") { |
12451 |
|
return (*this)[options::eMatching] ? "true" : "false"; |
12452 |
|
} |
12453 |
10 |
if (key == "elim-taut-quant") { |
12454 |
|
return (*this)[options::elimTautQuant] ? "true" : "false"; |
12455 |
|
} |
12456 |
10 |
if (key == "ext-rewrite-quant") { |
12457 |
|
return (*this)[options::extRewriteQuant] ? "true" : "false"; |
12458 |
|
} |
12459 |
10 |
if (key == "finite-model-find") { |
12460 |
|
return (*this)[options::finiteModelFind] ? "true" : "false"; |
12461 |
|
} |
12462 |
10 |
if (key == "fmf-bound") { |
12463 |
|
return (*this)[options::fmfBound] ? "true" : "false"; |
12464 |
|
} |
12465 |
10 |
if (key == "fmf-bound-int") { |
12466 |
|
return (*this)[options::fmfBoundInt] ? "true" : "false"; |
12467 |
|
} |
12468 |
10 |
if (key == "fmf-bound-lazy") { |
12469 |
|
return (*this)[options::fmfBoundLazy] ? "true" : "false"; |
12470 |
|
} |
12471 |
10 |
if (key == "fmf-fmc-simple") { |
12472 |
|
return (*this)[options::fmfFmcSimple] ? "true" : "false"; |
12473 |
|
} |
12474 |
10 |
if (key == "fmf-fresh-dc") { |
12475 |
|
return (*this)[options::fmfFreshDistConst] ? "true" : "false"; |
12476 |
|
} |
12477 |
10 |
if (key == "fmf-fun") { |
12478 |
|
return (*this)[options::fmfFunWellDefined] ? "true" : "false"; |
12479 |
|
} |
12480 |
10 |
if (key == "fmf-fun-rlv") { |
12481 |
|
return (*this)[options::fmfFunWellDefinedRelevant] ? "true" : "false"; |
12482 |
|
} |
12483 |
10 |
if (key == "fmf-inst-engine") { |
12484 |
|
return (*this)[options::fmfInstEngine] ? "true" : "false"; |
12485 |
|
} |
12486 |
10 |
if (key == "fmf-type-completion-thresh") { |
12487 |
|
return std::to_string((*this)[options::fmfTypeCompletionThresh]); |
12488 |
|
} |
12489 |
10 |
if (key == "fs-interleave") { |
12490 |
|
return (*this)[options::fullSaturateInterleave] ? "true" : "false"; |
12491 |
|
} |
12492 |
10 |
if (key == "fs-stratify") { |
12493 |
|
return (*this)[options::fullSaturateStratify] ? "true" : "false"; |
12494 |
|
} |
12495 |
10 |
if (key == "fs-sum") { |
12496 |
|
return (*this)[options::fullSaturateSum] ? "true" : "false"; |
12497 |
|
} |
12498 |
10 |
if (key == "full-saturate-quant") { |
12499 |
|
return (*this)[options::fullSaturateQuant] ? "true" : "false"; |
12500 |
|
} |
12501 |
10 |
if (key == "full-saturate-quant-limit") { |
12502 |
|
return std::to_string((*this)[options::fullSaturateLimit]); |
12503 |
|
} |
12504 |
10 |
if (key == "full-saturate-quant-rd") { |
12505 |
|
return (*this)[options::fullSaturateQuantRd] ? "true" : "false"; |
12506 |
|
} |
12507 |
10 |
if (key == "global-negate") { |
12508 |
|
return (*this)[options::globalNegate] ? "true" : "false"; |
12509 |
|
} |
12510 |
10 |
if (key == "ho-elim") { |
12511 |
|
return (*this)[options::hoElim] ? "true" : "false"; |
12512 |
|
} |
12513 |
10 |
if (key == "ho-elim-store-ax") { |
12514 |
|
return (*this)[options::hoElimStoreAx] ? "true" : "false"; |
12515 |
|
} |
12516 |
10 |
if (key == "ho-matching") { |
12517 |
|
return (*this)[options::hoMatching] ? "true" : "false"; |
12518 |
|
} |
12519 |
10 |
if (key == "ho-matching-var-priority") { |
12520 |
|
return (*this)[options::hoMatchingVarArgPriority] ? "true" : "false"; |
12521 |
|
} |
12522 |
10 |
if (key == "ho-merge-term-db") { |
12523 |
|
return (*this)[options::hoMergeTermDb] ? "true" : "false"; |
12524 |
|
} |
12525 |
10 |
if (key == "increment-triggers") { |
12526 |
|
return (*this)[options::incrementTriggers] ? "true" : "false"; |
12527 |
|
} |
12528 |
10 |
if (key == "inst-level-input-only") { |
12529 |
|
return (*this)[options::instLevelInputOnly] ? "true" : "false"; |
12530 |
|
} |
12531 |
10 |
if (key == "inst-max-level") { |
12532 |
|
return std::to_string((*this)[options::instMaxLevel]); |
12533 |
|
} |
12534 |
10 |
if (key == "inst-no-entail") { |
12535 |
|
return (*this)[options::instNoEntail] ? "true" : "false"; |
12536 |
|
} |
12537 |
10 |
if (key == "inst-when-phase") { |
12538 |
|
return std::to_string((*this)[options::instWhenPhase]); |
12539 |
|
} |
12540 |
10 |
if (key == "inst-when-strict-interleave") { |
12541 |
|
return (*this)[options::instWhenStrictInterleave] ? "true" : "false"; |
12542 |
|
} |
12543 |
10 |
if (key == "inst-when-tc-first") { |
12544 |
|
return (*this)[options::instWhenTcFirst] ? "true" : "false"; |
12545 |
|
} |
12546 |
10 |
if (key == "inst-when") { |
12547 |
|
std::stringstream ss; |
12548 |
|
ss << (*this)[options::instWhenMode]; |
12549 |
|
return ss.str(); |
12550 |
|
} |
12551 |
10 |
if (key == "int-wf-ind") { |
12552 |
|
return (*this)[options::intWfInduction] ? "true" : "false"; |
12553 |
|
} |
12554 |
10 |
if (key == "ite-dtt-split-quant") { |
12555 |
|
return (*this)[options::iteDtTesterSplitQuant] ? "true" : "false"; |
12556 |
|
} |
12557 |
10 |
if (key == "ite-lift-quant") { |
12558 |
|
std::stringstream ss; |
12559 |
|
ss << (*this)[options::iteLiftQuant]; |
12560 |
|
return ss.str(); |
12561 |
|
} |
12562 |
10 |
if (key == "literal-matching") { |
12563 |
|
std::stringstream ss; |
12564 |
|
ss << (*this)[options::literalMatchMode]; |
12565 |
|
return ss.str(); |
12566 |
|
} |
12567 |
10 |
if (key == "macros-quant") { |
12568 |
|
return (*this)[options::macrosQuant] ? "true" : "false"; |
12569 |
|
} |
12570 |
10 |
if (key == "macros-quant-mode") { |
12571 |
|
std::stringstream ss; |
12572 |
|
ss << (*this)[options::macrosQuantMode]; |
12573 |
|
return ss.str(); |
12574 |
|
} |
12575 |
10 |
if (key == "mbqi-interleave") { |
12576 |
|
return (*this)[options::mbqiInterleave] ? "true" : "false"; |
12577 |
|
} |
12578 |
10 |
if (key == "mbqi-one-inst-per-round") { |
12579 |
|
return (*this)[options::fmfOneInstPerRound] ? "true" : "false"; |
12580 |
|
} |
12581 |
10 |
if (key == "mbqi") { |
12582 |
|
std::stringstream ss; |
12583 |
|
ss << (*this)[options::mbqiMode]; |
12584 |
|
return ss.str(); |
12585 |
|
} |
12586 |
10 |
if (key == "miniscope-quant") { |
12587 |
|
return (*this)[options::miniscopeQuant] ? "true" : "false"; |
12588 |
|
} |
12589 |
10 |
if (key == "miniscope-quant-fv") { |
12590 |
|
return (*this)[options::miniscopeQuantFreeVar] ? "true" : "false"; |
12591 |
|
} |
12592 |
10 |
if (key == "multi-trigger-cache") { |
12593 |
|
return (*this)[options::multiTriggerCache] ? "true" : "false"; |
12594 |
|
} |
12595 |
10 |
if (key == "multi-trigger-linear") { |
12596 |
|
return (*this)[options::multiTriggerLinear] ? "true" : "false"; |
12597 |
|
} |
12598 |
10 |
if (key == "multi-trigger-priority") { |
12599 |
|
return (*this)[options::multiTriggerPriority] ? "true" : "false"; |
12600 |
|
} |
12601 |
10 |
if (key == "multi-trigger-when-single") { |
12602 |
|
return (*this)[options::multiTriggerWhenSingle] ? "true" : "false"; |
12603 |
|
} |
12604 |
10 |
if (key == "partial-triggers") { |
12605 |
|
return (*this)[options::partialTriggers] ? "true" : "false"; |
12606 |
|
} |
12607 |
10 |
if (key == "pool-inst") { |
12608 |
|
return (*this)[options::poolInst] ? "true" : "false"; |
12609 |
|
} |
12610 |
10 |
if (key == "pre-skolem-quant") { |
12611 |
|
return (*this)[options::preSkolemQuant] ? "true" : "false"; |
12612 |
|
} |
12613 |
10 |
if (key == "pre-skolem-quant-agg") { |
12614 |
|
return (*this)[options::preSkolemQuantAgg] ? "true" : "false"; |
12615 |
|
} |
12616 |
10 |
if (key == "pre-skolem-quant-nested") { |
12617 |
|
return (*this)[options::preSkolemQuantNested] ? "true" : "false"; |
12618 |
|
} |
12619 |
10 |
if (key == "prenex-quant-user") { |
12620 |
|
return (*this)[options::prenexQuantUser] ? "true" : "false"; |
12621 |
|
} |
12622 |
10 |
if (key == "prenex-quant") { |
12623 |
|
std::stringstream ss; |
12624 |
|
ss << (*this)[options::prenexQuant]; |
12625 |
|
return ss.str(); |
12626 |
|
} |
12627 |
10 |
if (key == "purify-triggers") { |
12628 |
|
return (*this)[options::purifyTriggers] ? "true" : "false"; |
12629 |
|
} |
12630 |
10 |
if (key == "qcf-all-conflict") { |
12631 |
|
return (*this)[options::qcfAllConflict] ? "true" : "false"; |
12632 |
|
} |
12633 |
10 |
if (key == "qcf-eager-check-rd") { |
12634 |
|
return (*this)[options::qcfEagerCheckRd] ? "true" : "false"; |
12635 |
|
} |
12636 |
10 |
if (key == "qcf-eager-test") { |
12637 |
|
return (*this)[options::qcfEagerTest] ? "true" : "false"; |
12638 |
|
} |
12639 |
10 |
if (key == "qcf-nested-conflict") { |
12640 |
|
return (*this)[options::qcfNestedConflict] ? "true" : "false"; |
12641 |
|
} |
12642 |
10 |
if (key == "qcf-skip-rd") { |
12643 |
|
return (*this)[options::qcfSkipRd] ? "true" : "false"; |
12644 |
|
} |
12645 |
10 |
if (key == "qcf-tconstraint") { |
12646 |
|
return (*this)[options::qcfTConstraint] ? "true" : "false"; |
12647 |
|
} |
12648 |
10 |
if (key == "qcf-vo-exp") { |
12649 |
|
return (*this)[options::qcfVoExp] ? "true" : "false"; |
12650 |
|
} |
12651 |
10 |
if (key == "quant-alpha-equiv") { |
12652 |
|
return (*this)[options::quantAlphaEquiv] ? "true" : "false"; |
12653 |
|
} |
12654 |
10 |
if (key == "quant-cf") { |
12655 |
|
return (*this)[options::quantConflictFind] ? "true" : "false"; |
12656 |
|
} |
12657 |
10 |
if (key == "quant-cf-mode") { |
12658 |
|
std::stringstream ss; |
12659 |
|
ss << (*this)[options::qcfMode]; |
12660 |
|
return ss.str(); |
12661 |
|
} |
12662 |
10 |
if (key == "quant-cf-when") { |
12663 |
|
std::stringstream ss; |
12664 |
|
ss << (*this)[options::qcfWhenMode]; |
12665 |
|
return ss.str(); |
12666 |
|
} |
12667 |
10 |
if (key == "quant-dsplit-mode") { |
12668 |
|
std::stringstream ss; |
12669 |
|
ss << (*this)[options::quantDynamicSplit]; |
12670 |
|
return ss.str(); |
12671 |
|
} |
12672 |
10 |
if (key == "quant-fun-wd") { |
12673 |
|
return (*this)[options::quantFunWellDefined] ? "true" : "false"; |
12674 |
|
} |
12675 |
10 |
if (key == "quant-ind") { |
12676 |
|
return (*this)[options::quantInduction] ? "true" : "false"; |
12677 |
|
} |
12678 |
10 |
if (key == "quant-rep-mode") { |
12679 |
|
std::stringstream ss; |
12680 |
|
ss << (*this)[options::quantRepMode]; |
12681 |
|
return ss.str(); |
12682 |
|
} |
12683 |
10 |
if (key == "quant-split") { |
12684 |
|
return (*this)[options::quantSplit] ? "true" : "false"; |
12685 |
|
} |
12686 |
10 |
if (key == "register-quant-body-terms") { |
12687 |
|
return (*this)[options::registerQuantBodyTerms] ? "true" : "false"; |
12688 |
|
} |
12689 |
10 |
if (key == "relational-triggers") { |
12690 |
|
return (*this)[options::relationalTriggers] ? "true" : "false"; |
12691 |
|
} |
12692 |
10 |
if (key == "relevant-triggers") { |
12693 |
|
return (*this)[options::relevantTriggers] ? "true" : "false"; |
12694 |
|
} |
12695 |
10 |
if (key == "strict-triggers") { |
12696 |
|
return (*this)[options::strictTriggers] ? "true" : "false"; |
12697 |
|
} |
12698 |
10 |
if (key == "sygus") { |
12699 |
|
return (*this)[options::sygus] ? "true" : "false"; |
12700 |
|
} |
12701 |
10 |
if (key == "sygus-active-gen-cfactor") { |
12702 |
|
return std::to_string((*this)[options::sygusActiveGenEnumConsts]); |
12703 |
|
} |
12704 |
10 |
if (key == "sygus-active-gen") { |
12705 |
|
std::stringstream ss; |
12706 |
|
ss << (*this)[options::sygusActiveGenMode]; |
12707 |
|
return ss.str(); |
12708 |
|
} |
12709 |
10 |
if (key == "sygus-add-const-grammar") { |
12710 |
|
return (*this)[options::sygusAddConstGrammar] ? "true" : "false"; |
12711 |
|
} |
12712 |
10 |
if (key == "sygus-arg-relevant") { |
12713 |
|
return (*this)[options::sygusArgRelevant] ? "true" : "false"; |
12714 |
|
} |
12715 |
10 |
if (key == "sygus-auto-unfold") { |
12716 |
|
return (*this)[options::sygusInvAutoUnfold] ? "true" : "false"; |
12717 |
|
} |
12718 |
10 |
if (key == "sygus-bool-ite-return-const") { |
12719 |
|
return (*this)[options::sygusBoolIteReturnConst] ? "true" : "false"; |
12720 |
|
} |
12721 |
10 |
if (key == "sygus-core-connective") { |
12722 |
|
return (*this)[options::sygusCoreConnective] ? "true" : "false"; |
12723 |
|
} |
12724 |
10 |
if (key == "sygus-crepair-abort") { |
12725 |
|
return (*this)[options::sygusConstRepairAbort] ? "true" : "false"; |
12726 |
|
} |
12727 |
10 |
if (key == "sygus-eval-opt") { |
12728 |
|
return (*this)[options::sygusEvalOpt] ? "true" : "false"; |
12729 |
|
} |
12730 |
10 |
if (key == "sygus-eval-unfold") { |
12731 |
|
return (*this)[options::sygusEvalUnfold] ? "true" : "false"; |
12732 |
|
} |
12733 |
10 |
if (key == "sygus-eval-unfold-bool") { |
12734 |
|
return (*this)[options::sygusEvalUnfoldBool] ? "true" : "false"; |
12735 |
|
} |
12736 |
10 |
if (key == "sygus-expr-miner-check-timeout") { |
12737 |
|
return std::to_string((*this)[options::sygusExprMinerCheckTimeout]); |
12738 |
|
} |
12739 |
10 |
if (key == "sygus-ext-rew") { |
12740 |
|
return (*this)[options::sygusExtRew] ? "true" : "false"; |
12741 |
|
} |
12742 |
10 |
if (key == "sygus-filter-sol-rev") { |
12743 |
|
return (*this)[options::sygusFilterSolRevSubsume] ? "true" : "false"; |
12744 |
|
} |
12745 |
10 |
if (key == "sygus-filter-sol") { |
12746 |
|
std::stringstream ss; |
12747 |
|
ss << (*this)[options::sygusFilterSolMode]; |
12748 |
|
return ss.str(); |
12749 |
|
} |
12750 |
10 |
if (key == "sygus-grammar-cons") { |
12751 |
|
std::stringstream ss; |
12752 |
|
ss << (*this)[options::sygusGrammarConsMode]; |
12753 |
|
return ss.str(); |
12754 |
|
} |
12755 |
10 |
if (key == "sygus-grammar-norm") { |
12756 |
|
return (*this)[options::sygusGrammarNorm] ? "true" : "false"; |
12757 |
|
} |
12758 |
10 |
if (key == "sygus-inference") { |
12759 |
|
return (*this)[options::sygusInference] ? "true" : "false"; |
12760 |
|
} |
12761 |
10 |
if (key == "sygus-inst") { |
12762 |
|
return (*this)[options::sygusInst] ? "true" : "false"; |
12763 |
|
} |
12764 |
10 |
if (key == "sygus-inst-mode") { |
12765 |
|
std::stringstream ss; |
12766 |
|
ss << (*this)[options::sygusInstMode]; |
12767 |
|
return ss.str(); |
12768 |
|
} |
12769 |
10 |
if (key == "sygus-inst-scope") { |
12770 |
|
std::stringstream ss; |
12771 |
|
ss << (*this)[options::sygusInstScope]; |
12772 |
|
return ss.str(); |
12773 |
|
} |
12774 |
10 |
if (key == "sygus-inst-term-sel") { |
12775 |
|
std::stringstream ss; |
12776 |
|
ss << (*this)[options::sygusInstTermSel]; |
12777 |
|
return ss.str(); |
12778 |
|
} |
12779 |
10 |
if (key == "sygus-inv-templ-when-sg") { |
12780 |
|
return (*this)[options::sygusInvTemplWhenSyntax] ? "true" : "false"; |
12781 |
|
} |
12782 |
10 |
if (key == "sygus-inv-templ") { |
12783 |
|
std::stringstream ss; |
12784 |
|
ss << (*this)[options::sygusInvTemplMode]; |
12785 |
|
return ss.str(); |
12786 |
|
} |
12787 |
10 |
if (key == "sygus-min-grammar") { |
12788 |
|
return (*this)[options::sygusMinGrammar] ? "true" : "false"; |
12789 |
|
} |
12790 |
10 |
if (key == "sygus-pbe") { |
12791 |
|
return (*this)[options::sygusUnifPbe] ? "true" : "false"; |
12792 |
|
} |
12793 |
10 |
if (key == "sygus-pbe-multi-fair") { |
12794 |
|
return (*this)[options::sygusPbeMultiFair] ? "true" : "false"; |
12795 |
|
} |
12796 |
10 |
if (key == "sygus-pbe-multi-fair-diff") { |
12797 |
|
return std::to_string((*this)[options::sygusPbeMultiFairDiff]); |
12798 |
|
} |
12799 |
10 |
if (key == "sygus-qe-preproc") { |
12800 |
|
return (*this)[options::sygusQePreproc] ? "true" : "false"; |
12801 |
|
} |
12802 |
10 |
if (key == "sygus-query-gen") { |
12803 |
|
return (*this)[options::sygusQueryGen] ? "true" : "false"; |
12804 |
|
} |
12805 |
10 |
if (key == "sygus-query-gen-check") { |
12806 |
|
return (*this)[options::sygusQueryGenCheck] ? "true" : "false"; |
12807 |
|
} |
12808 |
10 |
if (key == "sygus-query-gen-dump-files") { |
12809 |
|
std::stringstream ss; |
12810 |
|
ss << (*this)[options::sygusQueryGenDumpFiles]; |
12811 |
|
return ss.str(); |
12812 |
|
} |
12813 |
10 |
if (key == "sygus-query-gen-thresh") { |
12814 |
|
return std::to_string((*this)[options::sygusQueryGenThresh]); |
12815 |
|
} |
12816 |
10 |
if (key == "sygus-rec-fun") { |
12817 |
|
return (*this)[options::sygusRecFun] ? "true" : "false"; |
12818 |
|
} |
12819 |
10 |
if (key == "sygus-rec-fun-eval-limit") { |
12820 |
|
return std::to_string((*this)[options::sygusRecFunEvalLimit]); |
12821 |
|
} |
12822 |
10 |
if (key == "sygus-repair-const") { |
12823 |
|
return (*this)[options::sygusRepairConst] ? "true" : "false"; |
12824 |
|
} |
12825 |
10 |
if (key == "sygus-repair-const-timeout") { |
12826 |
|
return std::to_string((*this)[options::sygusRepairConstTimeout]); |
12827 |
|
} |
12828 |
10 |
if (key == "sygus-rr") { |
12829 |
|
return (*this)[options::sygusRew] ? "true" : "false"; |
12830 |
|
} |
12831 |
10 |
if (key == "sygus-rr-synth") { |
12832 |
|
return (*this)[options::sygusRewSynth] ? "true" : "false"; |
12833 |
|
} |
12834 |
10 |
if (key == "sygus-rr-synth-accel") { |
12835 |
|
return (*this)[options::sygusRewSynthAccel] ? "true" : "false"; |
12836 |
|
} |
12837 |
10 |
if (key == "sygus-rr-synth-check") { |
12838 |
|
return (*this)[options::sygusRewSynthCheck] ? "true" : "false"; |
12839 |
|
} |
12840 |
10 |
if (key == "sygus-rr-synth-filter-cong") { |
12841 |
|
return (*this)[options::sygusRewSynthFilterCong] ? "true" : "false"; |
12842 |
|
} |
12843 |
10 |
if (key == "sygus-rr-synth-filter-match") { |
12844 |
|
return (*this)[options::sygusRewSynthFilterMatch] ? "true" : "false"; |
12845 |
|
} |
12846 |
10 |
if (key == "sygus-rr-synth-filter-nl") { |
12847 |
|
return (*this)[options::sygusRewSynthFilterNonLinear] ? "true" : "false"; |
12848 |
|
} |
12849 |
10 |
if (key == "sygus-rr-synth-filter-order") { |
12850 |
|
return (*this)[options::sygusRewSynthFilterOrder] ? "true" : "false"; |
12851 |
|
} |
12852 |
10 |
if (key == "sygus-rr-synth-input") { |
12853 |
|
return (*this)[options::sygusRewSynthInput] ? "true" : "false"; |
12854 |
|
} |
12855 |
10 |
if (key == "sygus-rr-synth-input-nvars") { |
12856 |
|
return std::to_string((*this)[options::sygusRewSynthInputNVars]); |
12857 |
|
} |
12858 |
10 |
if (key == "sygus-rr-synth-input-use-bool") { |
12859 |
|
return (*this)[options::sygusRewSynthInputUseBool] ? "true" : "false"; |
12860 |
|
} |
12861 |
10 |
if (key == "sygus-rr-synth-rec") { |
12862 |
|
return (*this)[options::sygusRewSynthRec] ? "true" : "false"; |
12863 |
|
} |
12864 |
10 |
if (key == "sygus-rr-verify") { |
12865 |
|
return (*this)[options::sygusRewVerify] ? "true" : "false"; |
12866 |
|
} |
12867 |
10 |
if (key == "sygus-rr-verify-abort") { |
12868 |
|
return (*this)[options::sygusRewVerifyAbort] ? "true" : "false"; |
12869 |
|
} |
12870 |
10 |
if (key == "sygus-sample-fp-uniform") { |
12871 |
|
return (*this)[options::sygusSampleFpUniform] ? "true" : "false"; |
12872 |
|
} |
12873 |
10 |
if (key == "sygus-sample-grammar") { |
12874 |
|
return (*this)[options::sygusSampleGrammar] ? "true" : "false"; |
12875 |
|
} |
12876 |
10 |
if (key == "sygus-samples") { |
12877 |
|
return std::to_string((*this)[options::sygusSamples]); |
12878 |
|
} |
12879 |
10 |
if (key == "sygus-si-abort") { |
12880 |
|
return (*this)[options::cegqiSingleInvAbort] ? "true" : "false"; |
12881 |
|
} |
12882 |
10 |
if (key == "sygus-si-partial") { |
12883 |
|
return (*this)[options::cegqiSingleInvPartial] ? "true" : "false"; |
12884 |
|
} |
12885 |
10 |
if (key == "sygus-si-rcons-limit") { |
12886 |
|
return std::to_string((*this)[options::cegqiSingleInvReconstructLimit]); |
12887 |
|
} |
12888 |
10 |
if (key == "sygus-si-rcons") { |
12889 |
|
std::stringstream ss; |
12890 |
|
ss << (*this)[options::cegqiSingleInvReconstruct]; |
12891 |
|
return ss.str(); |
12892 |
|
} |
12893 |
10 |
if (key == "sygus-si-reconstruct-const") { |
12894 |
|
return (*this)[options::cegqiSingleInvReconstructConst] ? "true" : "false"; |
12895 |
|
} |
12896 |
10 |
if (key == "sygus-si") { |
12897 |
|
std::stringstream ss; |
12898 |
|
ss << (*this)[options::cegqiSingleInvMode]; |
12899 |
|
return ss.str(); |
12900 |
|
} |
12901 |
10 |
if (key == "sygus-stream") { |
12902 |
|
return (*this)[options::sygusStream] ? "true" : "false"; |
12903 |
|
} |
12904 |
10 |
if (key == "sygus-templ-embed-grammar") { |
12905 |
|
return (*this)[options::sygusTemplEmbedGrammar] ? "true" : "false"; |
12906 |
|
} |
12907 |
10 |
if (key == "sygus-unif-cond-independent-no-repeat-sol") { |
12908 |
|
return (*this)[options::sygusUnifCondIndNoRepeatSol] ? "true" : "false"; |
12909 |
|
} |
12910 |
10 |
if (key == "sygus-unif-pi") { |
12911 |
|
std::stringstream ss; |
12912 |
|
ss << (*this)[options::sygusUnifPi]; |
12913 |
|
return ss.str(); |
12914 |
|
} |
12915 |
10 |
if (key == "sygus-unif-shuffle-cond") { |
12916 |
|
return (*this)[options::sygusUnifShuffleCond] ? "true" : "false"; |
12917 |
|
} |
12918 |
10 |
if (key == "term-db-cd") { |
12919 |
|
return (*this)[options::termDbCd] ? "true" : "false"; |
12920 |
|
} |
12921 |
10 |
if (key == "term-db-mode") { |
12922 |
|
std::stringstream ss; |
12923 |
|
ss << (*this)[options::termDbMode]; |
12924 |
|
return ss.str(); |
12925 |
|
} |
12926 |
10 |
if (key == "trigger-active-sel") { |
12927 |
|
std::stringstream ss; |
12928 |
|
ss << (*this)[options::triggerActiveSelMode]; |
12929 |
|
return ss.str(); |
12930 |
|
} |
12931 |
10 |
if (key == "trigger-sel") { |
12932 |
|
std::stringstream ss; |
12933 |
|
ss << (*this)[options::triggerSelMode]; |
12934 |
|
return ss.str(); |
12935 |
|
} |
12936 |
10 |
if (key == "user-pat") { |
12937 |
|
std::stringstream ss; |
12938 |
|
ss << (*this)[options::userPatternsQuant]; |
12939 |
|
return ss.str(); |
12940 |
|
} |
12941 |
10 |
if (key == "var-elim-quant") { |
12942 |
|
return (*this)[options::varElimQuant] ? "true" : "false"; |
12943 |
|
} |
12944 |
10 |
if (key == "var-ineq-elim-quant") { |
12945 |
|
return (*this)[options::varIneqElimQuant] ? "true" : "false"; |
12946 |
|
} |
12947 |
10 |
if (key == "reproducible-resource-limit" || key == "rlimit-per") { |
12948 |
|
return std::to_string((*this)[options::perCallResourceLimit]); |
12949 |
|
} |
12950 |
10 |
if (key == "rlimit") { |
12951 |
|
return std::to_string((*this)[options::cumulativeResourceLimit]); |
12952 |
|
} |
12953 |
10 |
if (key == "tlimit-per") { |
12954 |
|
return std::to_string((*this)[options::perCallMillisecondLimit]); |
12955 |
|
} |
12956 |
10 |
if (key == "tlimit") { |
12957 |
|
return std::to_string((*this)[options::cumulativeMillisecondLimit]); |
12958 |
|
} |
12959 |
10 |
if (key == "sep-check-neg") { |
12960 |
|
return (*this)[options::sepCheckNeg] ? "true" : "false"; |
12961 |
|
} |
12962 |
10 |
if (key == "sep-child-refine") { |
12963 |
|
return (*this)[options::sepChildRefine] ? "true" : "false"; |
12964 |
|
} |
12965 |
10 |
if (key == "sep-deq-c") { |
12966 |
|
return (*this)[options::sepDisequalC] ? "true" : "false"; |
12967 |
|
} |
12968 |
10 |
if (key == "sep-exp") { |
12969 |
|
return (*this)[options::sepExp] ? "true" : "false"; |
12970 |
|
} |
12971 |
10 |
if (key == "sep-min-refine") { |
12972 |
|
return (*this)[options::sepMinimalRefine] ? "true" : "false"; |
12973 |
|
} |
12974 |
10 |
if (key == "sep-pre-skolem-emp") { |
12975 |
|
return (*this)[options::sepPreSkolemEmp] ? "true" : "false"; |
12976 |
|
} |
12977 |
10 |
if (key == "sets-ext") { |
12978 |
|
return (*this)[options::setsExt] ? "true" : "false"; |
12979 |
|
} |
12980 |
10 |
if (key == "sets-infer-as-lemmas") { |
12981 |
|
return (*this)[options::setsInferAsLemmas] ? "true" : "false"; |
12982 |
|
} |
12983 |
10 |
if (key == "sets-proxy-lemmas") { |
12984 |
|
return (*this)[options::setsProxyLemmas] ? "true" : "false"; |
12985 |
|
} |
12986 |
10 |
if (key == "abstract-values") { |
12987 |
|
return (*this)[options::abstractValues] ? "true" : "false"; |
12988 |
|
} |
12989 |
10 |
if (key == "ackermann") { |
12990 |
|
return (*this)[options::ackermann] ? "true" : "false"; |
12991 |
|
} |
12992 |
10 |
if (key == "block-models") { |
12993 |
|
std::stringstream ss; |
12994 |
|
ss << (*this)[options::blockModelsMode]; |
12995 |
|
return ss.str(); |
12996 |
|
} |
12997 |
10 |
if (key == "bvand-integer-granularity") { |
12998 |
|
return std::to_string((*this)[options::BVAndIntegerGranularity]); |
12999 |
|
} |
13000 |
10 |
if (key == "check-abducts") { |
13001 |
|
return (*this)[options::checkAbducts] ? "true" : "false"; |
13002 |
|
} |
13003 |
10 |
if (key == "check-interpols") { |
13004 |
|
return (*this)[options::checkInterpols] ? "true" : "false"; |
13005 |
|
} |
13006 |
10 |
if (key == "check-models") { |
13007 |
2 |
return (*this)[options::checkModels] ? "true" : "false"; |
13008 |
|
} |
13009 |
8 |
if (key == "check-proofs") { |
13010 |
|
return (*this)[options::checkProofs] ? "true" : "false"; |
13011 |
|
} |
13012 |
8 |
if (key == "check-synth-sol") { |
13013 |
|
return (*this)[options::checkSynthSol] ? "true" : "false"; |
13014 |
|
} |
13015 |
8 |
if (key == "check-unsat-cores") { |
13016 |
|
return (*this)[options::checkUnsatCores] ? "true" : "false"; |
13017 |
|
} |
13018 |
8 |
if (key == "debug-check-models") { |
13019 |
|
return (*this)[options::debugCheckModels] ? "true" : "false"; |
13020 |
|
} |
13021 |
8 |
if (key == "diagnostic-output-channel") { |
13022 |
|
return (*this)[options::diagnosticChannelName]; |
13023 |
|
} |
13024 |
8 |
if (key == "dump-instantiations") { |
13025 |
|
return (*this)[options::dumpInstantiations] ? "true" : "false"; |
13026 |
|
} |
13027 |
8 |
if (key == "dump-models") { |
13028 |
|
return (*this)[options::dumpModels] ? "true" : "false"; |
13029 |
|
} |
13030 |
8 |
if (key == "dump-proofs") { |
13031 |
|
return (*this)[options::dumpProofs] ? "true" : "false"; |
13032 |
|
} |
13033 |
8 |
if (key == "dump-to") { |
13034 |
|
return (*this)[options::dumpToFileName]; |
13035 |
|
} |
13036 |
8 |
if (key == "dump-unsat-cores") { |
13037 |
|
return (*this)[options::dumpUnsatCores] ? "true" : "false"; |
13038 |
|
} |
13039 |
8 |
if (key == "dump-unsat-cores-full") { |
13040 |
|
return (*this)[options::dumpUnsatCoresFull] ? "true" : "false"; |
13041 |
|
} |
13042 |
8 |
if (key == "dump") { |
13043 |
|
return (*this)[options::dumpModeString]; |
13044 |
|
} |
13045 |
8 |
if (key == "early-ite-removal") { |
13046 |
|
return (*this)[options::earlyIteRemoval] ? "true" : "false"; |
13047 |
|
} |
13048 |
8 |
if (key == "expand-definitions") { |
13049 |
|
return (*this)[options::expandDefinitions] ? "true" : "false"; |
13050 |
|
} |
13051 |
8 |
if (key == "ext-rew-prep") { |
13052 |
|
return (*this)[options::extRewPrep] ? "true" : "false"; |
13053 |
|
} |
13054 |
8 |
if (key == "ext-rew-prep-agg") { |
13055 |
|
return (*this)[options::extRewPrepAgg] ? "true" : "false"; |
13056 |
|
} |
13057 |
8 |
if (key == "force-no-limit-cpu-while-dump") { |
13058 |
|
return (*this)[options::forceNoLimitCpuWhileDump] ? "true" : "false"; |
13059 |
|
} |
13060 |
8 |
if (key == "foreign-theory-rewrite") { |
13061 |
|
return (*this)[options::foreignTheoryRewrite] ? "true" : "false"; |
13062 |
|
} |
13063 |
8 |
if (key == "iand-mode") { |
13064 |
|
std::stringstream ss; |
13065 |
|
ss << (*this)[options::iandMode]; |
13066 |
|
return ss.str(); |
13067 |
|
} |
13068 |
8 |
if (key == "incremental") { |
13069 |
2 |
return (*this)[options::incrementalSolving] ? "true" : "false"; |
13070 |
|
} |
13071 |
6 |
if (key == "interactive-mode") { |
13072 |
|
return (*this)[options::interactiveMode] ? "true" : "false"; |
13073 |
|
} |
13074 |
6 |
if (key == "ite-simp") { |
13075 |
|
return (*this)[options::doITESimp] ? "true" : "false"; |
13076 |
|
} |
13077 |
6 |
if (key == "model-cores") { |
13078 |
|
std::stringstream ss; |
13079 |
|
ss << (*this)[options::modelCoresMode]; |
13080 |
|
return ss.str(); |
13081 |
|
} |
13082 |
6 |
if (key == "model-u-print" || key == "model-uninterp-print") { |
13083 |
|
std::stringstream ss; |
13084 |
|
ss << (*this)[options::modelUninterpPrint]; |
13085 |
|
return ss.str(); |
13086 |
|
} |
13087 |
6 |
if (key == "model-witness-value") { |
13088 |
|
return (*this)[options::modelWitnessValue] ? "true" : "false"; |
13089 |
|
} |
13090 |
6 |
if (key == "on-repeat-ite-simp") { |
13091 |
|
return (*this)[options::doITESimpOnRepeat] ? "true" : "false"; |
13092 |
|
} |
13093 |
6 |
if (key == "produce-abducts") { |
13094 |
|
return (*this)[options::produceAbducts] ? "true" : "false"; |
13095 |
|
} |
13096 |
6 |
if (key == "produce-assertions") { |
13097 |
|
return (*this)[options::produceAssertions] ? "true" : "false"; |
13098 |
|
} |
13099 |
6 |
if (key == "produce-assignments") { |
13100 |
|
return (*this)[options::produceAssignments] ? "true" : "false"; |
13101 |
|
} |
13102 |
6 |
if (key == "produce-interpols") { |
13103 |
|
std::stringstream ss; |
13104 |
|
ss << (*this)[options::produceInterpols]; |
13105 |
|
return ss.str(); |
13106 |
|
} |
13107 |
6 |
if (key == "produce-models") { |
13108 |
3 |
return (*this)[options::produceModels] ? "true" : "false"; |
13109 |
|
} |
13110 |
3 |
if (key == "produce-proofs") { |
13111 |
|
return (*this)[options::produceProofs] ? "true" : "false"; |
13112 |
|
} |
13113 |
3 |
if (key == "produce-unsat-assumptions") { |
13114 |
|
return (*this)[options::unsatAssumptions] ? "true" : "false"; |
13115 |
|
} |
13116 |
3 |
if (key == "produce-unsat-cores") { |
13117 |
|
return (*this)[options::unsatCores] ? "true" : "false"; |
13118 |
|
} |
13119 |
3 |
if (key == "regular-output-channel") { |
13120 |
|
return (*this)[options::regularChannelName]; |
13121 |
|
} |
13122 |
3 |
if (key == "repeat-simp") { |
13123 |
|
return (*this)[options::repeatSimp] ? "true" : "false"; |
13124 |
|
} |
13125 |
3 |
if (key == "simp-ite-compress") { |
13126 |
|
return (*this)[options::compressItes] ? "true" : "false"; |
13127 |
|
} |
13128 |
3 |
if (key == "simp-ite-hunt-zombies") { |
13129 |
|
return std::to_string((*this)[options::zombieHuntThreshold]); |
13130 |
|
} |
13131 |
3 |
if (key == "simp-with-care") { |
13132 |
|
return (*this)[options::simplifyWithCareEnabled] ? "true" : "false"; |
13133 |
|
} |
13134 |
3 |
if (key == "simplification" || key == "simplification-mode") { |
13135 |
2 |
std::stringstream ss; |
13136 |
1 |
ss << (*this)[options::simplificationMode]; |
13137 |
1 |
return ss.str(); |
13138 |
|
} |
13139 |
2 |
if (key == "solve-bv-as-int") { |
13140 |
|
std::stringstream ss; |
13141 |
|
ss << (*this)[options::solveBVAsInt]; |
13142 |
|
return ss.str(); |
13143 |
|
} |
13144 |
2 |
if (key == "solve-int-as-bv") { |
13145 |
|
return std::to_string((*this)[options::solveIntAsBV]); |
13146 |
|
} |
13147 |
2 |
if (key == "solve-real-as-int") { |
13148 |
|
return (*this)[options::solveRealAsInt] ? "true" : "false"; |
13149 |
|
} |
13150 |
2 |
if (key == "sort-inference") { |
13151 |
|
return (*this)[options::sortInference] ? "true" : "false"; |
13152 |
|
} |
13153 |
2 |
if (key == "static-learning") { |
13154 |
|
return (*this)[options::doStaticLearning] ? "true" : "false"; |
13155 |
|
} |
13156 |
2 |
if (key == "sygus-out") { |
13157 |
|
std::stringstream ss; |
13158 |
|
ss << (*this)[options::sygusOut]; |
13159 |
|
return ss.str(); |
13160 |
|
} |
13161 |
2 |
if (key == "sygus-print-callbacks") { |
13162 |
|
return (*this)[options::sygusPrintCallbacks] ? "true" : "false"; |
13163 |
|
} |
13164 |
2 |
if (key == "unconstrained-simp") { |
13165 |
|
return (*this)[options::unconstrainedSimp] ? "true" : "false"; |
13166 |
|
} |
13167 |
2 |
if (key == "unsat-cores-mode") { |
13168 |
|
std::stringstream ss; |
13169 |
|
ss << (*this)[options::unsatCoresMode]; |
13170 |
|
return ss.str(); |
13171 |
|
} |
13172 |
2 |
if (key == "re-elim") { |
13173 |
|
return (*this)[options::regExpElim] ? "true" : "false"; |
13174 |
|
} |
13175 |
2 |
if (key == "re-elim-agg") { |
13176 |
|
return (*this)[options::regExpElimAgg] ? "true" : "false"; |
13177 |
|
} |
13178 |
2 |
if (key == "re-inter-mode") { |
13179 |
|
std::stringstream ss; |
13180 |
|
ss << (*this)[options::stringRegExpInterMode]; |
13181 |
|
return ss.str(); |
13182 |
|
} |
13183 |
2 |
if (key == "strings-check-entail-len") { |
13184 |
|
return (*this)[options::stringCheckEntailLen] ? "true" : "false"; |
13185 |
|
} |
13186 |
2 |
if (key == "strings-eager") { |
13187 |
|
return (*this)[options::stringEager] ? "true" : "false"; |
13188 |
|
} |
13189 |
2 |
if (key == "strings-eager-eval") { |
13190 |
|
return (*this)[options::stringEagerEval] ? "true" : "false"; |
13191 |
|
} |
13192 |
2 |
if (key == "strings-eager-len") { |
13193 |
|
return (*this)[options::stringEagerLen] ? "true" : "false"; |
13194 |
|
} |
13195 |
2 |
if (key == "strings-exp") { |
13196 |
|
return (*this)[options::stringExp] ? "true" : "false"; |
13197 |
|
} |
13198 |
2 |
if (key == "strings-ff") { |
13199 |
|
return (*this)[options::stringFlatForms] ? "true" : "false"; |
13200 |
|
} |
13201 |
2 |
if (key == "strings-fmf") { |
13202 |
|
return (*this)[options::stringFMF] ? "true" : "false"; |
13203 |
|
} |
13204 |
2 |
if (key == "strings-guess-model") { |
13205 |
|
return (*this)[options::stringGuessModel] ? "true" : "false"; |
13206 |
|
} |
13207 |
2 |
if (key == "strings-infer-as-lemmas") { |
13208 |
|
return (*this)[options::stringInferAsLemmas] ? "true" : "false"; |
13209 |
|
} |
13210 |
2 |
if (key == "strings-infer-sym") { |
13211 |
|
return (*this)[options::stringInferSym] ? "true" : "false"; |
13212 |
|
} |
13213 |
2 |
if (key == "strings-inm") { |
13214 |
|
return (*this)[options::stringIgnNegMembership] ? "true" : "false"; |
13215 |
|
} |
13216 |
2 |
if (key == "strings-lazy-pp") { |
13217 |
|
return (*this)[options::stringLazyPreproc] ? "true" : "false"; |
13218 |
|
} |
13219 |
2 |
if (key == "strings-len-norm") { |
13220 |
|
return (*this)[options::stringLenNorm] ? "true" : "false"; |
13221 |
|
} |
13222 |
2 |
if (key == "strings-lprop-csp") { |
13223 |
|
return (*this)[options::stringLenPropCsp] ? "true" : "false"; |
13224 |
|
} |
13225 |
2 |
if (key == "strings-min-prefix-explain") { |
13226 |
|
return (*this)[options::stringMinPrefixExplain] ? "true" : "false"; |
13227 |
|
} |
13228 |
2 |
if (key == "strings-process-loop-mode") { |
13229 |
|
std::stringstream ss; |
13230 |
|
ss << (*this)[options::stringProcessLoopMode]; |
13231 |
|
return ss.str(); |
13232 |
|
} |
13233 |
2 |
if (key == "strings-rexplain-lemmas") { |
13234 |
|
return (*this)[options::stringRExplainLemmas] ? "true" : "false"; |
13235 |
|
} |
13236 |
2 |
if (key == "strings-unified-vspt") { |
13237 |
|
return (*this)[options::stringUnifiedVSpt] ? "true" : "false"; |
13238 |
|
} |
13239 |
2 |
if (key == "assign-function-values") { |
13240 |
|
return (*this)[options::assignFunctionValues] ? "true" : "false"; |
13241 |
|
} |
13242 |
2 |
if (key == "condense-function-values") { |
13243 |
|
return (*this)[options::condenseFunctionValues] ? "true" : "false"; |
13244 |
|
} |
13245 |
2 |
if (key == "ee-mode") { |
13246 |
|
std::stringstream ss; |
13247 |
|
ss << (*this)[options::eeMode]; |
13248 |
|
return ss.str(); |
13249 |
|
} |
13250 |
2 |
if (key == "relevance-filter") { |
13251 |
|
return (*this)[options::relevanceFilter] ? "true" : "false"; |
13252 |
|
} |
13253 |
2 |
if (key == "tc-mode") { |
13254 |
|
std::stringstream ss; |
13255 |
|
ss << (*this)[options::tcMode]; |
13256 |
|
return ss.str(); |
13257 |
|
} |
13258 |
2 |
if (key == "theoryof-mode") { |
13259 |
|
std::stringstream ss; |
13260 |
|
ss << (*this)[options::theoryOfMode]; |
13261 |
|
return ss.str(); |
13262 |
|
} |
13263 |
2 |
if (key == "symmetry-breaker" || key == "uf-symmetry-breaker") { |
13264 |
|
return (*this)[options::ufSymmetryBreaker] ? "true" : "false"; |
13265 |
|
} |
13266 |
2 |
if (key == "uf-ho") { |
13267 |
|
return (*this)[options::ufHo] ? "true" : "false"; |
13268 |
|
} |
13269 |
2 |
if (key == "uf-ho-ext") { |
13270 |
|
return (*this)[options::ufHoExt] ? "true" : "false"; |
13271 |
|
} |
13272 |
2 |
if (key == "uf-ss-abort-card") { |
13273 |
|
return std::to_string((*this)[options::ufssAbortCardinality]); |
13274 |
|
} |
13275 |
2 |
if (key == "uf-ss-fair") { |
13276 |
|
return (*this)[options::ufssFairness] ? "true" : "false"; |
13277 |
|
} |
13278 |
2 |
if (key == "uf-ss-fair-monotone") { |
13279 |
|
return (*this)[options::ufssFairnessMonotone] ? "true" : "false"; |
13280 |
|
} |
13281 |
2 |
if (key == "uf-ss-totality-limited") { |
13282 |
|
return std::to_string((*this)[options::ufssTotalityLimited]); |
13283 |
|
} |
13284 |
2 |
if (key == "uf-ss-totality-sym-break") { |
13285 |
|
return (*this)[options::ufssTotalitySymBreak] ? "true" : "false"; |
13286 |
|
} |
13287 |
2 |
if (key == "uf-ss") { |
13288 |
|
std::stringstream ss; |
13289 |
|
ss << (*this)[options::ufssMode]; |
13290 |
|
return ss.str(); |
13291 |
|
} |
13292 |
|
|
13293 |
2 |
throw UnrecognizedOptionException(key); |
13294 |
|
} |
13295 |
|
// clang-format on |
13296 |
|
|
13297 |
28211 |
} // namespace cvc5 |
13298 |
|
|