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());
}
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
}
