smt2_temp_filet::smt2_temp_filet() { temp_out_filename=get_temporary_file("smt2_dec_out_", ""); temp_out.open( temp_out_filename.c_str(), std::ios_base::out | std::ios_base::trunc); }
void diff_it( std::list<linet> &lines1, std::list<linet> &lines2) { std::string tmp1_name=get_temporary_file("delta_diff1", "txt"); std::string tmp2_name=get_temporary_file("delta_diff2", "txt"); std::string tmp3_name=get_temporary_file("delta_diff3", "txt"); { std::ofstream out1(tmp1_name.c_str()); std::ofstream out2(tmp2_name.c_str()); for(std::list<linet>::const_iterator l_it=lines1.begin(); l_it!=lines1.end(); l_it++) out1 << l_it->line << "\n"; for(std::list<linet>::const_iterator l_it=lines2.begin(); l_it!=lines2.end(); l_it++) out2 << l_it->line << "\n"; } std::string cmdline="diff \""+tmp1_name+"\""+ " \""+tmp2_name+"\""+ "> \""+tmp3_name+"\""; int result=system(cmdline.c_str()); // open output if(result>=0) { std::ifstream in(tmp3_name.c_str()); std::string line; std::list<std::string> diff; while(std::getline(in, line)) diff.push_back(line); process_diff(lines1, lines2, diff); } // clean up unlink(tmp1_name.c_str()); unlink(tmp2_name.c_str()); unlink(tmp3_name.c_str()); }
void goto_cc_cmdlinet::add_infile_arg(const std::string &arg) { parsed_argv.push_back(argt(arg)); parsed_argv.back().is_infile_name=true; if(arg=="-") { stdin_file=get_temporary_file("goto-cc", "stdin"); FILE *tmp=fopen(stdin_file.c_str(), "wt"); char ch; while(std::cin.read(&ch, 1)) fputc(ch, tmp); fclose(tmp); } }
bool c_preprocess( std::istream &instream, std::ostream &outstream, message_handlert &message_handler) { std::string file=get_temporary_file("tmp.stdin", ".c"); FILE *tmp=fopen(file.c_str(), "wt"); char ch; while(instream.read(&ch, 1)) fputc(ch, tmp); fclose(tmp); bool result=c_preprocess(file, outstream, message_handler); unlink(file.c_str()); return result; }
bool c_preprocess_arm( const std::string &file, std::ostream &outstream, message_handlert &message_handler) { // check extension if(is_dot_i_file(file)) return c_preprocess_none(file, outstream, message_handler); // preprocessing using armcc message_streamt message_stream(message_handler); std::string stderr_file=get_temporary_file("tmp.stderr", ""); std::string command; command="armcc -E -D__CPROVER__"; // command+=" -D__sizeof_int="+i2string(config.ansi_c.int_width/8); // command+=" -D__sizeof_long="+i2string(config.ansi_c.long_int_width/8); // command+=" -D__sizeof_ptr="+i2string(config.ansi_c.pointer_width/8); //command+=" -D__EDG_VERSION__=308"; //command+=" -D__EDG__"; // command+=" -D__CC_ARM=1"; //command+=" -D__ARMCC_VERSION=410000"; // command+=" -D__arm__"; // if(config.ansi_c.endianness==configt::ansi_ct::IS_BIG_ENDIAN) // command+=" -D__BIG_ENDIAN"; // if(config.ansi_c.char_is_unsigned) // command+=" -D__CHAR_UNSIGNED__"; if(config.ansi_c.os!=configt::ansi_ct::OS_WIN) { command+=" -D__null=0"; command+=" -D__WORDSIZE="+i2string(config.ansi_c.pointer_width); if(config.ansi_c.int_width==16) command+=GCC_DEFINES_16; else if(config.ansi_c.int_width==32) command+=GCC_DEFINES_32; else if(config.ansi_c.int_width==64) command+=GCC_DEFINES_LP64; } // Standard Defines, ANSI9899 6.10.8 command+=" -D__STDC__"; //command+=" -D__STDC_VERSION__=199901L"; for(std::list<std::string>::const_iterator it=config.ansi_c.defines.begin(); it!=config.ansi_c.defines.end(); it++) command+=" "+shell_quote("-D"+*it); for(std::list<std::string>::const_iterator it=config.ansi_c.include_paths.begin(); it!=config.ansi_c.include_paths.end(); it++) command+=" "+shell_quote("-I"+*it); int result; #ifdef _WIN32 std::string tmpi=get_temporary_file("tmp.cl", ""); command+=" \""+file+"\""; command+=" > \""+tmpi+"\""; command+=" 2> \""+stderr_file+"\""; // _popen isn't very reliable on WIN32 // that's why we use system() and a temporary file result=system(command.c_str()); FILE *stream=fopen(tmpi.c_str(), "r"); if(stream!=NULL) { int ch; while((ch=fgetc(stream))!=EOF) outstream << (unsigned char)ch; fclose(stream); unlink(tmpi.c_str()); } else { unlink(tmpi.c_str()); unlink(stderr_file.c_str()); message_stream.error("ARMCC preprocessing failed (fopen failed)"); return true; } #else command+=" \""+file+"\""; command+=" 2> \""+stderr_file+"\""; FILE *stream=popen(command.c_str(), "r"); if(stream!=NULL) { int ch; while((ch=fgetc(stream))!=EOF) outstream << (unsigned char)ch; result=pclose(stream); } else { unlink(stderr_file.c_str()); message_stream.error("ARMCC preprocessing failed (popen failed)"); return true; } #endif // errors/warnings { std::ifstream stderr_stream(stderr_file.c_str()); char ch; while(stderr_stream.read(&ch, 1)) message_stream.str << ch; } unlink(stderr_file.c_str()); if(result!=0) { message_stream.error_parse(1); message_stream.error("ARMCC preprocessing failed"); return true; } else message_stream.error_parse(2); return false; }
bool c_preprocess_gcc_clang( const std::string &file, std::ostream &outstream, message_handlert &message_handler, configt::ansi_ct::preprocessort preprocessor) { // check extension if(is_dot_i_file(file)) return c_preprocess_none(file, outstream, message_handler); // preprocessing message_streamt message_stream(message_handler); std::string stderr_file=get_temporary_file("tmp.stderr", ""); std::string command; if(preprocessor==configt::ansi_ct::PP_CLANG) command="clang"; else command="gcc"; command +=" -E -undef -D__CPROVER__"; command+=" -D__null=0"; command+=" -D__WORDSIZE="+i2string(config.ansi_c.pointer_width); command+=" -D__DBL_MIN_EXP__=\"(-1021)\""; command+=" -D__FLT_MIN__=1.17549435e-38F"; command+=" -D__DEC64_SUBNORMAL_MIN__=0.000000000000001E-383DD"; command+=" -D__CHAR_BIT__=8"; command+=" -D__DBL_DENORM_MIN__=4.9406564584124654e-324"; command+=" -D__FLT_EVAL_METHOD__=0"; command+=" -D__DBL_MIN_10_EXP__=\"(-307)\""; command+=" -D__FINITE_MATH_ONLY__=0"; command+=" -D__DEC64_MAX_EXP__=384"; command+=" -D__SHRT_MAX__=32767"; command+=" -D__LDBL_MAX__=1.18973149535723176502e+4932L"; command+=" -D__DEC32_EPSILON__=1E-6DF"; command+=" -D__SCHAR_MAX__=127"; command+=" -D__USER_LABEL_PREFIX__=_"; command+=" -D__DEC64_MIN_EXP__=\"(-383)\""; command+=" -D__DBL_DIG__=15"; command+=" -D__FLT_EPSILON__=1.19209290e-7F"; command+=" -D__LDBL_MIN__=3.36210314311209350626e-4932L"; command+=" -D__DEC32_MAX__=9.999999E96DF"; command+=" -D__DECIMAL_DIG__=21"; command+=" -D__LDBL_HAS_QUIET_NAN__=1"; command+=" -D__DYNAMIC__=1"; command+=" -D__GNUC__=4"; command+=" -D__FLT_HAS_DENORM__=1"; command+=" -D__DBL_MAX__=1.7976931348623157e+308"; command+=" -D__DBL_HAS_INFINITY__=1"; command+=" -D__DEC32_MIN_EXP__=\"(-95)\""; command+=" -D__LDBL_HAS_DENORM__=1"; command+=" -D__DEC32_MIN__=1E-95DF"; command+=" -D__DBL_MAX_EXP__=1024"; command+=" -D__DEC128_EPSILON__=1E-33DL"; command+=" -D__SSE2_MATH__=1"; command+=" -D__GXX_ABI_VERSION=1002"; command+=" -D__FLT_MIN_EXP__=\"(-125)\""; command+=" -D__DBL_MIN__=2.2250738585072014e-308"; command+=" -D__DBL_HAS_QUIET_NAN__=1"; command+=" -D__DEC128_MIN__=1E-6143DL"; command+=" -D__REGISTER_PREFIX__="; command+=" -D__DBL_HAS_DENORM__=1"; command+=" -D__DEC_EVAL_METHOD__=2"; command+=" -D__DEC128_MAX__=9.999999999999999999999999999999999E6144DL"; command+=" -D__FLT_MANT_DIG__=24"; command+=" -D__DEC64_EPSILON__=1E-15DD"; command+=" -D__DEC128_MIN_EXP__=\"(-6143)\""; command+=" -D__DEC32_SUBNORMAL_MIN__=0.000001E-95DF"; command+=" -D__FLT_RADIX__=2"; command+=" -D__LDBL_EPSILON__=1.08420217248550443401e-19L"; command+=" -D__k8=1"; command+=" -D__LDBL_DIG__=18"; command+=" -D__FLT_HAS_QUIET_NAN__=1"; command+=" -D__FLT_MAX_10_EXP__=38"; command+=" -D__FLT_HAS_INFINITY__=1"; command+=" -D__DEC64_MAX__=9.999999999999999E384DD"; command+=" -D__DEC64_MANT_DIG__=16"; command+=" -D__DEC32_MAX_EXP__=96"; command+=" -D__DEC128_SUBNORMAL_MIN__=0.000000000000000000000000000000001E-6143DL"; command+=" -D__LDBL_MANT_DIG__=64"; command+=" -D__CONSTANT_CFSTRINGS__=1"; command+=" -D__DEC32_MANT_DIG__=7"; command+=" -D__k8__=1"; command+=" -D__pic__=2"; command+=" -D__FLT_DIG__=6"; command+=" -D__FLT_MAX_EXP__=128"; //command+=" -D__BLOCKS__=1"; command+=" -D__DBL_MANT_DIG__=53"; command+=" -D__DEC64_MIN__=1E-383DD"; command+=" -D__LDBL_MIN_EXP__=\"(-16381)\""; command+=" -D__LDBL_MAX_EXP__=16384"; command+=" -D__LDBL_MAX_10_EXP__=4932"; command+=" -D__DBL_EPSILON__=2.2204460492503131e-16"; command+=" -D__GNUC_PATCHLEVEL__=1"; command+=" -D__LDBL_HAS_INFINITY__=1"; command+=" -D__INTMAX_MAX__=9223372036854775807L"; command+=" -D__FLT_DENORM_MIN__=1.40129846e-45F"; command+=" -D__PIC__=2"; command+=" -D__FLT_MAX__=3.40282347e+38F"; command+=" -D__FLT_MIN_10_EXP__=\"(-37)\""; command+=" -D__DEC128_MAX_EXP__=6144"; command+=" -D__GNUC_MINOR__=2"; command+=" -D__DBL_MAX_10_EXP__=308"; command+=" -D__LDBL_DENORM_MIN__=3.64519953188247460253e-4951L"; command+=" -D__DEC128_MANT_DIG__=34"; command+=" -D__LDBL_MIN_10_EXP__=\"(-4931)\""; if(config.ansi_c.int_width==16) command+=GCC_DEFINES_16; else if(config.ansi_c.int_width==32) { if(config.ansi_c.pointer_width==64) { if(config.ansi_c.long_int_width==32) command+=GCC_DEFINES_LLP64; // Windows, for instance else command+=GCC_DEFINES_LP64; } else command+=GCC_DEFINES_32; } // The width of wchar_t depends on the OS! { command+=" -D__WCHAR_MAX__="+type_max(wchar_t_type()); std::string sig=config.ansi_c.wchar_t_is_unsigned?"unsigned":"signed"; if(config.ansi_c.wchar_t_width==config.ansi_c.short_int_width) command+=" -D__WCHAR_TYPE__=\""+sig+" short int\""; else if(config.ansi_c.wchar_t_width==config.ansi_c.int_width) command+=" -D__WCHAR_TYPE__=\""+sig+" int\""; else if(config.ansi_c.wchar_t_width==config.ansi_c.long_int_width) command+=" -D__WCHAR_TYPE__=\""+sig+" long int\""; else assert(false); } if(config.ansi_c.char_is_unsigned) command+=" -D __CHAR_UNSIGNED__"; // gcc switch(config.ansi_c.os) { case configt::ansi_ct::OS_LINUX: command+=" -Dlinux -D__linux -D__linux__ -D__gnu_linux__"; command+=" -Dunix -D__unix -D__unix__"; command+=" -D__USE_UNIX98"; break; case configt::ansi_ct::OS_MACOS: command+=" -D__APPLE__ -D__MACH__"; // needs to be __APPLE_CPP__ for C++ command+=" -D__APPLE_CC__"; break; case configt::ansi_ct::OS_WIN: command+=" -D _WIN32"; if(config.ansi_c.mode!=configt::ansi_ct::MODE_VISUAL_STUDIO_C_CPP) command+=" -D _M_IX86=Blend"; if(config.ansi_c.arch==configt::ansi_ct::ARCH_X86_64) command+=" -D _WIN64"; // yes, both _WIN32 and _WIN64 get defined if(config.ansi_c.char_is_unsigned) command+=" -D _CHAR_UNSIGNED"; // This is Visual Studio break; case configt::ansi_ct::NO_OS: command+=" -nostdinc"; // make sure we don't mess with the system library break; default: assert(false); } // Standard Defines, ANSI9899 6.10.8 command += " -D __STDC_VERSION__=199901L"; command += " -D __STDC_IEC_559__=1"; command += " -D __STDC_IEC_559_COMPLEX__=1"; command += " -D __STDC_ISO_10646__=1"; for(std::list<std::string>::const_iterator it=config.ansi_c.defines.begin(); it!=config.ansi_c.defines.end(); it++) command+=" -D"+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.include_paths.begin(); it!=config.ansi_c.include_paths.end(); it++) command+=" -I"+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.include_files.begin(); it!=config.ansi_c.include_files.end(); it++) command+=" -include "+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.preprocessor_options.begin(); it!=config.ansi_c.preprocessor_options.end(); it++) command+=" "+*it; int result; // the following forces the mode switch(config.ansi_c.mode) { case configt::ansi_ct::MODE_GCC_C: command+=" -x c"; break; case configt::ansi_ct::MODE_GCC_CPP: command+=" -x c++"; break; default:; } #ifdef _WIN32 std::string tmpi=get_temporary_file("tmp.gcc", ""); command+=" \""+file+"\""; command+=" -o \""+tmpi+"\""; command+=" 2> \""+stderr_file+"\""; // _popen isn't very reliable on WIN32 // that's why we use system() and a temporary file result=system(command.c_str()); FILE *stream=fopen(tmpi.c_str(), "r"); // errors/warnings { std::ifstream stderr_stream(stderr_file.c_str()); char ch; while(stderr_stream.read(&ch, 1)) message_stream.str << ch; } unlink(stderr_file.c_str()); if(stream!=NULL) { int ch; while((ch=fgetc(stream))!=EOF) outstream << (unsigned char)ch; fclose(stream); unlink(tmpi.c_str()); } else { unlink(tmpi.c_str()); message_stream.str << "GCC preprocessing failed (fopen failed)" << std::endl; result=1; } #else command+=" \""+file+"\""; command+=" 2> \""+stderr_file+"\""; FILE *stream=popen(command.c_str(), "r"); if(stream!=NULL) { int ch; while((ch=fgetc(stream))!=EOF) outstream << (unsigned char)ch; result=pclose(stream); } else { message_stream.str << "GCC preprocessing failed (popen failed)" << std::endl; result=1; } // errors/warnings { std::ifstream stderr_stream(stderr_file.c_str()); if(stderr_stream) message_stream.str << stderr_stream.rdbuf(); } unlink(stderr_file.c_str()); #endif if(result!=0) { message_stream.error_parse(1); message_stream.error("GCC preprocessing failed"); return true; } else message_stream.error_parse(2); return false; }
bool c_preprocess_codewarrior( const std::string &file, std::ostream &outstream, message_handlert &message_handler) { // check extension if(is_dot_i_file(file)) return c_preprocess_none(file, outstream, message_handler); // preprocessing message_streamt message_stream(message_handler); std::string stderr_file=get_temporary_file("tmp.stderr", ""); std::string command; command="mwcceppc -E -P -D__CPROVER__ -ppopt line -ppopt full"; for(std::list<std::string>::const_iterator it=config.ansi_c.defines.begin(); it!=config.ansi_c.defines.end(); it++) command+=" -D"+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.include_paths.begin(); it!=config.ansi_c.include_paths.end(); it++) command+=" -I"+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.include_files.begin(); it!=config.ansi_c.include_files.end(); it++) command+=" -include "+shell_quote(*it); for(std::list<std::string>::const_iterator it=config.ansi_c.preprocessor_options.begin(); it!=config.ansi_c.preprocessor_options.end(); it++) command+=" "+*it; int result; std::string tmpi=get_temporary_file("tmp.cl", ""); command+=" \""+file+"\""; command+=" -o \""+tmpi+"\""; command+=" 2> \""+stderr_file+"\""; result=system(command.c_str()); std::ifstream stream_i(tmpi.c_str()); if(stream_i) { postprocess_codewarrior(stream_i, outstream); stream_i.close(); unlink(tmpi.c_str()); } else { unlink(tmpi.c_str()); unlink(stderr_file.c_str()); message_stream.error("Preprocessing failed (fopen failed)"); return true; } // errors/warnings { std::ifstream stderr_stream(stderr_file.c_str()); char ch; while(stderr_stream.read(&ch, 1)) message_stream.str << ch; } unlink(stderr_file.c_str()); if(result!=0) { message_stream.error_parse(1); message_stream.error("Preprocessing failed"); return true; } else message_stream.error_parse(2); return false; }
bool c_preprocess_visual_studio( const std::string &file, std::ostream &outstream, message_handlert &message_handler) { // check extension if(is_dot_i_file(file)) return c_preprocess_none(file, outstream, message_handler); message_streamt message_stream(message_handler); // use Visual Studio's CL std::string stderr_file=get_temporary_file("tmp.stderr", ""); std::string command_file_name=get_temporary_file("tmp.cl-cmd", ""); { std::ofstream command_file(command_file_name.c_str()); // This marks the file as UTF-8, which Visual Studio // understands. command_file << char(0xef) << char(0xbb) << char(0xbf); command_file << "/nologo" << "\n"; command_file << "/E" << "\n"; command_file << "/D__CPROVER__" << "\n"; command_file << "/D__WORDSIZE=" << config.ansi_c.pointer_width << "\n"; if(config.ansi_c.pointer_width==64) { command_file << "\"/D__PTRDIFF_TYPE__=long long int\"" << "\n"; // yes, both _WIN32 and _WIN64 get defined command_file << "/D_WIN64" << "\n"; } else { command_file << "/D__PTRDIFF_TYPE__=int" << "\n"; command_file << "/U_WIN64" << "\n"; } if(config.ansi_c.char_is_unsigned) command_file << "/J" << "\n"; // This causes _CHAR_UNSIGNED to be defined // Standard Defines, ANSI9899 6.10.8 command_file << "/D__STDC_VERSION__=199901L" << "\n"; command_file << "/D__STDC_IEC_559__=1" << "\n"; command_file << "/D__STDC_IEC_559_COMPLEX__=1" << "\n"; command_file << "/D__STDC_ISO_10646__=1" << "\n"; for(std::list<std::string>::const_iterator it=config.ansi_c.defines.begin(); it!=config.ansi_c.defines.end(); it++) command_file << "/D" << shell_quote(*it) << "\n"; for(std::list<std::string>::const_iterator it=config.ansi_c.include_paths.begin(); it!=config.ansi_c.include_paths.end(); it++) command_file << "/I" << shell_quote(*it) << "\n"; for(std::list<std::string>::const_iterator it=config.ansi_c.include_files.begin(); it!=config.ansi_c.include_files.end(); it++) command_file << "/FI" << shell_quote(*it) << "\n"; // Finally, the file to be preprocessed // (this is already in UTF-8). command_file << shell_quote(file) << "\n"; } std::string tmpi=get_temporary_file("tmp.cl", ""); std::string command="CL @\""+command_file_name+"\""; command+=" > \""+tmpi+"\""; command+=" 2> \""+stderr_file+"\""; // _popen isn't very reliable on WIN32 // that's why we use system() int result=system(command.c_str()); FILE *stream=fopen(tmpi.c_str(), "r"); if(stream==NULL) { unlink(tmpi.c_str()); unlink(stderr_file.c_str()); unlink(command_file_name.c_str()); message_stream.error("CL Preprocessing failed (fopen failed)"); return true; } { int ch; while((ch=fgetc(stream))!=EOF) outstream << (unsigned char)ch; } fclose(stream); unlink(tmpi.c_str()); unlink(command_file_name.c_str()); // errors/warnings { std::ifstream stderr_stream(stderr_file.c_str()); char ch; while(stderr_stream.read(&ch, 1)) message_stream.str << ch; } unlink(stderr_file.c_str()); if(result!=0) { message_stream.error_parse(1); message_stream.error("CL Preprocessing failed"); return true; } else message_stream.error_parse(2); return false; }
decision_proceduret::resultt smt2_dect::dec_solve() { // we write the problem into a file smt2_temp_filet smt2_temp_file; // copy from string buffer into file smt2_temp_file.temp_out << stringstream.str(); // this finishes up and closes the SMT2 file write_footer(smt2_temp_file.temp_out); smt2_temp_file.temp_out.close(); smt2_temp_file.temp_result_filename= get_temporary_file("smt2_dec_result_", ""); std::string command; switch(solver) { case solvert::BOOLECTOR: command = "boolector --smt2 " + smt2_temp_file.temp_out_filename + " -m > " + smt2_temp_file.temp_result_filename; break; case solvert::CVC3: command = "cvc3 +model -lang smtlib -output-lang smtlib " + smt2_temp_file.temp_out_filename + " > " + smt2_temp_file.temp_result_filename; break; case solvert::CVC4: // The flags --bitblast=eager --bv-div-zero-const help but only // work for pure bit-vector formulas. command = "cvc4 -L smt2 " + smt2_temp_file.temp_out_filename + " > " + smt2_temp_file.temp_result_filename; break; case solvert::MATHSAT: // The options below were recommended by Alberto Griggio // on 10 July 2013 command = "mathsat -input=smt2" " -preprocessor.toplevel_propagation=true" " -preprocessor.simplification=7" " -dpll.branching_random_frequency=0.01" " -dpll.branching_random_invalidate_phase_cache=true" " -dpll.restart_strategy=3" " -dpll.glucose_var_activity=true" " -dpll.glucose_learnt_minimization=true" " -theory.bv.eager=true" " -theory.bv.bit_blast_mode=1" " -theory.bv.delay_propagated_eqs=true" " -theory.fp.mode=1" " -theory.fp.bit_blast_mode=2" " -theory.arr.mode=1" " < "+smt2_temp_file.temp_out_filename + " > "+smt2_temp_file.temp_result_filename; break; case solvert::OPENSMT: command = "opensmt " + smt2_temp_file.temp_out_filename + " > " + smt2_temp_file.temp_result_filename; break; case solvert::YICES: // command = "yices -smt -e " // Calling convention for older versions command = "yices-smt2 " // Calling for 2.2.1 + smt2_temp_file.temp_out_filename + " > " + smt2_temp_file.temp_result_filename; break; case solvert::Z3: command = "z3 -smt2 " + smt2_temp_file.temp_out_filename + " > " + smt2_temp_file.temp_result_filename; break; default: assert(false); } #if defined(__linux__) || defined(__APPLE__) command+=" 2>&1"; #endif int res=system(command.c_str()); if(res<0) { error() << "error running SMT2 solver" << eom; return decision_proceduret::resultt::D_ERROR; } std::ifstream in(smt2_temp_file.temp_result_filename.c_str()); return read_result(in); }
decision_proceduret::resultt smt1_dect::dec_solve() { // SMT1 is really not incremental assert(!dec_solve_was_called); dec_solve_was_called=true; post_process(); // this closes the SMT benchmark smt1_prop.finalize(); temp_out.close(); temp_result_filename= get_temporary_file("smt1_dec_result_", ""); std::string command; switch(solver) { case CVC3: command = "cvc3 +model -lang smtlib -output-lang smtlib " + temp_out_filename + " > " + temp_result_filename; break; case BOOLECTOR: // –rwl0 disables rewriting, which makes things slower, // but in return values for arrays appear command = "boolector -rwl0 --smt " + temp_out_filename + " -fm --output " + temp_result_filename; break; case OPENSMT: command = "todo " + temp_out_filename + " > " + temp_result_filename; break; case YICES: command = "yices -smt -e " + temp_out_filename + " > " + temp_result_filename; break; case MATHSAT: command = "mathsat -model -input=smt" " < "+temp_out_filename + " > "+temp_result_filename; break; case Z3: command = "z3 -m " + temp_out_filename + " > " + temp_result_filename; break; default: assert(false); } #if defined(__LINUX__) || defined(__APPLE__) command+=" 2>&1"; #endif system(command.c_str()); std::ifstream in(temp_result_filename.c_str()); switch(solver) { case BOOLECTOR: return read_result_boolector(in); case CVC3: return read_result_cvc3(in); case OPENSMT: return read_result_opensmt(in); case YICES: return read_result_yices(in); case MATHSAT: return read_result_mathsat(in); case Z3: return read_result_z3(in); default: assert(false); } }
decision_proceduret::resultt smt1_dect::dec_solve() { post_process(); // this closes the SMT benchmark smt1_prop.finalize(); temp_out.close(); temp_result_filename= get_temporary_file("smt1_dec_result_", ""); std::string command; switch(solver) { case CVC3: command = "cvc3 +model -lang smtlib -output-lang smtlib " + temp_out_filename + " > " + temp_result_filename; break; case BOOLECTOR: command = "boolector --smt " + temp_out_filename + " -fm --output " + temp_result_filename; break; case OPENSMT: command = "todo " + temp_out_filename + " > " + temp_result_filename; break; case YICES: command = "yices -smt -e " + temp_out_filename + " > " + temp_result_filename; break; case Z3: command = "z3 -m " + temp_out_filename + " > " + temp_result_filename; break; default: assert(false); } #if defined(__LINUX__) || defined(__APPLE__) command+=" 2>&1"; #endif system(command.c_str()); std::ifstream in(temp_result_filename.c_str()); switch(solver) { case BOOLECTOR: return read_result_boolector(in); case CVC3: return read_result_cvc3(in); case OPENSMT: return read_result_opensmt(in); case YICES: return read_result_yices(in); case Z3: return read_result_z3(in); default: assert(false); } }
decision_proceduret::resultt smt1_dect::dec_solve() { // SMT1 is really not incremental assert(!dec_solve_was_called); dec_solve_was_called=true; // this closes the SMT benchmark write_footer(); temp_out.close(); temp_result_filename= get_temporary_file("smt1_dec_result_", ""); std::string command; switch(solver) { case BOOLECTOR: // -rwl0 disables rewriting, which makes things slower, // but in return values for arrays appear // command = "boolector -rwl0 --smt " // Removed as not necessarily needed on newer versions command = "boolector --smt " + temp_out_filename + " --model --output " + temp_result_filename; break; case CVC3: command = "cvc3 +model -lang smtlib -output-lang smtlib " + temp_out_filename + " > " + temp_result_filename; break; case CVC4: command = "cvc4 -L smt1 " + temp_out_filename + " > " + temp_result_filename; break; case MATHSAT: command = "mathsat -model -input=smt" " < "+temp_out_filename + " > "+temp_result_filename; break; case OPENSMT: command = "opensmt " + temp_out_filename + " > " + temp_result_filename; break; case YICES: // command = "yices -smt -e " // Calling convention for older versions command = "yices-smt --full-model " // Calling for 2.2.1 + temp_out_filename + " > " + temp_result_filename; break; case Z3: command = "z3 -smt " + temp_out_filename + " > " + temp_result_filename; break; default: assert(false); } #if defined(__linux__) || defined(__APPLE__) command+=" 2>&1"; #endif int res=system(command.c_str()); if(res<0) { error() << "error running SMT1 solver" << eom; return decision_proceduret::D_ERROR; } std::ifstream in(temp_result_filename.c_str()); switch(solver) { case BOOLECTOR: return read_result_boolector(in); case CVC3: return read_result_cvc3(in); case CVC4: error() << "no support for CVC4 with SMT1, use SMT2 instead" << eom; return decision_proceduret::D_ERROR; case MATHSAT: return read_result_mathsat(in); case OPENSMT: return read_result_opensmt(in); case YICES: return read_result_yices(in); case Z3: return read_result_z3(in); case GENERIC: default: error() << "Generic solver can't solve" << eom; return decision_proceduret::D_ERROR; } }