int cbmc_parseoptionst::doit() { if(cmdline.isset("version")) { std::cout << CBMC_VERSION << std::endl; return 0; } // // unwinding of transition systems // if(cmdline.isset("module") || cmdline.isset("gen-interface")) { error("This version of CBMC has no support for " " hardware modules. Please use hw-cbmc."); return 1; } register_languages(); // // command line options // optionst options; get_command_line_options(options); bmct bmc(options, context, ui_message_handler); set_verbosity(bmc); set_verbosity(*this); if(cmdline.isset("preprocess")) { preprocessing(); return 0; } goto_functionst goto_functions; if(get_goto_program(options, bmc, goto_functions)) return 6; if(cmdline.isset("show-claims")) { const namespacet ns(context); show_claims(ns, get_ui(), goto_functions); return 0; } if(set_claims(goto_functions)) return 7; // do actual BMC return do_bmc(bmc, goto_functions); }
/// constructor goto_cc_modet::goto_cc_modet( goto_cc_cmdlinet &_cmdline, const std::string &_base_name, message_handlert &_message_handler): messaget(_message_handler), cmdline(_cmdline), base_name(_base_name) { register_languages(); }
int tan_parseoptionst::doit() { register_languages(); if(check_and_set_options()) return TAN_UNKNOWN; if(from_file(cmdline.args[0])) return TAN_UNKNOWN; if(prepare()) return TAN_UNKNOWN; return analyze(); }
action_t init::execute() { try { tts_engine=engine::create(); logger::log(3,"Initialized the engine"); register_languages(); register_voices(); synthesizer.start(); logger::log(2,"Started the synthesis thread"); } catch(const std::exception& e) { logger::log(2,"Initialization error: ",e.what()); reply r; r("399-",e.what()); r("399 ERROR CANNOT INITIALIZE MODULE"); return action_abort; } reply r; r("299-RHVoice initialized"); r("299 OK LOADED SUCCESSFULLY"); return action_continue; }
int goto_instrument_parse_optionst::doit() { if(cmdline.isset("version")) { std::cout << CBMC_VERSION << std::endl; return 0; } if(cmdline.args.size()!=1 && cmdline.args.size()!=2) { help(); return 0; } eval_verbosity(); try { register_languages(); get_goto_program(); instrument_goto_program(); if(cmdline.isset("show-value-sets")) { do_function_pointer_removal(); do_partial_inlining(); // recalculate numbers, etc. goto_functions.update(); status() << "Pointer Analysis" << eom; namespacet ns(symbol_table); value_set_analysist value_set_analysis(ns); value_set_analysis(goto_functions); show_value_sets(get_ui(), goto_functions, value_set_analysis); return 0; } if(cmdline.isset("show-global-may-alias")) { do_function_pointer_removal(); do_partial_inlining(); do_remove_returns(); parameter_assignments(symbol_table, goto_functions); // recalculate numbers, etc. goto_functions.update(); namespacet ns(symbol_table); global_may_alias_analysist global_may_alias_analysis; global_may_alias_analysis(goto_functions, ns); global_may_alias_analysis.output(ns, goto_functions, std::cout); return 0; } if(cmdline.isset("show-local-bitvector-analysis")) { do_function_pointer_removal(); do_partial_inlining(); parameter_assignments(symbol_table, goto_functions); // recalculate numbers, etc. goto_functions.update(); namespacet ns(symbol_table); forall_goto_functions(it, goto_functions) { local_bitvector_analysist local_bitvector_analysis(it->second); std::cout << ">>>>" << std::endl; std::cout << ">>>> " << it->first << std::endl; std::cout << ">>>>" << std::endl; local_bitvector_analysis.output(std::cout, it->second, ns); std::cout << std::endl; } return 0; }
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! }
int cbmc_parse_optionst::doit() { if(cmdline.isset("version")) { std::cout << CBMC_VERSION << std::endl; return 0; } // // command line options // optionst options; get_command_line_options(options); eval_verbosity(); // // Print a banner // status() << "CBMC version " CBMC_VERSION " " << sizeof(void *)*8 << "-bit " << config.this_architecture() << " " << config.this_operating_system() << eom; // // Unwinding of transition systems is done by hw-cbmc. // if(cmdline.isset("module") || cmdline.isset("gen-interface")) { error() << "This version of CBMC has no support for " " hardware modules. Please use hw-cbmc." << eom; return 1; } register_languages(); if(cmdline.isset("test-preprocessor")) return test_c_preprocessor(ui_message_handler)?8:0; if(cmdline.isset("preprocess")) { preprocessing(); return 0; } goto_functionst goto_functions; // get solver cbmc_solverst cbmc_solvers(options, symbol_table, ui_message_handler); cbmc_solvers.set_ui(get_ui()); std::unique_ptr<cbmc_solverst::solvert> cbmc_solver; try { cbmc_solver=cbmc_solvers.get_solver(); } catch(const char *error_msg) { error() << error_msg << eom; return 1; } prop_convt &prop_conv=cbmc_solver->prop_conv(); bmct bmc(options, symbol_table, ui_message_handler, prop_conv); int get_goto_program_ret= get_goto_program(options, bmc, goto_functions); if(get_goto_program_ret!=-1) return get_goto_program_ret; label_properties(goto_functions); if(cmdline.isset("show-claims") || // will go away cmdline.isset("show-properties")) // use this one { const namespacet ns(symbol_table); show_properties(ns, get_ui(), goto_functions); return 0; } if(cmdline.isset("show-reachable-properties")) // may replace --show-properties { const namespacet ns(symbol_table); // Entry point will have been set before and function pointers removed status() << "Removing Unused Functions" << eom; remove_unused_functions(goto_functions, ui_message_handler); show_properties(ns, get_ui(), goto_functions); return 0; } if(set_properties(goto_functions)) return 7; if(cmdline.isset("danger")) return run_danger(options, result(), symbol_table, goto_functions); if(cmdline.isset("safety")) return run_safety(options, result(), symbol_table, goto_functions); // do actual BMC return do_bmc(bmc, goto_functions); }
int goto_fence_inserter_parse_optionst::doit() { if(cmdline.isset("version")) { std::cout << MUSKETEER_VERSION << std::endl; return 0; } if(cmdline.args.size()!=1 && cmdline.args.size()!=2) { help(); return 0; } set_verbosity(); try { register_languages(); goto_functionst goto_functions; get_goto_program(goto_functions); instrument_goto_program(goto_functions); // write new binary? if(cmdline.args.size()==2) { status() << "Writing GOTO program to " << cmdline.args[1] << eom; if(write_goto_binary( cmdline.args[1], symbol_table, goto_functions, get_message_handler())) return 1; else return 0; } // help(); return 0; } catch(const char *e) { error() << e << eom; return 11; } catch(const std::string e) { error() << e << eom; return 11; } catch(int) { return 11; } catch(std::bad_alloc) { error() << "Out of memory" << eom; return 11; } }