static obj_t make_string_fn(obj_t args, Reporter rep)
{
size_t nargs, i, k;
char ch;
string str;
nargs = list_length(args);
if (nargs == 0 || nargs > 2) {
reportf(rep, "make-string: "
"length and optional fill char expected");
return unspecific;
}
if (!is_num(list_ref(args, 0))) {
reportf(rep, "make-string: "
"first argument must be a non-negative integer");
return unspecific;
}
if (nargs == 2 && !is_char(list_ref(args, 1))) {
reportf(rep, "make-string: "
"second argument must be a character");
return unspecific;
}
k = fetch_num(list_ref(args, 0));
ch = (nargs == 1) ? 0 : fetch_char(list_ref(args, 1));
str = string_alloc(k);
for (i = 0; i < str->len; i++)
str->data[i] = ch;
return make_string(str);
}
void SimpSMTSolver::verifyModel()
{
bool failed = false;
int cnt = 0;
// NOTE: elimtable.size() might be lower than nVars() at the moment
for (int i = 0; i < elimtable.size(); i++)
{
if (elimtable[i].order > 0)
{
for (int j = 0; j < elimtable[i].eliminated.size(); j++)
{
cnt++;
Clause& c = *elimtable[i].eliminated[j];
for (int k = 0; k < c.size(); k++)
if (modelValue(c[k]) == l_True)
goto next;
reportf("unsatisfied clause: ");
printClause(*elimtable[i].eliminated[j]);
reportf("\n");
failed = true;
next:;
}
}
}
assert(!failed);
// Modified line
// reportf("Verified %d eliminated clauses.\n", cnt);
/*
if ( config.sat_verbose )
reportf("# Verified %d eliminated clauses.\n#\n", cnt);
*/
}
// Will return '_undef_' if 'cost_limit' is exceeded.
//
Formula buildConstraint(const Linear& c, int max_cost)
{
vec<Formula> ps;
vec<Int> Cs;
for (int j = 0; j < c.size; j++)
ps.push(lit2fml(c[j])),
Cs.push(c(j));
vec<Int> dummy;
int cost;
vec<int> base;
optimizeBase(Cs, dummy, cost, base);
FEnv::push();
Formula ret;
try {
ret = buildConstraint(ps, Cs, base, c.lo, c.hi, max_cost);
}catch (Exception_TooBig){
FEnv::pop();
return _undef_;
}
if (opt_verbosity >= 1){
reportf("Sorter-cost:%5d ", FEnv::topSize());
reportf("Base:"); for (int i = 0; i < base.size(); i++) reportf(" %d", base[i]); reportf("\n");
}
FEnv::keep();
return ret;
}
void CoreSMTSolver::verifyModel()
{
#ifdef DREAL_DEBUG
bool failed = false;
#endif
for (int i = 0; i < clauses.size(); i++)
{
assert(clauses[i]->mark() == 0);
Clause& c = *clauses[i];
for (int j = 0; j < c.size(); j++)
if (modelValue(c[j]) == l_True ||
(config.nra_short_sat && modelValue(c[j]) != l_False))
goto next;
reportf("unsatisfied clause: ");
printClause(*clauses[i]);
printSMTClause( cerr, *clauses[i] );
reportf("\n");
#ifdef DREAL_DEBUG
failed = true;
#endif
next:;
}
#ifdef DREAL_DEBUG
assert(!failed);
#endif
// Removed line
// reportf("Verified %d original clauses.\n", clauses.size());
}
void PbSolver::propagate()
{
if (nVars() == 0) return;
if (occur.size() == 0) setupOccurs();
if (opt_verbosity >= 1) reportf(" -- Unit propagations: ", constrs.size());
bool found = false;
while (propQ_head < trail.size()){
//**/reportf("propagate("); dump(trail[propQ_head]); reportf(")\n");
Var x = var(trail[propQ_head++]);
for (int pol = 0; pol < 2; pol++){
vec<int>& cs = occur[index(Lit(x,pol))];
for (int i = 0; i < cs.size(); i++){
if (constrs[cs[i]] == NULL) continue;
int trail_sz = trail.size();
if (propagate(*constrs[cs[i]]))
constrs[cs[i]] = NULL;
if (opt_verbosity >= 1 && trail.size() > trail_sz) found = true, reportf("p");
if (!ok) return;
}
}
}
if (opt_verbosity >= 1) {
if (!found) reportf("(none)\n");
else reportf("\n");
}
occur.clear(true);
}
static void parse_DIMACS_main(B& in, mS& S) {
vec<Lit> lits;
Int w;
Int max=-1;
bool wcnf=false;
for (;;){
skipWhitespaceCnf(in);
if (*in == EOF)
break;
else if (*in == 'c') skipLineCnf(in);
else if(*in == 'p')
{
++in;
skipWhitespaceCnf(in);
if(*in== 'w') wcnf=true;
if (wcnf) {reportf("Parsing WCNF file...\n"); ++in; ++in; ++in; ++in;}
else { reportf("Parsing CNF file...\n"); ++in; ++in; ++in;}
//if (wcnf) {reportf("Parsing WCNF file...\n"); }
//else { reportf("Parsing CNF file...\n");}
parseIntCnf(in); // Number of variables
parseIntCnf(in); // Number of clauses
while(not (*in >= '0' and *in <= '9') and not(*in == '\n')){
++in;
}
S.setTop(-1);
if (*in >= '0' and *in <= '9') max=parseIntCnf(in);
if(max!=-1) {
reportf("UB %d \n",toint(max));
S.setTop(max);
}
skipLineCnf(in);
}
else
{
w=readClauseCnf(in, S, lits,wcnf);
if(opt_sat==1) // Satisfiability
S.addWeightedClause(lits,w,true);
else {// Max-SAT
if(lits.size()>1)
{
if(max >-1 and w>=max) S.addWeightedClause(lits,max,true);
else S.addWeightedClause(lits,w,false);
}
else {
if(max >-1 and w>=max) S.addWeightedClause(lits,max,true);
else S.addUnitSoftClauses(lits[0],w);
}
}
}
}
}
bool SimpSMTSolver::eliminateVar(Var v, bool fail)
{
if (!fail && asymm_mode && !asymmVar(v)) return false;
const vec<Clause*>& cls = getOccurs(v);
// if (value(v) != l_Undef || cls.size() == 0) return true;
if (value(v) != l_Undef) return true;
// Split the occurrences into positive and negative:
vec<Clause*> pos, neg;
for (int i = 0; i < cls.size(); i++)
(find(*cls[i], Lit(v)) ? pos : neg).push(cls[i]);
// Check if number of clauses decreases:
int cnt = 0;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(*pos[i], *neg[j], v) && ++cnt > cls.size() + grow)
return true;
#ifdef PEDANTIC_DEBUG
cerr << "XXY gonna-remove" << endl;
#endif
// Delete and store old clauses:
setDecisionVar(v, false);
elimtable[v].order = elimorder++;
assert(elimtable[v].eliminated.size() == 0);
for (int i = 0; i < cls.size(); i++)
{
elimtable[v].eliminated.push(Clause_new(*cls[i]));
removeClause(*cls[i]);
}
// Produce clauses in cross product:
int top = clauses.size();
vec<Lit> resolvent;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++)
if (merge(*pos[i], *neg[j], v, resolvent) && !addClause(resolvent))
return false;
// DEBUG: For checking that a clause set is saturated with respect to variable elimination.
// If the clause set is expected to be saturated at this point, this constitutes an
// error.
if (fail){
reportf("eliminated var %d, %d <= %d\n", v+1, cnt, cls.size());
reportf("previous clauses:\n");
for (int i = 0; i < cls.size(); i++){
printClause(*cls[i]); reportf("\n"); }
reportf("new clauses:\n");
for (int i = top; i < clauses.size(); i++){
printClause(*clauses[i]); reportf("\n"); }
assert(0); }
return backwardSubsumptionCheck();
}
void info(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
reportf("", fmt, args);
va_end(args);
}
bool PbSolver::convertPbs(void)
{
vec<Formula> fs;
vec<Lit> ts;
if (!rewriteAlmostClauses())
return false;
// construct formulas for all constraints
for (int i = 0; i < constrs.size(); i++){
if (constrs[i] == NULL) continue;
/**/reportf("---[%4d]---> ", constrs.size() - 1 - i);
linearAddition2(*constrs[i], fs);
}
clausify(sat_solver,fs,ts);
for (int i = 0; i < ts.size(); i++)
sat_solver.addUnit(ts[i]);
constrs.clear();
mem.clear();
return sat_solver.okay();
}
void warning(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
reportf("warning: ", fmt, args);
va_end(args);
}
void error(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
reportf("error: ", fmt, args);
va_end(args);
}
// Backward subsumption + backward subsumption resolution
bool SimpSolver::backwardSubsumptionCheck(bool verbose)
{
int cnt = 0;
int subsumed = 0;
int deleted_literals = 0;
assert(decisionLevel() == 0);
while (subsumption_queue.size() > 0 || bwdsub_assigns < trail.size()){
// Check top-level assignments by creating a dummy clause and placing it in the queue:
if (subsumption_queue.size() == 0 && bwdsub_assigns < trail.size()){
Lit l = trail[bwdsub_assigns++];
(*bwdsub_tmpunit)[0] = l;
bwdsub_tmpunit->calcAbstraction();
assert(bwdsub_tmpunit->mark() == 0);
subsumption_queue.insert(bwdsub_tmpunit); }
Clause& c = *subsumption_queue.peek(); subsumption_queue.pop();
if (c.mark()) continue;
if (verbose && verbosity >= 2 && cnt++ % 1000 == 0)
reportf("subsumption left: %10d (%10d subsumed, %10d deleted literals)\r", subsumption_queue.size(), subsumed, deleted_literals);
assert(c.size() > 1 || value(c[0]) == l_True); // Unit-clauses should have been propagated before this point.
// Find best variable to scan:
Var best = var(c[0]);
for (int i = 1; i < c.size(); i++)
if (occurs[var(c[i])].size() < occurs[best].size())
best = var(c[i]);
// Search all candidates:
vec<Clause*>& _cs = getOccurs(best);
Clause** cs = (Clause**)_cs;
for (int j = 0; j < _cs.size(); j++)
if (c.mark())
break;
else if (!cs[j]->mark() && cs[j] != &c){
Lit l = c.subsumes(*cs[j]);
if (l == lit_Undef)
subsumed++, removeClause(*cs[j]);
else if (l != lit_Error){
deleted_literals++;
if (!strengthenClause(*cs[j], ~l))
return false;
// Did current candidate get deleted from cs? Then check candidate at index j again:
if (var(l) == best)
j--;
}
}
}
return true;
}
static int parseDecimal(B& in, int& nbDec=0) {
int val = 0;
if (*in < '0' || *in > '9') reportf("PARSE ERROR! (parseDecimal) Unexpected char: %c\n", *in), exit(3);
while (*in >= '0' && *in <= '9')
val = val*10 + (*in - '0'),
++in, ++nbDec;
return val;
}
void fatal(const char *fmt, ...) {
va_list args;
va_start(args, fmt);
reportf("fatal: ", fmt, args);
va_end(args);
exit(EXIT_FAILURE);
}
bool PbSolver::convertPbs(bool first_call)
{
vec<Formula> converted_constrs;
if (first_call){
findIntervals();
if (!rewriteAlmostClauses()){
ok = false;
return false; }
}
for (int i = 0; i < constrs.size(); i++){
if (constrs[i] == NULL) continue;
Linear& c = *constrs[i]; assert(c.lo != Int_MIN || c.hi != Int_MAX);
if (options->opt_verbosity >= 1)
/**/reportf("---[%4d]---> ", constrs.size() - 1 - i);
if (options->opt_convert == ct_Sorters) {
if (options->opt_dump) { // no formulae built
buildConstraint(c,primesLoader, options);
} else {
converted_constrs.push(buildConstraint(c,primesLoader, options));
}
}
else if (options->opt_convert == ct_Adders)
linearAddition(c, converted_constrs, options->opt_verbosity);
else if (options->opt_convert == ct_BDDs)
converted_constrs.push(convertToBdd(c, options->opt_verbosity));
else if (options->opt_convert == ct_Mixed){
int adder_cost = estimatedAdderCost(c);
//**/printf("estimatedAdderCost: %d\n", estimatedAdderCost(c));
Formula result = convertToBdd(c, options->opt_verbosity, (int)(adder_cost * options->opt_bdd_thres));
if (result == _undef_)
result = buildConstraint(c,primesLoader, options, (int)(adder_cost * options->opt_sort_thres));
if (result == _undef_)
linearAddition(c, converted_constrs, options->opt_verbosity);
else
converted_constrs.push(result);
}else
assert(false);
if (!ok) return false;
}
if (!options->opt_validateResoult) cleanPBC();
formulaSize = converted_constrs.size();
clausify(*sat_solver, options, converted_constrs);
if (options->opt_dump) {
exit(0);
}
return ok;
}
void PbSolver::findIntervals()
{
if (opt_verbosity >= 1)
reportf(" -- Detecting intervals from adjacent constraints: ");
bool found = false;
int i = 0;
Linear* prev;
for (; i < constrs.size() && constrs[i] == NULL; i++);
if (i < constrs.size()){
prev = constrs[i++];
for (; i < constrs.size(); i++){
if (constrs[i] == NULL) continue;
Linear& c = *prev;
Linear& d = *constrs[i];
if (lhsEq(c, d)){
if (d.lo < c.lo) d.lo = c.lo;
if (d.hi > c.hi) d.hi = c.hi;
constrs[i-1] = NULL;
if (opt_verbosity >= 1) reportf("=");
found = true;
}
if (lhsEqc(c, d)){
Int sum = 0;
for (int j = 0; j < c.size; j++)
sum += c(j);
Int lo = (c.hi == Int_MAX) ? Int_MIN : sum - c.hi;
Int hi = (c.lo == Int_MIN) ? Int_MAX : sum - c.lo;
if (d.lo < lo) d.lo = lo;
if (d.hi > hi) d.hi = hi;
constrs[i-1] = NULL;
if (opt_verbosity >= 1) reportf("#");
found = true;
}
prev = &d;
}
}
if (opt_verbosity >= 1) {
if (!found) reportf("(none)\n");
else reportf("\n");
}
}
void Solver::verifyModel()
{
for (int i = 0; i < clauses.size(); i++){
Clause& c = *clauses[i];
for (int j = 0; j < c.size(); j++)
if (modelValue(c[j]) == l_True)
goto next;
reportf("unsatisfied clause: ");
printClause(*clauses[i]);
reportf("\n");
// bool failed = false;
// failed = true;
next:;
}
// reportf("Verified %d original clauses.\n", clauses.size());
}
void OpenSMTContext::PrintResult( const lbool & result, const lbool & config_status )
{
ostream & out = config.getRegularOut( );
#ifdef SMTCOMP
(void)config_status;
#else
fflush( stderr );
(void)config_status;
//
// For testing purposes we return error if bug is found
//
if ( config_status != l_Undef
&& result != l_Undef
&& result != config_status )
out << "error" << endl;
else
#endif
if ( result == l_True )
out << "sat" << endl;
else if ( result == l_False )
out << "unsat" << endl;
else if ( result == l_Undef )
out << "unknown" << endl;
else
opensmt_error( "unexpected result" );
fflush( stdout );
#ifndef SMTCOMP
if ( config.verbosity )
{
//
// Statistics
//
double cpu_time = cpuTime();
reportf( "#\n" );
reportf( "# CPU Time used: %g s\n", cpu_time == 0 ? 0 : cpu_time );
uint64_t mem_used = memUsed();
reportf( "# Memory used: %.3f MB\n", mem_used == 0 ? 0 : mem_used / 1048576.0 );
reportf( "#\n" );
}
#endif
}
static int parseInt(B& in) {
int val = 0;
bool neg = false;
skipWhitespace(in);
if (*in == '-') neg = true, ++in;
else if (*in == '+') ++in;
if (*in < '0' || *in > '9') reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
while (*in >= '0' && *in <= '9')
val = val*10 + (*in - '0'),
++in;
return neg ? -val : val; }
void printUsage(char** argv)
{
reportf("USAGE: %s [options] <input-file> <result-output-file>\n\n where input may be either in plain or gzipped DIMACS.\n\n", argv[0]);
reportf("OPTIONS:\n\n");
reportf(" -polarity-mode = {true,false,rnd}\n");
reportf(" -decay = <num> [ 0 - 1 ]\n");
reportf(" -rnd-freq = <num> [ 0 - 1 ]\n");
reportf(" -verbosity = {0,1,2}\n");
reportf("\n");
}
void MiniSATP::verifyModel()
{
bool failed = false;
for (int i = 0; i < clauses.size(); i++){
assert(clauses[i]->mark() == 0);
Clause& c = *clauses[i];
for (int j = 0; j < c.size(); j++)
if (modelValue(c[j]) == l_True)
goto next;
reportf("unsatisfied clause: ");
printClause(*clauses[i]);
reportf("\n");
failed = true;
next:;
}
assert(!failed);
// Modified Line
//reportf("Verified %d original clauses.\n", clauses.size());
}
static void parse_DIMACS_main(B& in, Solver& S) {
vec<Lit> lits;
for (;;){
skipWhitespace(in);
if (*in == EOF)
break;
else if (*in == 'p'){
if (match(in, "p cnf")){
int vars = parseInt(in);
int clauses = parseInt(in);
reportf("| Number of variables: %-12d |\n", vars);
reportf("| Number of clauses: %-12d |\n", clauses);
}else{
reportf("PARSE ERROR! Unexpected char: %c\n", *in), exit(3);
}
} else if (*in == 'c' || *in == 'p')
skipLine(in);
else
readClause(in, S, lits),
S.addClause(lits);
}
}
void printStats(SolverStats& stats, double cpu_time)
{
reportf("restarts : %"I64_fmt"\n", stats.starts);
reportf("conflicts : %-12"I64_fmt" (%.0f /sec)\n", stats.conflicts , stats.conflicts /cpu_time);
reportf("decisions : %-12"I64_fmt" (%.0f /sec)\n", stats.decisions , stats.decisions /cpu_time);
reportf("propagations : %-12"I64_fmt" (%.0f /sec)\n", stats.propagations, stats.propagations/cpu_time);
reportf("inspects : %-12"I64_fmt" (%.0f /sec)\n", stats.inspects , stats.inspects /cpu_time);
reportf("conflict literals : %-12"I64_fmt" (%4.2f %% deleted)\n", stats.tot_literals,
(stats.max_literals - stats.tot_literals)*100 / (double)stats.max_literals);
reportf("CPU time : %g s\n", cpu_time);
}
lbool Solver::solve(const vec<Lit>& assumps)
{
//start_time = getRunTime();
model.clear();
conflict.clear();
if (!ok) return false;
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
double nof_learnts = nClauses() * learntsize_factor;
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
bool reached_limit = false;
while (status == l_Undef && !reached_limit){
if (verbosity >= 1)
reportf("| %9d | %7d %8d %8d | %8d %8d %6.0f | %6.3f %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
reached_limit = limitsExpired();
nof_conflicts *= restart_inc;
nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++) model[i] = value(i);
#ifndef NDEBUG
verifyModel();
#endif
}else if(status == l_False) {
//assert(status == l_False);
if (conflict.size() == 0)
ok = false;
} // else {
// // limit reached
// }
//cancelUntil(init_level);
return status; // == l_True;
}
void printStats(Solver& solver)
{
double cpu_time = cpuTime();
uint64_t mem_used = memUsed();
reportf("restarts : %lld\n", solver.starts);
reportf("conflicts : %-12lld (%.0f /sec)\n", solver.conflicts , solver.conflicts /cpu_time);
reportf("decisions : %-12lld (%4.2f %% random) (%.0f /sec)\n", solver.decisions, (float)solver.rnd_decisions*100 / (float)solver.decisions, solver.decisions /cpu_time);
reportf("propagations : %-12lld (%.0f /sec)\n", solver.propagations, solver.propagations/cpu_time);
reportf("conflict literals : %-12lld (%4.2f %% deleted)\n", solver.tot_literals, (solver.max_literals - solver.tot_literals)*100 / (double)solver.max_literals);
if (mem_used != 0) reportf("Memory used : %.2f MB\n", mem_used / 1048576.0);
reportf("CPU time : %g s\n", cpu_time);
}
static void parse_MSZ_parameters(B& in,
unsigned int& nbSolvers,
unsigned int& nbFeatures,
unsigned int& nbInstances,
unsigned int& timeOut,
string*& solversNames,
string*& featuresNames,
string*& instancesNames,
double**& matrix) {
++in;++in;
if ( match(in, "msz") ) {
nbSolvers = parseInt(in);
solversNames=new string [nbSolvers];
nbFeatures = parseInt(in);
featuresNames=new string [nbFeatures];
nbInstances = parseInt(in);
instancesNames=new string [nbInstances];
const int nbCases = nbSolvers+nbFeatures;
matrix=new double* [nbInstances];
for (unsigned int i=0; i<nbInstances; i++)
matrix[i]=new double [nbCases];
timeOut = parseInt(in);
reportf("c Number of solvers: %2d\n", nbSolvers);
reportf("c Number of features: %2d\n", nbFeatures);
reportf("c Number of instances: %2d\n", nbInstances);
reportf("c Timeout: %2d\n", timeOut);
} else if ( match(in, "slv") ) {
reportf("c Solvers:");
for (unsigned int i=0; i<nbSolvers; i++) {
readWord(in,solversNames[i]);
reportf(" %s", solversNames[i].c_str());
}
reportf("\n");
}
else if ( match(in, "ftr") ) {
//reportf("c Features:");
for (unsigned int i=0; i<nbFeatures; i++) {
readWord(in,featuresNames[i]);
//reportf(" %s", featuresNames[i].c_str());
}
//reportf("\n");
}
else reportf("PARSE ERROR! (parse_MSZ) Unexpected params chars: %c %c %c\n", *in, *in, *in), exit(3);
}
static obj_t substring_fn(obj_t args, Reporter rep)
{
string str;
long start, end;
if (!args_match(rep, args, 3, is_string, is_num, is_num))
return unspecific;
str = fetch_string(list_ref(args, 0));
start = fetch_num(list_ref(args, 1));
end = fetch_num(list_ref(args, 2));
if (!(0 <= start && start <= end && end <= (long)str->len)) {
reportf(rep, "substring: invalid range [%d, %d)", start, end);
return unspecific;
}
return make_string(string_from(str->data + start, end - start));
}
lbool Solver::solve(const vec<Lit>& assumps)
{
model.clear();
conflict.clear();
if (!ok) {
return false;
}
assumps.copyTo(assumptions);
double nof_conflicts = restart_first;
double nof_learnts = nClauses() * learntsize_factor;
lbool status = l_Undef;
if (verbosity >= 1){
reportf("============================[ Search Statistics ]==============================\n");
reportf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
reportf("| | Vars Clauses Literals | Limit Clauses Lit/Cl | |\n");
reportf("===============================================================================\n");
}
// Search:
while (status == l_Undef){
if (verbosity >= 1)
reportf("| .%9d. | .%7d. .%8d. .%8d. | .%8d. .%8d. .%6.0f. | .%6.3f. %% |\n", (int)conflicts, order_heap.size(), nClauses(), (int)clauses_literals, (int)nof_learnts, nLearnts(), (double)learnts_literals/nLearnts(), progress_estimate*100), fflush(stdout);
status = search((int)nof_conflicts, (int)nof_learnts);
nof_conflicts *= restart_inc;
nof_learnts *= learntsize_inc;
}
if (verbosity >= 1)
reportf("===============================================================================\n");
if (status == l_True){
// Extend & copy model:
model.growTo(nVars());
for (int i = 0; i < nVars(); i++)
model[i] = value(i);
// printTrail();
#ifdef _DEBUG
verifyModel();
#endif
}else{
if (conflict.size() == 0) {
ok = false;
}
}
// cancelUntil(0);
return status;
}
static bool parse_PB(B& in, S& solver, bool abort_on_error)
{
try{
parseSize(in, solver);
parseGoal(in, solver);
return parseConstrs(in, solver);
}catch (cchar* msg){
if (abort_on_error){
reportf("PARSE ERROR! [line %d] %s\n", in.line, msg);
xfree(msg);
if (opt_satlive && !opt_try)
printf("s UNKNOWN\n");
exit(opt_try ? 5 : 0);
}else
throw msg;
}
}
static obj_t string_ref_fn(obj_t args, Reporter rep)
{
obj_t obj, idx;
long k;
if (!args_match(rep, args, 2, is_string, is_num))
return unspecific;
obj = list_ref(args, 0);
idx = list_ref(args, 1);
k = fetch_num(idx);
if (k < 0 || (size_t)k >= fetch_string(obj)->len) {
reportf(rep, "string-ref: index %ld is out of range", k);
return unspecific;
}
return make_char(fetch_string(obj)->data[k]);
}
