cadical 0.9.0

data/ext/cadical/cadical/src/constrain.cpp

@@ -0,0 +1,64 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::constrain (int lit) {
+  if (lit)
+    constraint.push_back (lit);
+  else {
+    if (level)
+      backtrack ();
+    LOG (constraint, "shrinking constraint");
+    bool satisfied_constraint = false;
+    const vector<int>::const_iterator end = constraint.end ();
+    vector<int>::iterator i = constraint.begin ();
+    for (vector<int>::const_iterator j = i; j != end; j++) {
+      int tmp = marked (*j);
+      if (tmp > 0) {
+        LOG ("removing duplicated literal %d from constraint", *j);
+      } else if (tmp < 0) {
+        LOG ("tautological since both %d and %d occur in constraint", -*j,
+             *j);
+        satisfied_constraint = true;
+        break;
+      } else {
+        tmp = val (*j);
+        if (tmp < 0) {
+          LOG ("removing falsified literal %d from constraint clause", *j);
+        } else if (tmp > 0) {
+          LOG ("satisfied constraint with literal %d", *j);
+          satisfied_constraint = true;
+          break;
+        } else {
+          *i++ = *j;
+          mark (*j);
+        }
+      }
+    }
+    constraint.resize (i - constraint.begin ());
+    for (const auto &lit : constraint)
+      unmark (lit);
+    if (satisfied_constraint)
+      constraint.clear ();
+    else if (constraint.empty ()) {
+      unsat_constraint = true;
+      if (!conflict_id)
+        marked_failed = false; // allow to trigger failing ()
+    } else
+      for (const auto lit : constraint)
+        freeze (lit);
+  }
+}
+
+bool Internal::failed_constraint () { return unsat_constraint; }
+
+void Internal::reset_constraint () {
+  for (auto lit : constraint)
+    melt (lit);
+  LOG ("cleared %zd constraint literals", constraint.size ());
+  constraint.clear ();
+  unsat_constraint = false;
+  marked_failed = true;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/contract.cpp

@@ -0,0 +1,27 @@
+#ifndef NCONTRACTS
+
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void fatal_message_start ();
+
+// See comments in 'contract.hpp'. Ugly hack we keep for now.
+
+void require_solver_pointer_to_be_non_zero (const void *ptr,
+                                            const char *function_name,
+                                            const char *file_name) {
+  if (ptr)
+    return;
+  fatal_message_start ();
+  fprintf (stderr,
+           "invalid API usage of '%s' in '%s': "
+           "solver 'this' pointer zero (not initialized)\n",
+           function_name, file_name);
+  fflush (stderr);
+  abort ();
+}
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/contract.hpp

@@ -0,0 +1,139 @@
+#ifndef _contract_hpp_INCLUDED
+#define _contract_hpp_INCLUDED
+
+/*------------------------------------------------------------------------*/
+#ifndef NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+// If the user violates API contracts while calling functions declared in
+// 'cadical.hpp' and implemented in 'solver.cpp' then an error is reported.
+// Currently we also force aborting the program.  In the future it might be
+// better to allow the user to provide a call back function, which then can
+// for instance throw a C++ exception or execute a 'longjmp' in 'C' etc.
+
+#define CONTRACT_VIOLATED(...) \
+  do { \
+    fatal_message_start (); \
+    fprintf (stderr, \
+             "invalid API usage of '%s' in '%s': ", __PRETTY_FUNCTION__, \
+             __FILE__); \
+    fprintf (stderr, __VA_ARGS__); \
+    fputc ('\n', stderr); \
+    fflush (stderr); \
+    abort (); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+// It would be much easier to just write 'REQUIRE (this, "not initialized")'
+// which however produces warnings due to the '-Wnonnull' check. Note, that
+// 'this' is always assumed to be non zero in modern C++.  Much worse, if we
+// use instead 'this != 0' or something similar like 'this != nullptr' then
+// optimization silently removes this check ('gcc-7.4.0' at least) even
+// though of course a zero pointer might be used as 'this' if the user did
+// not initialize it.  The only solution I found is to disable optimization
+// for this check. It does not seem to be necessary for 'clang++' though
+// ('clang++-6.0.0' at least).  The alternative is to not check that the
+// user forgot to initialize the solver pointer, but as long this works we
+// keep this ugly hack. It also forces the function not to be inlined.
+// The actual code I is in 'contract.cpp'.
+//
+void require_solver_pointer_to_be_non_zero (const void *ptr,
+                                            const char *function_name,
+                                            const char *file_name);
+#define REQUIRE_NON_ZERO_THIS() \
+  do { \
+    require_solver_pointer_to_be_non_zero (this, __PRETTY_FUNCTION__, \
+                                           __FILE__); \
+  } while (0)
+
+} // namespace CaDiCaL
+
+/*------------------------------------------------------------------------*/
+
+// These are common shortcuts for 'Solver' API contracts (requirements).
+
+#define REQUIRE(COND, ...) \
+  do { \
+    if ((COND)) \
+      break; \
+    CONTRACT_VIOLATED (__VA_ARGS__); \
+  } while (0)
+
+#define REQUIRE_INITIALIZED() \
+  do { \
+    REQUIRE_NON_ZERO_THIS (); \
+    REQUIRE (external, "external solver not initialized"); \
+    REQUIRE (internal, "internal solver not initialized"); \
+  } while (0)
+
+#define REQUIRE_VALID_STATE() \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    REQUIRE (this->state () & VALID, "solver in invalid state"); \
+  } while (0)
+
+#define REQUIRE_READY_STATE() \
+  do { \
+    REQUIRE_VALID_STATE (); \
+    REQUIRE (state () != ADDING, \
+             "clause incomplete (terminating zero not added)"); \
+  } while (0)
+
+#define REQUIRE_VALID_OR_SOLVING_STATE() \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    REQUIRE (this->state () & (VALID | SOLVING), \
+             "solver neither in valid nor solving state"); \
+  } while (0)
+
+#define REQUIRE_VALID_LIT(LIT) \
+  do { \
+    REQUIRE ((int) (LIT) && ((int) (LIT)) != INT_MIN, \
+             "invalid literal '%d'", (int) (LIT)); \
+    REQUIRE (external->is_valid_input ((int) (LIT)), \
+             "extension variable '%d' defined by the solver internally " \
+             "(all user variables have to be declared explicitly " \
+             "if 'factor' is enabled)", /* TODO only reason? */ \
+             (int) abs (LIT)); \
+  } while (0)
+
+#define REQUIRE_STEADY_STATE() \
+  do { \
+    REQUIRE_INITIALIZED (); \
+    REQUIRE (this->state () & STEADY, "solver is not in steady state"); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#else // NCONTRACTS
+/*------------------------------------------------------------------------*/
+
+#define REQUIRE(...) \
+  do { \
+  } while (0)
+#define REQUIRE_INITIALIZED() \
+  do { \
+  } while (0)
+#define REQUIRE_VALID_STATE() \
+  do { \
+  } while (0)
+#define REQUIRE_READY_STATE() \
+  do { \
+  } while (0)
+#define REQUIRE_VALID_OR_SOLVING_STATE() \
+  do { \
+  } while (0)
+#define REQUIRE_VALID_LIT(...) \
+  do { \
+  } while (0)
+#define REQUIRE_STEADY_STATE() \
+  do { \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+#endif
+/*------------------------------------------------------------------------*/
+
+#endif