bool symex_parseoptionst::get_goto_program(
const optionst &options,
goto_functionst &goto_functions)
{
if(cmdline.args.empty())
{
error() << "Please provide a program to verify" << eom;
return true;
}
try
{
if(cmdline.args.size()==1 &&
is_goto_binary(cmdline.args[0]))
{
status() << "Reading GOTO program from file" << eom;
if(read_goto_binary(cmdline.args[0],
symbol_table, goto_functions, get_message_handler()))
return true;
config.ansi_c.set_from_symbol_table(symbol_table);
if(cmdline.isset("show-symbol-table"))
{
show_symbol_table();
return true;
}
irep_idt entry_point=goto_functions.entry_point();
if(symbol_table.symbols.find(entry_point)==symbol_table.symbols.end())
{
error() << "The goto binary has no entry point; please complete linking" << eom;
return true;
}
}
else if(cmdline.isset("show-parse-tree"))
{
if(cmdline.args.size()!=1)
{
error() << "Please give one source file only" << eom;
return true;
}
std::string filename=cmdline.args[0];
#ifdef _MSC_VER
std::ifstream infile(widen(filename).c_str());
#else
std::ifstream infile(filename.c_str());
#endif
if(!infile)
{
error() << "failed to open input file `" << filename << "'" << eom;
return true;
}
languaget *language=get_language_from_filename(filename);
if(language==NULL)
{
error() << "failed to figure out type of file `" << filename << "'" << eom;
return true;
}
status("Parsing", filename);
if(language->parse(infile, filename, get_message_handler()))
{
error() << "PARSING ERROR" << eom;
return true;
}
language->show_parse(std::cout);
return true;
}
else
{
if(parse()) return true;
if(typecheck()) return true;
if(final()) return true;
// we no longer need any parse trees or language files
clear_parse();
if(cmdline.isset("show-symbol-table"))
{
show_symbol_table();
return true;
}
irep_idt entry_point=goto_functions.entry_point();
if(symbol_table.symbols.find(entry_point)==symbol_table.symbols.end())
{
error() << "No entry point; please provide a main function" << eom;
return true;
}
status() << "Generating GOTO Program" << eom;
goto_convert(symbol_table, goto_functions, ui_message_handler);
}
// finally add the library
status() << "Adding CPROVER library" << eom;
link_to_library(symbol_table, goto_functions, ui_message_handler);
if(process_goto_program(options, goto_functions))
return true;
}
catch(const char *e)
{
error(e);
return true;
}
catch(const std::string e)
{
error(e);
return true;
}
catch(int)
{
return true;
}
catch(std::bad_alloc)
{
error() << "Out of memory" << eom;
return true;
}
return false;
}
int preparet::doit()
{
register_languages();
try
{
// do we have a goto binary?
if(cmdline.args.size()==1 &&
is_goto_binary(cmdline.args[0]))
{
status("Reading GOTO program from file");
if(read_goto_binary(cmdline.args[0],
context, goto_functions,
get_message_handler()))
return 1;
config.ansi_c.set_from_context(context);
}
else
{
//
// parsing
//
if(parse()) return 1;
//
// type checking
//
if(typecheck()) return 1;
//
// final adjustments
//
if(final()) return 1;
}
{
int return_value_get_sync_modules=get_sync_modules();
if(return_value_get_sync_modules>=0)
return return_value_get_sync_modules;
}
{
int return_value_get_async_modules=get_async_modules();
if(return_value_get_async_modules>=0)
return return_value_get_async_modules;
}
if(cmdline.isset("show-claims"))
{
show_claims(ns, get_ui(), goto_functions);
return 0;
}
// get the user provided predicates
if(cmdline.isset("predicates"))
get_predicates(
cmdline.getval("predicates"),
get_message_handler(),
ns,
user_provided_predicates);
}
catch(const char *e)
{
error(e);
return 1;
}
catch(const std::string e)
{
error(e);
return 1;
}
catch(int)
{
return 1;
}
return -1; // proceed!
}
bool get_goto_modelt::operator()(const std::vector<std::string> &files)
{
if(files.empty())
{
error() << "Please provide a program" << eom;
return true;
}
try
{
std::vector<std::string> binaries, sources;
binaries.reserve(files.size());
sources.reserve(files.size());
for(const auto &file : files)
{
if(is_goto_binary(file))
binaries.push_back(file);
else
sources.push_back(file);
}
if(!sources.empty())
{
language_filest language_files;
language_files.set_message_handler(get_message_handler());
for(const auto &filename : sources)
{
#ifdef _MSC_VER
std::ifstream infile(widen(filename));
#else
std::ifstream infile(filename);
#endif
if(!infile)
{
error() << "failed to open input file `" << filename
<< '\'' << eom;
return true;
}
std::pair<language_filest::file_mapt::iterator, bool>
result=language_files.file_map.insert(
std::pair<std::string, language_filet>(filename, language_filet()));
language_filet &lf=result.first->second;
lf.filename=filename;
lf.language=get_language_from_filename(filename);
if(lf.language==NULL)
{
error("failed to figure out type of file", filename);
return true;
}
languaget &language=*lf.language;
language.set_message_handler(get_message_handler());
status() << "Parsing " << filename << eom;
if(language.parse(infile, filename))
{
error() << "PARSING ERROR" << eom;
return true;
}
lf.get_modules();
}
status() << "Converting" << eom;
if(language_files.typecheck(symbol_table))
{
error() << "CONVERSION ERROR" << eom;
return true;
}
if(binaries.empty())
{
if(language_files.final(symbol_table))
{
error() << "CONVERSION ERROR" << eom;
return true;
}
}
}
for(const auto &file : binaries)
{
status() << "Reading GOTO program from file" << eom;
if(read_object_and_link(file, *this, get_message_handler()))
return true;
}
if(!binaries.empty())
config.set_from_symbol_table(symbol_table);
status() << "Generating GOTO Program" << eom;
goto_convert(symbol_table,
goto_functions,
get_message_handler());
}
bool cbmc_parseoptionst::get_goto_program(
const optionst &options,
bmct &bmc,
goto_functionst &goto_functions)
{
if(cmdline.args.size()==0)
{
error("Please provide a program to verify");
return true;
}
try
{
if(cmdline.args.size()==1 &&
is_goto_binary(cmdline.args[0]))
{
status("Reading GOTO program from file");
if(read_goto_binary(cmdline.args[0],
context, goto_functions, get_message_handler()))
return true;
config.ansi_c.set_from_context(context);
if(cmdline.isset("show-symbol-table"))
{
show_symbol_table();
return true;
}
if(context.symbols.find(ID_main)==context.symbols.end())
{
error("The goto binary has no entry point; please complete linking");
return true;
}
}
else
{
if(parse()) return true;
if(typecheck()) return true;
if(get_modules(bmc)) return true;
if(final()) return true;
// we no longer need any parse trees or language files
clear_parse();
if(cmdline.isset("show-symbol-table"))
{
show_symbol_table();
return true;
}
if(context.symbols.find(ID_main)==context.symbols.end())
{
error("No entry point; please provide a main function");
return true;
}
status("Generating GOTO Program");
goto_convert(
context, options, goto_functions,
ui_message_handler);
}
// finally add the library
status("Adding CPROVER library");
link_to_library(
context, goto_functions, options, ui_message_handler);
if(process_goto_program(options, goto_functions))
return true;
}
catch(const char *e)
{
error(e);
return true;
}
catch(const std::string e)
{
error(e);
return true;
}
catch(int)
{
return true;
}
catch(std::bad_alloc)
{
error("Out of memory");
return true;
}
return false;
}
int cbmc_parse_optionst::get_goto_program(
const optionst &options,
bmct &bmc, // for get_modules
goto_functionst &goto_functions)
{
if(cmdline.args.empty())
{
error() << "Please provide a program to verify" << eom;
return 6;
}
try
{
if(cmdline.isset("show-parse-tree"))
{
if(cmdline.args.size()!=1 ||
is_goto_binary(cmdline.args[0]))
{
error() << "Please give exactly one source file" << eom;
return 6;
}
std::string filename=cmdline.args[0];
#ifdef _MSC_VER
std::ifstream infile(widen(filename).c_str());
#else
std::ifstream infile(filename.c_str());
#endif
if(!infile)
{
error() << "failed to open input file `" << filename << "'" << eom;
return 6;
}
languaget *language=get_language_from_filename(filename);
if(language==NULL)
{
error() << "failed to figure out type of file `" << filename << "'" << eom;
return 6;
}
language->set_message_handler(get_message_handler());
status("Parsing", filename);
if(language->parse(infile, filename))
{
error() << "PARSING ERROR" << eom;
return 6;
}
language->show_parse(std::cout);
return 0;
}
cmdlinet::argst binaries;
binaries.reserve(cmdline.args.size());
for(cmdlinet::argst::iterator
it=cmdline.args.begin();
it!=cmdline.args.end();
) // no ++it
{
if(is_goto_binary(*it))
{
binaries.push_back(*it);
it=cmdline.args.erase(it);
continue;
}
++it;
}
if(!cmdline.args.empty())
{
if(parse()) return 6;
if(typecheck()) return 6;
int get_modules_ret=get_modules(bmc);
if(get_modules_ret!=-1) return get_modules_ret;
if(binaries.empty() && final()) return 6;
// we no longer need any parse trees or language files
clear_parse();
}
for(cmdlinet::argst::const_iterator
it=binaries.begin();
it!=binaries.end();
++it)
{
status() << "Reading GOTO program from file " << eom;
if(read_object_and_link(*it, symbol_table, goto_functions, *this))
return 6;
}
if(!binaries.empty())
config.set_from_symbol_table(symbol_table);
if(cmdline.isset("show-symbol-table"))
{
show_symbol_table();
return 0;
}
if(entry_point(symbol_table, "main", get_message_handler()))
return 6;
status() << "Generating GOTO Program" << eom;
goto_convert(symbol_table, goto_functions, ui_message_handler);
if(process_goto_program(options, goto_functions))
return 6;
}
catch(const char *e)
{
error() << e << eom;
return 6;
}
catch(const std::string e)
{
error() << e << eom;
return 6;
}
catch(int)
{
return 6;
}
catch(std::bad_alloc)
{
error() << "Out of memory" << eom;
return 6;
}
return -1; // no error, continue
}
