654 lines
23 KiB
C++
654 lines
23 KiB
C++
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
|
|
|
|
/*
|
|
* Main authors:
|
|
* Guido Tack <guido.tack@monash.edu>
|
|
* Gleb Belov <gleb.belov@monash.edu>
|
|
*/
|
|
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was ! distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifdef _MSC_VER
|
|
#define _CRT_SECURE_NO_WARNINGS
|
|
#endif
|
|
|
|
#include <minizinc/solns2out.hh>
|
|
#include <minizinc/solver.hh>
|
|
|
|
#include <fstream>
|
|
#include <utility>
|
|
|
|
using namespace std;
|
|
using namespace MiniZinc;
|
|
|
|
void Solns2Out::printHelp(ostream& os) {
|
|
os << "Solution output options:" << std::endl
|
|
<< " --ozn-file <file>\n Read output specification from ozn file." << std::endl
|
|
<< " -o <file>, --output-to-file <file>\n Filename for generated output." << std::endl
|
|
<< " -i <n>, --ignore-lines <n>, --ignore-leading-lines <n>\n Ignore the first <n> lines "
|
|
"in the FlatZinc solution stream."
|
|
<< std::endl
|
|
<< " --soln-sep <s>, --soln-separator <s>, --solution-separator <s>\n Specify the string "
|
|
"printed after each solution (as a separate line).\n The default is to use the same as "
|
|
"FlatZinc, \"----------\"."
|
|
<< std::endl
|
|
<< " --soln-comma <s>, --solution-comma <s>\n Specify the string used to separate "
|
|
"solutions.\n The default is the empty string."
|
|
<< std::endl
|
|
<< " --unsat-msg (--unsatisfiable-msg), --unbounded-msg, --unsatorunbnd-msg,\n"
|
|
" --unknown-msg, --error-msg, --search-complete-msg <msg>\n"
|
|
" Specify solution status messages. The defaults:\n"
|
|
" \"=====UNSATISFIABLE=====\", \"=====UNSATorUNBOUNDED=====\", "
|
|
"\"=====UNBOUNDED=====\",\n"
|
|
" \"=====UNKNOWN=====\", \"=====ERROR=====\", \"==========\", respectively."
|
|
<< std::endl
|
|
<< " --non-unique\n Allow duplicate solutions.\n"
|
|
<< " -c, --canonicalize\n Canonicalize the output solution stream (i.e., buffer and "
|
|
"sort).\n"
|
|
<< " --output-non-canonical <file>\n Non-buffered solution output file in case of "
|
|
"canonicalization.\n"
|
|
<< " --output-raw <file>\n File to dump the solver's raw output (not for hard-linked "
|
|
"solvers)\n"
|
|
// Unclear how to exit then:
|
|
// << " --number-output <n>\n Maximal number of different solutions printed." <<
|
|
// std::endl
|
|
<< " --no-output-comments\n Do not print comments in the FlatZinc solution stream."
|
|
<< std::endl
|
|
<< " --output-time\n Print timing information in the FlatZinc solution stream."
|
|
<< std::endl
|
|
<< " --no-flush-output\n Don't flush output stream after every line." << std::endl;
|
|
}
|
|
|
|
bool Solns2Out::processOption(int& i, std::vector<std::string>& argv,
|
|
const std::string& workingDir) {
|
|
CLOParser cop(i, argv);
|
|
std::string buffer;
|
|
if (cop.getOption("--ozn-file", &buffer)) {
|
|
initFromOzn(FileUtils::file_path(buffer, workingDir));
|
|
} else if (cop.getOption("-o --output-to-file", &buffer)) {
|
|
opt.flagOutputFile = buffer;
|
|
} else if (cop.getOption("--no-flush-output")) {
|
|
opt.flagOutputFlush = false;
|
|
} else if (cop.getOption("--no-output-comments")) {
|
|
opt.flagOutputComments = false;
|
|
} else if (cop.getOption("-i --ignore-lines --ignore-leading-lines",
|
|
&opt.flagIgnoreLines)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--output-time")) {
|
|
opt.flagOutputTime = true;
|
|
} else if (cop.getOption("--soln-sep --soln-separator --solution-separator",
|
|
&opt.solutionSeparator)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--soln-comma --solution-comma",
|
|
&opt.solutionComma)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--unsat-msg --unsatisfiable-msg",
|
|
&opt.unsatisfiableMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--unbounded-msg",
|
|
&opt.unboundedMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--unsatorunbnd-msg",
|
|
&opt.unsatorunbndMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--unknown-msg", &opt.unknownMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--error-msg", &opt.errorMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--search-complete-msg",
|
|
&opt.searchCompleteMsg)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--unique")) {
|
|
opt.flagUnique = true;
|
|
} else if (cop.getOption("--non-unique")) {
|
|
opt.flagUnique = false;
|
|
} else if (cop.getOption("-c --canonicalize")) {
|
|
opt.flagCanonicalize = true;
|
|
} else if (cop.getOption("--output-non-canonical --output-non-canon",
|
|
&opt.flagOutputNoncanonical)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (cop.getOption("--output-raw",
|
|
&opt.flagOutputRaw)) { // NOLINT: Allow repeated empty if
|
|
// Parsed by reference
|
|
} else if (opt.flagStandaloneSolns2Out) {
|
|
std::string oznfile(argv[i]);
|
|
if (oznfile.length() <= 4) {
|
|
return false;
|
|
}
|
|
size_t last_dot = oznfile.find_last_of('.');
|
|
if (last_dot == string::npos) {
|
|
return false;
|
|
}
|
|
std::string extension = oznfile.substr(last_dot, string::npos);
|
|
if (extension == ".ozn") {
|
|
initFromOzn(oznfile);
|
|
return true;
|
|
}
|
|
return false;
|
|
} else {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Solns2Out::initFromEnv(Env* pE) {
|
|
assert(pE);
|
|
_env = pE;
|
|
_includePaths.push_back(_stdlibDir + "/std/");
|
|
init();
|
|
return true;
|
|
}
|
|
|
|
void Solns2Out::initFromOzn(const std::string& filename) {
|
|
std::vector<string> filenames(1, filename);
|
|
|
|
_includePaths.push_back(_stdlibDir + "/std/");
|
|
|
|
for (auto& includePath : _includePaths) {
|
|
if (!FileUtils::directory_exists(includePath)) {
|
|
std::cerr << "solns2out: cannot access include directory " << includePath << "\n";
|
|
std::exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
|
|
{
|
|
_env = new Env();
|
|
std::stringstream errstream;
|
|
if ((_outputModel = parse(*_env, filenames, std::vector<std::string>(), "", "", _includePaths,
|
|
false, false, false, false, errstream)) != nullptr) {
|
|
std::vector<TypeError> typeErrors;
|
|
_env->model(_outputModel);
|
|
MZN_ASSERT_HARD_MSG(_env, "solns2out: could not allocate Env");
|
|
_envGuard.reset(_env);
|
|
MiniZinc::typecheck(*_env, _outputModel, typeErrors, false, false);
|
|
MiniZinc::register_builtins(*_env);
|
|
_env->envi().swapOutput();
|
|
init();
|
|
} else {
|
|
throw Error(errstream.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
Solns2Out::DE& Solns2Out::findOutputVar(const ASTString& name) {
|
|
declNewOutput();
|
|
auto it = _declmap.find(name);
|
|
MZN_ASSERT_HARD_MSG(_declmap.end() != it, "solns2out_base: unexpected id in output: " << name);
|
|
return it->second;
|
|
}
|
|
|
|
void Solns2Out::restoreDefaults() {
|
|
for (auto& i : *getModel()) {
|
|
if (auto* vdi = i->dynamicCast<VarDeclI>()) {
|
|
if (vdi->e()->id()->idn() != -1 || (vdi->e()->id()->v() != "_mzn_solution_checker" &&
|
|
vdi->e()->id()->v() != "_mzn_stats_checker")) {
|
|
GCLock lock;
|
|
auto& de = findOutputVar(vdi->e()->id()->str());
|
|
vdi->e()->e(de.second());
|
|
vdi->e()->evaluated(false);
|
|
}
|
|
}
|
|
}
|
|
_fNewSol2Print = false;
|
|
}
|
|
|
|
void Solns2Out::parseAssignments(string& solution) {
|
|
std::vector<SyntaxError> se;
|
|
unique_ptr<Model> sm(parse_from_string(*_env, solution, "solution received from solver",
|
|
_includePaths, false, true, false, false, _log, se));
|
|
if (sm == nullptr) {
|
|
throw Error("solns2out_base: could not parse solution");
|
|
}
|
|
solution = "";
|
|
for (unsigned int i = 0; i < sm->size(); i++) {
|
|
if (auto* ai = (*sm)[i]->dynamicCast<AssignI>()) {
|
|
auto& de = findOutputVar(ai->id());
|
|
if (!ai->e()->isa<BoolLit>() && !ai->e()->isa<IntLit>() && !ai->e()->isa<FloatLit>()) {
|
|
Type de_t = de.first->type();
|
|
de_t.cv(false);
|
|
ai->e()->type(de_t);
|
|
}
|
|
ai->decl(de.first);
|
|
typecheck(*_env, getModel(), ai);
|
|
if (Call* c = ai->e()->dynamicCast<Call>()) {
|
|
// This is an arrayXd call, make sure we get the right builtin
|
|
assert(c->arg(c->argCount() - 1)->isa<ArrayLit>());
|
|
for (unsigned int i = 0; i < c->argCount(); i++) {
|
|
c->arg(i)->type(Type::parsetint());
|
|
}
|
|
c->arg(c->argCount() - 1)->type(de.first->type());
|
|
c->decl(getModel()->matchFn(_env->envi(), c, false));
|
|
}
|
|
de.first->e(ai->e());
|
|
}
|
|
}
|
|
declNewOutput();
|
|
}
|
|
|
|
void Solns2Out::declNewOutput() {
|
|
_fNewSol2Print = true;
|
|
status = SolverInstance::SAT;
|
|
}
|
|
|
|
bool Solns2Out::evalOutput(const string& s_ExtraInfo) {
|
|
if (!_fNewSol2Print) {
|
|
return true;
|
|
}
|
|
ostringstream oss;
|
|
if (!_checkerModel.empty()) {
|
|
auto& checkerStream = _env->envi().checkerOutput;
|
|
checkerStream.clear();
|
|
checkerStream.str("");
|
|
checkSolution(checkerStream);
|
|
}
|
|
if (!evalOutputInternal(oss)) {
|
|
return false;
|
|
}
|
|
bool fNew = true;
|
|
if (opt.flagUnique || opt.flagCanonicalize) {
|
|
auto res = _sSolsCanon.insert(oss.str());
|
|
if (!res.second) { // repeated solution
|
|
fNew = false;
|
|
}
|
|
}
|
|
if (fNew) {
|
|
{
|
|
auto& checkerStream = _env->envi().checkerOutput;
|
|
checkerStream.flush();
|
|
std::string line;
|
|
if (std::getline(checkerStream, line)) {
|
|
_os << "% Solution checker report:\n";
|
|
_os << "% " << line << "\n";
|
|
while (std::getline(checkerStream, line)) {
|
|
_os << "% " << line << "\n";
|
|
}
|
|
}
|
|
}
|
|
++stats.nSolns;
|
|
if (opt.flagCanonicalize) {
|
|
if (_outStreamNonCanon != nullptr) {
|
|
if (_outStreamNonCanon->good()) {
|
|
(*_outStreamNonCanon) << oss.str();
|
|
(*_outStreamNonCanon) << comments;
|
|
if (!s_ExtraInfo.empty()) {
|
|
(*_outStreamNonCanon) << s_ExtraInfo;
|
|
if ('\n' != s_ExtraInfo.back()) { /// TODO is this enough to check EOL?
|
|
(*_outStreamNonCanon) << '\n';
|
|
}
|
|
}
|
|
if (opt.flagOutputTime) {
|
|
(*_outStreamNonCanon) << "% time elapsed: " << _starttime.stoptime() << "\n";
|
|
}
|
|
if (!opt.solutionSeparator.empty()) {
|
|
(*_outStreamNonCanon) << opt.solutionSeparator << '\n';
|
|
}
|
|
if (opt.flagOutputFlush) {
|
|
_outStreamNonCanon->flush();
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
if ((!opt.solutionComma.empty()) && stats.nSolns > 1) {
|
|
getOutput() << opt.solutionComma << '\n';
|
|
}
|
|
getOutput() << oss.str();
|
|
}
|
|
}
|
|
getOutput() << comments; // print them now ????
|
|
comments = "";
|
|
if (!s_ExtraInfo.empty()) {
|
|
getOutput() << s_ExtraInfo;
|
|
if ('\n' != s_ExtraInfo.back()) { /// TODO is this enough to check EOL?
|
|
getOutput() << '\n';
|
|
}
|
|
}
|
|
if (fNew && opt.flagOutputTime) {
|
|
getOutput() << "% time elapsed: " << _starttime.stoptime() << "\n";
|
|
}
|
|
if (fNew && !opt.flagCanonicalize && !opt.solutionSeparator.empty()) {
|
|
getOutput() << opt.solutionSeparator << '\n';
|
|
}
|
|
if (opt.flagOutputFlush) {
|
|
getOutput().flush();
|
|
}
|
|
restoreDefaults(); // cleans data. evalOutput() should not be called again w/o assigning new
|
|
// data.
|
|
return true;
|
|
}
|
|
|
|
// NOLINTNEXTLINE(readability-convert-member-functions-to-static): Appears static without Gecode
|
|
void Solns2Out::checkSolution(std::ostream& oss) {
|
|
#ifdef HAS_GECODE
|
|
|
|
std::ostringstream checker;
|
|
checker << _checkerModel;
|
|
{
|
|
GCLock lock;
|
|
for (auto& i : *getModel()) {
|
|
if (auto* vdi = i->dynamicCast<VarDeclI>()) {
|
|
if (vdi->e()->ann().contains(constants().ann.mzn_check_var)) {
|
|
checker << vdi->e()->id()->str() << " = ";
|
|
Expression* e = eval_par(getEnv()->envi(), vdi->e()->e());
|
|
auto* al = e->dynamicCast<ArrayLit>();
|
|
std::vector<Id*> enumids;
|
|
if (Call* cev = vdi->e()->ann().getCall(constants().ann.mzn_check_enum_var)) {
|
|
auto* enumIdsAl = cev->arg(0)->cast<ArrayLit>();
|
|
for (int j = 0; j < enumIdsAl->size(); j++) {
|
|
enumids.push_back((*enumIdsAl)[j]->dynamicCast<Id>());
|
|
}
|
|
}
|
|
|
|
if (al != nullptr) {
|
|
checker << "array" << al->dims() << "d(";
|
|
for (int i = 0; i < al->dims(); i++) {
|
|
if (!enumids.empty() && enumids[i] != nullptr) {
|
|
checker << "to_enum(" << *enumids[i] << ",";
|
|
}
|
|
checker << al->min(i) << ".." << al->max(i);
|
|
if (!enumids.empty() && enumids[i] != nullptr) {
|
|
checker << ")";
|
|
}
|
|
checker << ",";
|
|
}
|
|
}
|
|
if (!enumids.empty() && enumids.back() != nullptr) {
|
|
checker << "to_enum(" << *enumids.back() << "," << *e << ")";
|
|
} else {
|
|
checker << *e;
|
|
}
|
|
if (al != nullptr) {
|
|
checker << ")";
|
|
}
|
|
checker << ";\n";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
MznSolver slv(oss, oss);
|
|
slv.s2out.opt.solutionSeparator = "";
|
|
try {
|
|
std::vector<std::string> args({"--solver", "org.minizinc.gecode_presolver"});
|
|
slv.run(args, checker.str(), "minizinc", "checker.mzc");
|
|
} catch (const LocationException& e) {
|
|
oss << e.loc() << ":" << std::endl;
|
|
oss << e.what() << ": " << e.msg() << std::endl;
|
|
} catch (const Exception& e) {
|
|
std::string what = e.what();
|
|
oss << what << (what.empty() ? "" : ": ") << e.msg() << std::endl;
|
|
} catch (const exception& e) {
|
|
oss << e.what() << std::endl;
|
|
} catch (...) {
|
|
oss << " UNKNOWN EXCEPTION." << std::endl;
|
|
}
|
|
|
|
#else
|
|
oss << "% solution checking not supported (need built-in Gecode)" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
// NOLINTNEXTLINE(readability-convert-member-functions-to-static): Appears static without Gecode
|
|
void Solns2Out::checkStatistics(std::ostream& oss) {
|
|
#ifdef HAS_GECODE
|
|
|
|
std::ostringstream checker;
|
|
checker << _statisticsCheckerModel;
|
|
checker << "mzn_stats_failures = " << stats.nFails << ";\n";
|
|
checker << "mzn_stats_solutions = " << stats.nSolns << ";\n";
|
|
checker << "mzn_stats_nodes = " << stats.nNodes << ";\n";
|
|
checker << "mzn_stats_time = " << _starttime.ms() << ";\n";
|
|
|
|
MznSolver slv(oss, oss);
|
|
slv.s2out.opt.solutionSeparator = "";
|
|
try {
|
|
std::vector<std::string> args({"--solver", "org.minizinc.gecode_presolver"});
|
|
slv.run(args, checker.str(), "minizinc", "checker.mzc");
|
|
} catch (const LocationException& e) {
|
|
oss << e.loc() << ":" << std::endl;
|
|
oss << e.what() << ": " << e.msg() << std::endl;
|
|
} catch (const Exception& e) {
|
|
std::string what = e.what();
|
|
oss << what << (what.empty() ? "" : ": ") << e.msg() << std::endl;
|
|
} catch (const exception& e) {
|
|
oss << e.what() << std::endl;
|
|
} catch (...) {
|
|
oss << " UNKNOWN EXCEPTION." << std::endl;
|
|
}
|
|
|
|
#else
|
|
oss << "% statistics checking not supported (need built-in Gecode)" << std::endl;
|
|
#endif
|
|
}
|
|
|
|
bool Solns2Out::evalOutputInternal(ostream& fout) {
|
|
if (nullptr != _outputExpr) {
|
|
_env->envi().evalOutput(fout, _log);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Solns2Out::evalStatus(SolverInstance::Status status) {
|
|
if (opt.flagCanonicalize) {
|
|
evalOutputFinalInternal(opt.flagOutputFlush);
|
|
}
|
|
evalStatusMsg(status);
|
|
fStatusPrinted = true;
|
|
return true;
|
|
}
|
|
|
|
bool Solns2Out::evalOutputFinalInternal(bool /*b*/) {
|
|
/// Print the canonical list
|
|
for (const auto& sol : _sSolsCanon) {
|
|
if ((!opt.solutionComma.empty()) && &sol != &*_sSolsCanon.begin()) {
|
|
getOutput() << opt.solutionComma << '\n';
|
|
}
|
|
getOutput() << sol;
|
|
if (!opt.solutionSeparator.empty()) {
|
|
getOutput() << opt.solutionSeparator << '\n';
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool Solns2Out::evalStatusMsg(SolverInstance::Status status) {
|
|
std::map<SolverInstance::Status, string> stat2msg;
|
|
stat2msg[SolverInstance::OPT] = opt.searchCompleteMsg;
|
|
stat2msg[SolverInstance::UNSAT] = opt.unsatisfiableMsg;
|
|
stat2msg[SolverInstance::UNBND] = opt.unboundedMsg;
|
|
stat2msg[SolverInstance::UNSATorUNBND] = opt.unsatorunbndMsg;
|
|
stat2msg[SolverInstance::UNKNOWN] = opt.unknownMsg;
|
|
stat2msg[SolverInstance::ERROR] = opt.errorMsg;
|
|
stat2msg[SolverInstance::NONE] = "";
|
|
auto it = stat2msg.find(status);
|
|
if (stat2msg.end() != it) {
|
|
getOutput() << comments;
|
|
if (!it->second.empty()) {
|
|
getOutput() << it->second << '\n';
|
|
}
|
|
if (opt.flagOutputTime) {
|
|
getOutput() << "% time elapsed: " << _starttime.stoptime() << "\n";
|
|
}
|
|
if (opt.flagOutputFlush) {
|
|
getOutput().flush();
|
|
}
|
|
Solns2Out::status = status;
|
|
} else {
|
|
getOutput() << comments;
|
|
if (opt.flagOutputFlush) {
|
|
getOutput().flush();
|
|
}
|
|
MZN_ASSERT_HARD_MSG(SolverInstance::SAT == status, // which is ignored
|
|
"solns2out_base: undefined solution status code " << status);
|
|
Solns2Out::status = SolverInstance::SAT;
|
|
}
|
|
comments = "";
|
|
return true;
|
|
}
|
|
|
|
void Solns2Out::init() {
|
|
_declmap.clear();
|
|
for (auto& i : *getModel()) {
|
|
if (auto* oi = i->dynamicCast<OutputI>()) {
|
|
_outputExpr = oi->e();
|
|
} else if (auto* vdi = i->dynamicCast<VarDeclI>()) {
|
|
if (vdi->e()->id()->idn() == -1 && vdi->e()->id()->v() == "_mzn_solution_checker") {
|
|
_checkerModel = eval_string(getEnv()->envi(), vdi->e()->e());
|
|
if (!_checkerModel.empty() && _checkerModel[0] == '@') {
|
|
_checkerModel = FileUtils::decode_base64(_checkerModel);
|
|
FileUtils::inflate_string(_checkerModel);
|
|
}
|
|
} else if (vdi->e()->id()->idn() == -1 && vdi->e()->id()->v() == "_mzn_stats_checker") {
|
|
_statisticsCheckerModel = eval_string(getEnv()->envi(), vdi->e()->e());
|
|
if (!_statisticsCheckerModel.empty() && _statisticsCheckerModel[0] == '@') {
|
|
_statisticsCheckerModel = FileUtils::decode_base64(_statisticsCheckerModel);
|
|
FileUtils::inflate_string(_statisticsCheckerModel);
|
|
}
|
|
} else {
|
|
GCLock lock;
|
|
_declmap.insert(make_pair(vdi->e()->id()->str(), DE(vdi->e(), vdi->e()->e())));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Main output file
|
|
if (nullptr == _outStream) {
|
|
if (!opt.flagOutputFile.empty()) {
|
|
_outStream.reset(new ofstream(FILE_PATH(opt.flagOutputFile)));
|
|
MZN_ASSERT_HARD_MSG(_outStream.get(),
|
|
"solns2out_base: could not allocate stream object for file output into "
|
|
<< opt.flagOutputFile);
|
|
check_io_status(_outStream->good(), opt.flagOutputFile);
|
|
}
|
|
}
|
|
/// Non-canonical output
|
|
if (opt.flagCanonicalize && (!opt.flagOutputNoncanonical.empty())) {
|
|
_outStreamNonCanon.reset(new ofstream(FILE_PATH(opt.flagOutputNoncanonical)));
|
|
MZN_ASSERT_HARD_MSG(_outStreamNonCanon.get(),
|
|
"solns2out_base: could not allocate stream object for non-canon output");
|
|
check_io_status(_outStreamNonCanon->good(), opt.flagOutputNoncanonical, false);
|
|
}
|
|
/// Raw output
|
|
if (!opt.flagOutputRaw.empty()) {
|
|
_outStreamRaw.reset(new ofstream(FILE_PATH(opt.flagOutputRaw)));
|
|
MZN_ASSERT_HARD_MSG(_outStreamRaw.get(),
|
|
"solns2out_base: could not allocate stream object for raw output");
|
|
check_io_status(_outStreamRaw->good(), opt.flagOutputRaw, false);
|
|
}
|
|
/// Assume all options are set before
|
|
nLinesIgnore = opt.flagIgnoreLines;
|
|
}
|
|
|
|
Solns2Out::Solns2Out(std::ostream& os0, std::ostream& log0, std::string stdlibDir0)
|
|
: _os(os0), _log(log0), _stdlibDir(std::move(stdlibDir0)) {}
|
|
|
|
Solns2Out::~Solns2Out() {
|
|
getOutput() << comments;
|
|
if (opt.flagOutputFlush) {
|
|
getOutput() << flush;
|
|
}
|
|
}
|
|
|
|
ostream& Solns2Out::getOutput() {
|
|
return (((_outStream != nullptr) && _outStream->good()) ? *_outStream : _os);
|
|
}
|
|
|
|
ostream& Solns2Out::getLog() { return _log; }
|
|
|
|
bool Solns2Out::feedRawDataChunk(const char* data) {
|
|
istringstream solstream(data);
|
|
while (solstream.good()) {
|
|
string line;
|
|
getline(solstream, line);
|
|
if (!_linePart.empty()) {
|
|
line = _linePart + line;
|
|
_linePart.clear();
|
|
}
|
|
if (solstream.eof()) { // wait next chunk
|
|
_linePart = line;
|
|
break; // to get to raw output
|
|
}
|
|
if (!line.empty()) {
|
|
if ('\r' == line.back()) {
|
|
line.pop_back(); // For WIN files
|
|
}
|
|
}
|
|
if (nLinesIgnore > 0) {
|
|
--nLinesIgnore;
|
|
continue;
|
|
}
|
|
if (_mapInputStatus.empty()) {
|
|
createInputMap();
|
|
}
|
|
auto it = _mapInputStatus.find(line);
|
|
if (_mapInputStatus.end() != it) {
|
|
if (SolverInstance::SAT == it->second) {
|
|
parseAssignments(solution);
|
|
evalOutput();
|
|
} else {
|
|
evalStatus(it->second);
|
|
}
|
|
} else {
|
|
solution += line + '\n';
|
|
if (opt.flagOutputComments) {
|
|
std::istringstream iss(line);
|
|
char c = '_';
|
|
iss >> skipws >> c;
|
|
if (iss.good() && '%' == c) {
|
|
// Feed comments directly
|
|
getOutput() << line << '\n';
|
|
if (opt.flagOutputFlush) {
|
|
getOutput().flush();
|
|
}
|
|
if (_outStreamNonCanon != nullptr) {
|
|
if (_outStreamNonCanon->good()) {
|
|
(*_outStreamNonCanon) << line << '\n';
|
|
}
|
|
}
|
|
if (line.substr(0, 13) == "%%%mzn-stat: " && line.size() > 13) {
|
|
if (line.substr(13, 6) == "nodes=") {
|
|
std::istringstream iss(line.substr(19));
|
|
int n_nodes;
|
|
iss >> n_nodes;
|
|
stats.nNodes = n_nodes;
|
|
} else if (line.substr(13, 9) == "failures=") {
|
|
std::istringstream iss(line.substr(22));
|
|
int n_failures;
|
|
iss >> n_failures;
|
|
stats.nFails = n_failures;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (_outStreamRaw != nullptr) {
|
|
*_outStreamRaw << data;
|
|
if (opt.flagOutputFlush) {
|
|
_outStreamRaw->flush();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Solns2Out::createInputMap() {
|
|
_mapInputStatus[opt.searchCompleteMsgDef] = SolverInstance::OPT;
|
|
_mapInputStatus[opt.solutionSeparatorDef] = SolverInstance::SAT;
|
|
_mapInputStatus[opt.unsatisfiableMsgDef] = SolverInstance::UNSAT;
|
|
_mapInputStatus[opt.unboundedMsgDef] = SolverInstance::UNBND;
|
|
_mapInputStatus[opt.unsatorunbndMsgDef] = SolverInstance::UNSATorUNBND;
|
|
_mapInputStatus[opt.unknownMsgDef] = SolverInstance::UNKNOWN;
|
|
_mapInputStatus[opt.errorMsg] = SolverInstance::ERROR;
|
|
}
|
|
|
|
void Solns2Out::printStatistics(ostream& os) {
|
|
os << "%%%mzn-stat: nSolutions=" << stats.nSolns << "\n";
|
|
if (!_statisticsCheckerModel.empty()) {
|
|
std::ostringstream oss;
|
|
checkStatistics(oss);
|
|
os << "%%%mzn-stat: statisticsCheck=\"" << Printer::escapeStringLit(oss.str()) << "\"\n";
|
|
}
|
|
os << "%%%mzn-stat-end\n";
|
|
}
|