std::pair< bool, std::ostream* > OstreamOpener::open(const std::string& optarg) const
{
if(optarg == "") {
std::stringstream ss;
ss << "Bad file name setting for " << d_channelName;
throw OptionException(ss.str());
}
if(d_specialCases.find(optarg) != d_specialCases.end()){
return std::make_pair(false, (*d_specialCases.find(optarg)).second);
} else if(!options::filesystemAccess()) {
throw OptionException(std::string("Filesystem access not permitted"));
} else {
errno = 0;
std::ostream* outStream;
outStream = new std::ofstream(optarg.c_str(),
std::ofstream::out | std::ofstream::trunc);
if(outStream == NULL || !*outStream) {
std::stringstream ss;
ss << "Cannot open " << d_channelName << " file: `"
<< optarg << "': " << cvc4_errno_failreason();
throw OptionException(ss.str());
}
return make_pair(true, outStream);
}
}
void parseThreadSpecificOptions(OptionsList& threadOptions, const Options& opts)
{
unsigned numThreads = opts.getThreads();
for(unsigned i = 0; i < numThreads; ++i) {
threadOptions.push_back_copy(opts);
Options& tOpts = threadOptions.back();
// Set thread identifier
tOpts.setThreadId(i);
const std::vector<std::string>& optThreadArgvs = opts.getThreadArgv();
if(i < optThreadArgvs.size() && (! optThreadArgvs[i].empty())) {
// separate out the thread's individual configuration string
stringstream optidss;
optidss << "--thread" << i;
string optid = optidss.str();
int targc = 1;
char* tbuf = strdup(optThreadArgvs[i].c_str());
char* p = tbuf;
// string length is certainly an upper bound on size needed
char** targv = new char*[optThreadArgvs[i].size()];
char** vp = targv;
*vp++ = strdup(optid.c_str());
p = strtok(p, " ");
while(p != NULL) {
*vp++ = p;
++targc;
p = strtok(NULL, " ");
}
*vp++ = NULL;
if(targc > 1) { // this is necessary in case you do e.g. --thread0=" "
try {
Options::parseOptions(&tOpts, targc, targv);
} catch(OptionException& e) {
stringstream ss;
ss << optid << ": " << e.getMessage();
throw OptionException(ss.str());
}
if(tOpts.getThreads() != numThreads ||
tOpts.getThreadArgv() != opts.getThreadArgv()) {
stringstream ss;
ss << "not allowed to set thread options in " << optid << " !";
throw OptionException(ss.str());
}
}
free(targv[0]);
delete [] targv;
free(tbuf);
}
}
assert(numThreads >= 1); //do we need this?
}
OutputLanguage toOutputLanguage(std::string language) {
if(language == "cvc4" || language == "pl" ||
language == "presentation" || language == "native" ||
language == "LANG_CVC4") {
return output::LANG_CVC4;
} else if(language == "cvc3" || language == "LANG_CVC3") {
return output::LANG_CVC3;
} else if(language == "smtlib1" || language == "smt1" ||
language == "LANG_SMTLIB_V1") {
return output::LANG_SMTLIB_V1;
} else if(language == "smtlib" || language == "smt" ||
language == "smtlib2" || language == "smt2" ||
language == "LANG_SMTLIB_V2") {
return output::LANG_SMTLIB_V2;
} else if(language == "tptp" || language == "LANG_TPTP") {
return output::LANG_TPTP;
} else if(language == "z3str" || language == "z3-str" ||
language == "LANG_Z3STR") {
return output::LANG_Z3STR;
} else if(language == "ast" || language == "LANG_AST") {
return output::LANG_AST;
} else if(language == "auto" || language == "LANG_AUTO") {
return output::LANG_AUTO;
}
throw OptionException(std::string("unknown output language `" + language + "'"));
}/* toOutputLanguage() */
InputLanguage toInputLanguage(std::string language) {
if(language == "cvc4" || language == "pl" ||
language == "presentation" || language == "native" ||
language == "LANG_CVC4") {
return input::LANG_CVC4;
} else if(language == "smtlib1" || language == "smt1" ||
language == "LANG_SMTLIB_V1") {
return input::LANG_SMTLIB_V1;
} else if(language == "smtlib" || language == "smt" ||
language == "smtlib2" || language == "smt2" ||
language == "smtlib2.0" || language == "smt2.0" ||
language == "LANG_SMTLIB_V2_0" || language == "LANG_SMTLIB_V2") {
return input::LANG_SMTLIB_V2_0;
} else if(language == "smtlib2.5" || language == "smt2.5" ||
language == "LANG_SMTLIB_V2_5") {
return input::LANG_SMTLIB_V2_5;
} else if(language == "sygus" || language == "LANG_SYGUS") {
return input::LANG_SYGUS;
} else if(language == "tptp" || language == "LANG_TPTP") {
return input::LANG_TPTP;
} else if(language == "z3str" || language == "z3-str" ||
language == "LANG_Z3STR") {
return input::LANG_Z3STR;
} else if(language == "auto" || language == "LANG_AUTO") {
return input::LANG_AUTO;
}
throw OptionException(std::string("unknown input language `" + language + "'"));
}/* toInputLanguage() */
void OptionGroupParser::read(const cxxopts::ParseResult &parseResult)
{
const auto parsingModeString = parseResult["parsing-mode"].as<std::string>();
if (parsingModeString == "compatibility")
parsingMode = pddl::Mode::Compatibility;
else if (parsingModeString != "strict")
throw OptionException("unknown parsing mode “" + parsingModeString + "”");
if (parseResult.count("input"))
inputFiles = parseResult["input"].as<std::vector<std::string>>();
const auto languageName = parseResult["language"].as<std::string>();
language = plasp::Language::fromString(languageName);
if (language == plasp::Language::Type::Unknown)
throw OptionException("unknown input language “" + languageName + "”");
}
void OptionGroupOutput::read(const cxxopts::ParseResult &parseResult)
{
const auto colorPolicyString = parseResult["color"].as<std::string>();
if (colorPolicyString == "auto")
colorPolicy = colorlog::ColorStream::ColorPolicy::Auto;
else if (colorPolicyString == "never")
colorPolicy = colorlog::ColorStream::ColorPolicy::Never;
else if (colorPolicyString == "always")
colorPolicy = colorlog::ColorStream::ColorPolicy::Always;
else
throw OptionException("unknown color policy “" + colorPolicyString + "”");
const auto logPriorityString = parseResult["log-priority"].as<std::string>();
try
{
logPriority = colorlog::priorityFromName(logPriorityString.c_str());
}
catch (const std::exception &e)
{
throw OptionException(e.what());
}
}
void DumpC::setDumpFromString(const std::string& optarg) {
#ifdef CVC4_DUMPING
char* optargPtr = strdup(optarg.c_str());
char* tokstr = optargPtr;
char* toksave;
while((optargPtr = strtok_r(tokstr, ",", &toksave)) != NULL) {
tokstr = NULL;
if(!strcmp(optargPtr, "benchmark")) {
} else if(!strcmp(optargPtr, "declarations")) {
} else if(!strcmp(optargPtr, "assertions")) {
Dump.on("assertions:post-everything");
} else if(!strncmp(optargPtr, "assertions:", 11)) {
const char* p = optargPtr + 11;
if(!strncmp(p, "pre-", 4)) {
p += 4;
} else if(!strncmp(p, "post-", 5)) {
p += 5;
} else {
throw OptionException(std::string("don't know how to dump `") +
optargPtr + "'. Please consult --dump help.");
}
if(!strcmp(p, "everything")) {
} else if(!strcmp(p, "definition-expansion")) {
} else if(!strcmp(p, "boolean-terms")) {
} else if(!strcmp(p, "constrain-subtypes")) {
} else if(!strcmp(p, "substitution")) {
} else if(!strcmp(p, "strings-pp")) {
} else if(!strcmp(p, "skolem-quant")) {
} else if(!strcmp(p, "simplify")) {
} else if(!strcmp(p, "static-learning")) {
} else if(!strcmp(p, "ite-removal")) {
} else if(!strcmp(p, "repeat-simplify")) {
} else if(!strcmp(p, "rewrite-apply-to-const")) {
} else if(!strcmp(p, "theory-preprocessing")) {
} else if(!strcmp(p, "nonclausal")) {
} else if(!strcmp(p, "theorypp")) {
} else if(!strcmp(p, "itesimp")) {
} else if(!strcmp(p, "unconstrained")) {
} else if(!strcmp(p, "repeatsimp")) {
} else {
throw OptionException(std::string("don't know how to dump `") +
optargPtr + "'. Please consult --dump help.");
}
Dump.on("assertions");
} else if(!strcmp(optargPtr, "skolems")) {
} else if(!strcmp(optargPtr, "clauses")) {
} else if(!strcmp(optargPtr, "t-conflicts") ||
!strcmp(optargPtr, "t-lemmas") ||
!strcmp(optargPtr, "t-explanations") ||
!strcmp(optargPtr, "bv-rewrites") ||
!strcmp(optargPtr, "theory::fullcheck")) {
// These are "non-state-dumping" modes. If state (SAT decisions,
// propagations, etc.) is dumped, it will interfere with the validity
// of these generated queries.
if(Dump.isOn("state")) {
throw OptionException(std::string("dump option `") + optargPtr +
"' conflicts with a previous, "
"state-dumping dump option. You cannot "
"mix stateful and non-stateful dumping modes; "
"see --dump help.");
} else {
Dump.on("no-permit-state");
}
} else if(!strcmp(optargPtr, "state") ||
!strcmp(optargPtr, "missed-t-conflicts") ||
!strcmp(optargPtr, "t-propagations") ||
!strcmp(optargPtr, "missed-t-propagations")) {
// These are "state-dumping" modes. If state (SAT decisions,
// propagations, etc.) is not dumped, it will interfere with the
// validity of these generated queries.
if(Dump.isOn("no-permit-state")) {
throw OptionException(std::string("dump option `") + optargPtr +
"' conflicts with a previous, "
"non-state-dumping dump option. You cannot "
"mix stateful and non-stateful dumping modes; "
"see --dump help.");
} else {
Dump.on("state");
}
} else if(!strcmp(optargPtr, "help")) {
puts(s_dumpHelp.c_str());
exit(1);
} else if(!strcmp(optargPtr, "bv-abstraction")) {
Dump.on("bv-abstraction");
} else if(!strcmp(optargPtr, "bv-algebraic")) {
Dump.on("bv-algebraic");
} else {
throw OptionException(std::string("unknown option for --dump: `") +
optargPtr + "'. Try --dump help.");
}
Dump.on(optargPtr);
Dump.on("benchmark");
if(strcmp(optargPtr, "benchmark")) {
Dump.on("declarations");
if(strcmp(optargPtr, "declarations")) {
Dump.on("skolems");
}
}
}
free(optargPtr);
#else /* CVC4_DUMPING */
throw OptionException("The dumping feature was disabled in this build of CVC4.");
#endif /* CVC4_DUMPING */
}
vector<Options> parseThreadSpecificOptions(Options opts)
{
vector<Options> threadOptions;
unsigned numThreads = opts[options::threads];
/**
* Use satRandomSeed for generating random numbers, in particular
* satRandomSeed-s
*/
srand((unsigned int)(-opts[options::satRandomSeed]));
for(unsigned i = 0; i < numThreads; ++i) {
threadOptions.push_back(opts);
Options& tOpts = threadOptions.back();
// Set thread identifier
tOpts.set(options::thread_id, i);
// If the random-seed is negative, pick a random seed randomly
if(opts[options::satRandomSeed] < 0) {
tOpts.set(options::satRandomSeed, (double)rand());
}
if(i < opts[options::threadArgv].size() &&
!opts[options::threadArgv][i].empty()) {
// separate out the thread's individual configuration string
stringstream optidss;
optidss << "--thread" << i;
string optid = optidss.str();
int targc = 1;
char* tbuf = strdup(opts[options::threadArgv][i].c_str());
char* p = tbuf;
// string length is certainly an upper bound on size needed
char** targv = new char*[opts[options::threadArgv][i].size()];
char** vp = targv;
*vp++ = strdup(optid.c_str());
p = strtok(p, " ");
while(p != NULL) {
*vp++ = p;
++targc;
p = strtok(NULL, " ");
}
*vp++ = NULL;
if(targc > 1) { // this is necessary in case you do e.g. --thread0=" "
try {
tOpts.parseOptions(targc, targv);
} catch(OptionException& e) {
stringstream ss;
ss << optid << ": " << e.getMessage();
throw OptionException(ss.str());
}
if(optind != targc) {
stringstream ss;
ss << "unused argument `" << targv[optind]
<< "' in thread configuration " << optid << " !";
throw OptionException(ss.str());
}
if(tOpts[options::threads] != numThreads
|| tOpts[options::threadArgv] != opts[options::threadArgv]) {
stringstream ss;
ss << "not allowed to set thread options in " << optid << " !";
throw OptionException(ss.str());
}
}
free(targv[0]);
delete targv;
free(tbuf);
}
}
assert(numThreads >= 1); //do we need this?
return threadOptions;
}
std::pair<int, S> runPortfolio(int numThreads,
boost::function<T()> driverFn,
boost::function<S()> threadFns[],
size_t stackSize,
bool optionWaitToJoin,
TimerStat& statWaitTime) {
boost::thread thread_driver;
boost::thread* threads = new boost::thread[numThreads];
S* threads_returnValue = new S[numThreads];
global_flag_done = false;
global_winner = -1;
for(int t = 0; t < numThreads; ++t) {
#if BOOST_HAS_THREAD_ATTR
boost::thread::attributes attrs;
if(stackSize > 0) {
attrs.set_stack_size(stackSize);
}
threads[t] =
boost::thread(attrs, boost::bind(runThread<S>, t, threadFns[t],
boost::ref(threads_returnValue[t]) ) );
#else /* BOOST_HAS_THREAD_ATTR */
if(stackSize > 0) {
throw OptionException("cannot specify a stack size for worker threads; requires CVC4 to be built with Boost thread library >= 1.50.0");
}
threads[t] =
boost::thread(boost::bind(runThread<S>, t, threadFns[t],
boost::ref(threads_returnValue[t]) ) );
#endif /* BOOST_HAS_THREAD_ATTR */
#if defined(BOOST_THREAD_PLATFORM_PTHREAD)
if(Chat.isOn()) {
void *stackaddr;
size_t stacksize;
pthread_attr_t attr;
pthread_getattr_np(threads[t].native_handle(), &attr);
pthread_attr_getstack(&attr, &stackaddr, &stacksize);
Chat() << "Created worker thread " << t << " with stack size " << stacksize << std::endl;
}
#endif
}
if(not driverFn.empty())
thread_driver = boost::thread(driverFn);
boost::unique_lock<boost::mutex> lock(mutex_main_wait);
while(global_flag_done == false) {
condition_var_main_wait.wait(lock);
}
statWaitTime.start();
if(not driverFn.empty()) {
thread_driver.interrupt();
thread_driver.join();
}
for(int t = 0; t < numThreads; ++t) {
if(optionWaitToJoin) {
threads[t].join();
}
}
std::pair<int, S> retval(global_winner, threads_returnValue[global_winner]);
delete[] threads;
delete[] threads_returnValue;
return retval;
}