| /*------------------------------------------------------------------------*/ | |
| // Do include 'internal.hpp' but try to minimize internal dependencies. | |
| #include "internal.hpp" | |
| #include "signal.hpp" // Separate, only need for apps. | |
| /*------------------------------------------------------------------------*/ | |
| namespace CaDiCaL { | |
| // A wrapper app which makes up the CaDiCaL stand alone solver. It in | |
| // essence only consists of the 'App::main' function. So this class | |
| // contains code, which is not required if only the library interface in | |
| // the class 'Solver' is used (defined in 'cadical.hpp'). It further uses | |
| // static data structures in order to have a signal handler catch signals. | |
| // | |
| // It is thus neither thread-safe nor reentrant. If you want to use | |
| // multiple instances of the solver use the 'Solver' interface directly | |
| // which is thread-safe and reentrant among different solver instances. | |
| /*------------------------------------------------------------------------*/ | |
| class App : public Handler { | |
| Solver *solver; // Global solver. | |
| #ifndef _WIN32 | |
| // Command line options. | |
| // | |
| int time_limit; // '-t <sec>' | |
| #endif | |
| // Strictness of (DIMACS) parsing: | |
| // | |
| // 0 = force parsing and completely ignore header | |
| // 1 = relaxed header handling (default) | |
| // 2 = strict header handling | |
| // | |
| // To use '0' use '-f' of '--force'. | |
| // To use '2' use '--strict'. | |
| // | |
| int force_strict_parsing; | |
| bool force_writing; | |
| static bool most_likely_existing_cnf_file (const char *path); | |
| // Internal variables. | |
| // | |
| int max_var; // Set after parsing. | |
| volatile sig_atomic_t signal_value; // Caught signal. | |
| // Printing. | |
| // | |
| void print_usage (bool all = false); | |
| void print_witness (FILE *); | |
| #ifndef QUIET | |
| void signal_message (const char *msg, int sig); | |
| #endif | |
| // Option handling. | |
| // | |
| bool set (const char *); | |
| bool set (const char *, int); | |
| int get (const char *); | |
| bool verbose () { return get ("verbose") && !get ("quiet"); } | |
| /*----------------------------------------------------------------------*/ | |
| // The actual initialization. | |
| // | |
| void init (); | |
| // Handler interface. | |
| // | |
| void catch_signal (int sig); | |
| void catch_alarm (); | |
| public: | |
| App (); | |
| ~App (); | |
| // Parse the arguments and run the solver. | |
| // | |
| int main (int arg, char **argv); | |
| }; | |
| /*------------------------------------------------------------------------*/ | |
| // clang-format off | |
| void App::print_usage (bool all) { | |
| printf ( | |
| "usage: cadical [ <option> ... ] [ <input> [ <proof> ] ]\n" | |
| "\n" | |
| "where '<option>' is one of the following common options:\n" | |
| "\n" | |
| ); | |
| if (!all) { // Print only a short list of common options. | |
| printf ( | |
| " -h print this short list of common options\n" | |
| " --help print complete list of all options\n" | |
| " --version print version\n" | |
| "\n" | |
| " -n do not print witness\n" | |
| #ifndef QUIET | |
| " -v increase verbosity\n" | |
| " -q be quiet\n" | |
| #endif | |
| "\n" | |
| #ifndef _WIN32 | |
| " -t <sec> set wall clock time limit\n" | |
| #endif | |
| ); | |
| } else { // Print complete list of all options. | |
| printf ( | |
| " -h print alternatively only a list of common options\n" | |
| " --help print this complete list of all options\n" | |
| " --version print version\n" | |
| "\n" | |
| " -n do not print witness (same as '--no-witness')\n" | |
| #ifndef QUIET | |
| " -v increase verbosity (see also '--verbose' below)\n" | |
| " -q be quiet (same as '--quiet')\n" | |
| #endif | |
| #ifndef _WIN32 | |
| " -t <sec> set wall clock time limit\n" | |
| #endif | |
| "\n" | |
| "Or '<option>' is one of the less common options\n" | |
| "\n" | |
| " -L<rounds> run local search initially (default '0' rounds)\n" | |
| " -O<level> increase limits by '2^<level>' or '10^<level>'\n" | |
| " -P<rounds> initial preprocessing (default '0' rounds)\n" | |
| "\n" | |
| "Note there is no separating space for the options above while the\n" | |
| "following options require a space after the option name:\n" | |
| "\n" | |
| " -c <limit> limit the number of conflicts (default unlimited)\n" | |
| " -d <limit> limit the number of decisions (default unlimited)\n" | |
| "\n" | |
| " -o <output> write simplified CNF in DIMACS format to file\n" | |
| " -e <extend> write reconstruction/extension stack to file\n" | |
| #ifdef LOGGING | |
| " -l enable logging messages (same as '--log')\n" | |
| #endif | |
| "\n" | |
| " --force | -f parsing broken DIMACS header and writing proofs\n" | |
| " --strict strict parsing (no white space in header)\n" | |
| "\n" | |
| " -r <sol> read solution in competition output format\n" | |
| " to check consistency of learned clauses\n" | |
| " during testing and debugging\n" | |
| "\n" | |
| " -w <sol> write result including a potential witness\n" | |
| " solution in competition format to the given " | |
| "file\n" | |
| "\n" | |
| " --colors force colored output\n" | |
| " --no-colors disable colored output to terminal\n" | |
| " --no-witness do not print witness (see also '-n' above)\n" | |
| "\n" | |
| " --build print build configuration\n" | |
| " --copyright print copyright information\n"); | |
| printf ( | |
| "\n" | |
| "There are pre-defined configurations of advanced internal options:\n" | |
| "\n" | |
| ); | |
| solver->configurations (); | |
| printf ( | |
| "\n" | |
| "Or '<option>' is one of the following advanced internal options:\n" | |
| "\n" | |
| ); | |
| solver->usage (); | |
| printf ( | |
| "\n" | |
| "The internal options have their default value printed in brackets\n" | |
| "after their description. They can also be used in the form\n" | |
| "'--<name>' which is equivalent to '--<name>=1' and in the form\n" | |
| "'--no-<name>' which is equivalent to '--<name>=0'. One can also\n" | |
| "use 'true' instead of '1', 'false' instead of '0', as well as\n" | |
| "numbers with positive exponent such as '1e3' instead of '1000'.\n" | |
| "\n" | |
| "Alternatively option values can also be specified in the header\n" | |
| "of the DIMACS file, e.g., 'c --elim=false', or through environment\n" | |
| "variables, such as 'CADICAL_ELIM=false'. The embedded options in\n" | |
| "the DIMACS file have highest priority, followed by command line\n" | |
| "options and then values specified through environment variables.\n" | |
| ); | |
| } | |
| //------------------------------------------------------------------------ | |
| // Common to both complete and common option usage. | |
| printf ( | |
| "\n" | |
| "The input is read from '<input>' assumed to be in DIMACS format.\n" | |
| "Incremental 'p inccnf' files are supported too with cubes at the end.\n" | |
| "If '<proof>' is given then a DRAT proof is written to that file.\n" | |
| ); | |
| //------------------------------------------------------------------------ | |
| // More explanations for complete option usage. | |
| if (all) { | |
| printf ( | |
| "\n" | |
| "If '<input>' is missing then the solver reads from '<stdin>',\n" | |
| "also if '-' is used as input path name '<input>'. Similarly,\n" | |
| "\n" | |
| "For incremental files each cube is solved in turn. The solver\n" | |
| "stops at the first satisfied cube if there is one and uses that\n" | |
| "one for the witness to print. Conflict and decision limits are\n" | |
| "applied to each individual cube solving call while '-P', '-L'" | |
| #ifdef _WIN32 | |
| "\n" | |
| #else | |
| " and\n" | |
| "'-t' " | |
| #endif | |
| "remain global. Only if all cubes were unsatisfiable the solver\n" | |
| "prints the standard unsatisfiable solution line ('s UNSATISFIABLE').\n" | |
| "\n" | |
| "By default the proof is stored in the binary DRAT format unless\n" | |
| "the option '--no-binary' is specified or the proof is written\n" | |
| "to '<stdout>' and '<stdout>' is connected to a terminal.\n" | |
| "\n" | |
| "The input is assumed to be compressed if it is given explicitly\n" | |
| "and has a '.gz', '.bz2', '.xz' or '.7z' suffix. The same applies\n" | |
| "to the output file. In order to use compression and decompression\n" | |
| "the corresponding utilities 'gzip', 'bzip', 'xz', and '7z' (depending\n" | |
| "on the format) are required and need to be installed on the system.\n" | |
| "The solver checks file type signatures though and falls back to\n" | |
| "non-compressed file reading if the signature does not match.\n" | |
| ); | |
| } | |
| } | |
| // clang-format on | |
| /*------------------------------------------------------------------------*/ | |
| // Pretty print competition format witness with 'v' lines. | |
| void App::print_witness (FILE *file) { | |
| int c = 0, tmp = 0; | |
| if (solver->internal->opts.modelalllits) { | |
| for (auto elit = 1; elit <= solver->external->max_var; ++elit) { | |
| if (!c) | |
| fputc ('v', file), c = 1; | |
| if (solver->external->ervars[elit]) | |
| tmp = elit; | |
| else | |
| tmp = solver->val (elit) < 0 ? -elit : elit; | |
| if (signal_value) | |
| break; | |
| char str[32]; | |
| snprintf (str, sizeof str, " %d", tmp); | |
| int l = strlen (str); | |
| if (c + l > 78) | |
| fputs ("\nv", file), c = 1; | |
| fputs (str, file); | |
| c += l; | |
| } | |
| } else { | |
| if (solver->external->e2i.use_hash_map) { | |
| for (auto eilit : solver->external->e2i.h_e2i) { | |
| const int elit = eilit.first; | |
| if (!c) | |
| fputc ('v', file), c = 1; | |
| if (!elit) // the hash-table can contain stall entries | |
| continue; | |
| assert (elit); | |
| if (solver->external->ervars[elit]) | |
| continue; | |
| else | |
| tmp = solver->val (elit) < 0 ? -elit : elit; | |
| solver->internal->terminated_asynchronously (); | |
| char str[32]; | |
| snprintf (str, sizeof str, " %d", tmp); | |
| int l = strlen (str); | |
| if (c + l > 78) | |
| fputs ("\nv", file), c = 1; | |
| fputs (str, file); | |
| c += l; | |
| } | |
| } else { | |
| for (size_t i = 1; i < solver->external->e2i.vec_e2i.table.size (); | |
| ++i) { | |
| auto eilit = std::pair<int, int> (i, solver->external->e2i[i]); | |
| const int elit = eilit.first; | |
| if (!c) | |
| fputc ('v', file), c = 1; | |
| assert (elit); | |
| if (solver->external->ervars[elit]) | |
| continue; | |
| else | |
| tmp = solver->val (elit) < 0 ? -elit : elit; | |
| solver->internal->terminated_asynchronously (); | |
| char str[32]; | |
| snprintf (str, sizeof str, " %d", tmp); | |
| int l = strlen (str); | |
| if (c + l > 78) | |
| fputs ("\nv", file), c = 1; | |
| fputs (str, file); | |
| c += l; | |
| } | |
| } | |
| } | |
| if (c) | |
| fputs (" 0\n", file); | |
| } | |
| /*------------------------------------------------------------------------*/ | |
| // Wrapper around option setting. | |
| int App::get (const char *o) { return solver->get (o); } | |
| bool App::set (const char *o, int v) { return solver->set (o, v); } | |
| bool App::set (const char *arg) { return solver->set_long_option (arg); } | |
| /*------------------------------------------------------------------------*/ | |
| bool App::most_likely_existing_cnf_file (const char *path) { | |
| if (!File::exists (path)) | |
| return false; | |
| if (has_suffix (path, ".dimacs")) | |
| return true; | |
| if (has_suffix (path, ".dimacs.gz")) | |
| return true; | |
| if (has_suffix (path, ".dimacs.xz")) | |
| return true; | |
| if (has_suffix (path, ".dimacs.bz2")) | |
| return true; | |
| if (has_suffix (path, ".dimacs.7z")) | |
| return true; | |
| if (has_suffix (path, ".dimacs.lzma")) | |
| return true; | |
| if (has_suffix (path, ".cnf")) | |
| return true; | |
| if (has_suffix (path, ".cnf.gz")) | |
| return true; | |
| if (has_suffix (path, ".cnf.xz")) | |
| return true; | |
| if (has_suffix (path, ".cnf.bz2")) | |
| return true; | |
| if (has_suffix (path, ".cnf.7z")) | |
| return true; | |
| if (has_suffix (path, ".cnf.lzma")) | |
| return true; | |
| return false; | |
| } | |
| /*------------------------------------------------------------------------*/ | |
| // Short-cut for errors to avoid a hard 'exit'. | |
| #define APPERR(...) \ | |
| do { \ | |
| solver->error (__VA_ARGS__); \ | |
| } while (0) | |
| /*------------------------------------------------------------------------*/ | |
| int App::main (int argc, char **argv) { | |
| // Handle options which lead to immediate exit first. | |
| if (argc == 2) { | |
| const char *arg = argv[1]; | |
| if (!strcmp (arg, "-h")) { | |
| print_usage (); | |
| return 0; | |
| } else if (!strcmp (arg, "--help")) { | |
| print_usage (true); | |
| return 0; | |
| } else if (!strcmp (arg, "--version")) { | |
| printf ("%s\n", CaDiCaL::version ()); | |
| return 0; | |
| } else if (!strcmp (arg, "--build")) { | |
| tout.disable (); | |
| Solver::build (stdout, ""); | |
| return 0; | |
| } else if (!strcmp (arg, "--copyright")) { | |
| printf ("%s\n", copyright ()); | |
| printf ("%s\n", authors ()); | |
| printf ("%s\n", affiliations ()); | |
| return 0; | |
| } | |
| } | |
| // Now initialize solver. | |
| init (); | |
| // Set all argument option values to not used yet. | |
| const char *preprocessing_specified = 0, *optimization_specified = 0; | |
| const char *read_solution_path = 0, *write_result_path = 0; | |
| const char *dimacs_path = 0, *proof_path = 0; | |
| bool proof_specified = false, dimacs_specified = false; | |
| int optimize = 0, preprocessing = 0, localsearch = 0; | |
| const char *output_path = 0, *extension_path = 0; | |
| int conflict_limit = -1, decision_limit = -1; | |
| const char *conflict_limit_specified = 0; | |
| const char *decision_limit_specified = 0; | |
| const char *localsearch_specified = 0; | |
| #ifndef __MINGW32__ | |
| const char *time_limit_specified = 0; | |
| #endif | |
| bool witness = true, less = false, status = true; | |
| const char *dimacs_name, *err; | |
| for (int i = 1; i < argc; i++) { | |
| if (!strcmp (argv[i], "-h") || !strcmp (argv[i], "--help") || | |
| !strcmp (argv[i], "--build") || !strcmp (argv[i], "--version") || | |
| !strcmp (argv[i], "--copyright")) { | |
| if (!strcmp (argv[i], "-h")) { | |
| print_usage (); | |
| return 0; | |
| } else if (!strcmp (argv[i], "--help")) { | |
| print_usage (true); | |
| return 0; | |
| } else if (!strcmp (argv[i], "--version")) { | |
| printf ("%s\n", CaDiCaL::version ()); | |
| return 0; | |
| } else if (!strcmp (argv[i], "--build")) { | |
| tout.disable (); | |
| Solver::build (stdout, ""); | |
| return 0; | |
| } else if (!strcmp (argv[i], "--copyright")) { | |
| printf ("%s\n", copyright ()); | |
| printf ("%s\n", authors ()); | |
| printf ("%s\n", affiliations ()); | |
| return 0; | |
| } | |
| APPERR ("can only use '%s' as single first option", argv[i]); | |
| } else if (!strcmp (argv[i], "-")) { | |
| if (proof_specified) | |
| APPERR ("too many arguments"); | |
| else if (!dimacs_specified) | |
| dimacs_specified = true; | |
| else | |
| proof_specified = true; | |
| } else if (!strcmp (argv[i], "-r")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-r' missing"); | |
| else if (read_solution_path) | |
| APPERR ("multiple read solution file options '-r %s' and '-r %s'", | |
| read_solution_path, argv[i]); | |
| else | |
| read_solution_path = argv[i]; | |
| } else if (!strcmp (argv[i], "-w")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-w' missing"); | |
| else if (write_result_path) | |
| APPERR ("multiple solution file options '-w %s' and '-w %s'", | |
| write_result_path, argv[i]); | |
| else | |
| write_result_path = argv[i]; | |
| } else if (!strcmp (argv[i], "-o")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-o' missing"); | |
| else if (output_path) | |
| APPERR ("multiple output file options '-o %s' and '-o %s'", | |
| output_path, argv[i]); | |
| else if (!force_writing && most_likely_existing_cnf_file (argv[i])) | |
| APPERR ("output file '%s' most likely existing CNF (use '-f')", | |
| argv[i]); | |
| else if (!File::writable (argv[i])) | |
| APPERR ("output file '%s' not writable", argv[i]); | |
| else | |
| output_path = argv[i]; | |
| } else if (!strcmp (argv[i], "-e")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-e' missing"); | |
| else if (extension_path) | |
| APPERR ("multiple extension file options '-e %s' and '-e %s'", | |
| extension_path, argv[i]); | |
| else if (!force_writing && most_likely_existing_cnf_file (argv[i])) | |
| APPERR ("extension file '%s' most likely existing CNF (use '-f')", | |
| argv[i]); | |
| else if (!File::writable (argv[i])) | |
| APPERR ("extension file '%s' not writable", argv[i]); | |
| else | |
| extension_path = argv[i]; | |
| } else if (is_color_option (argv[i])) { | |
| tout.force_colors (); | |
| terr.force_colors (); | |
| } else if (is_no_color_option (argv[i])) { | |
| tout.force_no_colors (); | |
| terr.force_no_colors (); | |
| } else if (!strcmp (argv[i], "--witness") || | |
| !strcmp (argv[i], "--witness=true") || | |
| !strcmp (argv[i], "--witness=1")) | |
| witness = true; | |
| else if (!strcmp (argv[i], "-n") || !strcmp (argv[i], "--no-witness") || | |
| !strcmp (argv[i], "--witness=false") || | |
| !strcmp (argv[i], "--witness=0")) | |
| witness = false; | |
| else if (!strcmp (argv[i], "--status") || | |
| !strcmp (argv[i], "--status=true") || | |
| !strcmp (argv[i], "--status=1")) | |
| status = true; | |
| else if (!strcmp (argv[i], "-n") || !strcmp (argv[i], "--no-status") || | |
| !strcmp (argv[i], "--status=false") || | |
| !strcmp (argv[i], "--status=0")) | |
| status = false; | |
| else if (!strcmp (argv[i], "--less")) { // EXPERIMENTAL! | |
| if (less) | |
| APPERR ("multiple '--less' options"); | |
| else if (!isatty (1)) | |
| APPERR ("'--less' without '<stdout>' connected to terminal"); | |
| else | |
| less = true; | |
| } else if (!strcmp (argv[i], "-c")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-c' missing"); | |
| else if (conflict_limit_specified) | |
| APPERR ("multiple conflict limits '-c %s' and '-c %s'", | |
| conflict_limit_specified, argv[i]); | |
| else if (!parse_int_str (argv[i], conflict_limit, true)) | |
| APPERR ("invalid argument in '-c %s'", argv[i]); | |
| else if (conflict_limit < 0) | |
| APPERR ("invalid conflict limit"); | |
| else | |
| conflict_limit_specified = argv[i]; | |
| } else if (!strcmp (argv[i], "-d")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-d' missing"); | |
| else if (decision_limit_specified) | |
| APPERR ("multiple decision limits '-d %s' and '-d %s'", | |
| decision_limit_specified, argv[i]); | |
| else if (!parse_int_str (argv[i], decision_limit, true)) | |
| APPERR ("invalid argument in '-d %s'", argv[i]); | |
| else if (decision_limit < 0) | |
| APPERR ("invalid decision limit"); | |
| else | |
| decision_limit_specified = argv[i]; | |
| } | |
| #ifndef _WIN32 | |
| else if (!strcmp (argv[i], "-t")) { | |
| if (++i == argc) | |
| APPERR ("argument to '-t' missing"); | |
| else if (time_limit_specified) | |
| APPERR ("multiple time limit '-t %s' and '-t %s'", | |
| time_limit_specified, argv[i]); | |
| else if (!parse_int_str (argv[i], time_limit, true)) | |
| APPERR ("invalid argument in '-d %s'", argv[i]); | |
| else if (time_limit < 0) | |
| APPERR ("invalid time limit"); | |
| else | |
| time_limit_specified = argv[i]; | |
| } | |
| #endif | |
| #ifndef QUIET | |
| else if (!strcmp (argv[i], "-q")) | |
| set ("--quiet"); | |
| else if (!strcmp (argv[i], "-v")) | |
| set ("verbose", get ("verbose") + 1); | |
| #endif | |
| #ifdef LOGGING | |
| else if (!strcmp (argv[i], "-l")) | |
| set ("--log"); | |
| #endif | |
| else if (!strcmp (argv[i], "-f") || !strcmp (argv[i], "--force") || | |
| !strcmp (argv[i], "--force=1") || | |
| !strcmp (argv[i], "--force=true")) | |
| force_strict_parsing = 0, force_writing = true, | |
| solver->set ("factorcheck", 0); | |
| else if (!strcmp (argv[i], "--strict") || | |
| !strcmp (argv[i], "--strict=1") || | |
| !strcmp (argv[i], "--strict=true")) | |
| force_strict_parsing = 2; | |
| else if (has_prefix (argv[i], "-O")) { | |
| if (optimization_specified) | |
| APPERR ("multiple optimization options '%s' and '%s'", | |
| optimization_specified, argv[i]); | |
| optimization_specified = argv[i]; | |
| if (!parse_int_str (argv[i] + 2, optimize, true)) | |
| APPERR ("invalid optimization option '%s'", argv[i]); | |
| if (optimize < -31 || optimize > 31) | |
| APPERR ("invalid argument in '%s' (expected '-31..31')", argv[i]); | |
| } else if (has_prefix (argv[i], "-P")) { | |
| if (preprocessing_specified) | |
| APPERR ("multiple preprocessing options '%s' and '%s'", | |
| preprocessing_specified, argv[i]); | |
| preprocessing_specified = argv[i]; | |
| if (!parse_int_str (argv[i] + 2, preprocessing, true)) | |
| APPERR ("invalid preprocessing option '%s'", argv[i]); | |
| if (preprocessing < 0) | |
| APPERR ("invalid argument in '%s' (expected non-negative number)", | |
| argv[i]); | |
| } else if (has_prefix (argv[i], "-L")) { | |
| if (localsearch_specified) | |
| APPERR ("multiple local search options '%s' and '%s'", | |
| localsearch_specified, argv[i]); | |
| localsearch_specified = argv[i]; | |
| if (!parse_int_str (argv[i] + 2, localsearch, true)) | |
| APPERR ("invalid local search option '%s'", argv[i]); | |
| if (localsearch < 0) | |
| APPERR ("invalid argument in '%s' (expected non-negative number)", | |
| argv[i]); | |
| } else if (has_prefix (argv[i], "--") && | |
| solver->is_valid_configuration (argv[i] + 2)) { | |
| solver->configure (argv[i] + 2); | |
| } else if (set (argv[i])) { | |
| /* nothing do be done */ | |
| } else if (argv[i][0] == '-') | |
| APPERR ("invalid option '%s'", argv[i]); | |
| else if (proof_specified) | |
| APPERR ("too many arguments"); | |
| else if (dimacs_specified) { | |
| proof_path = argv[i]; | |
| proof_specified = true; | |
| if (!force_writing && most_likely_existing_cnf_file (proof_path)) | |
| APPERR ("DRAT proof file '%s' most likely existing CNF (use '-f')", | |
| proof_path); | |
| else if (!File::writable (proof_path)) | |
| APPERR ("DRAT proof file '%s' not writable", proof_path); | |
| } else | |
| dimacs_specified = true, dimacs_path = argv[i]; | |
| } | |
| /*----------------------------------------------------------------------*/ | |
| if (dimacs_specified && dimacs_path && !File::exists (dimacs_path)) | |
| APPERR ("DIMACS input file '%s' does not exist", dimacs_path); | |
| if (read_solution_path && !File::exists (read_solution_path)) | |
| APPERR ("solution file '%s' does not exist", read_solution_path); | |
| if (dimacs_specified && dimacs_path && proof_specified && proof_path && | |
| !strcmp (dimacs_path, proof_path) && strcmp (dimacs_path, "-")) | |
| APPERR ("DIMACS input file '%s' also specified as DRAT proof file", | |
| dimacs_path); | |
| /*----------------------------------------------------------------------*/ | |
| // The '--less' option is not fully functional yet (it is also not | |
| // mentioned in the 'usage' message yet). It only works as expected if | |
| // you let the solver run until it exits. The goal is to have a similar | |
| // experience as with 'git diff' if the terminal is too small for the | |
| // printed messages, but this needs substantial hacking. | |
| // | |
| // TODO: add proper forking, waiting, signal catching & propagating ... | |
| // | |
| FILE *less_pipe; | |
| if (less) { | |
| assert (isatty (1)); | |
| less_pipe = popen ("less -r", "w"); | |
| if (!less_pipe) | |
| APPERR ("could not execute and open pipe to 'less -r' command"); | |
| dup2 (fileno (less_pipe), 1); | |
| } else | |
| less_pipe = 0; | |
| /*----------------------------------------------------------------------*/ | |
| if (read_solution_path && !get ("check")) | |
| set ("--check"); | |
| #ifndef QUIET | |
| if (!get ("quiet")) { | |
| solver->section ("banner"); | |
| solver->message ("%sCaDiCaL SAT Solver%s", tout.bright_magenta_code (), | |
| tout.normal_code ()); | |
| solver->message ("%s%s%s", tout.bright_magenta_code (), copyright (), | |
| tout.normal_code ()); | |
| solver->message ("%s%s%s", tout.bright_magenta_code (), authors (), | |
| tout.normal_code ()); | |
| solver->message ("%s%s%s", tout.bright_magenta_code (), affiliations (), | |
| tout.normal_code ()); | |
| solver->message (); | |
| CaDiCaL::Solver::build (stdout, "c "); | |
| } | |
| #endif | |
| if (preprocessing > 0 || localsearch > 0 || | |
| #ifndef _WIN32 | |
| time_limit >= 0 || | |
| #endif | |
| conflict_limit >= 0 || decision_limit >= 0) { | |
| solver->section ("limit"); | |
| if (preprocessing > 0) { | |
| solver->message ( | |
| "enabling %d initial rounds of preprocessing (due to '%s')", | |
| preprocessing, preprocessing_specified); | |
| solver->limit ("preprocessing", preprocessing); | |
| } | |
| if (localsearch > 0) { | |
| solver->message ( | |
| "enabling %d initial rounds of local search (due to '%s')", | |
| localsearch, localsearch_specified); | |
| solver->limit ("localsearch", localsearch); | |
| } | |
| #ifndef _WIN32 | |
| if (time_limit >= 0) { | |
| solver->message ( | |
| "setting time limit to %d seconds real time (due to '-t %s')", | |
| time_limit, time_limit_specified); | |
| Signal::alarm (time_limit); | |
| } | |
| #endif | |
| if (conflict_limit >= 0) { | |
| solver->message ( | |
| "setting conflict limit to %d conflicts (due to '%s')", | |
| conflict_limit, conflict_limit_specified); | |
| bool succeeded = solver->limit ("conflicts", conflict_limit); | |
| assert (succeeded), (void) succeeded; | |
| } | |
| if (decision_limit >= 0) { | |
| solver->message ( | |
| "setting decision limit to %d decisions (due to '%s')", | |
| decision_limit, decision_limit_specified); | |
| bool succeeded = solver->limit ("decisions", decision_limit); | |
| assert (succeeded), (void) succeeded; | |
| } | |
| } | |
| if (verbose () || proof_specified) | |
| solver->section ("proof tracing"); | |
| if (proof_specified) { | |
| if (!proof_path) { | |
| const bool force_binary = (isatty (1) && get ("binary")); | |
| if (force_binary) | |
| set ("--no-binary"); | |
| solver->message ("writing %s proof trace to %s'<stdout>'%s", | |
| (get ("binary") ? "binary" : "non-binary"), | |
| tout.green_code (), tout.normal_code ()); | |
| if (force_binary) | |
| solver->message ( | |
| "connected to terminal thus non-binary proof forced"); | |
| solver->trace_proof (stdout, "<stdout>"); | |
| } else if (!solver->trace_proof (proof_path)) | |
| APPERR ("can not open and write proof trace to '%s'", proof_path); | |
| else | |
| solver->message ("writing %s proof trace to %s'%s'%s", | |
| (get ("binary") ? "binary" : "non-binary"), | |
| tout.green_code (), proof_path, tout.normal_code ()); | |
| } else | |
| solver->verbose (1, "will not generate nor write DRAT proof"); | |
| solver->section ("parsing input"); | |
| dimacs_name = dimacs_path ? dimacs_path : "<stdin>"; | |
| string help; | |
| if (!dimacs_path) { | |
| help += " "; | |
| help += tout.magenta_code (); | |
| help += "(use '-h' for a list of common options)"; | |
| help += tout.normal_code (); | |
| } | |
| solver->message ("reading DIMACS file from %s'%s'%s%s", | |
| tout.green_code (), dimacs_name, tout.normal_code (), | |
| help.c_str ()); | |
| bool incremental; | |
| vector<int> cube_literals; | |
| if (dimacs_path) | |
| err = solver->read_dimacs (dimacs_path, max_var, force_strict_parsing, | |
| incremental, cube_literals); | |
| else { | |
| // Otherwise we may catch a SIGINT and continue to wait for an user | |
| // input in getc. | |
| Signal::reset (); | |
| err = solver->read_dimacs (stdin, dimacs_name, max_var, | |
| force_strict_parsing, incremental, | |
| cube_literals); | |
| Signal::set (this); | |
| } | |
| if (err) | |
| APPERR ("%s", err); | |
| if (read_solution_path) { | |
| solver->section ("parsing solution"); | |
| solver->message ("reading solution file from '%s'", read_solution_path); | |
| if ((err = solver->read_solution (read_solution_path))) | |
| APPERR ("%s", err); | |
| } | |
| solver->section ("options"); | |
| if (optimize) { | |
| solver->optimize (optimize); | |
| solver->message (); | |
| } | |
| solver->options (); | |
| int res = 0; | |
| if (incremental) { | |
| bool reporting = get ("report") > 1 || get ("verbose") > 0; | |
| if (!reporting) | |
| set ("report", 0); | |
| if (!reporting) | |
| solver->section ("incremental solving"); | |
| size_t cubes = 0, solved = 0; | |
| size_t satisfiable = 0, unsatisfiable = 0, inconclusive = 0; | |
| #ifndef QUIET | |
| bool quiet = get ("quiet"); | |
| struct { | |
| double start, delta, sum; | |
| } time = {0, 0, 0}; | |
| #endif | |
| for (auto lit : cube_literals) | |
| if (!lit) | |
| cubes++; | |
| if (!reporting) { | |
| if (cubes) | |
| solver->message ("starting to solve %zu cubes", cubes), | |
| solver->message (); | |
| else | |
| solver->message ("no cube to solve"); | |
| } | |
| vector<int> cube, failed; | |
| for (auto lit : cube_literals) { | |
| if (lit) | |
| cube.push_back (lit); | |
| else { | |
| reverse (cube.begin (), cube.end ()); | |
| for (auto other : cube) | |
| solver->assume (other); | |
| if (solved++) { | |
| if (conflict_limit >= 0) | |
| (void) solver->limit ("conflicts", conflict_limit); | |
| if (decision_limit >= 0) | |
| (void) solver->limit ("decisions", decision_limit); | |
| } | |
| #ifndef QUIET | |
| char buffer[256]; | |
| if (!quiet) { | |
| if (reporting) { | |
| snprintf (buffer, sizeof buffer, | |
| "solving cube %zu / %zu %.0f%%", solved, cubes, | |
| percent (solved, cubes)); | |
| solver->section (buffer); | |
| } | |
| time.start = absolute_process_time (); | |
| } | |
| #endif | |
| res = solver->solve (); | |
| #ifndef QUIET | |
| if (!quiet) { | |
| time.delta = absolute_process_time () - time.start; | |
| time.sum += time.delta; | |
| snprintf (buffer, sizeof buffer, | |
| "%s" | |
| "in %.3f sec " | |
| "(%.0f%% after %.2f sec at %.0f ms/cube)" | |
| "%s", | |
| tout.magenta_code (), time.delta, | |
| percent (solved, cubes), time.sum, | |
| relative (1e3 * time.sum, solved), tout.normal_code ()); | |
| if (reporting) | |
| solver->message (); | |
| const char *cube_str, *status_str, *color_code; | |
| if (res == 10) { | |
| cube_str = "CUBE"; | |
| color_code = tout.green_code (); | |
| status_str = "SATISFIABLE"; | |
| } else if (res == 20) { | |
| cube_str = "CUBE"; | |
| color_code = tout.cyan_code (); | |
| status_str = "UNSATISFIABLE"; | |
| } else { | |
| cube_str = "cube"; | |
| color_code = tout.magenta_code (); | |
| status_str = "inconclusive"; | |
| } | |
| const char *fmt; | |
| if (reporting) | |
| fmt = "%s%s %zu %s%s %s"; | |
| else | |
| fmt = "%s%s %zu %-13s%s %s"; | |
| solver->message (fmt, color_code, cube_str, solved, status_str, | |
| tout.normal_code (), buffer); | |
| } | |
| #endif | |
| if (res == 10) { | |
| satisfiable++; | |
| solver->conclude (); | |
| break; | |
| } else if (res == 20) { | |
| unsatisfiable++; | |
| solver->conclude (); | |
| for (auto other : cube) | |
| if (solver->failed (other)) | |
| failed.push_back (other); | |
| for (auto other : failed) | |
| solver->add (-other); | |
| solver->add (0); | |
| failed.clear (); | |
| } else { | |
| assert (!res); | |
| inconclusive++; | |
| } | |
| cube.clear (); | |
| } | |
| } | |
| solver->section ("incremental summary"); | |
| solver->message ("%zu cubes solved %.0f%%", solved, | |
| percent (solved, cubes)); | |
| solver->message ("%zu cubes inconclusive %.0f%%", inconclusive, | |
| percent (inconclusive, solved)); | |
| solver->message ("%zu cubes unsatisfiable %.0f%%", unsatisfiable, | |
| percent (unsatisfiable, solved)); | |
| solver->message ("%zu cubes satisfiable %.0f%%", satisfiable, | |
| percent (satisfiable, solved)); | |
| if (inconclusive && res == 20) | |
| res = 0; | |
| } else { | |
| solver->section ("solving"); | |
| res = solver->solve (); | |
| } | |
| if (proof_specified) { | |
| solver->section ("closing proof"); | |
| solver->close_proof_trace (!get ("quiet")); | |
| } | |
| if (output_path) { | |
| solver->section ("writing output"); | |
| solver->message ("writing simplified CNF to DIMACS file %s'%s'%s", | |
| tout.green_code (), output_path, tout.normal_code ()); | |
| err = solver->write_dimacs (output_path, max_var); | |
| if (err) | |
| APPERR ("%s", err); | |
| } | |
| if (extension_path) { | |
| solver->section ("writing extension"); | |
| solver->message ("writing extension stack to %s'%s'%s", | |
| tout.green_code (), extension_path, | |
| tout.normal_code ()); | |
| err = solver->write_extension (extension_path); | |
| if (err) | |
| APPERR ("%s", err); | |
| } | |
| solver->section ("result"); | |
| FILE *write_result_file; | |
| write_result_file = stdout; | |
| if (write_result_path) { | |
| write_result_file = fopen (write_result_path, "w"); | |
| if (!write_result_file) | |
| APPERR ("could not write solution to '%s'", write_result_path); | |
| solver->message ("writing result to '%s'", write_result_path); | |
| } | |
| assert (write_result_file); | |
| if (res == 10) { | |
| if (status) | |
| fputs ("s SATISFIABLE\n", write_result_file); | |
| if (witness) | |
| print_witness (write_result_file); | |
| } else if (res == 20 && status) | |
| fputs ("s UNSATISFIABLE\n", write_result_file); | |
| else if (status) | |
| fputs ("c UNKNOWN\n", write_result_file); | |
| fflush (write_result_file); | |
| if (write_result_path) | |
| fclose (write_result_file); | |
| solver->statistics (); | |
| solver->resources (); | |
| solver->section ("shutting down"); | |
| solver->message ("exit %d", res); | |
| #ifndef QUIET | |
| if (!res && Signal::received () == SIGALRM && !solver->get ("quiet")) { | |
| fputs ("c Timeout reached! 😅 This instance is a real thinker.\n" | |
| "c 🚧 🚧 🚧 Please consider contributing it to the page\n" | |
| "c https://mysolvertimesout.org/#sat in order to improve\n" | |
| "c automated reasoning. 🚧 🚧 🚧\n", | |
| write_result_file); | |
| fflush (write_result_file); | |
| } | |
| #endif | |
| if (less_pipe) { | |
| close (1); | |
| pclose (less_pipe); | |
| } | |
| #ifndef _WIN32 | |
| if (time_limit > 0) | |
| alarm (0); | |
| #endif | |
| if (signal_value) { | |
| CaDiCaL::Signal::reset (); | |
| #ifndef QUIET | |
| signal_message ("raising", signal_value); | |
| #endif | |
| raise (signal_value); | |
| } | |
| return res; | |
| } | |
| /*------------------------------------------------------------------------*/ | |
| // The real initialization is delayed. | |
| void App::init () { | |
| assert (!solver); | |
| #ifndef _WIN32 | |
| time_limit = -1; | |
| #endif | |
| force_strict_parsing = 1; | |
| force_writing = false; | |
| max_var = 0; | |
| #if !defined(NOPTIONS) | |
| // Call 'new Solver' only after setting 'reportdefault' and do not | |
| // add this call to the member initialization above. This is because for | |
| // stand-alone usage the default report default value is 'true' while for | |
| // library usage it should remain 'false'. See the explanation in | |
| // 'options.hpp' related to 'reportdefault' for details. | |
| CaDiCaL::Options::reportdefault = 1; | |
| #endif | |
| solver = new Solver (); | |
| Signal::set (this); | |
| } | |
| /*------------------------------------------------------------------------*/ | |
| App::App () | |
| : solver (0), time_limit (-1), force_strict_parsing (false), | |
| force_writing (false), max_var (0), signal_value (0) { | |
| } // Only partially initialize the app. | |
| App::~App () { | |
| if (!solver) | |
| return; // Only partially initialized. | |
| Signal::reset (); | |
| delete solver; | |
| } | |
| /*------------------------------------------------------------------------*/ | |
| #ifndef QUIET | |
| void App::signal_message (const char *msg, int sig) { | |
| solver->message ("%s%s %ssignal %d%s (%s)%s", tout.red_code (), msg, | |
| tout.bright_red_code (), sig, tout.red_code (), | |
| Signal::name (sig), tout.normal_code ()); | |
| } | |
| #endif | |
| void App::catch_signal (int sig) { | |
| signal_value = sig; // Store copy to re-raise signal in main | |
| solver->terminate (); // Immediate asynchronous call into solver. | |
| Signal::reset (); // Use the first signal caught only | |
| } | |
| void App::catch_alarm () { | |
| solver->terminate (); // Immediate asynchronous call into solver. | |
| } | |
| } // namespace CaDiCaL | |
| /*------------------------------------------------------------------------*/ | |
| // The actual app is allocated on the stack and then its 'main' function is | |
| // called. This looks like that there are no static variables, which is not | |
| // completely true, since both the signal handler connected to the app as | |
| // well as the terminal have statically allocated components as well as the | |
| // options table 'Options::table'. All are shared among solvers. | |
| int main (int argc, char **argv) { | |
| CaDiCaL::App app; | |
| int res = app.main (argc, argv); | |
| const int sig = CaDiCaL::Signal::received (); | |
| if (sig) { | |
| CaDiCaL::Signal::reset (); // Disconnects signal handler | |
| raise (sig); | |
| } | |
| return res; | |
| } |