cadical 0.9.0

data/ext/cadical/cadical/src/parse.cpp

@@ -0,0 +1,471 @@
+#include "internal.hpp"
+
+/*------------------------------------------------------------------------*/
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+// Parse error.
+
+#define PER(...) \
+  do { \
+    internal->error_message.init ( \
+        "%s:%" PRIu64 ": parse error: ", file->name (), \
+        (uint64_t) file->lineno ()); \
+    return internal->error_message.append (__VA_ARGS__); \
+  } while (0)
+
+/*------------------------------------------------------------------------*/
+
+// Parsing utilities.
+
+inline int Parser::parse_char () { return file->get (); }
+
+// Return an non zero error string if a parse error occurred.
+
+inline const char *Parser::parse_string (const char *str, char prev) {
+  for (const char *p = str; *p; p++)
+    if (parse_char () == *p)
+      prev = *p;
+    else if (*p == ' ')
+      PER ("expected space after '%c'", prev);
+    else
+      PER ("expected '%c' after '%c'", *p, prev);
+  return 0;
+}
+
+inline const char *Parser::parse_positive_int (int &ch, int &res,
+                                               const char *name) {
+  assert (isdigit (ch));
+  res = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX / 10 < res || INT_MAX - digit < 10 * res)
+      PER ("too large '%s' in header", name);
+    res = 10 * res + digit;
+  }
+  return 0;
+}
+
+inline const char *Parser::parse_positive_uint64_t (int &ch, uint64_t &res,
+                                                    const char *name) {
+  assert (isdigit (ch));
+  res = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (UINT64_MAX / 10 < res || UINT64_MAX - digit < 10 * res)
+      PER ("too large '%s' in header", name);
+    res = 10 * res + digit;
+  }
+  return 0;
+}
+static const char *cube_token = "unexpected 'a' in CNF";
+
+inline const char *Parser::parse_lit (int &ch, int &lit, int &vars,
+                                      int strict) {
+  if (ch == 'a')
+    return cube_token;
+  int sign = 0;
+  if (ch == '-') {
+    if (!isdigit (ch = parse_char ()))
+      PER ("expected digit after '-'");
+    sign = -1;
+  } else if (!isdigit (ch))
+    PER ("expected digit or '-'");
+  else
+    sign = 1;
+  lit = ch - '0';
+  while (isdigit (ch = parse_char ())) {
+    int digit = ch - '0';
+    if (INT_MAX / 10 < lit || INT_MAX - digit < 10 * lit)
+      PER ("literal too large");
+    lit = 10 * lit + digit;
+  }
+  if (ch == '\r')
+    ch = parse_char ();
+  if (ch != 'c' && ch != ' ' && ch != '\t' && ch != '\n' && ch != EOF)
+    PER ("expected white space after '%d'", sign * lit);
+  if (lit > vars) {
+    if (strict != FORCED)
+      PER ("literal %d exceeds maximum variable %d", sign * lit, vars);
+    else
+      vars = lit;
+  }
+  lit *= sign;
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing CNF in DIMACS format.
+
+const char *Parser::parse_dimacs_non_profiled (int &vars, int strict) {
+
+#ifndef QUIET
+  double start = internal->time ();
+#endif
+
+  bool found_inccnf_header = false;
+  int ch = 0, declared = 0;
+  uint64_t clauses = 0;
+
+  vars = 0;
+
+  // First read comments before header with possibly embedded options.
+  //
+  for (;;) {
+    ch = parse_char ();
+    if (strict != STRICT)
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+        continue;
+    if (ch != 'c')
+      break;
+    string buf;
+    while ((ch = parse_char ()) != '\n')
+      if (ch == EOF)
+        PER ("unexpected end-of-file in header comment");
+      else if (ch != '\r')
+        buf.push_back (ch);
+    const char *o;
+    for (o = buf.c_str (); *o && *o != '-'; o++)
+      ;
+    if (!*o)
+      continue;
+    PHASE ("parse-dimacs", "found option '%s'", o);
+    if (*o)
+      solver->set_long_option (o);
+  }
+
+  if (ch != 'p')
+    PER ("expected 'c' or 'p'");
+
+  ch = parse_char ();
+  if (strict == STRICT) {
+    if (ch != ' ')
+      PER ("expected space after 'p'");
+    ch = parse_char ();
+  } else if (ch != ' ' && ch != '\t')
+    PER ("expected white space after 'p'");
+  else {
+    do
+      ch = parse_char ();
+    while (ch == ' ' || ch == '\t');
+  }
+
+  // Now read 'p cnf <var> <clauses>' header of DIMACS file
+  // or 'p inccnf' of incremental 'INCCNF' file.
+  //
+  if (ch == 'c') {
+    assert (!found_inccnf_header);
+    if (strict == STRICT) {
+      const char *err = parse_string ("nf ", 'c');
+      if (err)
+        return err;
+      ch = parse_char ();
+      if (!isdigit (ch))
+        PER ("expected digit after 'p cnf '");
+      err = parse_positive_int (ch, vars, "<max-var>");
+      if (err)
+        return err;
+      if (ch != ' ')
+        PER ("expected ' ' after 'p cnf %d'", vars);
+      if (!isdigit (ch = parse_char ()))
+        PER ("expected digit after 'p cnf %d '", vars);
+      err = parse_positive_uint64_t (ch, clauses, "<num-clauses>");
+      if (err)
+        return err;
+      if (ch != '\n')
+        PER ("expected new-line after 'p cnf %d %" PRIu64 "'", vars,
+             clauses);
+    } else {
+      if (parse_char () != 'n')
+        PER ("expected 'n' after 'p c'");
+      if (parse_char () != 'f')
+        PER ("expected 'f' after 'p cn'");
+      ch = parse_char ();
+      if (!isspace (ch))
+        PER ("expected space after 'p cnf'");
+      do
+        ch = parse_char ();
+      while (isspace (ch));
+      if (!isdigit (ch))
+        PER ("expected digit after 'p cnf '");
+      const char *err = parse_positive_int (ch, vars, "<max-var>");
+      if (err)
+        return err;
+      if (!isspace (ch))
+        PER ("expected space after 'p cnf %d'", vars);
+      do
+        ch = parse_char ();
+      while (isspace (ch));
+      if (!isdigit (ch))
+        PER ("expected digit after 'p cnf %d '", vars);
+      err = parse_positive_uint64_t (ch, clauses, "<num-clauses>");
+      if (err)
+        return err;
+      while (ch != '\n') {
+        if (ch != '\r' && !isspace (ch))
+          PER ("expected new-line after 'p cnf %d %" PRIu64 "'", vars,
+               clauses);
+        ch = parse_char ();
+      }
+    }
+
+    MSG ("found %s'p cnf %d %" PRIu64 "'%s header", tout.green_code (),
+         vars, clauses, tout.normal_code ());
+
+    if (vars) {
+      assert (vars > 0);
+      solver->resize (vars);
+      declared = vars;
+    }
+
+    internal->reserve_ids (clauses);
+
+  } else if (!parse_inccnf_too)
+    PER ("expected 'c' after 'p '");
+  else if (ch == 'i') {
+    found_inccnf_header = true;
+    const char *err = parse_string ("nccnf", 'i');
+    if (err)
+      return err;
+    ch = parse_char ();
+    if (strict == STRICT) {
+      if (ch != '\n')
+        PER ("expected new-line after 'p inccnf'");
+    } else {
+      while (ch != '\n') {
+        if (ch != '\r' && !isspace (ch))
+          PER ("expected new-line after 'p inccnf'");
+        ch = parse_char ();
+      }
+    }
+
+    MSG ("found %s'p inccnf'%s header", tout.green_code (),
+         tout.normal_code ());
+
+    // Cube & Conquer 'inccnf' format is not compatible with factor:
+    internal->opts.factor = 0;
+
+    strict = FORCED;
+  } else
+    PER ("expected 'c' or 'i' after 'p '");
+
+  if (parse_inccnf_too)
+    *parse_inccnf_too = false;
+
+  // Now read body of DIMACS part.
+  //
+  int lit = 0;
+  uint64_t parsed = 0;
+  while ((ch = parse_char ()) != EOF) {
+    if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+      continue;
+    if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n' && ch != EOF)
+        ;
+      if (ch == EOF)
+        break;
+      continue;
+    }
+    if (ch == 'a' && found_inccnf_header)
+      break;
+    const char *err = parse_lit (ch, lit, vars, strict);
+    if (err)
+      return err;
+    if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF)
+          PER ("unexpected end-of-file in comment");
+    }
+    if (vars > declared) {
+      assert (strict == FORCED);
+      const int more_vars = vars - declared;
+      assert (more_vars > 0);
+      const int start = solver->declare_more_variables (more_vars);
+      assert (vars == start + more_vars - 1);
+      declared = vars;
+#ifdef NDEBUG
+      (void) start;
+#endif
+    }
+    solver->add (lit);
+    if (!found_inccnf_header && !lit && parsed++ >= clauses &&
+        strict != FORCED)
+      PER ("too many clauses");
+  }
+
+  if (lit)
+    PER ("last clause without terminating '0'");
+
+  if (!found_inccnf_header && parsed < clauses && strict != FORCED)
+    PER ("clause missing");
+
+#ifndef QUIET
+  double end = internal->time ();
+  MSG ("parsed %" PRIu64 " clauses in %.2f seconds %s time", parsed,
+       end - start, internal->opts.realtime ? "real" : "process");
+#endif
+
+#ifndef QUIET
+  start = end;
+  size_t num_cubes = 0;
+#endif
+  if (ch == 'a') {
+    assert (parse_inccnf_too);
+    assert (found_inccnf_header);
+    if (!*parse_inccnf_too)
+      *parse_inccnf_too = true;
+    for (;;) {
+      ch = parse_char ();
+      if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+        continue;
+      if (ch == 'c') {
+        while ((ch = parse_char ()) != '\n' && ch != EOF)
+          ;
+        if (ch == EOF)
+          break;
+        continue;
+      }
+      const char *err = parse_lit (ch, lit, vars, strict);
+      if (err == cube_token)
+        PER ("two 'a' in a row");
+      else if (err)
+        return err;
+      if (ch == 'c') {
+        while ((ch = parse_char ()) != '\n')
+          if (ch == EOF)
+            PER ("unexpected end-of-file in comment");
+      }
+      if (cubes)
+        cubes->push_back (lit);
+      if (!lit) {
+#ifndef QUIET
+        num_cubes++;
+#endif
+        for (;;) {
+          ch = parse_char ();
+          if (ch == ' ' || ch == '\n' || ch == '\t' || ch == '\r')
+            continue;
+          if (ch == 'c') {
+            while ((ch = parse_char ()) != '\n' && ch != EOF)
+              ;
+            if (ch == EOF)
+              break;
+          }
+          if (ch == EOF)
+            break;
+          if (ch != 'a')
+            PER ("expected 'a' or end-of-file after zero");
+          lit = INT_MIN;
+          break;
+        }
+        if (ch == EOF)
+          break;
+      }
+    }
+    if (lit)
+      PER ("last cube without terminating '0'");
+  }
+#ifndef QUIET
+  if (found_inccnf_header) {
+    double end = internal->time ();
+    MSG ("parsed %zd cubes in %.2f seconds %s time", num_cubes, end - start,
+         internal->opts.realtime ? "real" : "process");
+  }
+#endif
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Parsing solution in competition output format.
+
+const char *Parser::parse_solution_non_profiled () {
+  external->solution = new signed char[external->max_var + 1u];
+  external->solution_size = external->max_var;
+  clear_n (external->solution, external->max_var + 1u);
+  int ch;
+  for (;;) {
+    ch = parse_char ();
+    if (ch == EOF)
+      PER ("missing 's' line");
+    else if (ch == 'c') {
+      while ((ch = parse_char ()) != '\n')
+        if (ch == EOF)
+          PER ("unexpected end-of-file in comment");
+    } else if (ch == 's')
+      break;
+    else
+      PER ("expected 'c' or 's'");
+  }
+  const char *err = parse_string (" SATISFIABLE", 's');
+  if (err)
+    return err;
+  if ((ch = parse_char ()) == '\r')
+    ch = parse_char ();
+  if (ch != '\n')
+    PER ("expected new-line after 's SATISFIABLE'");
+#ifndef QUIET
+  int count = 0;
+#endif
+  for (;;) {
+    ch = parse_char ();
+    if (ch != 'v')
+      PER ("expected 'v' at start-of-line");
+    if ((ch = parse_char ()) != ' ')
+      PER ("expected ' ' after 'v'");
+    int lit = 0;
+    ch = parse_char ();
+    do {
+      if (ch == ' ' || ch == '\t') {
+        ch = parse_char ();
+        continue;
+      }
+      err = parse_lit (ch, lit, external->max_var, false);
+      if (err)
+        return err;
+      if (ch == 'c')
+        PER ("unexpected comment");
+      if (!lit)
+        break;
+      if (external->solution[abs (lit)])
+        PER ("variable %d occurs twice", abs (lit));
+      LOG ("solution %d", lit);
+      external->solution[abs (lit)] = sign (lit);
+#ifndef QUIET
+      count++;
+#endif
+      if (ch == '\r')
+        ch = parse_char ();
+    } while (ch != '\n');
+    if (!lit)
+      break;
+  }
+  MSG ("parsed %d values %.2f%%", count,
+       percent (count, external->max_var));
+  return 0;
+}
+
+/*------------------------------------------------------------------------*/
+
+// Wrappers to profile parsing and at the same time use the convenient
+// implicit 'return' in PER in the non-profiled versions.
+
+const char *Parser::parse_dimacs (int &vars, int strict) {
+  assert (strict == FORCED || strict == RELAXED || strict == STRICT);
+  START (parse);
+  const char *err = parse_dimacs_non_profiled (vars, strict);
+  STOP (parse);
+  return err;
+}
+
+const char *Parser::parse_solution () {
+  START (parse);
+  const char *err = parse_solution_non_profiled ();
+  STOP (parse);
+  return err;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/parse.hpp

@@ -0,0 +1,75 @@
+#ifndef _parse_hpp_INCLUDED
+#define _parse_hpp_INCLUDED
+
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+namespace CaDiCaL {
+
+// Factors out common functions for parsing of DIMACS and solution files.
+
+class File;
+struct External;
+struct Internal;
+
+class Parser {
+
+  Solver *solver;
+  Internal *internal;
+  External *external;
+  File *file;
+
+  void perr (const char *fmt, ...) CADICAL_ATTRIBUTE_FORMAT (2, 3);
+  int parse_char ();
+
+  enum {
+    FORCED = 0,  // Force reading even if header is broken.
+    RELAXED = 1, // Relaxed white space treatment in header.
+    STRICT = 2,  // Strict white space and header compliance.
+  };
+
+  const char *parse_string (const char *str, char prev);
+  const char *parse_positive_int (int &ch, int &res, const char *name);
+  const char *parse_positive_uint64_t (int &ch, uint64_t &res,
+                                       const char *name);
+  const char *parse_lit (int &ch, int &lit, int &vars, int strict);
+  const char *parse_dimacs_non_profiled (int &vars, int strict);
+  const char *parse_solution_non_profiled ();
+
+  bool *parse_inccnf_too;
+  vector<int> *cubes;
+
+public:
+  // Parse a DIMACS CNF or ICNF file.
+  //
+  // Return zero if successful. Otherwise parse error.
+  Parser (Solver *s, File *f, bool *i, vector<int> *c)
+      : solver (s), internal (s->internal), external (s->external),
+        file (f), parse_inccnf_too (i), cubes (c) {}
+
+  // Parse a DIMACS file.  Return zero if successful. Otherwise a parse
+  // error is return. The parsed clauses are added to the solver and the
+  // maximum variable index found is returned in the 'vars' argument. The
+  // 'strict' argument can be '0' in which case the numbers in the header
+  // can be arbitrary, e.g., 'p cnf 0 0' all the time, without producing a
+  // parse error.  Only for this setting the parsed literals are not checked
+  // to overflow the maximum variable index of the header.  The strictest
+  // form of parsing is enforced  for the value '2' of 'strict', in which
+  // case the header can not have additional white space, while a value of
+  // '1' exactly relaxes this, e.g., 'p cnf \t  1   3  \r\n' becomes legal.
+  //
+  const char *parse_dimacs (int &vars, int strict);
+
+  // Parse a solution file as used in the SAT competition, e.g., with
+  // comment lines 'c ...', a status line 's ...' and value lines 'v ...'.
+  // Returns zero if successful. Otherwise a string is returned describing
+  // the parse error.  The parsed solution is saved in 'solution' and can be
+  // accessed with 'sol (int lit)'.  We use it for checking learned clauses.
+  //
+  const char *parse_solution ();
+};
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/phases.cpp

@@ -0,0 +1,56 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::copy_phases (vector<signed char> &dst) {
+  START (copy);
+  for (auto i : vars) {
+    const signed char tmp = phases.saved[i];
+    if (tmp)
+      dst[i] = tmp;
+  }
+  STOP (copy);
+}
+
+void Internal::save_assigned_phases (vector<signed char> &dst) {
+  START (copy);
+  for (auto i : vars) {
+    if (vals[i])
+      dst[i] = vals[i];
+  }
+  STOP (copy);
+}
+
+void Internal::clear_phases (vector<signed char> &dst) {
+  START (copy);
+  for (auto i : vars)
+    dst[i] = 0;
+  STOP (copy);
+}
+
+void Internal::phase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  signed char new_forced_phase = sign (lit);
+  if (old_forced_phase == new_forced_phase) {
+    LOG ("forced phase remains at %d", old_forced_phase * idx);
+    return;
+  }
+  if (old_forced_phase)
+    LOG ("overwriting old forced phase %d", old_forced_phase * idx);
+  LOG ("new forced phase %d", new_forced_phase * idx);
+  phases.forced[idx] = new_forced_phase;
+}
+
+void Internal::unphase (int lit) {
+  const int idx = vidx (lit);
+  signed char old_forced_phase = phases.forced[idx];
+  if (!old_forced_phase) {
+    LOG ("forced phase of %d already reset", lit);
+    return;
+  }
+  LOG ("clearing old forced phase %d", old_forced_phase * idx);
+  phases.forced[idx] = 0;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/phases.hpp

@@ -0,0 +1,19 @@
+#ifndef _phases_hpp_INCLUDED
+#define _phases_hpp_INCLUDED
+
+#include <vector>
+
+namespace CaDiCaL {
+
+struct Phases {
+
+  std::vector<signed char> best;   // The current largest trail phase.
+  std::vector<signed char> forced; // Forced through 'phase'.
+  std::vector<signed char> prev;   // Previous during local search.
+  std::vector<signed char> saved;  // The actual saved phase.
+  std::vector<signed char> target; // The current target phase.
+};
+
+} // namespace CaDiCaL
+
+#endif