void symex_parseoptionst::eval_verbosity()
{
// this is our default verbosity
int v=messaget::M_STATISTICS;
if(cmdline.isset("verbosity"))
{
v=unsafe_string2int(cmdline.getval("verbosity"));
if(v<0)
v=0;
else if(v>10)
v=10;
}
set_verbosity(v);
}
/// takes a string and unescapes any xml style escaped symbols
/// \par parameters: a string
/// \return the unescaped string
std::string xmlt::unescape(const std::string &str)
{
std::string result("");
result.reserve(str.size());
for(std::string::const_iterator it=str.begin();
it!=str.end();
it++)
{
if(*it=='&')
{
std::string tmp;
it++;
while(it!=str.end() && *it!=';')
tmp+=*it++;
if(tmp=="gt")
result+='>';
else if(tmp=="lt")
result+='<';
else if(tmp=="amp")
result+='&';
else if(tmp[0]=='#' && tmp[1]!='x')
{
char c=unsafe_string2int(tmp.substr(1, tmp.size()-1));
result+=c;
}
else
throw "XML escape code not implemented"; // NOLINT(readability/throw)
}
else
result+=*it;
}
return result;
}
bool qbf_skizzo_coret::get_certificate(void)
{
std::string result_tmp_file="ozziKs.out";
std::string options="-dump qbm=bdd";
std::string log_file = qbf_tmp_file + ".sKizzo.log";
system(("ozziKs " + options + " " + log_file +
" > "+result_tmp_file).c_str());
// read result
bool result=false;
{
std::ifstream in(result_tmp_file.c_str());
std::string key=" [OK, VALID,";
while(in)
{
std::string line;
std::getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line.compare(0, key.size(), key)==0)
{
result=true;
break;
}
}
}
if(!result)
{
messaget::error() << "Skizzo failed: unknown result" << messaget::eom;
return true;
}
remove(result_tmp_file.c_str());
remove(log_file.c_str());
// certificate reconstruction done, now let's load it from the .qbm file
int n_e;
std::vector<int> e_list;
int e_max=0;
// check header
result=false;
{
std::ifstream in((qbf_tmp_file+".qbm").c_str());
std::string key="# existentials[";
std::string line;
std::getline(in, line);
assert(line=="# QBM file, 1.3");
while(in)
{
std::getline(in, line);
if(line!="" && line[line.size()-1]=='\r')
line.resize(line.size()-1);
if(line.compare(0, key.size(), key)==0)
{
result=true;
break;
}
}
size_t ob=line.find('[');
std::string n_es=line.substr(ob+1, line.find(']')-ob-1);
n_e=unsafe_string2int(n_es);
assert(n_e!=0);
e_list.resize(n_e);
std::string e_lists=line.substr(line.find(':')+2);
for(int i=0; i<n_e; i++)
{
size_t space=e_lists.find(' ');
int cur=unsafe_string2int(e_lists.substr(0, space));
assert(cur!=0);
e_list[i]=cur;
if(cur>e_max) e_max=cur;
e_lists = e_lists.substr(space+1);
}
if(!result)
throw ("Existential mapping from sKizzo missing");
in.close();
// workaround for long comments
system(("sed -e \"s/^#.*$/# no comment/\" -i "+qbf_tmp_file+".qbm").c_str());
}
{
DdNode **bdds;
std::string bdd_file=qbf_tmp_file+".qbm";
// dddmp insists on a non-const string here...
char filename[bdd_file.size()+1];
strcpy(filename, bdd_file.c_str());
bdd_manager->AutodynEnable(CUDD_REORDER_SIFT);
int nroots =
Dddmp_cuddBddArrayLoad(bdd_manager->getManager(),
DDDMP_ROOT_MATCHLIST, NULL,
DDDMP_VAR_MATCHIDS, NULL, NULL, NULL,
DDDMP_MODE_DEFAULT,
filename,
NULL,
&bdds);
assert(nroots=2*n_e); // ozziKs documentation guarantees that.
model_bdds.resize(e_max+1, NULL);
for(unsigned i=0; i<e_list.size(); i++)
{
int cur=e_list[i];
DdNode *posNode = bdds[2*i];
DdNode *negNode = bdds[2*i+1];
if(Cudd_DagSize(posNode) <= Cudd_DagSize(negNode))
model_bdds[cur]=new BDD(*bdd_manager, posNode);
else
model_bdds[cur]=new BDD(*bdd_manager, Cudd_Not(negNode));
}
// tell CUDD that we don't need those BDDs anymore.
for(int i=0; i<nroots; i++)
Cudd_Deref(bdds[i]);
free(bdds);
bdds=NULL;
remove(bdd_file.c_str());
remove((qbf_tmp_file+".qbm").c_str());
}
return false;
}
void document_propertiest::get_code(
const source_locationt &source_location,
std::string &dest)
{
dest="";
const irep_idt &file=source_location.get_file();
const irep_idt &line=source_location.get_line();
if(file=="" || line=="") return;
std::ifstream in(id2string(file));
if(!in)
{
dest+="ERROR: unable to open ";
dest+=id2string(file);
dest+="\n";
return;
}
int line_int=unsafe_string2int(id2string(line));
int line_start=line_int-3,
line_end=line_int+3;
if(line_start<=1) line_start=1;
// skip line_start-1 lines
for(int l=0; l<line_start-1; l++)
{
std::string tmp;
std::getline(in, tmp);
}
// read till line_end
std::list<linet> lines;
for(int l=line_start; l<=line_end && in; l++)
{
lines.push_back(linet());
std::string &line=lines.back().text;
std::getline(in, line);
if(!line.empty() && line[line.size()-1]=='\r')
line.resize(line.size()-1);
lines.back().line_number=l;
}
// remove empty lines at the end and at the beginning
for(std::list<linet>::iterator it=lines.begin();
it!=lines.end();)
{
if(is_empty(it->text))
it=lines.erase(it);
else
break;
}
for(std::list<linet>::iterator it=lines.end();
it!=lines.begin();)
{
it--;
if(is_empty(it->text))
it=lines.erase(it);
else
break;
}
// strip space
strip_space(lines);
// build dest
for(std::list<linet>::iterator it=lines.begin();
it!=lines.end(); it++)
{
std::string line_no=std::to_string(it->line_number);
std::string tmp;
switch(format)
{
case LATEX:
while(line_no.size()<4)
line_no=" "+line_no;
line_no+" ";
tmp+=escape_latex(it->text, true);
if(it->line_number==line_int)
tmp="{\\ttb{}"+tmp+"}";
break;
case HTML:
while(line_no.size()<4)
line_no=" "+line_no;
line_no+" ";
tmp+=escape_html(it->text);
if(it->line_number==line_int)
tmp="<em>"+tmp+"</em>";
break;
}
dest+=tmp+"\n";
}
}
int irept::get_int(const irep_namet &name) const
{
return unsafe_string2int(get_string(name));
}
bool irept::get_bool(const irep_namet &name) const
{
return unsafe_string2int(get_string(name))!=0;
}
int armcc_modet::doit()
{
if(cmdline.isset('?') || cmdline.isset("help"))
{
help();
return EX_OK;
}
unsigned int verbosity=1;
compilet compiler(cmdline);
#if 0
bool act_as_ld=
has_prefix(base_name, "ld") ||
has_prefix(base_name, "goto-ld") ||
has_prefix(base_name, "link") ||
has_prefix(base_name, "goto-link");
#endif
if(cmdline.isset("verbosity"))
verbosity=unsafe_string2int(cmdline.get_value("verbosity"));
compiler.ui_message_handler.set_verbosity(verbosity);
ui_message_handler.set_verbosity(verbosity);
debug() << "ARM mode" << eom;
// get configuration
config.set(cmdline);
config.ansi_c.mode=configt::ansi_ct::flavourt::MODE_ARM_C_CPP;
config.ansi_c.arch="arm";
// determine actions to be taken
if(cmdline.isset('E'))
compiler.mode=compilet::PREPROCESS_ONLY;
else if(cmdline.isset('c') || cmdline.isset('S'))
compiler.mode=compilet::COMPILE_ONLY;
else
compiler.mode=compilet::COMPILE_LINK_EXECUTABLE;
if(cmdline.isset('U'))
config.ansi_c.undefines=cmdline.get_values('U');
if(cmdline.isset('L'))
compiler.library_paths=cmdline.get_values('L');
// Don't add the system paths!
// these take precedence over -I
if(cmdline.isset('J'))
{
const std::list<std::string> &values=
cmdline.get_values('J');
for(std::list<std::string>::const_iterator
it=values.begin();
it!=values.end();
it++)
config.ansi_c.preprocessor_options.push_back("-J"+*it);
}
if(cmdline.isset("preinclude="))
{
const std::list<std::string> &values=
cmdline.get_values("preinclude=");
for(std::list<std::string>::const_iterator
it=values.begin();
it!=values.end();
it++)
config.ansi_c.preprocessor_options.push_back("--preinclude="+*it);
}
// armcc's default is .o
if(cmdline.isset("default_extension="))
compiler.object_file_extension=
cmdline.get_value("default_extension=");
else
compiler.object_file_extension="o";
// note that ARM's default is "unsigned_chars",
// in contrast to gcc's default!
if(cmdline.isset("signed_chars"))
config.ansi_c.char_is_unsigned=false;
else
config.ansi_c.char_is_unsigned=true;
// ARM's default is 16 bits for wchar_t
if(cmdline.isset("wchar32"))
config.ansi_c.wchar_t_width=32;
else
config.ansi_c.wchar_t_width=16;
if(cmdline.isset('o'))
{
// given goto-armcc -o file1 -o file2, we output to file2, not file1
compiler.output_file_object=cmdline.get_values('o').back();
compiler.output_file_executable=cmdline.get_values('o').back();
}
else
{
compiler.output_file_object="";
compiler.output_file_executable="a.out";
}
if(verbosity>8)
{
std::list<std::string>::iterator it;
std::cout << "Defines:\n";
for(it=config.ansi_c.defines.begin();
it!=config.ansi_c.defines.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Undefines:\n";
for(it=config.ansi_c.undefines.begin();
it!=config.ansi_c.undefines.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Preprocessor Options:\n";
for(it=config.ansi_c.preprocessor_options.begin();
it!=config.ansi_c.preprocessor_options.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Include Paths:\n";
for(it=config.ansi_c.include_paths.begin();
it!=config.ansi_c.include_paths.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Library Paths:\n";
for(it=compiler.library_paths.begin();
it!=compiler.library_paths.end();
it++)
{
std::cout << " " << (*it) << std::endl;
}
std::cout << "Output file (object): " << compiler.output_file_object << std::endl;
std::cout << "Output file (executable): " << compiler.output_file_executable << std::endl;
}
// Parse input program, convert to goto program, write output
return compiler.doit() ? EX_USAGE : EX_OK;
}
exprt convert_integer_literal(const std::string &src)
{
bool is_unsigned=false, is_imaginary=false;
unsigned long_cnt=0;
unsigned width_suffix=0;
unsigned base=10;
for(unsigned i=0; i<src.size(); i++)
{
char ch=src[i];
if(ch=='u' || ch=='U')
is_unsigned=true;
else if(ch=='l' || ch=='L')
long_cnt++;
else if(ch=='i' || ch=='I')
{
// This can be "1i128" in MS mode,
// and "10i" (imaginary) for GCC.
// If it's followed by a number, we do MS mode.
if((i+1)<src.size() && isdigit(src[i+1]))
width_suffix=unsafe_string2int(src.substr(i+1));
else
is_imaginary=true;
}
else if(ch=='j' || ch=='J')
is_imaginary=true;
}
mp_integer value;
if(src.size()>=2 && src[0]=='0' && tolower(src[1])=='x')
{
// hex; strip "0x"
base=16;
std::string without_prefix(src, 2, std::string::npos);
value=string2integer(without_prefix, 16);
}
else if(src.size()>=2 && src[0]=='0' && tolower(src[1])=='b')
{
// binary; strip "0x"
// see http://gcc.gnu.org/onlinedocs/gcc/Binary-constants.html
base=2;
std::string without_prefix(src, 2, std::string::npos);
value=string2integer(without_prefix, 2);
}
else if(src.size()>=2 && src[0]=='0' && isdigit(src[1]))
{
// octal
base=8;
value=string2integer(src, 8);
}
else
{
// The default is base 10.
value=string2integer(src, 10);
}
if(width_suffix!=0)
{
// this is a Microsoft extension
irep_idt c_type;
if(width_suffix<=config.ansi_c.int_width)
c_type=is_unsigned?ID_unsigned_int:ID_signed_int;
else if(width_suffix<=config.ansi_c.long_int_width)
c_type=is_unsigned?ID_unsigned_long_int:ID_signed_long_int;
else
c_type=is_unsigned?ID_unsigned_long_long_int:ID_signed_long_long_int;
typet type=typet(is_unsigned?ID_unsignedbv:ID_signedbv);
type.set(ID_width, width_suffix);
type.set(ID_C_c_type, c_type);
exprt result=from_integer(value, type);
return result;
}
mp_integer value_abs=value;
if(value<0)
value_abs.negate();
bool is_hex_or_oct_or_bin=(base==8) || (base==16) || (base==2);
#define FITS(width, signed) \
((signed?!is_unsigned:(is_unsigned || is_hex_or_oct_or_bin)) && \
(power(2, signed?width-1:width)>value_abs))
unsigned width;
bool is_signed=false;
irep_idt c_type;
if(FITS(config.ansi_c.int_width, true) && long_cnt==0) // int
{
width=config.ansi_c.int_width;
is_signed=true;
c_type=ID_signed_int;
}
else if(FITS(config.ansi_c.int_width, false) && long_cnt==0) // unsigned int
{
width=config.ansi_c.int_width;
is_signed=false;
c_type=ID_unsigned_int;
}
else if(FITS(config.ansi_c.long_int_width, true) && long_cnt!=2) // long int
{
width=config.ansi_c.long_int_width;
is_signed=true;
c_type=ID_signed_long_int;
}
// unsigned long int
else if(FITS(config.ansi_c.long_int_width, false) && long_cnt!=2)
{
width=config.ansi_c.long_int_width;
is_signed=false;
c_type=ID_unsigned_long_int;
}
else if(FITS(config.ansi_c.long_long_int_width, true)) // long long int
{
width=config.ansi_c.long_long_int_width;
is_signed=true;
c_type=ID_signed_long_long_int;
}
// unsigned long long int
else if(FITS(config.ansi_c.long_long_int_width, false))
{
width=config.ansi_c.long_long_int_width;
is_signed=false;
c_type=ID_unsigned_long_long_int;
}
else
{
// Way too large. Should consider issuing a warning.
width=config.ansi_c.long_long_int_width;
if(is_unsigned)
{
is_signed=false;
c_type=ID_unsigned_long_long_int;
}
else
c_type=ID_signed_long_long_int;
}
typet type=typet(is_signed?ID_signedbv:ID_unsignedbv);
type.set(ID_width, width);
type.set(ID_C_c_type, c_type);
exprt result;
if(is_imaginary)
{
complex_typet complex_type;
complex_type.subtype()=type;
result=exprt(ID_complex, complex_type);
result.operands().resize(2);
result.op0()=from_integer(0, type);
result.op1()=from_integer(value, type);
}
else
{
result=from_integer(value, type);
result.set(ID_C_base, base);
}
return result;
}