From d09904ea463555c0cfeb1a5d5fdd3956b1cbd657 Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:46:28 +0000 Subject: [PATCH 1/7] first pass cpplint fixes in unit --- unit/float_utils.cpp | 2 +- unit/ieee_float.cpp | 6 +++--- unit/wp.cpp | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/unit/float_utils.cpp b/unit/float_utils.cpp index d91caabde58..d9280280c41 100644 --- a/unit/float_utils.cpp +++ b/unit/float_utils.cpp @@ -63,7 +63,7 @@ int main() f3=f1; int op=(binopt)i%3; - //op=PLUS; + // op=PLUS; #else f1=-0.25; f2=-2.5; diff --git a/unit/ieee_float.cpp b/unit/ieee_float.cpp index d854d870dcb..56c218a7f89 100644 --- a/unit/ieee_float.cpp +++ b/unit/ieee_float.cpp @@ -34,7 +34,7 @@ std::string float2binary(float f) } c; c.f = f; - return integer2binary(c.i,32); + return integer2binary(c.i, 32); } float random_float() @@ -160,11 +160,11 @@ void check_comparison(int i) switch(op) { case EQ: - ires = ieee_equal(i1,i2); + ires = ieee_equal(i1, i2); fres = (f1 == f2); break; case NEQ: - ires = ieee_not_equal(i1,i2); + ires = ieee_not_equal(i1, i2); fres = (f1 != f2); break; case LT: diff --git a/unit/wp.cpp b/unit/wp.cpp index 01a398d3345..b4f836ab7ea 100644 --- a/unit/wp.cpp +++ b/unit/wp.cpp @@ -46,7 +46,7 @@ int main(int argc, const char **argv) const goto_programt &p=f_it->second.body; - //p.output(namespacet(symbol_table), "f", std::cout); + // p.output(namespacet(symbol_table), "f", std::cout); forall_goto_program_instructions(it, p) { From 4d79c7a9cb96d221a68f2c7e007a9b5247767cbc Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:46:29 +0000 Subject: [PATCH 2/7] first pass cpplint fixes in src/cegis --- src/cegis/cegis-util/cbmc_runner.cpp | 8 ++-- src/cegis/cegis-util/constant_width.cpp | 12 +++--- src/cegis/cegis-util/counterexample_vars.cpp | 14 +++---- src/cegis/cegis-util/inline_user_program.cpp | 10 ++--- src/cegis/cegis-util/instruction_iterator.cpp | 12 +++--- src/cegis/cegis-util/irep_pipe.cpp | 18 ++++---- src/cegis/cegis-util/module_helper.cpp | 2 +- src/cegis/cegis-util/program_helper.cpp | 42 +++++++++---------- src/cegis/cegis-util/string_helper.cpp | 2 +- src/cegis/cegis-util/task_pool.cpp | 22 +++++----- src/cegis/cegis-util/type_helper.cpp | 12 +++--- src/cegis/constant/add_constant.cpp | 18 ++++---- .../default_cegis_constant_strategy.cpp | 6 +-- src/cegis/constant/literals_collector.cpp | 6 +-- src/cegis/control/facade/control_runner.cpp | 2 +- .../control/learn/print_control_solution.cpp | 2 +- .../learn/rational_solution_configuration.cpp | 6 +-- .../learn/vector_solution_configuration.cpp | 4 +- .../preprocessing/control_preprocessing.cpp | 18 ++++---- .../propagate_controller_sizes.cpp | 24 +++++------ .../simplify/remove_unused_elements.cpp | 22 +++++----- src/cegis/control/value/float_helper.cpp | 8 ++-- src/cegis/control/verify/insert_solution.cpp | 6 +-- src/cegis/control/verify/zero_solutions.cpp | 4 +- .../constraint/danger_constraint_factory.cpp | 6 +-- src/cegis/danger/facade/danger_runner.cpp | 16 +++---- .../genetic/dynamic_danger_test_runner.cpp | 2 +- .../danger/options/danger_program_printer.cpp | 4 +- .../add_ranking_and_skolem_variables.cpp | 4 +- .../preprocess/store_nondet_choices.cpp | 10 ++--- .../symex/fitness/danger_fitness_config.cpp | 12 +++--- .../symex/learn/add_programs_to_learn.cpp | 6 +-- .../danger/symex/learn/add_variable_refs.cpp | 4 +- .../symex/learn/add_x0_placeholders.cpp | 2 +- .../symex/learn/danger_learn_config.cpp | 2 +- src/cegis/danger/symex/learn/read_x0.cpp | 6 +-- .../danger/symex/learn/solution_factory.cpp | 28 ++++++------- .../symex/verify/danger_verify_config.cpp | 2 +- .../danger/symex/verify/insert_candidate.cpp | 6 +-- .../verify/parallel_danger_verify_task.cpp | 10 ++--- .../symex/verify/restrict_counterexamples.cpp | 6 +-- src/cegis/genetic/concrete_test_runner.cpp | 24 +++++------ .../genetic/dynamic_test_runner_helper.cpp | 10 ++--- .../genetic/genetic_constant_strategy.cpp | 4 +- .../genetic/instruction_set_info_factory.cpp | 10 ++--- src/cegis/genetic/match_select.cpp | 36 ++++++++-------- src/cegis/genetic/random_cross.cpp | 12 +++--- src/cegis/genetic/random_individual.cpp | 22 +++++----- src/cegis/genetic/random_mutate.cpp | 18 ++++---- src/cegis/genetic/serialise_individual.cpp | 14 +++---- src/cegis/genetic/tournament_select.cpp | 24 +++++------ .../instructions/instruction_set_factory.cpp | 14 +++---- src/cegis/instrument/cegis_library.cpp | 2 +- .../instrument/find_cprover_initialize.cpp | 8 ++-- src/cegis/instrument/instrument_var_ops.cpp | 30 ++++++------- src/cegis/instrument/meta_variables.cpp | 2 +- src/cegis/invariant/constant/add_constant.cpp | 18 ++++---- .../constant/default_constant_strategy.cpp | 2 +- .../constant/literals_constant_strategy.cpp | 10 ++--- .../concrete_fitness_source_provider.cpp | 20 ++++----- .../add_invariants_and_temp_variables.cpp | 6 +-- .../preprocess/remove_loops_and_assertion.cpp | 16 +++---- .../symex/learn/add_counterexamples.cpp | 18 ++++---- .../learn/add_invariant_programs_to_learn.cpp | 2 +- .../invariant/symex/learn/instrument_vars.cpp | 10 ++--- .../symex/learn/replace_operators.cpp | 12 +++--- .../symex/verify/extract_counterexample.cpp | 8 ++-- .../invariant/symex/verify/insert_program.cpp | 10 ++--- .../invariant/util/copy_instructions.cpp | 20 ++++----- .../util/invariant_constraint_variables.cpp | 16 +++---- .../util/invariant_program_helper.cpp | 8 ++-- src/cegis/jsa/converters/counterexample.cpp | 30 ++++++------- .../jsa/converters/replace_operators.cpp | 40 +++++++++--------- src/cegis/jsa/converters/solution.cpp | 2 +- .../converters/translate_to_goto_program.cpp | 4 +- src/cegis/jsa/facade/jsa_runner.cpp | 4 +- .../jsa/genetic/dynamic_jsa_test_runner.cpp | 4 +- src/cegis/jsa/genetic/jsa_random.cpp | 10 ++--- src/cegis/jsa/genetic/jsa_serialiser.cpp | 16 +++---- src/cegis/jsa/genetic/jsa_source_provider.cpp | 16 +++---- src/cegis/jsa/genetic/random_jsa_cross.cpp | 8 ++-- src/cegis/jsa/genetic/random_jsa_mutate.cpp | 8 ++-- src/cegis/jsa/instrument/jsa_meta_data.cpp | 6 +-- src/cegis/jsa/instrument/temps_helper.cpp | 14 +++---- src/cegis/jsa/learn/execute_jsa_programs.cpp | 2 +- src/cegis/jsa/learn/extract_candidate.cpp | 26 ++++++------ src/cegis/jsa/learn/insert_counterexample.cpp | 12 +++--- .../learn/insert_predicates_and_queries.cpp | 2 +- src/cegis/jsa/learn/instrument_pred_ops.cpp | 18 ++++---- src/cegis/jsa/learn/jsa_symex_learn.cpp | 4 +- .../preprocessing/add_synthesis_library.cpp | 16 +++---- src/cegis/jsa/preprocessing/clone_heap.cpp | 16 +++---- .../jsa/preprocessing/collect_variables.cpp | 10 ++--- .../preprocessing/create_temp_variables.cpp | 2 +- .../default_jsa_constant_strategy.cpp | 2 +- .../jsa/preprocessing/inline_user_program.cpp | 10 ++--- src/cegis/jsa/value/jsa_solution.cpp | 2 +- src/cegis/jsa/value/jsa_solution_printer.cpp | 10 ++--- .../jsa/verify/extract_counterexample.cpp | 4 +- src/cegis/jsa/verify/insert_solution.cpp | 10 ++--- src/cegis/jsa/verify/jsa_symex_verify.cpp | 2 +- src/cegis/jsa/verify/renondet_inputs.cpp | 6 +-- src/cegis/learn/constraint_helper.cpp | 8 ++-- src/cegis/learn/insert_counterexample.cpp | 30 ++++++------- .../constraint/constraint_factory.cpp | 30 ++++++------- .../environment/instrument_state_vars.cpp | 6 +-- .../cegis_instruction_factory.cpp | 4 +- .../cegis_processor_body_factory.cpp | 22 +++++----- .../instructionset/create_cegis_processor.cpp | 20 ++++----- .../instructionset/execute_cegis_program.cpp | 24 +++++------ .../learn/instrument_counterexamples.cpp | 16 +++---- .../learn/refactor_candidate_printer.cpp | 10 ++--- .../refactor/learn/refactor_symex_learn.cpp | 6 +-- .../refactor/nullobject/nullable_analysis.cpp | 42 +++++++++---------- .../refactor/nullobject/range_collector.cpp | 22 +++++----- .../refactor/options/refactor_program.cpp | 6 +-- .../refactor/options/refactoring_type.cpp | 2 +- .../preprocessing/collect_counterexamples.cpp | 4 +- .../preprocessing/refactor_preprocessing.cpp | 12 +++--- .../refactor/verify/refactor_symex_verify.cpp | 4 +- src/cegis/runner/cegis_parse_options.cpp | 14 +++---- .../constraint/safety_constraint_factory.cpp | 2 +- src/cegis/safety/facade/safety_runner.cpp | 12 +++--- .../genetic/dynamic_safety_test_runner.cpp | 2 +- .../safety/options/safety_program_printer.cpp | 2 +- .../preprocessing/safety_preprocessing.cpp | 4 +- .../symex/fitness/safety_fitness_config.cpp | 12 +++--- .../symex/learn/add_counterexamples.cpp | 6 +-- .../safety/symex/learn/add_variable_refs.cpp | 2 +- .../symex/learn/safety_learn_config.cpp | 6 +-- .../safety/symex/learn/solution_factory.cpp | 12 +++--- .../safety/symex/verify/insert_candidate.cpp | 4 +- .../symex/verify/safety_verify_config.cpp | 2 +- src/cegis/seed/literals_seed.cpp | 36 ++++++++-------- src/cegis/value/assignments_printer.cpp | 2 +- .../program_individual_serialisation.cpp | 32 +++++++------- src/cegis/wordsize/restrict_bv_size.cpp | 30 ++++++------- 137 files changed, 788 insertions(+), 788 deletions(-) diff --git a/src/cegis/cegis-util/cbmc_runner.cpp b/src/cegis/cegis-util/cbmc_runner.cpp index 1d30bbfa63e..10703739484 100644 --- a/src/cegis/cegis-util/cbmc_runner.cpp +++ b/src/cegis/cegis-util/cbmc_runner.cpp @@ -41,7 +41,7 @@ std::string get_goto_file_name(const size_t index) std::string get_next_goto_file_name() { size_t index=0; - while (exists(get_goto_file_name(index))) + while(exists(get_goto_file_name(index))) ++index; return get_goto_file_name(index); } @@ -89,8 +89,8 @@ class cbmc_runnert:public cbmc_parse_optionst symbol_table=st; goto_functions.clear(); goto_functions.copy_from(gf); - if (process_goto_program(options, goto_functions)) return 6; - if (keep_goto_programs) + if(process_goto_program(options, goto_functions)) return 6; + if(keep_goto_programs) { const std::string path(get_next_goto_file_name()); message_handlert &msg=get_message_handler(); @@ -127,7 +127,7 @@ safety_checkert::resultt run_cbmc(const symbol_tablet &st, cbmc_runnert runner(st, gf, cbmc_result, keep_goto_programs); const int result=runner.main(); disable_output.release(); - if (EXIT_SUCCESS != result) + if(EXIT_SUCCESS != result) throw std::runtime_error("cbmc_runner.cbmc-execution-failed"); return runner.get_bmc_result(); } diff --git a/src/cegis/cegis-util/constant_width.cpp b/src/cegis/cegis-util/constant_width.cpp index 4f951e35694..814cc5bea19 100644 --- a/src/cegis/cegis-util/constant_width.cpp +++ b/src/cegis/cegis-util/constant_width.cpp @@ -18,15 +18,15 @@ size_t get_min_word_width(const exprt &expr) { assert(ID_constant == expr.id()); const std::string &value=id2string(to_constant_expr(expr).get_value()); - if (value.empty()) return MIN_WORD_WIDTH; + if(value.empty()) return MIN_WORD_WIDTH; const bool is_neg_if_signed=value[0] == '1'; std::string::size_type first_sb=value.find(is_neg_if_signed ? '0' : '1'); - if (std::string::npos == first_sb) return MIN_WORD_WIDTH; + if(std::string::npos == first_sb) return MIN_WORD_WIDTH; const size_t value_width=value.size() - first_sb + 1; // TODO: Make more flexible for other word widths - if (value_width > 16u) return value.size(); - if (value_width > 8u) return 16u; - if (value_width > 4u) return 8u; - if (value_width > 2u) return 4u; + if(value_width > 16u) return value.size(); + if(value_width > 8u) return 16u; + if(value_width > 4u) return 8u; + if(value_width > 2u) return 4u; return MIN_WORD_WIDTH; } diff --git a/src/cegis/cegis-util/counterexample_vars.cpp b/src/cegis/cegis-util/counterexample_vars.cpp index f0593f7f486..8ab7b0f9a30 100644 --- a/src/cegis/cegis-util/counterexample_vars.cpp +++ b/src/cegis/cegis-util/counterexample_vars.cpp @@ -26,8 +26,8 @@ size_t collect_counterexample_locations(goto_programt::targetst &locs, { goto_programt::instructionst &body=prog.instructions; const goto_programt::targett end(body.end()); - for (goto_programt::targett instr=body.begin(); instr != end; ++instr) - if (is_nondet(instr, end) && !is_meta(instr)) + for(goto_programt::targett instr=body.begin(); instr != end; ++instr) + if(is_nondet(instr, end) && !is_meta(instr)) { assert(instr->labels.empty()); instr->labels.push_back(marker_prefix + std::to_string(marker_index++)); @@ -50,7 +50,7 @@ bool default_cegis_meta_criterion(const goto_programt::const_targett pos) { const goto_programt::instructiont &instr=*pos; const goto_program_instruction_typet type=instr.type; - if (goto_program_instruction_typet::ASSIGN == type + if(goto_program_instruction_typet::ASSIGN == type && ID_symbol != to_code_assign(instr.code).rhs().id()) return false; const std::string &name=id2string(get_affected_variable(instr)); return contains(name, TMP_IF_EXPR_PREFIX) || contains(name, CPROVER_PREFIX) @@ -104,12 +104,12 @@ std::map extract_counterexample( { const goto_tracet::stepst &steps=trace.steps; std::map result; - for (const goto_trace_stept &step : steps) + for(const goto_trace_stept &step : steps) { typedef goto_programt::instructiont::labelst labelst; const labelst &labels=step.pc->labels; const labelst::const_iterator it=find_ce_label(labels); - if (labels.end() == it) continue; + if(labels.end() == it) continue; result[*it].push_back(step.full_lhs_value); } return result; @@ -118,12 +118,12 @@ std::map extract_counterexample( void show_assignments(std::ostream &os, const std::map &assignments) { - for (const std::pair &ass : assignments) + for(const std::pair &ass : assignments) { os << "" << std::endl; os << " " << ass.first << "" << std::endl; os << " " << std::endl; - for (const exprt &value : ass.second) + for(const exprt &value : ass.second) os << " " << value.pretty() << "" << std::endl; os << " " << std::endl; os << "" << std::endl; diff --git a/src/cegis/cegis-util/inline_user_program.cpp b/src/cegis/cegis-util/inline_user_program.cpp index 8a34803d62f..a3d34a56822 100644 --- a/src/cegis/cegis-util/inline_user_program.cpp +++ b/src/cegis/cegis-util/inline_user_program.cpp @@ -19,24 +19,24 @@ namespace bool is_user_function(const irep_idt &name, const goto_functionst::goto_functiont &func) { - if (std::string::npos != id2string(name).find(id2string(CPROVER_PREFIX))) + if(std::string::npos != id2string(name).find(id2string(CPROVER_PREFIX))) return false; - if (!func.body_available()) return false; + if(!func.body_available()) return false; const goto_programt::instructionst &instrs=func.body.instructions; - if (instrs.empty()) return false; + if(instrs.empty()) return false; return !is_builtin(instrs.front().source_location); } void mark_user_function(const irep_idt &name, goto_functionst::goto_functiont &func) { - if (is_user_function(name, func)) func.type.set_inlined(true); + if(is_user_function(name, func)) func.type.set_inlined(true); } } void inline_user_program(const symbol_tablet &st, goto_functionst &gf) { - for (goto_functionst::function_mapt::value_type &f : gf.function_map) + for(goto_functionst::function_mapt::value_type &f : gf.function_map) mark_user_function(f.first, f.second); const namespacet ns(st); diff --git a/src/cegis/cegis-util/instruction_iterator.cpp b/src/cegis/cegis-util/instruction_iterator.cpp index f6dbaca1eda..0244aacad07 100644 --- a/src/cegis/cegis-util/instruction_iterator.cpp +++ b/src/cegis/cegis-util/instruction_iterator.cpp @@ -14,7 +14,7 @@ namespace bool has_body(const goto_functionst::function_mapt::iterator &it, const goto_functionst::function_mapt::const_iterator &end) { - if (end == it) return false; + if(end == it) return false; return it->second.body_available(); } } @@ -26,24 +26,24 @@ instr_iteratort::instr_iteratort() instr_iteratort::instr_iteratort(goto_functionst &gf) : func_it(gf.function_map.begin()), func_end(gf.function_map.end()) { - while (!has_body(func_it, func_end) && func_end != func_it) + while(!has_body(func_it, func_end) && func_end != func_it) ++func_it; - if (has_body(func_it, func_end)) + if(has_body(func_it, func_end)) prog_it=func_it->second.body.instructions.begin(); } instr_iteratort &instr_iteratort::operator++() { - if (func_it->second.body.instructions.end() == prog_it) do + if(func_it->second.body.instructions.end() == prog_it) do { ++func_it; - if (func_end == func_it) + if(func_end == func_it) { func_it=goto_functionst::function_mapt::iterator(); prog_it=goto_programt::targett(); break; } else prog_it=func_it->second.body.instructions.begin(); - } while (func_it->second.body.instructions.end() == prog_it); + } while(func_it->second.body.instructions.end() == prog_it); else ++prog_it; return *this; } diff --git a/src/cegis/cegis-util/irep_pipe.cpp b/src/cegis/cegis-util/irep_pipe.cpp index 40300014409..1b4f9463aa1 100644 --- a/src/cegis/cegis-util/irep_pipe.cpp +++ b/src/cegis/cegis-util/irep_pipe.cpp @@ -25,7 +25,7 @@ namespace void open_pipe(int filedes[2]) { #ifndef _WIN32 - if (pipe(filedes)) + if(pipe(filedes)) { perror(IREP_PIPE " open"); throw std::runtime_error("Error creating pipe."); @@ -48,7 +48,7 @@ irep_pipet::irep_pipet(const bool auto_close) : irep_pipet::~irep_pipet() { - if (close_on_destuction) close(); + if(close_on_destuction) close(); } void irep_pipet::close_read() @@ -81,8 +81,8 @@ bool irep_pipet::is_write_closed() const void irep_pipet::close() { - if (!read_closed) close_read(); - if (!write_closed) close_write(); + if(!read_closed) close_read(); + if(!write_closed) close_write(); } namespace @@ -101,10 +101,10 @@ void irep_pipet::send(const irept &sdu) const const std::string data(os.str()); const size_t size=data.size() + 1; const char * offset=data.c_str(); - for (size_t written=0; written < size;) + for(size_t written=0; written < size;) { const ssize_t result=write(fd[1u], offset + written, size - written); - if (result == -1) + if(result == -1) { perror(IREP_PIPE " write"); throw std::runtime_error("Error writing pipe."); @@ -131,14 +131,14 @@ void irep_pipet::receive(irept &sdu) const do { const ssize_t result=read(fd[0u], buffer, sizeof(buffer)); - if (result == -1) + if(result == -1) { perror(IREP_PIPE " read"); throw std::runtime_error("Error reading pipe."); } - if (result > 0) data.append(buffer, result); + if(result > 0) data.append(buffer, result); else break; - } while (true); + } while(true); data.erase(data.end() - 1); std::istringstream is(data); xmlt xml; diff --git a/src/cegis/cegis-util/module_helper.cpp b/src/cegis/cegis-util/module_helper.cpp index b4fd6e0157a..ced2432085e 100644 --- a/src/cegis/cegis-util/module_helper.cpp +++ b/src/cegis/cegis-util/module_helper.cpp @@ -25,7 +25,7 @@ std::string get_current_executable_file_path() #else char buffer[PATH_MAX]; const ssize_t len=::readlink("/proc/self/exe", buffer, sizeof(buffer) - 1); - if (len == -1) throw std::runtime_error("module helper: readlink failed"); + if(len == -1) throw std::runtime_error("module helper: readlink failed"); buffer[len]='\0'; return std::string(buffer); #endif diff --git a/src/cegis/cegis-util/program_helper.cpp b/src/cegis/cegis-util/program_helper.cpp index 80693d852c8..88520f879f6 100644 --- a/src/cegis/cegis-util/program_helper.cpp +++ b/src/cegis/cegis-util/program_helper.cpp @@ -76,8 +76,8 @@ class id_searcht: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_symbol != expr.id() || found) return; - if (id == to_symbol_expr(expr).get_identifier()) found=true; + if(ID_symbol != expr.id() || found) return; + if(id == to_symbol_expr(expr).get_identifier()) found=true; } bool is_found() @@ -98,33 +98,33 @@ bool is_nondet(goto_programt::const_targett target, goto_programt::const_targett end) { const goto_programt::instructiont &instr=*target; - switch (instr.type) + switch(instr.type) { case goto_program_instruction_typet::DECL: { goto_programt::const_targett next=std::next(target); - if (next == end) return true; - if (goto_program_instruction_typet::FUNCTION_CALL == next->type) + if(next == end) return true; + if(goto_program_instruction_typet::FUNCTION_CALL == next->type) { - if (to_code_function_call(next->code).lhs().is_not_nil()) return false; + if(to_code_function_call(next->code).lhs().is_not_nil()) return false; else ++next; } const goto_programt::instructiont next_instr=*next; - if (goto_program_instruction_typet::ASSIGN != next_instr.type) return true; + if(goto_program_instruction_typet::ASSIGN != next_instr.type) return true; const irep_idt id(get_affected_variable(instr)); - if (id != get_affected_variable(next_instr)) return true; + if(id != get_affected_variable(next_instr)) return true; return contains(to_code_assign(next_instr.code).rhs(), id); } case goto_program_instruction_typet::ASSIGN: { const exprt &rhs=to_code_assign(instr.code).rhs(); - if (ID_side_effect != rhs.id()) return false; + if(ID_side_effect != rhs.id()) return false; return ID_nondet == to_side_effect_expr(rhs).get_statement(); } case goto_program_instruction_typet::FUNCTION_CALL: { const code_function_callt &call=to_code_function_call(instr.code); - if (call.lhs().is_not_nil()) return false; + if(call.lhs().is_not_nil()) return false; } default: return false; @@ -139,7 +139,7 @@ bool is_return_value_name(const std::string &name) const typet &get_affected_type(const goto_programt::instructiont &instr) { - switch (instr.type) + switch(instr.type) { case goto_program_instruction_typet::DECL: return to_code_decl(instr.code).symbol().type(); @@ -154,7 +154,7 @@ const typet &get_affected_type(const goto_programt::instructiont &instr) const irep_idt &get_affected_variable(const goto_programt::instructiont &instr) { - switch (instr.type) + switch(instr.type) { case goto_program_instruction_typet::DECL: return to_code_decl(instr.code).get_identifier(); @@ -172,8 +172,8 @@ goto_programt::targetst find_nondet_instructions(goto_programt &body) goto_programt::targetst result; goto_programt::instructionst &instrs=body.instructions; const goto_programt::targett end(instrs.end()); - for (goto_programt::targett it=instrs.begin(); it != end; ++it) - if (is_nondet(it, end)) result.push_back(it); + for(goto_programt::targett it=instrs.begin(); it != end; ++it) + if(is_nondet(it, end)) result.push_back(it); return result; } @@ -183,18 +183,18 @@ const char NS_SEP[]="::"; } bool is_global_const(const irep_idt &name, const typet &type) { - if (!type.get_bool(ID_C_constant)) return false; + if(!type.get_bool(ID_C_constant)) return false; const std::string &n=id2string(name); - if (std::string::npos != n.find(CEGIS_CONSTANT_PREFIX)) return true; + if(std::string::npos != n.find(CEGIS_CONSTANT_PREFIX)) return true; return std::string::npos == n.find(NS_SEP); } void move_labels(goto_programt::instructionst &body, const goto_programt::targett &from, const goto_programt::targett &to) { - for (goto_programt::instructiont &instr : body) - for (goto_programt::targett &target : instr.targets) - if (from == target) target=to; + for(goto_programt::instructiont &instr : body) + for(goto_programt::targett &target : instr.targets) + if(from == target) target=to; } void move_labels(goto_programt &body, const goto_programt::targett &from, @@ -213,7 +213,7 @@ goto_programt::targett insert_before_preserve_labels(goto_programt &body, bool is_builtin(const source_locationt &loc) { - if (loc.is_nil()) return true; + if(loc.is_nil()) return true; const std::string &file=id2string(loc.get_file()); return file.empty() || file.at(0) == '<'; } @@ -251,7 +251,7 @@ void cegis_assign(const symbol_tablet &st, goto_programt::instructiont &instr, instr.source_location=loc; const namespacet ns(st); const typet &type=lhs.type(); - if (type_eq(type, rhs.type(), ns)) instr.code=code_assignt(lhs, rhs); + if(type_eq(type, rhs.type(), ns)) instr.code=code_assignt(lhs, rhs); else instr.code=code_assignt(lhs, typecast_exprt(rhs, type)); } diff --git a/src/cegis/cegis-util/string_helper.cpp b/src/cegis/cegis-util/string_helper.cpp index 883550d0c90..10055438139 100644 --- a/src/cegis/cegis-util/string_helper.cpp +++ b/src/cegis/cegis-util/string_helper.cpp @@ -25,7 +25,7 @@ bool ends_with(const std::string &haystack, const std::string &suffix) { const std::string::size_type haystack_sz=haystack.size(); const std::string::size_type suffix_sz=suffix.size(); - if (haystack_sz < suffix_sz) return false; + if(haystack_sz < suffix_sz) return false; return haystack.substr(haystack_sz - suffix_sz) == suffix; } diff --git a/src/cegis/cegis-util/task_pool.cpp b/src/cegis/cegis-util/task_pool.cpp index 769dc49be79..d667a704c97 100644 --- a/src/cegis/cegis-util/task_pool.cpp +++ b/src/cegis/cegis-util/task_pool.cpp @@ -41,7 +41,7 @@ void execute_and_remove(task_poolt::handlerst &handlers, const pid_t pid, const int status) { const task_poolt::handlerst::iterator it=handlers.find(pid); - if (handlers.end() != it) + if(handlers.end() != it) { it->second(status); handlers.erase(it); @@ -54,10 +54,10 @@ void cleanup(task_poolt::task_idst &task_ids, task_poolt::handlerst &handlers) #ifndef _WIN32 std::map joined; int status; - for (pid_t child_pid=waitpid(-1, &status, WNOHANG); child_pid > 0; child_pid= + for(pid_t child_pid=waitpid(-1, &status, WNOHANG); child_pid > 0; child_pid= waitpid(-1, &status, WNOHANG)) joined.insert(std::make_pair(child_pid, status)); - for (const std::pair &task : joined) + for(const std::pair &task : joined) { const task_poolt::task_idt id=task.first; execute_and_remove(handlers, id, task.second); @@ -72,7 +72,7 @@ void cleanup(task_poolt::task_idst &task_ids, task_poolt::handlerst &handlers) bool erase_if_managed(task_poolt::task_idst &ids, const task_poolt::task_idt id) { const task_poolt::task_idst::iterator task_id=ids.find(id); - if (ids.end() == task_id) return false; + if(ids.end() == task_id) return false; ids.erase(task_id); return true; } @@ -86,12 +86,12 @@ task_poolt::task_idt task_poolt::schedule(const taskt &task) cleanup(task_ids, handlers); #ifndef _WIN32 const pid_t child_pid=fork(); - if (child_pid == -1) + if(child_pid == -1) { perror(FORK_ERROR); throw std::runtime_error(FORK_ERROR); } - if (child_pid) + if(child_pid) { task_ids.insert(child_pid); return child_pid; @@ -124,15 +124,15 @@ task_poolt::task_idt task_poolt::schedule(const taskt &task, void task_poolt::cancel(const task_idt id) { #ifndef _WIN32 - if (!erase_if_managed(task_ids, id)) return; + if(!erase_if_managed(task_ids, id)) return; int status; size_t wait_count=0; do { kill(id, SIGTERM); usleep(20000); - } while (!waitpid(id, &status, WNOHANG) && ++wait_count < MAX_WAIT); - if (wait_count >= MAX_WAIT) + } while(!waitpid(id, &status, WNOHANG) && ++wait_count < MAX_WAIT); + if(wait_count >= MAX_WAIT) { kill(id, SIGKILL); waitpid(id, &status, 0); @@ -146,7 +146,7 @@ void task_poolt::cancel(const task_idt id) void task_poolt::join(const task_idt id) { #ifndef _WIN32 - if (!erase_if_managed(task_ids, id)) return; + if(!erase_if_managed(task_ids, id)) return; int status; waitpid(id, &status, 0); execute_and_remove(handlers, id, status); @@ -160,7 +160,7 @@ void task_poolt::join_all() #ifndef _WIN32 const size_t num_children=task_ids.size(); int status; - for (size_t i=0; i < num_children; ++i) + for(size_t i=0; i < num_children; ++i) { const pid_t pid=waitpid(-1, &status, 0); assert(pid > 0); diff --git a/src/cegis/cegis-util/type_helper.cpp b/src/cegis/cegis-util/type_helper.cpp index b20ea9d08e6..b63d6df6801 100644 --- a/src/cegis/cegis-util/type_helper.cpp +++ b/src/cegis/cegis-util/type_helper.cpp @@ -20,7 +20,7 @@ const typet &replace_struct_by_symbol_type(const symbol_tablet &st, const typet &type) { const irep_idt &type_id=type.id(); - if (ID_struct != type_id && ID_incomplete_struct != type_id + if(ID_struct != type_id && ID_incomplete_struct != type_id && ID_union != type_id && ID_incomplete_union != type_id) return type; std::string tag(TAG_PREFIX); tag+=id2string(to_struct_union_type(type).get_tag()); @@ -31,14 +31,14 @@ namespace { bool instanceof(const typet &lhs, const typet &rhs, const namespacet &ns) { - if (type_eq(lhs, rhs, ns)) return true; + if(type_eq(lhs, rhs, ns)) return true; assert(ID_class == lhs.id()); const class_typet &lhs_class=to_class_type(lhs); const irept::subt &bases=lhs_class.bases(); - for (const irept &base : bases) + for(const irept &base : bases) { const typet &type=static_cast(base.find(ID_type)); - if (instanceof(ns.follow(type), rhs, ns)) return true; + if(instanceof(ns.follow(type), rhs, ns)) return true; } return false; } @@ -49,7 +49,7 @@ bool instanceof(const symbol_tablet &st, const typet &lhs, const typet &rhs) const namespacet ns(st); const typet &resolved_lhs=ns.follow(lhs); const typet &resolved_rhs=ns.follow(rhs); - if (ID_class != resolved_lhs.id() || ID_class != resolved_rhs.id()) + if(ID_class != resolved_lhs.id() || ID_class != resolved_rhs.id()) return type_eq(resolved_lhs, resolved_rhs, ns); return instanceof(resolved_lhs, resolved_rhs, ns); } @@ -62,7 +62,7 @@ instanceof_anyt::instanceof_anyt(const symbol_tablet &st, bool instanceof_anyt::operator ()(const typet &type) const { - if (types.empty()) return true; + if(types.empty()) return true; return types.end() != std::find_if(types.begin(), types.end(), [this, &type](const typet &rhs) diff --git a/src/cegis/constant/add_constant.cpp b/src/cegis/constant/add_constant.cpp index 29472aff5bc..74098c4fa1e 100644 --- a/src/cegis/constant/add_constant.cpp +++ b/src/cegis/constant/add_constant.cpp @@ -19,10 +19,10 @@ namespace const char NS_SEP[]="::"; bool is_meta_or_not_global(const symbolt &symbol) { - if (ID_code == symbol.type.id()) return true; + if(ID_code == symbol.type.id()) return true; const std::string &name=id2string(symbol.name); - if (std::string::npos != name.find("#return_value")) return true; - if (std::string::npos != name.find(CPROVER_PREFIX)) return true; + if(std::string::npos != name.find("#return_value")) return true; + if(std::string::npos != name.find(CPROVER_PREFIX)) return true; return std::string::npos != name.find(NS_SEP); } @@ -32,13 +32,13 @@ bool contains_constant(const symbol_tablet &st, const exprt &value) exprt lhs=value; lhs.add_source_location()=source_locationt(); const symbolst &s=st.symbols; - for (symbolst::const_iterator it=s.begin(); it != s.end(); ++it) + for(symbolst::const_iterator it=s.begin(); it != s.end(); ++it) { const symbolt &symbol=it->second; - if (is_meta_or_not_global(symbol)) continue; + if(is_meta_or_not_global(symbol)) continue; exprt rhs=symbol.value; rhs.add_source_location()=lhs.source_location(); - if (lhs == rhs) return true; + if(lhs == rhs) return true; } return false; } @@ -52,19 +52,19 @@ bool is_empty(const exprt &expr) void add_cegis_constant(symbol_tablet &st, goto_functionst &gf, const std::string &name, const exprt &value, goto_programt::targett pos) { - while (is_builtin(pos->source_location)) + while(is_builtin(pos->source_location)) ++pos; typet type=value.type(); type.set(ID_C_constant, true); create_cegis_symbol(st, name, type).value=value; - if (!is_empty(value)) + if(!is_empty(value)) pos=cegis_assign_user_variable(st, gf, pos, name, value); } void add_cegis_constant(symbol_tablet &st, goto_functionst &gf, const exprt &value, goto_programt::targett pos) { - if (contains_constant(st, value)) return; + if(contains_constant(st, value)) return; const namespacet ns(st); std::string name(CEGIS_CONSTANT_PREFIX); name+=expr2c(value, ns); diff --git a/src/cegis/constant/default_cegis_constant_strategy.cpp b/src/cegis/constant/default_cegis_constant_strategy.cpp index 74fd4fac76a..c02abe8e048 100644 --- a/src/cegis/constant/default_cegis_constant_strategy.cpp +++ b/src/cegis/constant/default_cegis_constant_strategy.cpp @@ -31,11 +31,11 @@ size_t default_cegis_constant_strategy(symbol_tablet &st, goto_functionst &gf) size_t const_index=0u; goto_programt::targett pos=get_entry_body(gf).instructions.begin(); // XXX: Literals strategy, benchmark performance - for (const constant_exprt &expr : literals) + for(const constant_exprt &expr : literals) { // XXX: Debug - //std::cout << "" << const_index << "" << std::endl; - //std::cout << "" << expr.to_string() << "" << std::endl; + // std::cout << "" << const_index << "" << std::endl; + // std::cout << "" << expr.to_string() << "" << std::endl; // XXX: Debug const std::string base_name(get_name(const_index++)); pos=declare_cegis_meta_variable(st, gf, pos, base_name, expr.type()); diff --git a/src/cegis/constant/literals_collector.cpp b/src/cegis/constant/literals_collector.cpp index 4f779d331c1..e72a4dca9fc 100644 --- a/src/cegis/constant/literals_collector.cpp +++ b/src/cegis/constant/literals_collector.cpp @@ -47,10 +47,10 @@ class constant_expr_visitort: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_constant != expr.id()) return; + if(ID_constant != expr.id()) return; const typet &expr_type=expr.type(); const irep_idt &type_id=expr_type.id(); - if (ID_unsignedbv != type_id && ID_signedbv != type_id) return; + if(ID_unsignedbv != type_id && ID_signedbv != type_id) return; const constant_exprt constant(to_constant_expr(expr)); const bv_arithmetict bv(constant); const mp_integer::llong_t value=bv.to_integer().to_long(); @@ -59,7 +59,7 @@ class constant_expr_visitort: public const_expr_visitort void operator()(const goto_programt::instructiont &instr) { - if (is_builtin(instr.source_location)) return; + if(is_builtin(instr.source_location)) return; instr.code.visit(*this); instr.guard.visit(*this); } diff --git a/src/cegis/control/facade/control_runner.cpp b/src/cegis/control/facade/control_runner.cpp index 140f1ef3908..06e126864b3 100644 --- a/src/cegis/control/facade/control_runner.cpp +++ b/src/cegis/control/facade/control_runner.cpp @@ -44,7 +44,7 @@ int run(optionst &o, messaget::mstreamt &result, const symbol_tablet &st, int run_control(optionst &o, messaget::mstreamt &result, const symbol_tablet &st, const goto_functionst &gf) { - if (is_vector_solution_config(st)) + if(is_vector_solution_config(st)) { const zero_vector_solutiont def(st); return run(o, result, st, gf, def); diff --git a/src/cegis/control/learn/print_control_solution.cpp b/src/cegis/control/learn/print_control_solution.cpp index 6b66990c7a5..c8946711039 100644 --- a/src/cegis/control/learn/print_control_solution.cpp +++ b/src/cegis/control/learn/print_control_solution.cpp @@ -18,7 +18,7 @@ void print_control_array(messaget::mstreamt &os, const array_exprt &array, const namespacet ns(st); const array_exprt::operandst &ops=array.operands(); os << '<' << name << '>' << messaget::endl; - for (const array_exprt::operandst::value_type &value : ops) + for(const array_exprt::operandst::value_type &value : ops) os << "" << expr2c(value, ns) << "" << messaget::endl; os << "' << messaget::endl; os << '<' << name << "_size>" << ops.size(); diff --git a/src/cegis/control/learn/rational_solution_configuration.cpp b/src/cegis/control/learn/rational_solution_configuration.cpp index 41fb7aa0cdc..c49f81e621d 100644 --- a/src/cegis/control/learn/rational_solution_configuration.cpp +++ b/src/cegis/control/learn/rational_solution_configuration.cpp @@ -27,12 +27,12 @@ namespace { const struct_exprt &find_solution(const goto_tracet &trace) { - for (const goto_trace_stept &step : trace.steps) + for(const goto_trace_stept &step : trace.steps) { const exprt &lhs=step.full_lhs; - if (ID_symbol != lhs.id()) continue; + if(ID_symbol != lhs.id()) continue; const std::string &id=id2string(to_symbol_expr(lhs).get_identifier()); - if (CEGIS_CONTROL_SOLUTION_VAR_NAME != id) continue; + if(CEGIS_CONTROL_SOLUTION_VAR_NAME != id) continue; return to_struct_expr(step.full_lhs_value); } assert(!"Control solution not found in trace."); diff --git a/src/cegis/control/learn/vector_solution_configuration.cpp b/src/cegis/control/learn/vector_solution_configuration.cpp index 5da8cdc3192..33dc43a730e 100644 --- a/src/cegis/control/learn/vector_solution_configuration.cpp +++ b/src/cegis/control/learn/vector_solution_configuration.cpp @@ -23,7 +23,7 @@ namespace { bool is_assignment_to_solution_var(const goto_programt::instructiont &instr) { - if (goto_program_instruction_typet::ASSIGN != instr.type) return false; + if(goto_program_instruction_typet::ASSIGN != instr.type) return false; const std::string &var_name=id2string(get_affected_variable(instr)); return CEGIS_CONTROL_VECTOR_SOLUTION_VAR_NAME == var_name; } @@ -53,7 +53,7 @@ namespace bool is_solution(const goto_trace_stept &step) { const exprt &lhs=step.full_lhs; - if (ID_symbol != lhs.id()) return false; + if(ID_symbol != lhs.id()) return false; const std::string &id=id2string(to_symbol_expr(lhs).get_identifier()); return CEGIS_CONTROL_VECTOR_SOLUTION_VAR_NAME == id; } diff --git a/src/cegis/control/preprocessing/control_preprocessing.cpp b/src/cegis/control/preprocessing/control_preprocessing.cpp index d9b86289226..42535dbe805 100644 --- a/src/cegis/control/preprocessing/control_preprocessing.cpp +++ b/src/cegis/control/preprocessing/control_preprocessing.cpp @@ -43,18 +43,18 @@ const char * const excluded_functions[]= { bool is_meta(const goto_programt::const_targett pos) { - if (default_cegis_meta_criterion(pos)) return true; + if(default_cegis_meta_criterion(pos)) return true; const source_locationt &loc=pos->code.source_location(); const std::string &func=id2string(loc.get_function()); - for (const char * const excluded : excluded_functions) - if (contains(func, excluded)) return true; - if ((goto_program_instruction_typet::ASSIGN != pos->type + for(const char * const excluded : excluded_functions) + if(contains(func, excluded)) return true; + if((goto_program_instruction_typet::ASSIGN != pos->type && goto_program_instruction_typet::DECL != pos->type) || !pos->code.has_operands() || (pos->code.has_operands() && ID_symbol != pos->code.op0().id())) return false; const std::string &var=id2string(get_affected_variable(*pos)); - if (contains(var, TMP_MARKER) || contains(var, RETURN_VALUE_SUFFIX) + if(contains(var, TMP_MARKER) || contains(var, RETURN_VALUE_SUFFIX) || contains(var, CPROVER_PREFIX)) return true; return CEGIS_CONTROL_SOLUTION_VAR_NAME == var || CEGIS_CONTROL_VECTOR_SOLUTION_VAR_NAME == var; @@ -67,17 +67,17 @@ void add_explicit_nondet_for_extern_vars(const symbol_tablet &st, goto_programt &init_body=get_body(gf, CPROVER_INIT); goto_programt::targett entry_pos=entry_body.instructions.begin(); goto_programt::targett init_pos=std::prev(init_body.instructions.end(), 1); - for (const symbol_tablet::symbolst::value_type &id_and_symbol : st.symbols) + for(const symbol_tablet::symbolst::value_type &id_and_symbol : st.symbols) { const symbolt &symbol=id_and_symbol.second; const std::string &name=id2string(id_and_symbol.first); - if (!symbol.is_extern || contains(name, CPROVER_PREFIX)) continue; + if(!symbol.is_extern || contains(name, CPROVER_PREFIX)) continue; const bool is_solution_var=CEGIS_CONTROL_VECTOR_SOLUTION_VAR_NAME == name || CEGIS_CONTROL_SOLUTION_VAR_NAME == name; goto_programt &body=is_solution_var ? init_body : entry_body; goto_programt::targett &pos=is_solution_var ? init_pos : entry_pos; const source_locationt &loc=pos->source_location; - if (is_solution_var) pos=body.insert_before(pos); + if(is_solution_var) pos=body.insert_before(pos); else pos=body.insert_after(pos); pos->source_location=loc; pos->type=goto_program_instruction_typet::ASSIGN; @@ -99,7 +99,7 @@ void control_preprocessingt::operator ()() add_explicit_nondet_for_extern_vars(st, gf); collect_counterexample_locations(locs, body, is_meta); // XXX: Debug - for (const goto_programt::const_targett target : locs) + for(const goto_programt::const_targett target : locs) { std::cout << "" << target->code.pretty() << "" << std::endl; } diff --git a/src/cegis/control/preprocessing/propagate_controller_sizes.cpp b/src/cegis/control/preprocessing/propagate_controller_sizes.cpp index 48a1aece609..a451f290965 100644 --- a/src/cegis/control/preprocessing/propagate_controller_sizes.cpp +++ b/src/cegis/control/preprocessing/propagate_controller_sizes.cpp @@ -23,8 +23,8 @@ exprt_typet &get_comp(const namespacet &ns, struct_exprt_typet &value, { const struct_typet &type=to_struct_type(ns.follow(value.type())); const struct_typet::componentst &comps=type.components(); - for (size_t i=0; i < comps.size(); ++i) - if (id2string(comps[i].get_name()) == comp) return value.operands()[i]; + for(size_t i=0; i < comps.size(); ++i) + if(id2string(comps[i].get_name()) == comp) return value.operands()[i]; assert(!"Solution component not found."); } } @@ -80,31 +80,31 @@ class replace_sizes_visitort: public expr_visitort virtual ~replace_sizes_visitort() { - for (exprt * const expr : a_sizes) + for(exprt * const expr : a_sizes) *expr=a_size; - for (exprt * const expr : b_sizes) + for(exprt * const expr : b_sizes) *expr=b_size; } virtual void operator()(exprt &expr) { - if (ID_member != expr.id()) return; + if(ID_member != expr.id()) return; const member_exprt &member=to_member_expr(expr); const exprt &struct_op=member.struct_op(); - if (ID_symbol != struct_op.id()) return; + if(ID_symbol != struct_op.id()) return; const symbol_exprt &symbol=to_symbol_expr(struct_op); const std::string &var=id2string(symbol.get_identifier()); - if (CEGIS_CONTROL_SOLUTION_VAR_NAME != var) return; + if(CEGIS_CONTROL_SOLUTION_VAR_NAME != var) return; const std::string &comp=id2string(member.get_component_name()); - if (CEGIS_CONTROL_A_SIZE_MEMBER_NAME == comp) a_sizes.push_back(&expr); - else if (CEGIS_CONTROL_B_SIZE_MEMBER_NAME == comp) b_sizes.push_back(&expr); + if(CEGIS_CONTROL_A_SIZE_MEMBER_NAME == comp) a_sizes.push_back(&expr); + else if(CEGIS_CONTROL_B_SIZE_MEMBER_NAME == comp) b_sizes.push_back(&expr); } }; } void propagate_controller_sizes(const symbol_tablet &st, goto_functionst &gf) { - if (!st.has_symbol(CEGIS_CONTROL_SOLUTION_VAR_NAME)) return; + if(!st.has_symbol(CEGIS_CONTROL_SOLUTION_VAR_NAME)) return; const symbolt &symbol=st.lookup(CEGIS_CONTROL_SOLUTION_VAR_NAME); const struct_exprt &controller_value=to_struct_expr(symbol.value); const namespacet ns(st); @@ -112,7 +112,7 @@ void propagate_controller_sizes(const symbol_tablet &st, goto_functionst &gf) const exprt &b_size=get_b_size(ns, controller_value); replace_sizes_visitort visitor(a_size, b_size); goto_programt &body=get_entry_body(gf); - for (goto_programt::instructiont &instr : body.instructions) + for(goto_programt::instructiont &instr : body.instructions) { instr.code.visit(visitor); instr.guard.visit(visitor); @@ -123,7 +123,7 @@ namespace { bool is_sol_assign(const goto_programt::instructiont &instr) { - if (goto_program_instruction_typet::ASSIGN != instr.type) return false; + if(goto_program_instruction_typet::ASSIGN != instr.type) return false; const std::string &var=id2string(get_affected_variable(instr)); return CEGIS_CONTROL_SOLUTION_VAR_NAME == var; } diff --git a/src/cegis/control/simplify/remove_unused_elements.cpp b/src/cegis/control/simplify/remove_unused_elements.cpp index 140eeae9222..cdd163bd7a0 100644 --- a/src/cegis/control/simplify/remove_unused_elements.cpp +++ b/src/cegis/control/simplify/remove_unused_elements.cpp @@ -29,7 +29,7 @@ class symbol_visitort: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_symbol != expr.id()) return; + if(ID_symbol != expr.id()) return; vars.insert(to_symbol_expr(expr).get_identifier()); } }; @@ -38,11 +38,11 @@ void visit_functions(std::set &vars, std::set &funcs, const goto_functionst &gf, const goto_programt &body) { symbol_visitort visitor(vars); - for (const goto_programt::instructiont &instr : body.instructions) + for(const goto_programt::instructiont &instr : body.instructions) { instr.code.visit(visitor); instr.guard.visit(visitor); - if (goto_program_instruction_typet::FUNCTION_CALL != instr.type) continue; + if(goto_program_instruction_typet::FUNCTION_CALL != instr.type) continue; const exprt &func=to_code_function_call(instr.code).function(); assert(ID_symbol == func.id()); const irep_idt &id=to_symbol_expr(func).get_identifier(); @@ -52,7 +52,7 @@ void visit_functions(std::set &vars, std::set &funcs, const fmapt::const_iterator it=fmap.find(id); assert(fmap.end() != it); const goto_function_templatet &prog=it->second; - if (prog.body_available()) visit_functions(vars, funcs, gf, prog.body); + if(prog.body_available()) visit_functions(vars, funcs, gf, prog.body); } } } @@ -62,10 +62,10 @@ void remove_unused_functions(symbol_tablet &st, goto_functionst &gf, { typedef goto_functionst::function_mapt fmapt; fmapt &fmap=gf.function_map; - for (fmapt::iterator it=fmap.begin(); it != fmap.end();) + for(fmapt::iterator it=fmap.begin(); it != fmap.end();) { const irep_idt &id=it->first; - if (funcs.end() == funcs.find(id)) + if(funcs.end() == funcs.find(id)) { it=fmap.erase(it); st.remove(id); @@ -78,10 +78,10 @@ namespace void remove_assignments_to(goto_programt &init, const irep_idt &id) { goto_programt::instructionst &ins=init.instructions; - for (goto_programt::targett pos=ins.begin(); pos != ins.end();) + for(goto_programt::targett pos=ins.begin(); pos != ins.end();) { const goto_programt::instructiont &instr=*pos; - if (goto_program_instruction_typet::ASSIGN == instr.type + if(goto_program_instruction_typet::ASSIGN == instr.type && ID_symbol == to_code_assign(instr.code).lhs().id() && id == to_symbol_expr(to_code_assign(instr.code).lhs()).get_identifier()) @@ -102,15 +102,15 @@ void remove_unused_globals(symbol_tablet &st, goto_functionst &gf, const std::set &variables) { std::set to_remove; - for (const std::pair named_symbol : st.symbols) + for(const std::pair named_symbol : st.symbols) { const symbolt &symbol=named_symbol.second; const irep_idt &name=named_symbol.first; - if (symbol.is_static_lifetime && variables.end() == variables.find(name) + if(symbol.is_static_lifetime && variables.end() == variables.find(name) && !is_meta(name)) to_remove.insert(name); } goto_programt &init=get_body(gf, CPROVER_INIT); - for (const irep_idt &var : to_remove) + for(const irep_idt &var : to_remove) { st.remove(var); remove_assignments_to(init, var); diff --git a/src/cegis/control/value/float_helper.cpp b/src/cegis/control/value/float_helper.cpp index 39ac8fdbeb4..a905061b942 100644 --- a/src/cegis/control/value/float_helper.cpp +++ b/src/cegis/control/value/float_helper.cpp @@ -23,7 +23,7 @@ Author: Daniel Kroening, kroening@kroening.com double to_control_float(const constant_exprt &expr) { const typet &data_type=expr.type(); - if (ID_fixedbv == data_type.id()) + if(ID_fixedbv == data_type.id()) { // TODO: Implement assert(false); @@ -36,7 +36,7 @@ double to_control_float(const constant_exprt &expr) exprt to_control_float_expr(const symbol_tablet &st, double value) { const typet &data_type=control_float_value_type(st); - if (ID_fixedbv == data_type.id()) + if(ID_fixedbv == data_type.id()) { const fixedbv_spect spec(to_fixedbv_type(data_type)); const bool is_neg=value < 0.0; @@ -47,12 +47,12 @@ exprt to_control_float_expr(const symbol_tablet &st, double value) bv.spec=spec; bv.from_integer(converted); const constant_exprt constant_expr(bv.to_expr()); - if (!is_neg) return constant_expr; + if(!is_neg) return constant_expr; return unary_minus_exprt(constant_expr); } ieee_floatt ieee(ieee_float_spect::double_precision()); ieee.from_double(value); const exprt result(ieee.to_expr()); - if (type_eq(result.type(), data_type, namespacet(st))) return result; + if(type_eq(result.type(), data_type, namespacet(st))) return result; return typecast_exprt(result, data_type); } diff --git a/src/cegis/control/verify/insert_solution.cpp b/src/cegis/control/verify/insert_solution.cpp index 67743961feb..db4d09d3038 100644 --- a/src/cegis/control/verify/insert_solution.cpp +++ b/src/cegis/control/verify/insert_solution.cpp @@ -30,8 +30,8 @@ exprt &get_comp(struct_exprt::operandst &ops, const struct_typet &struct_type, const struct_typet::componentst &comps=struct_type.components(); const size_t comps_size=comps.size(); size_t offset=0; - for (offset=0; offset < comps_size; ++offset) - if (id2string(comps[offset].get_name()) == comp) break; + for(offset=0; offset < comps_size; ++offset) + if(id2string(comps[offset].get_name()) == comp) break; assert(offset < comps_size); return ops[offset]; } @@ -86,7 +86,7 @@ class is_assignment_tot bool operator()(const goto_programt::instructiont &instr) const { - if (goto_program_instruction_typet::ASSIGN != instr.type) return false; + if(goto_program_instruction_typet::ASSIGN != instr.type) return false; const std::string &var=id2string(get_affected_variable(instr)); return name == var; } diff --git a/src/cegis/control/verify/zero_solutions.cpp b/src/cegis/control/verify/zero_solutions.cpp index 22249c9b7e4..3b4656b97fb 100644 --- a/src/cegis/control/verify/zero_solutions.cpp +++ b/src/cegis/control/verify/zero_solutions.cpp @@ -38,7 +38,7 @@ struct_exprt make_zero(const namespacet &ns, const symbol_typet &type) void zero_rational_solutiont::operator ()(control_solutiont &solution) const { - if (!solution.a.operands().empty()) return; + if(!solution.a.operands().empty()) return; const symbol_typet &type=control_solution_type(st); const namespacet ns(st); const struct_exprt zero_struct=make_zero(ns, type); @@ -54,7 +54,7 @@ zero_vector_solutiont::zero_vector_solutiont(const symbol_tablet &st) : void zero_vector_solutiont::operator ()( control_vector_solutiont &solution) const { - if (!solution.K.operands().empty()) return; + if(!solution.K.operands().empty()) return; const namespacet ns(st); const array_typet &type=control_vector_solution_type(st); const source_locationt loc(default_cegis_source_location()); diff --git a/src/cegis/danger/constraint/danger_constraint_factory.cpp b/src/cegis/danger/constraint/danger_constraint_factory.cpp index 5cea1a36dd2..23f0344c773 100644 --- a/src/cegis/danger/constraint/danger_constraint_factory.cpp +++ b/src/cegis/danger/constraint/danger_constraint_factory.cpp @@ -39,7 +39,7 @@ exprt create_danger_constraint(const size_t number_of_loops, const bool use_rank const constant_exprt min(get_min_value()); and_exprt root; root.copy_to_operands(as_bool(get_Dx0())); - for (size_t i=0; i < number_of_loops; ++i) + for(size_t i=0; i < number_of_loops; ++i) { const notequal_exprt D0_x(as_bool(get_Dx(i))); const notequal_exprt D0_x_prime(as_bool(get_Dx_prime(i))); @@ -49,7 +49,7 @@ exprt create_danger_constraint(const size_t number_of_loops, const bool use_rank const and_exprt D0_x_and_G0_x(D0_x, G0_x); const not_exprt not_D0_x_and_G0_x(D0_x_and_G0_x); exprt first_conseq; - if (use_ranking) + if(use_ranking) { const binary_predicate_exprt R0_x_gt_min(R0_x, ID_gt, min); const binary_predicate_exprt R0_x_prime_lt_R0_x(R0_x_prime, ID_lt, R0_x); @@ -63,7 +63,7 @@ exprt create_danger_constraint(const size_t number_of_loops, const bool use_rank const notequal_exprt A_x(as_bool(get_Ax())); exprt second_conseq; const bool is_last_component=(i == (number_of_loops - 1)); - if (is_last_component) second_conseq=not_exprt(A_x); + if(is_last_component) second_conseq=not_exprt(A_x); else second_conseq=D1_x; const or_exprt second_implication(not_D0_x_and_not_G0_x, second_conseq); root.copy_to_operands(second_implication); diff --git a/src/cegis/danger/facade/danger_runner.cpp b/src/cegis/danger/facade/danger_runner.cpp index 57ebc1f43e0..3ce2b47b0e0 100644 --- a/src/cegis/danger/facade/danger_runner.cpp +++ b/src/cegis/danger/facade/danger_runner.cpp @@ -65,9 +65,9 @@ int run_statistics(mstreamt &os, const optionst &opt, preproct &preproc) { null_seedt seed; - //danger_literals_seedt seed(prog); // XXX: Benchmark performance + // danger_literals_seedt seed(prog); // XXX: Benchmark performance const size_t max_prog_size=opt.get_unsigned_int_option(CEGIS_MAX_SIZE); - if (!opt.get_bool_option(CEGIS_STATISTICS)) + if(!opt.get_bool_option(CEGIS_STATISTICS)) return run_cegis(learn, verify, preproc, seed, max_prog_size, os); cegis_statistics_wrappert stat(learn, verify, os, opt); return run_cegis(stat, stat, preproc, seed, max_prog_size, os); @@ -78,7 +78,7 @@ int run_limited(mstreamt &os, optionst &options, const danger_programt &prog, danger_verify_configt &config, learnert &learn, verifiert &verify, preproct &preproc) { - if (!options.get_bool_option(CEGIS_LIMIT_WORDSIZE)) + if(!options.get_bool_option(CEGIS_LIMIT_WORDSIZE)) return run_statistics(os, options, prog, learn, verify, preproc); limited_wordsize_verifyt limited_verify(options, verify, [&config](const size_t width) @@ -91,7 +91,7 @@ int run_parallel(mstreamt &os, optionst &options, const danger_programt &prog, learnert &learn, preproct &preproc) { danger_verify_configt config(prog); - if (options.get_bool_option(CEGIS_PARALLEL_VERIFY)) + if(options.get_bool_option(CEGIS_PARALLEL_VERIFY)) { parallel_danger_verifiert verify(options, config); return run_limited(os, options, prog, config, learn, verify, preproc); @@ -109,14 +109,14 @@ int run_match(mstreamt &os, optionst &opt, const danger_programt &prog, { const size_t symex_head_start=opt.get_unsigned_int_option(CEGIS_SYMEX_HEAD_START); const individual_to_danger_solution_deserialisert deser(prog, info_fac); - if (opt.get_bool_option(CEGIS_MATCH_SELECT)) + if(opt.get_bool_option(CEGIS_MATCH_SELECT)) { typedef match_selectt selectt; selectt select(fitness.get_test_case_data(), rnd, rounds); typedef ga_learnt ga_learnt; ga_learnt ga_learn(opt, rnd, select, mutate, cross, fitness, converter); #ifndef _WIN32 - if (!opt.get_bool_option(CEGIS_GENETIC_ONLY)) + if(!opt.get_bool_option(CEGIS_GENETIC_ONLY)) { concurrent_learnt learn(ga_learn, symex_learn, serialise, std::ref(deser), deserialise, symex_head_start); @@ -130,7 +130,7 @@ int run_match(mstreamt &os, optionst &opt, const danger_programt &prog, typedef ga_learnt ga_learnt; ga_learnt ga_learn(opt, rnd, select, mutate, cross, fitness, converter); #ifndef _WIN32 - if (!opt.get_bool_option(CEGIS_GENETIC_ONLY)) + if(!opt.get_bool_option(CEGIS_GENETIC_ONLY)) { concurrent_learnt learn(ga_learn, symex_learn, serialise, std::ref(deser), deserialise, symex_head_start); @@ -144,7 +144,7 @@ template int run_genetic_and_symex(mstreamt &os, optionst &opt, const danger_programt &prog, preproct &prep) { - if (!is_genetic(opt)) + if(!is_genetic(opt)) { danger_learn_configt cfg(prog); cegis_symex_learnt learn(opt, prep, cfg); diff --git a/src/cegis/danger/genetic/dynamic_danger_test_runner.cpp b/src/cegis/danger/genetic/dynamic_danger_test_runner.cpp index ba874730b63..8a81346abd8 100644 --- a/src/cegis/danger/genetic/dynamic_danger_test_runner.cpp +++ b/src/cegis/danger/genetic/dynamic_danger_test_runner.cpp @@ -40,7 +40,7 @@ void dynamic_danger_test_runnert::run_test(individualt &ind, const int argc=args.size(); std::vector argv; argv.resize(argc); - for (int i=0; i < argc; ++i) + for(int i=0; i < argc; ++i) argv[i]=args[i]; on_complete(EXIT_SUCCESS == fitness_tester(argv.data())); diff --git a/src/cegis/danger/options/danger_program_printer.cpp b/src/cegis/danger/options/danger_program_printer.cpp index a889ad266df..2b200136ff5 100644 --- a/src/cegis/danger/options/danger_program_printer.cpp +++ b/src/cegis/danger/options/danger_program_printer.cpp @@ -37,7 +37,7 @@ class danger_program_printert tmp.compute_target_numbers(); tmp.output(ns, "", os);*/ // XXX: Debug - for (goto_programt::const_targett it=prog.begin(); it != prog.end(); ++it) + for(goto_programt::const_targett it=prog.begin(); it != prog.end(); ++it) body_printer.output_instruction(ns, "", os, it); // XXX: Debug } @@ -78,7 +78,7 @@ void print_danger_program(messaget::mstreamt &os, { const danger_goto_solutiont::nondet_choicest &x0=solution.x0_choices; const danger_goto_solutiont::danger_programst &progs=solution.danger_programs; - if (x0.empty() && progs.empty()) return; + if(x0.empty() && progs.empty()) return; os << "x0:" << messaget::endl; const expr_printert x0_printer(program, os); std::for_each(x0.begin(), x0.end(), x0_printer); diff --git a/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp b/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp index 6d05f817c7d..2771384dbe2 100644 --- a/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp +++ b/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp @@ -68,7 +68,7 @@ class create_danger_meta_variables_for_loopt goto_programt::targett pos=im.Gx; ++pos; const size_t ranking_count=1; // XXX: Lexicographical ranking? - if (use_ranking) for (size_t i=0; i < ranking_count; ++i) + if(use_ranking) for (size_t i=0; i < ranking_count; ++i) { pos=declare_cegis_meta_variable(st, gf, pos, get_Rx(loop_id, i), type); dm.Rx.push_back(pos); @@ -77,7 +77,7 @@ class create_danger_meta_variables_for_loopt const create_skolem_meta_variablest create_sklm(st, gf, loop_id, dm, pos); std::for_each(sklm.begin(), sklm.end(), create_sklm); pos=im.Ix_prime; - if (use_ranking) for (size_t i=0; i < ranking_count; ++i) + if(use_ranking) for (size_t i=0; i < ranking_count; ++i) { const std::string rx_prime(get_Rx_prime(loop_id, i)); pos=declare_cegis_meta_variable(st, gf, pos, rx_prime, type); diff --git a/src/cegis/danger/preprocess/store_nondet_choices.cpp b/src/cegis/danger/preprocess/store_nondet_choices.cpp index 88246dd1bfa..79da79aa775 100644 --- a/src/cegis/danger/preprocess/store_nondet_choices.cpp +++ b/src/cegis/danger/preprocess/store_nondet_choices.cpp @@ -19,8 +19,8 @@ void store_skolem_choices_for_loop(invariant_programt::invariant_loopt *loop) { const danger_programt::program_ranget &range=loop->body; const goto_programt::targett &end=range.end; - for (goto_programt::targett it=range.begin; it != end; ++it) - if (is_nondet(it, end)) loop->skolem_choices.push_back(it); + for(goto_programt::targett it=range.begin; it != end; ++it) + if(is_nondet(it, end)) loop->skolem_choices.push_back(it); } } @@ -35,8 +35,8 @@ namespace void store_x0_choices_for_range(invariant_programt &program, const goto_programt::targett &begin, const goto_programt::targett &end) { - for (goto_programt::targett it=begin; it != end; ++it) - if (is_nondet(it, end)) program.x0_choices.push_back(it); + for(goto_programt::targett it=begin; it != end; ++it) + if(is_nondet(it, end)) program.x0_choices.push_back(it); } } @@ -46,7 +46,7 @@ void store_x0_choices(invariant_programt &program) goto_programt::targett end; const invariant_programt &prog=program; const invariant_programt::const_invariant_loopst loops(prog.get_loops()); - for (const invariant_programt::const_invariant_loopst::value_type &loop : loops) + for(const invariant_programt::const_invariant_loopst::value_type &loop : loops) { end=loop->body.begin; store_x0_choices_for_range(program, begin, end); diff --git a/src/cegis/danger/symex/fitness/danger_fitness_config.cpp b/src/cegis/danger/symex/fitness/danger_fitness_config.cpp index 2df293372be..a5b3e143435 100644 --- a/src/cegis/danger/symex/fitness/danger_fitness_config.cpp +++ b/src/cegis/danger/symex/fitness/danger_fitness_config.cpp @@ -53,7 +53,7 @@ void fix_quantifiers(const danger_programt &org_prog, danger_programt &new_prog, goto_programt::targett new_off=new_prog.loops.front().meta_variables.Ix; --new_off; goto_programt::targett::difference_type diff; - for (goto_programt::targett &q : quantifiers) + for(goto_programt::targett &q : quantifiers) { diff=std::distance(org_off, static_cast(q)); q=new_off; @@ -64,7 +64,7 @@ void fix_quantifiers(const danger_programt &org_prog, danger_programt &new_prog, void danger_fitness_configt::set_candidate(const candidatet &candidate) { - if (!constraint_inserted) + if(!constraint_inserted) { program_with_constraint=original_program; const danger_constraint constraint(program_with_constraint.use_ranking); @@ -81,15 +81,15 @@ void danger_fitness_configt::set_candidate(const candidatet &candidate) void danger_fitness_configt::set_test_case(const counterexamplet &ce) { - if (quantifiers.empty()) return; + if(quantifiers.empty()) return; goto_functionst &gf=program.gf; - for (goto_programt::targett quantifier : quantifiers) + for(goto_programt::targett quantifier : quantifiers) { const irep_idt &var=get_affected_variable(*quantifier); const counterexamplet::const_iterator it=ce.find(var); - if (ce.end() == it) continue; + if(ce.end() == it) continue; symbol_tablet &st=program.st; - if (program_contains_ce) + if(program_contains_ce) { goto_programt::targett assignment=quantifier; erase_target(get_entry_body(gf).instructions, ++assignment); diff --git a/src/cegis/danger/symex/learn/add_programs_to_learn.cpp b/src/cegis/danger/symex/learn/add_programs_to_learn.cpp index 665ac91771e..6404d6ba743 100644 --- a/src/cegis/danger/symex/learn/add_programs_to_learn.cpp +++ b/src/cegis/danger/symex/learn/add_programs_to_learn.cpp @@ -43,7 +43,7 @@ class declare_danger_programst loop.danger_meta_variables; const goto_programt::targetst &rx=dm.Rx; const goto_programt::targetst &rx_prime=dm.Rx_prime; - if (!rx.empty() && !rx_prime.empty()) + if(!rx.empty() && !rx_prime.empty()) { const goto_programt::targett rx_prog=*rx.rbegin(); pos=add_inv_prog(prog, pos, max_sol_sz, rx_prog); @@ -51,7 +51,7 @@ class declare_danger_programst execute_inv_prog(st, gf, max_sol_sz, *rx_prime.rbegin(), rx_prog_name); } const goto_programt::targetst &sx=dm.Sx; - if (!sx.empty()) pos=add_inv_prog(prog, pos, max_sol_sz, *sx.rbegin()); + if(!sx.empty()) pos=add_inv_prog(prog, pos, max_sol_sz, *sx.rbegin()); } }; } @@ -59,7 +59,7 @@ class declare_danger_programst void danger_add_programs_to_learn(danger_programt &prog, const size_t max_sz) { const danger_programt::loopst &loops=prog.loops; - if (loops.empty()) return; + if(loops.empty()) return; const goto_programt::targett pos=add_invariant_progs_to_learn(prog, max_sz); const declare_danger_programst declare_danger_progs(prog, max_sz, pos); std::for_each(loops.begin(), loops.end(), declare_danger_progs); diff --git a/src/cegis/danger/symex/learn/add_variable_refs.cpp b/src/cegis/danger/symex/learn/add_variable_refs.cpp index 412c92f1ac0..aacce395c14 100644 --- a/src/cegis/danger/symex/learn/add_variable_refs.cpp +++ b/src/cegis/danger/symex/learn/add_variable_refs.cpp @@ -30,7 +30,7 @@ void link_skolem(danger_programt &prog, const size_t num_user_vars, const danger_programt::loopt &loop) { const goto_programt::targetst &sklm=loop.danger_meta_variables.Sx; - if (sklm.empty()) return; + if(sklm.empty()) return; const symbol_tablet &st=prog.st; goto_programt &body=get_entry_body(prog.gf); goto_programt::targett pos=sklm.front(); @@ -38,7 +38,7 @@ void link_skolem(danger_programt &prog, const size_t num_user_vars, const size_t num_tmp=max_solution_size - num_skolem; link_temp_vars(st, body, --pos, num_tmp, user_vars); goto_programt::targetst::const_iterator it=sklm.begin(); - for (size_t i=0; i < num_skolem - 1; ++i, ++it) + for(size_t i=0; i < num_skolem - 1; ++i, ++it) { pos=*it; const goto_programt::instructiont &instr=*pos; diff --git a/src/cegis/danger/symex/learn/add_x0_placeholders.cpp b/src/cegis/danger/symex/learn/add_x0_placeholders.cpp index 2d69c1ad791..206ad30aaf7 100644 --- a/src/cegis/danger/symex/learn/add_x0_placeholders.cpp +++ b/src/cegis/danger/symex/learn/add_x0_placeholders.cpp @@ -20,7 +20,7 @@ namespace const typet &get_type(const goto_programt::targett &target) { const goto_programt::instructiont &instr=*target; - switch (instr.type) + switch(instr.type) { case goto_program_instruction_typet::DECL: return to_code_decl(instr.code).symbol().type(); diff --git a/src/cegis/danger/symex/learn/danger_learn_config.cpp b/src/cegis/danger/symex/learn/danger_learn_config.cpp index 7a085695713..a955ac49257 100644 --- a/src/cegis/danger/symex/learn/danger_learn_config.cpp +++ b/src/cegis/danger/symex/learn/danger_learn_config.cpp @@ -62,7 +62,7 @@ void danger_learn_configt::process(const size_t max_solution_size) counterexamplet dummy_ce; const typet type(cegis_default_integer_type()); // XXX: Currently single data type const exprt zero(from_integer(0, type)); - for (const symbol_exprt &var : ce_vars) + for(const symbol_exprt &var : ce_vars) dummy_ce.insert(std::make_pair(var.get_identifier(), zero)); counterexamplest empty(1, dummy_ce); process(empty, max_solution_size); diff --git a/src/cegis/danger/symex/learn/read_x0.cpp b/src/cegis/danger/symex/learn/read_x0.cpp index ba504cfa5b1..7240f18424c 100644 --- a/src/cegis/danger/symex/learn/read_x0.cpp +++ b/src/cegis/danger/symex/learn/read_x0.cpp @@ -27,7 +27,7 @@ bool is_placeholder_of(const goto_programt::targett &x0, const goto_programt::const_targett &placeholder) { const goto_programt::instructiont &placeholder_instr=*placeholder; - if (goto_program_instruction_typet::DECL != placeholder_instr.type) + if(goto_program_instruction_typet::DECL != placeholder_instr.type) return false; std::string placeholder_base(DANGER_X0_PLACEHOLDER_PREFIX); placeholder_base+=id2string(get_affected_variable(*x0)); @@ -51,7 +51,7 @@ class extract_x0_choice void operator()(const goto_programt::targett &x0) { const goto_tracet::stepst::const_iterator end(trace.steps.end()); - while (end != current_step && !is_placeholder_of(x0, current_step->pc)) + while(end != current_step && !is_placeholder_of(x0, current_step->pc)) ++current_step; assert(end != current_step); result.x0_choices.push_back(current_step->full_lhs_value); @@ -73,7 +73,7 @@ void danger_read_x0(program_individualt &ind, const danger_programt &prog, danger_goto_solutiont tmp; danger_read_x0(tmp, prog, trace); program_individualt::x0t &x0=ind.x0; - for (const danger_goto_solutiont::nondet_choicest::value_type &choice : tmp.x0_choices) + for(const danger_goto_solutiont::nondet_choicest::value_type &choice : tmp.x0_choices) { const bv_arithmetict arith(choice); const mp_integer::llong_t value=arith.to_integer().to_long(); diff --git a/src/cegis/danger/symex/learn/solution_factory.cpp b/src/cegis/danger/symex/learn/solution_factory.cpp index ead676a3456..b548724e991 100644 --- a/src/cegis/danger/symex/learn/solution_factory.cpp +++ b/src/cegis/danger/symex/learn/solution_factory.cpp @@ -32,7 +32,7 @@ namespace { size_t create_temps(invariant_variable_namest &rnames, const size_t num_tmp) { - for (size_t i=0; i < num_tmp; ++i) + for(size_t i=0; i < num_tmp; ++i) rnames.insert(std::make_pair(i, get_cegis_meta_name(get_tmp(i)))); return num_tmp; } @@ -46,10 +46,10 @@ goto_programt::instructionst &get_prog( danger_goto_solutiont::danger_programst &progs, const prog_typet type, const size_t instr_idx) { - switch (type) + switch(type) { case INV: - if (!instr_idx) progs.push_back(danger_goto_solutiont::danger_programt()); + if(!instr_idx) progs.push_back(danger_goto_solutiont::danger_programt()); return progs.back().invariant; case SKO: return progs.back().skolem; @@ -77,11 +77,11 @@ class read_instrt { insidx=0; rnames.clear(); - switch (prog_type) + switch(prog_type) { case INV: { - if (prog_size) + if(prog_size) { const size_t idx=create_temps(rnames, prog_size - 1); const std::string result(get_cegis_meta_name(get_Rx(loop_index, 0))); // XXX: Lexicographical ranking? @@ -95,7 +95,7 @@ class read_instrt const danger_programt::loopt &loop=danger_prog.loops[loop_index]; const size_t num_skolem=loop.skolem_choices.size(); const size_t num_temps=create_temps(rnames, prog_size - num_skolem); - for (size_t i=num_temps; i < prog_size; ++i) + for(size_t i=num_temps; i < prog_size; ++i) { const size_t sk=i - num_temps; const std::string name(get_cegis_meta_name(get_Sx(loop_index, sk))); @@ -144,7 +144,7 @@ class read_instrt goto_programt::targett first=prog.end(); const goto_programt::targett last=prog.end(); copy_instructionst copy_instr; - for (goto_programt::const_targett it=instr.begin(); it != instr.end(); ++it) + for(goto_programt::const_targett it=instr.begin(); it != instr.end(); ++it) { prog.push_back(goto_programt::instructiont()); goto_programt::targett new_instr=prog.end(); @@ -160,14 +160,14 @@ class read_instrt const symbol_tablet &st=danger_prog.st; replace_ops_in_instr(st, DANGER_EXECUTE, first, last, names, rnames, op0, op1, op2, insidx); - if (++insidx % prog_size == 0) invariant_make_presentable(prog); + if(++insidx % prog_size == 0) invariant_make_presentable(prog); } void operator()(const exprt &prog_arary_member) { const struct_exprt &instr_rep=to_struct_expr(prog_arary_member); operator()(to_program_individual_instruction(instr_rep)); - if (insidx % prog_size == 0) switch_prog(); + if(insidx % prog_size == 0) switch_prog(); } void set_prog_size(const size_t prog_size) @@ -190,8 +190,8 @@ class extract_programt void operator()(const goto_trace_stept &step) { - if (!is_program_individual_decl(step)) return; - for (const exprt &prog_array_member : step.full_lhs_value.operands()) + if(!is_program_individual_decl(step)) return; + for(const exprt &prog_array_member : step.full_lhs_value.operands()) read_instr(prog_array_member); } }; @@ -240,16 +240,16 @@ void create_danger_solution(danger_goto_solutiont &result, typedef program_individualt individualt; const individualt::programst &ind_progs=ind.programs; read_instrt extract(progs, prog, names, instr_set); - for (const individualt::programt &program : ind_progs) + for(const individualt::programt &program : ind_progs) { extract.set_prog_size(program.size()); - for (const individualt::instructiont &instr : program) + for(const individualt::instructiont &instr : program) extract(instr); } danger_goto_solutiont::nondet_choicest &nondet=result.x0_choices; nondet.clear(); const typet type=cegis_default_integer_type(); // XXX: Currently single data type. - for (const individualt::x0t::value_type &x0 : ind.x0) + for(const individualt::x0t::value_type &x0 : ind.x0) nondet.push_back(from_integer(x0, type)); } diff --git a/src/cegis/danger/symex/verify/danger_verify_config.cpp b/src/cegis/danger/symex/verify/danger_verify_config.cpp index c5bcf426212..a583829df5a 100644 --- a/src/cegis/danger/symex/verify/danger_verify_config.cpp +++ b/src/cegis/danger/symex/verify/danger_verify_config.cpp @@ -35,7 +35,7 @@ void danger_verify_configt::process(const candidatet &candidate) invariant_insert_constraint(quantifiers, program, std::cref(constraint)); danger_insert_candidate(program, candidate); goto_functionst &gf=program.gf; - if (limit_ce) restrict_bv_size(program.st, gf, max_ce_width); + if(limit_ce) restrict_bv_size(program.st, gf, max_ce_width); gf.update(); } diff --git a/src/cegis/danger/symex/verify/insert_candidate.cpp b/src/cegis/danger/symex/verify/insert_candidate.cpp index 9fae8310f28..cf79475bde1 100644 --- a/src/cegis/danger/symex/verify/insert_candidate.cpp +++ b/src/cegis/danger/symex/verify/insert_candidate.cpp @@ -75,7 +75,7 @@ class insert_danger_programt const irep_idt &Dx=get_affected_variable(*im.Ix); const irep_idt &Dx_prime=get_affected_variable(*im.Ix_prime); insert_program(body, im.Ix_prime, solution.invariant, Dx, Dx_prime); - if (!dm.Rx.empty() && !dm.Rx_prime.empty()) + if(!dm.Rx.empty() && !dm.Rx_prime.empty()) { const goto_programt::targett Rx=*dm.Rx.rbegin(); insert_program(body, *dm.Rx.rbegin(), solution.ranking); @@ -84,14 +84,14 @@ class insert_danger_programt const irep_idt &Rx_pn=get_affected_variable(*Rx_prime); insert_program(body, Rx_prime, solution.ranking, Rx_n, Rx_pn); // XXX: Lexicographical ranking? } - if (!dm.Sx.empty()) insert_program(body, *dm.Sx.rbegin(), solution.skolem); + if(!dm.Sx.empty()) insert_program(body, *dm.Sx.rbegin(), solution.skolem); } }; void insert_programs(danger_programt &prog, const candidatet &candidate) { const candidatet::danger_programst &progs=candidate.danger_programs; - if (progs.empty()) return; + if(progs.empty()) return; goto_programt &body=get_entry_body(prog.gf); const goto_programt::instructionst &first_inv=progs.begin()->invariant; const std::string D0x(get_cegis_meta_name(get_Dx(0))); diff --git a/src/cegis/danger/symex/verify/parallel_danger_verify_task.cpp b/src/cegis/danger/symex/verify/parallel_danger_verify_task.cpp index 01d127e6559..843f033a18c 100644 --- a/src/cegis/danger/symex/verify/parallel_danger_verify_task.cpp +++ b/src/cegis/danger/symex/verify/parallel_danger_verify_task.cpp @@ -222,7 +222,7 @@ void to_irep(irept &result, const bool success, void from_irep(danger_verify_configt::counterexamplet &ce, const irept &result) { - forall_named_irep(it, result.get_named_sub()){ + forall_named_irep(it, result.get_named_sub()) { const exprt &expr=static_cast(it->second); ce.insert(std::make_pair(it->first, expr)); } @@ -232,7 +232,7 @@ void from_irep(bool &success, danger_verify_configt::counterexamplest &ces, const irept &result) { success=result.get_bool(RESULT); - forall_irep(it, result.get_sub()){ + forall_irep(it, result.get_sub()) { ces.push_back(danger_verify_configt::counterexamplet()); danger_verify_configt::counterexamplet &ce=ces.back(); from_irep(ce, *it); @@ -242,7 +242,7 @@ void from_irep(bool &success, danger_verify_configt::counterexamplest &ces, void parallel_danger_verify_taskt::operator()() { - switch (mode) + switch(mode) { case modet::FULL: success=run_bmc(new_ces, options, config, candidate); @@ -294,7 +294,7 @@ void parallel_danger_verify_poolt::schedule(parallel_danger_verify_taskt::modet parallel_danger_verify_taskt &task=tasks.back(); #ifndef _WIN32 const pid_t child_pid=fork(); - if (child_pid) return task.set_parent_mode(child_pid); + if(child_pid) return task.set_parent_mode(child_pid); #endif task(); #ifndef _WIN32 @@ -322,7 +322,7 @@ void operator()(parallel_danger_verify_taskt &task) const #endif bool success=false; task.read_counterexamples(success, counterexamples); - if (!success) this->success=false; + if(!success) this->success=false; } }; } diff --git a/src/cegis/danger/symex/verify/restrict_counterexamples.cpp b/src/cegis/danger/symex/verify/restrict_counterexamples.cpp index 886d8186895..fde94f98cab 100644 --- a/src/cegis/danger/symex/verify/restrict_counterexamples.cpp +++ b/src/cegis/danger/symex/verify/restrict_counterexamples.cpp @@ -38,7 +38,7 @@ goto_programt::targett add_assume(goto_functionst &gf) { goto_programt &body=get_entry_body(gf); goto_programt::targett pos=find_assertion(gf); - if (goto_program_instruction_typet::ASSUME == (--pos)->type) return pos; + if(goto_program_instruction_typet::ASSUME == (--pos)->type) return pos; pos=body.insert_after(pos); pos->type=goto_program_instruction_typet::ASSUME; pos->source_location=default_cegis_source_location(); @@ -47,7 +47,7 @@ goto_programt::targett add_assume(goto_functionst &gf) void force_all_guards_violated(exprt::operandst &op, const size_t num_loops) { - for (size_t i=0; i < num_loops; ++i) + for(size_t i=0; i < num_loops; ++i) { const notequal_exprt Gx=danger_component_as_bool(get_Gx(i)); const equal_exprt not_Gx(Gx.lhs(), Gx.rhs()); @@ -70,7 +70,7 @@ void force_assertion_violation(goto_functionst &gf, const size_t num_loops) void force_ranking_error(goto_functionst &gf, const size_t num_loops) { exprt::operandst op; - for (size_t i=0; i < num_loops; ++i) + for(size_t i=0; i < num_loops; ++i) { const exprt::operandst conj={ danger_component_as_bool(get_Dx(i)), danger_component_as_bool(get_Dx(i)), danger_component_as_bool(get_Gx(i)), diff --git a/src/cegis/genetic/concrete_test_runner.cpp b/src/cegis/genetic/concrete_test_runner.cpp index e529b798f70..7af89361018 100644 --- a/src/cegis/genetic/concrete_test_runner.cpp +++ b/src/cegis/genetic/concrete_test_runner.cpp @@ -74,7 +74,7 @@ void prepare_executable(bool &executable_compiled, const std::function &source_code_provider, const std::string &executable) { - if (executable_compiled) return; + if(executable_compiled) return; const temporary_filet source_file(SOURCE_FILE_PREFIX, SOURCE_FILE_SUFFIX); const std::string source_file_name(source_file()); std::string source; @@ -86,7 +86,7 @@ void prepare_executable(bool &executable_compiled, compile_command+=ARTIFACT_SEPARATOR; compile_command+=executable; const int result=system(compile_command.c_str()); - if (result) throw std::runtime_error(COMPLING_FAILED); + if(result) throw std::runtime_error(COMPLING_FAILED); executable_compiled=true; } @@ -109,7 +109,7 @@ class conrete_test_runner_taskt { #ifndef _WIN32 const int result=system(command.c_str()); - if (!WIFEXITED(result)) return EXIT_FAILURE; + if(!WIFEXITED(result)) return EXIT_FAILURE; return WEXITSTATUS(result); #else NOT_SUPPORTED(); @@ -120,8 +120,8 @@ class conrete_test_runner_taskt void operator()(const int status) const { #ifndef _WIN32 - if (!WIFEXITED(status)) return; - if (EXIT_SUCCESS == WEXITSTATUS(status)) ++ind.fitness; + if(!WIFEXITED(status)) return; + if(EXIT_SUCCESS == WEXITSTATUS(status)) ++ind.fitness; #else NOT_SUPPORTED(); #endif @@ -137,34 +137,34 @@ void concrete_test_runnert::run_test(individualt &ind, const std::string exe(executable()); prepare_executable(executable_compiled, source_code_provider, exe); std::string command(exe); - for (const std::pair &assignment : ce) + for(const std::pair &assignment : ce) { command+=" "; const bv_arithmetict arith(assignment.second); const mp_integer::llong_t v=arith.to_integer().to_long(); command+=integer2string(static_cast(v)); } - for (const individualt::programt &prog : ind.programs) + for(const individualt::programt &prog : ind.programs) { - if (prog.empty()) continue; + if(prog.empty()) continue; command+=" "; command+=integer2string(prog.size()); - for (const individualt::instructiont &instr : prog) + for(const individualt::instructiont &instr : prog) { command+=" "; command+=integer2string(static_cast(instr.opcode)); size_t op_count=0; - for (const individualt::instructiont::opt &op : instr.ops) + for(const individualt::instructiont::opt &op : instr.ops) { command+=" "; command+=integer2string(static_cast(op)); ++op_count; } - for (; op_count < 3u; ++op_count) + for(; op_count < 3u; ++op_count) command+=" 0"; } } - for (const individualt::x0t::value_type &x0 : ind.x0) + for(const individualt::x0t::value_type &x0 : ind.x0) { command+=" "; command+=integer2string(static_cast(x0)); diff --git a/src/cegis/genetic/dynamic_test_runner_helper.cpp b/src/cegis/genetic/dynamic_test_runner_helper.cpp index bb3de1236d5..106b92e75af 100644 --- a/src/cegis/genetic/dynamic_test_runner_helper.cpp +++ b/src/cegis/genetic/dynamic_test_runner_helper.cpp @@ -23,7 +23,7 @@ Author: Daniel Kroening, kroening@kroening.com void close_fitness_tester_library(fitness_lib_handlet &handle) { - if (handle) + if(handle) { #if !defined(_WIN32) || defined(_HAVE_DLFCN) dlclose(handle); @@ -63,7 +63,7 @@ void *prepare_fitness_tester_library(fitness_lib_handlet &handle, const std::string source_file_name(source_file()); write_file(source_file_name, source_code_provider()); std::string compile_command; - if (configt::ansi_ct::preprocessort::CLANG == config.ansi_c.preprocessor) + if(configt::ansi_ct::preprocessort::CLANG == config.ansi_c.preprocessor) compile_command+=CLANG_COMPILE_COMMAND; else compile_command+=COMPILE_COMMAND; @@ -72,18 +72,18 @@ void *prepare_fitness_tester_library(fitness_lib_handlet &handle, compile_command+=ARTIFACT_SEPARATOR; compile_command+=library_file_path; const int result=system(compile_command.c_str()); - if (result) throw std::runtime_error(COMPLING_FAILED); + if(result) throw std::runtime_error(COMPLING_FAILED); #if !defined(_WIN32) || defined(_HAVE_DLFCN) handle=dlopen(library_file_path.c_str(), RTLD_NOW); - if (!handle) + if(!handle) { perror(OPEN_LIB_FAILED); throw std::runtime_error(OPEN_LIB_FAILED); } void * const func_result=dlsym(handle, CEGIS_FITNESS_TEST_FUNC); char *error=0; - if ((error=dlerror())) + if((error=dlerror())) { perror(error); throw std::runtime_error(LOAD_FUNC_FAILED); diff --git a/src/cegis/genetic/genetic_constant_strategy.cpp b/src/cegis/genetic/genetic_constant_strategy.cpp index 5bc356e5dff..4840fb2be26 100644 --- a/src/cegis/genetic/genetic_constant_strategy.cpp +++ b/src/cegis/genetic/genetic_constant_strategy.cpp @@ -49,10 +49,10 @@ size_t genetic_constant_strategy(invariant_programt &prog, size_t max_word_width=0u; size_t const_index=0u; // XXX: Literals strategy, benchmark performance - for (const constant_exprt &expr : literals) + for(const constant_exprt &expr : literals) { // XXX: Debug - if (!constants_printed) + if(!constants_printed) { std::cout << "" << const_index << "" << std::endl; std::cout << "" << from_expr(ns, "", expr) << "\n"; diff --git a/src/cegis/genetic/instruction_set_info_factory.cpp b/src/cegis/genetic/instruction_set_info_factory.cpp index d9b1f06d7de..a6213810fa4 100644 --- a/src/cegis/genetic/instruction_set_info_factory.cpp +++ b/src/cegis/genetic/instruction_set_info_factory.cpp @@ -45,11 +45,11 @@ class count_ops: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_symbol != expr.id()) return; + if(ID_symbol != expr.id()) return; const std::string &id=id2string(to_symbol_expr(expr).get_identifier()); - if (std::string::npos != id.find(OPCODE_SIGNIFIER)) return; + if(std::string::npos != id.find(OPCODE_SIGNIFIER)) return; const std::string::size_type op_id_pos=id.find(OP_SIGNIFIER); - if (std::string::npos == op_id_pos) return; + if(std::string::npos == op_id_pos) return; const std::string::size_type value_pos=op_id_pos + strlen(OP_SIGNIFIER); const mp_integer::llong_t v=string2integer(id.substr(value_pos)).to_long(); const size_t op_id=static_cast(v); @@ -64,7 +64,7 @@ class count_ops: public const_expr_visitort const count_ops &operator()(const goto_programt::instructionst &instrs) { - for (const goto_programt::instructiont &instr : instrs) + for(const goto_programt::instructiont &instr : instrs) this->operator()(instr); return *this; } @@ -93,7 +93,7 @@ class transform_to_info void initialise(instruction_set_infot &info, instruction_sett &ins, const std::function &body_provider) { - if (!info.empty()) return; + if(!info.empty()) return; const goto_programt &body=body_provider(); ins=extract_instruction_set(body); const transform_to_info op; diff --git a/src/cegis/genetic/match_select.cpp b/src/cegis/genetic/match_select.cpp index cf3e0f59b0f..2359dc7c7bb 100644 --- a/src/cegis/genetic/match_select.cpp +++ b/src/cegis/genetic/match_select.cpp @@ -24,7 +24,7 @@ match_selectt::~match_selectt() void match_selectt::init(populationt &pop) { pop.resize(pop_size); - for (program_individualt &ind : pop) + for(program_individualt &ind : pop) random.havoc(ind); } @@ -64,8 +64,8 @@ class is_contestant_less_thant bool operator()(const contestantt &lhs, const contestantt &rhs) const { const bool is_rhs_null=no_contestant == rhs; - if (no_contestant == lhs) return !is_rhs_null; - if (is_rhs_null) return false; + if(no_contestant == lhs) return !is_rhs_null; + if(is_rhs_null) return false; return lhs->fitness < rhs->fitness; } }; @@ -84,8 +84,8 @@ size_t get_match_fitness(const match_selectt::test_case_datat &data, assert(f_data_size == m_dt.size()); size_t match_value=mother->fitness; typedef std::list::const_iterator itert; - for (itert fv=f_dt.begin(), mv=m_dt.begin(); fv != f_dt.end(); ++fv, ++mv) - if (*fv != *mv) match_value+=2; // Excessive? + for(itert fv=f_dt.begin(), mv=m_dt.begin(); fv != f_dt.end(); ++fv, ++mv) + if(*fv != *mv) match_value+=2; // Excessive? return match_value; } } @@ -95,27 +95,27 @@ match_selectt::selectiont match_selectt::select(populationt &pop) const contestantt no_contestant=pop.end(); const is_contestant_less_thant is_less_than(no_contestant); contestantt father=no_contestant; - for (size_t contestants=0; contestants < rounds / 2;) + for(size_t contestants=0; contestants < rounds / 2;) { contestantt contestant=pop.begin(); std::advance(contestant, random.rand() % pop.size()); - if (father == contestant) continue; - if (is_less_than(father, contestant)) father=contestant; + if(father == contestant) continue; + if(is_less_than(father, contestant)) father=contestant; ++contestants; } contestantt mother=no_contestant; size_t match_fitness=0u; - for (size_t contestants=0; contestants < rounds / 2;) + for(size_t contestants=0; contestants < rounds / 2;) { contestantt contestant=pop.begin(); std::advance(contestant, random.rand() % pop.size()); - if (mother == contestant || father == contestant) continue; - if (no_contestant == mother) mother=contestant; + if(mother == contestant || father == contestant) continue; + if(no_contestant == mother) mother=contestant; else { const size_t new_match=get_match_fitness(test_case_data, no_contestant, father, contestant); - if (match_fitness < new_match) + if(match_fitness < new_match) { match_fitness=new_match; mother=contestant; @@ -125,19 +125,19 @@ match_selectt::selectiont match_selectt::select(populationt &pop) } contestantt son=no_contestant; contestantt daughter=no_contestant; - for (size_t contestants=0; contestants < rounds / 2;) + for(size_t contestants=0; contestants < rounds / 2;) { contestantt contestant=pop.begin(); std::advance(contestant, random.rand() % pop.size()); - if (father == contestant || mother == contestant || son == contestant + if(father == contestant || mother == contestant || son == contestant || daughter == contestant) continue; - if (no_contestant == son) son=contestant; - else if (no_contestant == daughter) daughter=contestant; - else if (son->fitness > contestant->fitness) + if(no_contestant == son) son=contestant; + else if(no_contestant == daughter) daughter=contestant; + else if(son->fitness > contestant->fitness) { daughter=son; son=contestant; - } else if (daughter->fitness > contestant->fitness) daughter=contestant; + } else if(daughter->fitness > contestant->fitness) daughter=contestant; ++contestants; } selectiont selection; diff --git a/src/cegis/genetic/random_cross.cpp b/src/cegis/genetic/random_cross.cpp index 6af2f9b9472..507f6a18476 100644 --- a/src/cegis/genetic/random_cross.cpp +++ b/src/cegis/genetic/random_cross.cpp @@ -28,10 +28,10 @@ namespace void fix_result_ops(random_crosst::programt::value_type &instr, const size_t org_index, const size_t new_index, const size_t num_vars) { - for (random_crosst::programt::value_type::opt &op : instr.ops) + for(random_crosst::programt::value_type::opt &op : instr.ops) { - if (op < num_vars) continue; - if (org_index > new_index) op-=(org_index - new_index); + if(op < num_vars) continue; + if(org_index > new_index) op-=(org_index - new_index); else op+=(new_index - org_index); op%=(num_vars + new_index); } @@ -69,7 +69,7 @@ void random_crosst::operator ()(const individualst &parents, const size_t max_prog_sz=random.get_max_prog_size(target_prog_index); const size_t f_sz=f_prog.size(); const size_t m_sz=m_prog.size(); - if (f_sz < min_prog_sz || m_sz < min_prog_sz) return; + if(f_sz < min_prog_sz || m_sz < min_prog_sz) return; const size_t all_instrs=f_sz + m_sz; const size_t child_max=std::min(max_prog_sz, all_instrs - min_prog_sz); const size_t father_offset=random.rand() % (f_sz + 1); @@ -88,8 +88,8 @@ void random_crosst::operator ()(const individualst &parents, std::copy(f_prog.begin(), f_prog.begin() + father_offset, s_prog.begin()); std::copy(m_prog.begin(), m_prog.begin() + mother_offset, d_prog.begin()); const size_t num_vars=random.get_num_vars(); - for (size_t f=father_offset, m=mother_offset; m < m_sz; ++f, ++m) + for(size_t f=father_offset, m=mother_offset; m < m_sz; ++f, ++m) fix_result_ops(s_prog[f]=m_prog[m], m, f, num_vars); - for (size_t m=mother_offset, f=father_offset; f < f_sz; ++m, ++f) + for(size_t m=mother_offset, f=father_offset; f < f_sz; ++m, ++f) fix_result_ops(d_prog[m]=f_prog[f], f, m, num_vars); } diff --git a/src/cegis/genetic/random_individual.cpp b/src/cegis/genetic/random_individual.cpp index d4fe319acab..34b9c01c93e 100644 --- a/src/cegis/genetic/random_individual.cpp +++ b/src/cegis/genetic/random_individual.cpp @@ -30,9 +30,9 @@ random_individualt::~random_individualt() size_t random_individualt::prog_size(const size_t index) const { const size_t max=settings.max_prog_sz(index); - if (max == 0u) return 0u; + if(max == 0u) return 0u; const size_t min=settings.min_prog_sz(index); - if (min >= max) return min; + if(min >= max) return min; const size_t diff=max - min; return min + rand() % (diff + 1); } @@ -57,7 +57,7 @@ void random_individualt::havoc(program_individualt::instructiont &instr, const instruction_set_infot::const_iterator num_ops=info.find(instr.opcode); assert(info.end() != num_ops); instr.ops.resize(num_ops->second); - for (program_individualt::instructiont::opt &o : instr.ops) + for(program_individualt::instructiont::opt &o : instr.ops) o=op(index); } @@ -66,7 +66,7 @@ void random_individualt::havoc(program_individualt::programt &prog, { const size_t prog_sz=prog_size(index); prog.resize(prog_sz); - for (size_t i=0; i < prog_sz; ++i) + for(size_t i=0; i < prog_sz; ++i) havoc(prog[i], i); } @@ -82,7 +82,7 @@ program_individualt::x0t::value_type random_individualt::constant() const const mp_integer::llong_t v=spec.max_value().to_long(); const unsigned int wordmask=static_cast(v); const unsigned int r=rand() % 6u; - switch (r) + switch(r) { case 0: return 0; @@ -103,16 +103,16 @@ void random_individualt::havoc(program_individualt &ind) { program_individualt::programst &progs=ind.programs; progs.resize(settings.num_progs()); - for (size_t i=0u; i < progs.size(); ++i) + for(size_t i=0u; i < progs.size(); ++i) havoc(progs[i], i); post_process(ind); const size_t number_of_x0=settings.num_x0(); program_individualt::x0t &ind_x0=ind.x0; ind_x0.resize(number_of_x0); const size_t number_of_constants=settings.num_consts(); - for (size_t i=0; i < number_of_constants; ++i) + for(size_t i=0; i < number_of_constants; ++i) ind_x0[i]=constant(); - for (size_t i=number_of_constants; i < number_of_x0; ++i) + for(size_t i=number_of_constants; i < number_of_x0; ++i) ind_x0[i]=x0(); } @@ -145,10 +145,10 @@ void random_individualt::post_process(program_individualt &ind) const { // XXX: Specific optimisation for PLDI 2016 submissions. program_individualt::programst &progs=ind.programs; - if (progs.size() <= RANKING_INDEX) return; + if(progs.size() <= RANKING_INDEX) return; program_individualt::programt &ranking=progs[RANKING_INDEX]; - for (program_individualt::instructiont &instr : ranking) - switch (instr.opcode) + for(program_individualt::instructiont &instr : ranking) + switch(instr.opcode) { case 1u: case 19u: diff --git a/src/cegis/genetic/random_mutate.cpp b/src/cegis/genetic/random_mutate.cpp index 71ef128d14f..45c85bc7aee 100644 --- a/src/cegis/genetic/random_mutate.cpp +++ b/src/cegis/genetic/random_mutate.cpp @@ -31,7 +31,7 @@ void mutate_opcode(random_mutatet::individualt::instructiont &instr, rand.havoc(instr, index); random_mutatet::individualt::instructiont::opst &new_ops=instr.ops; const size_t size=std::min(old_ops.size(), new_ops.size()); - for (size_t i=0; i < size; ++i) + for(size_t i=0; i < size; ++i) new_ops[i]=old_ops[i]; } } @@ -41,33 +41,33 @@ void random_mutatet::operator()(individualt &lhs, const individualt &rhs) const lhs=rhs; const size_t num_x0=lhs.x0.size(); size_t num_mutation_candidates=num_x0; - for (const individualt::programt &prog : lhs.programs) + for(const individualt::programt &prog : lhs.programs) { - for (const individualt::instructiont &instr : prog) + for(const individualt::instructiont &instr : prog) num_mutation_candidates+=instr.ops.size() + 1; } size_t mutation_target=random.rand() % (num_mutation_candidates + 1); - if (mutation_target < num_consts()) + if(mutation_target < num_consts()) { lhs.x0[mutation_target]=random.constant(); return; } - if (mutation_target < num_x0) + if(mutation_target < num_x0) { lhs.x0[mutation_target]=random.x0(); return; } mutation_target-=num_x0; - for (individualt::programt &prog : lhs.programs) + for(individualt::programt &prog : lhs.programs) { - for (size_t i=0; i < prog.size(); ++i) + for(size_t i=0; i < prog.size(); ++i) { individualt::instructiont &instr=prog[i]; - if (!mutation_target) return mutate_opcode(instr, random, i); + if(!mutation_target) return mutate_opcode(instr, random, i); --mutation_target; const size_t length=instr.ops.size(); - if (mutation_target < length) + if(mutation_target < length) { instr.ops[mutation_target]=random.op(i); return; diff --git a/src/cegis/genetic/serialise_individual.cpp b/src/cegis/genetic/serialise_individual.cpp index f8655df986d..9bf5da35d8c 100644 --- a/src/cegis/genetic/serialise_individual.cpp +++ b/src/cegis/genetic/serialise_individual.cpp @@ -18,33 +18,33 @@ void serialise(std::deque &stream, { const program_individualt::programst &progs=ind.programs; const size_t num_progs=progs.size(); - for (size_t i=0; i < num_progs; ++i) + for(size_t i=0; i < num_progs; ++i) { - if (max_prog_sz(i) == 0u) continue; + if(max_prog_sz(i) == 0u) continue; const program_individualt::programt &prog=progs[i]; assert(!prog.empty()); stream.push_back(static_cast(prog.size())); - for (const program_individualt::instructiont &instr : prog) + for(const program_individualt::instructiont &instr : prog) { stream.push_back(static_cast(instr.opcode)); size_t op_count=0; - for (const program_individualt::instructiont::opt &op : instr.ops) + for(const program_individualt::instructiont::opt &op : instr.ops) { stream.push_back(static_cast(op)); ++op_count; } - for (; op_count < 3u; ++op_count) + for(; op_count < 3u; ++op_count) stream.push_back(0u); } } - for (const program_individualt::x0t::value_type &x0 : ind.x0) + for(const program_individualt::x0t::value_type &x0 : ind.x0) stream.push_back(static_cast(x0)); } void serialise(std::deque &stream, const std::map assignments) { - for (const std::pair &assignment : assignments) + for(const std::pair &assignment : assignments) { const bv_arithmetict arith(assignment.second); const mp_integer::llong_t v=arith.to_integer().to_long(); diff --git a/src/cegis/genetic/tournament_select.cpp b/src/cegis/genetic/tournament_select.cpp index 855a2890e68..16e80cbbb3d 100644 --- a/src/cegis/genetic/tournament_select.cpp +++ b/src/cegis/genetic/tournament_select.cpp @@ -51,7 +51,7 @@ tournament_selectt::~tournament_selectt() void tournament_selectt::init(populationt &pop) { pop.resize(pop_size); - for (program_individualt &ind : pop) + for(program_individualt &ind : pop) random.havoc(ind); } @@ -80,21 +80,21 @@ class arenat bool add_contestant(const contestantt &contestant) { - if (contains(contestant)) return false; - if (no_contestant == father) father=contestant; - else if (no_contestant == mother) mother=contestant; - else if (no_contestant == son) son=contestant; - else if (no_contestant == daughter) daughter=contestant; - else if (father->fitness < contestant->fitness) + if(contains(contestant)) return false; + if(no_contestant == father) father=contestant; + else if(no_contestant == mother) mother=contestant; + else if(no_contestant == son) son=contestant; + else if(no_contestant == daughter) daughter=contestant; + else if(father->fitness < contestant->fitness) { mother=father; father=contestant; - } else if (mother->fitness < contestant->fitness) mother=contestant; - else if (daughter->fitness > contestant->fitness) + } else if(mother->fitness < contestant->fitness) mother=contestant; + else if(daughter->fitness > contestant->fitness) { son=daughter; daughter=contestant; - } else if (son->fitness > contestant->fitness) son=contestant; + } else if(son->fitness > contestant->fitness) son=contestant; return true; } @@ -111,11 +111,11 @@ class arenat tournament_selectt::selectiont tournament_selectt::select(populationt &pop) { arenat arena(pop); - for (size_t contestants=0; contestants < rounds;) + for(size_t contestants=0; contestants < rounds;) { populationt::iterator contestant=pop.begin(); std::advance(contestant, rand() % pop.size()); - if (arena.add_contestant(contestant)) ++contestants; + if(arena.add_contestant(contestant)) ++contestants; } tournament_selectt::selectiont selection; arena.select(selection); diff --git a/src/cegis/instructions/instruction_set_factory.cpp b/src/cegis/instructions/instruction_set_factory.cpp index fb9438f7e92..e8b7b48ff9a 100644 --- a/src/cegis/instructions/instruction_set_factory.cpp +++ b/src/cegis/instructions/instruction_set_factory.cpp @@ -43,19 +43,19 @@ class execute_instruction_handlert { const goto_programt::instructiont &instr=*target; const goto_programt::instructiont::labelst &labels=instr.labels; - if (labels.empty()) return; + if(labels.empty()) return; const std::string &label=id2string(instr.labels.front()); - if (std::string::npos != label.find(first_prefix)) + if(std::string::npos != label.find(first_prefix)) { current_instr_offset=target; has_current_instr=true; is_last_in_range=false; instr_idx=string2integer(label.substr(first_prefix.size())).to_ulong(); - } else if (std::string::npos != label.find(last_prefix)) + } else if(std::string::npos != label.find(last_prefix)) { is_last_in_range=true; instr_idx=string2integer(label.substr(last_prefix.size())).to_ulong(); - } else if (std::string::npos != label.find(single_prefix)) + } else if(std::string::npos != label.find(single_prefix)) { has_current_instr=true; is_last_in_range=true; @@ -69,7 +69,7 @@ class execute_instruction_handlert instr.push_back(goto_programt::instructiont()); goto_programt::targett new_target=instr.end(); copy_instruction(--new_target, target); - if (is_last_in_range) + if(is_last_in_range) { instr.push_back(goto_programt::instructiont(SKIP)); goto_programt::targett new_target=instr.end(); @@ -81,7 +81,7 @@ class execute_instruction_handlert void operator()(const goto_programt::const_targett &target) { handle_meta_info(target); - if (has_current_instr) copy_op(target); + if(has_current_instr) copy_op(target); } }; } @@ -102,7 +102,7 @@ instruction_sett extract_instruction_set(const goto_programt &body, const goto_programt::instructionst &instrs=body.instructions; instruction_sett instruction_set; execute_instruction_handlert handler(first_prefix, last_prefix, single_prefix, instruction_set); - for (goto_programt::const_targett it=instrs.begin(); it != instrs.end(); ++it) + for(goto_programt::const_targett it=instrs.begin(); it != instrs.end(); ++it) handler(it); return instruction_set; } diff --git a/src/cegis/instrument/cegis_library.cpp b/src/cegis/instrument/cegis_library.cpp index 920f620f74a..6de8c886961 100644 --- a/src/cegis/instrument/cegis_library.cpp +++ b/src/cegis/instrument/cegis_library.cpp @@ -58,7 +58,7 @@ code_typet cegis_execute_type() void add_execute_placeholder(symbol_tablet &symbol_table, const std::string &func_name, const code_typet &type) { - if (symbol_table.has_symbol(func_name)) return; + if(symbol_table.has_symbol(func_name)) return; symbolt symbol; symbol.name=func_name; symbol.base_name=symbol.name; diff --git a/src/cegis/instrument/find_cprover_initialize.cpp b/src/cegis/instrument/find_cprover_initialize.cpp index 658fd614002..14c4714bde1 100644 --- a/src/cegis/instrument/find_cprover_initialize.cpp +++ b/src/cegis/instrument/find_cprover_initialize.cpp @@ -15,15 +15,15 @@ goto_programt::targett find_cprover_initialize(goto_programt &body) goto_programt::instructionst &instrs=body.instructions; goto_programt::targett pos; const goto_programt::targett end=instrs.end(); - for (pos=instrs.begin(); pos != end; ++pos) + for(pos=instrs.begin(); pos != end; ++pos) { const goto_programt::instructiont &instr=*pos; - if (goto_program_instruction_typet::FUNCTION_CALL != instr.type) continue; + if(goto_program_instruction_typet::FUNCTION_CALL != instr.type) continue; const code_function_callt &call=to_code_function_call(instr.code); const exprt &func=call.function(); - if (ID_symbol != func.id()) continue; + if(ID_symbol != func.id()) continue; const std::string &func_id=id2string(to_symbol_expr(func).get_identifier()); - if (CPROVER_INIT == func_id) break; + if(CPROVER_INIT == func_id) break; } assert(end != pos); return pos; diff --git a/src/cegis/instrument/instrument_var_ops.cpp b/src/cegis/instrument/instrument_var_ops.cpp index 485476c944d..1bbce736d58 100644 --- a/src/cegis/instrument/instrument_var_ops.cpp +++ b/src/cegis/instrument/instrument_var_ops.cpp @@ -31,20 +31,20 @@ void link_user_symbols(const symbol_tablet &st, operand_variable_idst &var_ids, { typedef symbol_tablet::symbolst symbolst; const symbolst &symbols=st.symbols; - for (symbolst::const_iterator it=symbols.begin(); it != symbols.end(); ++it) + for(symbolst::const_iterator it=symbols.begin(); it != symbols.end(); ++it) { const symbolt &s=it->second; - if (!is_op_variable(s.name, s.type) + if(!is_op_variable(s.name, s.type) || (is_builtin(s.location) && !is_cegis_constant(s.name))) continue; const bool is_const=is_global_const(s.name, s.type); - if (is_const == consts) + if(is_const == consts) var_ids.insert(std::make_pair(s.name, variable_id++)); } } size_t get_min_id(const operand_variable_idst &ids) { - if (ids.empty()) return 0; + if(ids.empty()) return 0; return std::max_element(ids.begin(), ids.end(), [](const operand_variable_idst::value_type &lhs, const operand_variable_idst::value_type &rhs) { return lhs.second < rhs.second;})->second + 1; @@ -68,13 +68,13 @@ const char RETURN_VALUE_IDENTIFIER[]="#return_value"; bool is_instrumentable_user_variable(const irep_idt &id, const typet &type) { - if (ID_code == type.id()) return false; + if(ID_code == type.id()) return false; const std::string &name=id2string(id); - if (std::string::npos != name.find("::") + if(std::string::npos != name.find("::") && std::string::npos == name.find(id2string(ID_main)) && std::string::npos == name.find(id2string(goto_functionst::entry_point()))) return false; // Inlined variables - if (std::string::npos != name.find(RETURN_VALUE_IDENTIFIER)) return false; + if(std::string::npos != name.find(RETURN_VALUE_IDENTIFIER)) return false; return std::string::npos == name.find(CPROVER_PREFIX); } @@ -101,30 +101,30 @@ void link_user_program_variable_ops(const symbol_tablet &st, goto_programt &body=get_entry_body(gf); goto_programt::instructionst &instrs=body.instructions; goto_programt::targett pos=begin; - while (is_builtin(pos->source_location) && pos != end) + while(is_builtin(pos->source_location) && pos != end) ++pos; - for (goto_programt::targett it=pos; it != end; ++it) + for(goto_programt::targett it=pos; it != end; ++it) { goto_programt::instructiont &instr=*it; const goto_program_instruction_typet type=instr.type; - if (DECL != type && DEAD != type) continue; + if(DECL != type && DEAD != type) continue; const irep_idt &name=get_affected_variable(instr); - if (!is_op_variable(name, st.lookup(name).type)) continue; + if(!is_op_variable(name, st.lookup(name).type)) continue; const operand_variable_idst::const_iterator id=var_ids.find(name); - if (DEAD == type) set_ops_reference(st, body, it, get_null(), id->second); + if(DEAD == type) set_ops_reference(st, body, it, get_null(), id->second); else { set_ops_reference(st, body, it, name, id->second); to_instrument.erase(id->first); } } - if (pos != instrs.begin()) --pos; + if(pos != instrs.begin()) --pos; typedef operand_variable_idst::const_iterator itt; const itt first=to_instrument.begin(); - for (itt it=first; it != to_instrument.end(); ++it) + for(itt it=first; it != to_instrument.end(); ++it) { pos=set_ops_reference(st, body, pos, it->first, it->second); - if (first == it) move_labels(body, begin, pos); + if(first == it) move_labels(body, begin, pos); } } diff --git a/src/cegis/instrument/meta_variables.cpp b/src/cegis/instrument/meta_variables.cpp index 83d48e70ecb..2b5e302a546 100644 --- a/src/cegis/instrument/meta_variables.cpp +++ b/src/cegis/instrument/meta_variables.cpp @@ -133,7 +133,7 @@ const symbolt &declare_global_meta_variable(symbol_tablet &st, goto_programt &init_body=get_body(gf, CPROVER_INIT); goto_programt::instructionst &instrs=init_body.instructions; goto_programt::targett pos=instrs.begin(); - if (instrs.size() >= 2) pos=std::prev(init_body.instructions.end(), 2); + if(instrs.size() >= 2) pos=std::prev(init_body.instructions.end(), 2); const symbol_exprt lhs(symbol.symbol_expr()); cegis_assign(st, init_body, pos, lhs, value, default_cegis_source_location()); return symbol; diff --git a/src/cegis/invariant/constant/add_constant.cpp b/src/cegis/invariant/constant/add_constant.cpp index e64ff8f871f..585268973fa 100644 --- a/src/cegis/invariant/constant/add_constant.cpp +++ b/src/cegis/invariant/constant/add_constant.cpp @@ -22,10 +22,10 @@ namespace const char NS_SEP[]="::"; bool is_meta_or_not_global(const symbolt &symbol) { - if (ID_code == symbol.type.id()) return true; + if(ID_code == symbol.type.id()) return true; const std::string &name=id2string(symbol.name); - if (std::string::npos != name.find("#return_value")) return true; - if (std::string::npos != name.find(CPROVER_PREFIX)) return true; + if(std::string::npos != name.find("#return_value")) return true; + if(std::string::npos != name.find(CPROVER_PREFIX)) return true; return std::string::npos != name.find(NS_SEP); } @@ -35,13 +35,13 @@ bool contains_constant(const symbol_tablet &st, const exprt &value) exprt lhs=value; lhs.add_source_location()=source_locationt(); const symbolst &s=st.symbols; - for (symbolst::const_iterator it=s.begin(); it != s.end(); ++it) + for(symbolst::const_iterator it=s.begin(); it != s.end(); ++it) { const symbolt &symbol=it->second; - if (is_meta_or_not_global(symbol)) continue; + if(is_meta_or_not_global(symbol)) continue; exprt rhs=symbol.value; rhs.add_source_location()=lhs.source_location(); - if (lhs == rhs) return true; + if(lhs == rhs) return true; } return false; } @@ -55,7 +55,7 @@ bool is_empty(const exprt &expr) void add_danger_constant(invariant_programt &program, const exprt &value) { symbol_tablet &st=program.st; - if (contains_constant(st, value)) return; + if(contains_constant(st, value)) return; const namespacet ns(st); std::string name(CEGIS_CONSTANT_PREFIX); name+=expr2c(value, ns); @@ -66,12 +66,12 @@ void add_danger_constant(invariant_programt &prog, const std::string &name, const exprt &value) { goto_programt::targett pos=prog.invariant_range.begin; - while (is_builtin(pos->source_location)) + while(is_builtin(pos->source_location)) ++pos; typet type=value.type(); type.set(ID_C_constant, true); symbol_tablet &st=prog.st; create_cegis_symbol(st, name, type).value=value; - if (!is_empty(value)) + if(!is_empty(value)) pos=cegis_assign_user_variable(st, prog.gf, pos, name, value); } diff --git a/src/cegis/invariant/constant/default_constant_strategy.cpp b/src/cegis/invariant/constant/default_constant_strategy.cpp index 36e12634a09..3123a7eab71 100644 --- a/src/cegis/invariant/constant/default_constant_strategy.cpp +++ b/src/cegis/invariant/constant/default_constant_strategy.cpp @@ -25,7 +25,7 @@ size_t default_constant_strategy(invariant_programt &program, add_danger_constant(program, from_integer(spec.max_value().to_ulong(), type)); add_danger_constant(program, from_integer(0u, type)); return std::max(size_t(1u), literals_constant_strategy(program, max_length)); - //return 2u + literals_constant_strategy(program, max_length); + // return 2u + literals_constant_strategy(program, max_length); /*for (size_t i=0; i < max_length; ++i) { const side_effect_expr_nondett value(type); diff --git a/src/cegis/invariant/constant/literals_constant_strategy.cpp b/src/cegis/invariant/constant/literals_constant_strategy.cpp index d1890f4135c..afdfbded2b7 100644 --- a/src/cegis/invariant/constant/literals_constant_strategy.cpp +++ b/src/cegis/invariant/constant/literals_constant_strategy.cpp @@ -49,17 +49,17 @@ class constant_expr_visitort: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_constant != expr.id()) return; + if(ID_constant != expr.id()) return; const typet &expr_type=expr.type(); const irep_idt &type_id=expr_type.id(); - if (ID_unsignedbv != type_id && ID_signedbv != type_id) return; + if(ID_unsignedbv != type_id && ID_signedbv != type_id) return; const constant_exprt constant(to_constant_expr(expr)); const bv_arithmetict bv(constant); const mp_integer value=bv.to_integer(); constants.insert(from_integer(value, type)); // XXX: Add constant +/- 1? - //constants.insert(from_integer(value + 1, type)); - //constants.insert(from_integer(value - 1, type)); + // constants.insert(from_integer(value + 1, type)); + // constants.insert(from_integer(value - 1, type)); } void operator()(const goto_programt::instructiont &instr) @@ -101,7 +101,7 @@ size_t literals_constant_strategy(invariant_programt &program, { const std::vector lit(collect_literal_constants(program)); size_t max_word_width=0u; - for (const constant_exprt &expr : lit) + for(const constant_exprt &expr : lit) { add_danger_constant(program, expr); // XXX: Add negation of every constant? diff --git a/src/cegis/invariant/fitness/concrete_fitness_source_provider.cpp b/src/cegis/invariant/fitness/concrete_fitness_source_provider.cpp index dbfa21257c5..5269d8d1d47 100644 --- a/src/cegis/invariant/fitness/concrete_fitness_source_provider.cpp +++ b/src/cegis/invariant/fitness/concrete_fitness_source_provider.cpp @@ -102,7 +102,7 @@ void replace_assume(std::string &line) void replace_danger_execute_size(std::string &line) { - if (!contains(line, "__CPROVER_danger_execute(")) return; + if(!contains(line, "__CPROVER_danger_execute(")) return; const std::string::size_type name_start=line.find('(') + 1; const std::string::size_type name_end=line.find(','); const std::string::size_type name_len=name_end - name_start; @@ -129,8 +129,8 @@ bool handle_programs(std::string &source, bool &initialised, const std::string &line) { const size_t len=PROG_PREFIX_LEN; - if (PROG_PREFIX != line.substr(0, len)) return false; - if (!initialised) + if(PROG_PREFIX != line.substr(0, len)) return false; + if(!initialised) { source+=" " CEGIS_PREFIX "deserialise_init();\n"; initialised=true; @@ -149,7 +149,7 @@ bool handle_programs(std::string &source, bool &initialised, bool handle_x0(std::string &source, std::string &line) { - if (!contains(line, "__CPROVER") || !contains(line, "_x0_") + if(!contains(line, "__CPROVER") || !contains(line, "_x0_") || contains(line, "=")) return false; fix_cprover_names(line); const std::string::size_type name_start=line.rfind(' ') + 1; @@ -163,10 +163,10 @@ bool handle_x0(std::string &source, std::string &line) bool handle_ce(std::string &source, bool &initialised, const std::string &line) { - if (!(contains(line, CEGIS_PREFIX "x_choice_") + if(!(contains(line, CEGIS_PREFIX "x_choice_") || contains(line, CEGIS_PREFIX "x0_choice_")) || contains(line, CEGIS_PREFIX "x_index")) return false; - if (!initialised) + if(!initialised) { source+=" " CEGIS_PREFIX "ce_value_init();\n"; initialised=true; @@ -182,14 +182,14 @@ bool handle_ce(std::string &source, bool &initialised, const std::string &line) bool handle_second_instr_struct(std::string &source, const std::string &line) { - if ("struct " CEGIS_PREFIX "instructiont" != line) return false; + if("struct " CEGIS_PREFIX "instructiont" != line) return false; source+="struct " CEGIS_PREFIX "instructiont_escaped\n"; return true; } bool handle_ce_loop(const std::string &line, std::stringstream &ss) { - if (" " CEGIS_PREFIX "x_index = " CEGIS_PREFIX "x_index + 1u;" == line + if(" " CEGIS_PREFIX "x_index = " CEGIS_PREFIX "x_index + 1u;" == line || " do" == line) { std::string skip; @@ -201,7 +201,7 @@ bool handle_ce_loop(const std::string &line, std::stringstream &ss) bool handle_internals(const std::string &line) { - if (contains(line, "ARRAY_OF(")) return true; + if(contains(line, "ARRAY_OF(")) return true; return contains(line, "__CPROVER_malloc_size =") || contains(line, "__CPROVER_dead_object =") || contains(line, "__CPROVER_deallocated =") @@ -225,7 +225,7 @@ void post_process( { bool deserialise_initialised=false; bool ce_initialised=false; - for (std::string line; std::getline(ss, line);) + for(std::string line; std::getline(ss, line);) { if(handle_start(gf, source, line) || handle_return_value(line) || diff --git a/src/cegis/invariant/preprocess/add_invariants_and_temp_variables.cpp b/src/cegis/invariant/preprocess/add_invariants_and_temp_variables.cpp index 417a581ae3c..2532a1ceca3 100644 --- a/src/cegis/invariant/preprocess/add_invariants_and_temp_variables.cpp +++ b/src/cegis/invariant/preprocess/add_invariants_and_temp_variables.cpp @@ -34,17 +34,17 @@ void create_tmp_variables(invariant_programt &program, void create_tmp_variables(invariant_programt &program, const size_t max_program_length, const typet &type) { - if (!need_temp_variables(max_program_length)) return; + if(!need_temp_variables(max_program_length)) return; symbol_tablet &st=program.st; goto_functionst &gf=program.gf; goto_programt &body=get_entry_body(gf); goto_programt::targett insert_after=program.invariant_range.begin; --insert_after; - for (size_t i=0; i < max_program_length - 1; ++i) + for(size_t i=0; i < max_program_length - 1; ++i) { const std::string name(get_tmp(i)); insert_after=declare_cegis_meta_variable(st, gf, insert_after, name, type); - if (i == 0) move_labels(body, program.invariant_range.begin, insert_after); + if(i == 0) move_labels(body, program.invariant_range.begin, insert_after); } } diff --git a/src/cegis/invariant/preprocess/remove_loops_and_assertion.cpp b/src/cegis/invariant/preprocess/remove_loops_and_assertion.cpp index 60a34406bf8..acaa96e499a 100644 --- a/src/cegis/invariant/preprocess/remove_loops_and_assertion.cpp +++ b/src/cegis/invariant/preprocess/remove_loops_and_assertion.cpp @@ -20,7 +20,7 @@ bool handle_assertion_removal(invariant_programt &program, goto_programt::instructionst &instrs, const goto_programt::targett &target) { const goto_programt::instructiont &instr=*target; - if (goto_program_instruction_typet::ASSERT != instr.type) return false; + if(goto_program_instruction_typet::ASSERT != instr.type) return false; const namespacet ns(program.st); assert(program.assertion.id().empty()); program.assertion=instr.guard; @@ -31,14 +31,14 @@ bool handle_assertion_removal(invariant_programt &program, const bool is_last_loop_end=last_loop_end == target; erase_target(instrs, target); ++end; - if (is_last_loop_end) last_loop_end=end; + if(is_last_loop_end) last_loop_end=end; return true; } goto_programt::targett handle_loop_removal(invariant_programt &program, goto_programt::instructionst &instrs, goto_programt::targett target) { - if (!target->is_backwards_goto()) return target; + if(!target->is_backwards_goto()) return target; invariant_programt::invariant_loopt &loop=program.add_loop(); const goto_programt::targett next_in_loop=std::prev(target); invariant_remove_loop(program.st, instrs, target, loop.guard, loop.body.begin, @@ -55,14 +55,14 @@ void invariant_remove_loop(const symbol_tablet &st, const goto_programt::instructiont &instr=*target; const namespacet ns(st); const goto_programt::targett goto_target=instr.get_target(); - if (instr.guard.is_true()) + if(instr.guard.is_true()) { goto_programt::targett guard_instr=goto_target; const goto_programt::targett end=instrs.end(); - while (end != guard_instr && guard_instr->guard.is_true()) + while(end != guard_instr && guard_instr->guard.is_true()) ++guard_instr; assert(end != guard_instr); - if (ID_not == guard.id()) guard=to_not_expr(guard_instr->guard).op(); + if(ID_not == guard.id()) guard=to_not_expr(guard_instr->guard).op(); else guard=simplify_expr(not_exprt(guard_instr->guard), ns); body_begin=std::next(guard_instr); erase_target(instrs, guard_instr); @@ -82,9 +82,9 @@ void invariant_remove_loops_and_assertion(invariant_programt &program) goto_programt &body=get_entry_body(program.gf); goto_programt::instructionst &instrs=body.instructions; program.invariant_range.begin=instrs.begin(); - for (goto_programt::targett it=instrs.begin(); it != instrs.end(); ++it) + for(goto_programt::targett it=instrs.begin(); it != instrs.end(); ++it) { - if (handle_assertion_removal(program, instrs, it)) break; + if(handle_assertion_removal(program, instrs, it)) break; it=handle_loop_removal(program, instrs, it); } } diff --git a/src/cegis/invariant/symex/learn/add_counterexamples.cpp b/src/cegis/invariant/symex/learn/add_counterexamples.cpp index 5359762a0c7..6e4c83e59b9 100644 --- a/src/cegis/invariant/symex/learn/add_counterexamples.cpp +++ b/src/cegis/invariant/symex/learn/add_counterexamples.cpp @@ -42,13 +42,13 @@ class create_x_array_valuest vals(vals), prototype(prototype), num_ces(num_ces) { const constant_exprt size(from_integer(num_ces, unsigned_int_type())); - for (ceitt it=prototype.begin(); it != prototype.end(); ++it) + for(ceitt it=prototype.begin(); it != prototype.end(); ++it) vals.insert(to_array(it, size)); } void operator()(const counterexamplet &ce) const { - for (ceitt it=ce.begin(); it != ce.end(); ++it) + for(ceitt it=ce.begin(); it != ce.end(); ++it) vals[it->first].copy_to_operands(it->second); } }; @@ -57,7 +57,7 @@ void declare_x_arrays(symbol_tablet &st, goto_functionst &gf, goto_programt::targett pos, const array_valuest &vals, const std::string &meta_var_prefix) { - for (array_valuest::const_iterator it=vals.begin(); it != vals.end(); ++it) + for(array_valuest::const_iterator it=vals.begin(); it != vals.end(); ++it) { std::string base_name(meta_var_prefix); base_name+=id2string(it->first); @@ -78,8 +78,8 @@ symbol_exprt get_index(const symbol_tablet &st) goto_programt::targett find_decl(goto_programt::targett begin, const goto_programt::targett &end, const irep_idt &id) { - for (; begin != end; ++begin) - if (begin->is_decl() && get_affected_variable(*begin) == id) return begin; + for(; begin != end; ++begin) + if(begin->is_decl() && get_affected_variable(*begin) == id) return begin; return end; } @@ -113,7 +113,7 @@ class assign_ce_valuet assert(!loops.empty()); pos=begin_pos; ++pos; - if (use_x0_ce) + if(use_x0_ce) { pos=get_entry_body(gf).insert_after(pos); pos->type=goto_program_instruction_typet::GOTO; @@ -133,13 +133,13 @@ class assign_ce_valuet const symbol_exprt lhs(st.lookup(id).symbol_expr()); const goto_programt::targett end(prog.invariant_range.end); const goto_programt::targett decl(find_decl(pos, end, id)); - if (end == decl) pos=cegis_assign(st, gf, pos, lhs, rhs); + if(end == decl) pos=cegis_assign(st, gf, pos, lhs, rhs); else cegis_assign(st, gf, decl, lhs, rhs); } void finalize_x0_case() { - if (use_x0_ce) goto_pos->targets.push_back(++pos); + if(use_x0_ce) goto_pos->targets.push_back(++pos); } }; @@ -238,7 +238,7 @@ void invariant_add_learned_counterexamples(invariant_programt &prog, const bool x0_ce) { // TODO: Danger counterexamples need one map per loop (per quantifier)! - if (ces.empty()) return; + if(ces.empty()) return; const std::string pre(X_CHOICE_PREFIX); invariant_declare_x_choice_arrays(prog, ces, pre); const size_t sz=ces.size(); diff --git a/src/cegis/invariant/symex/learn/add_invariant_programs_to_learn.cpp b/src/cegis/invariant/symex/learn/add_invariant_programs_to_learn.cpp index 5ad3c8740d6..39f9b696072 100644 --- a/src/cegis/invariant/symex/learn/add_invariant_programs_to_learn.cpp +++ b/src/cegis/invariant/symex/learn/add_invariant_programs_to_learn.cpp @@ -116,7 +116,7 @@ goto_programt::targett add_invariant_progs_to_learn(invariant_programt &prog, { const invariant_programt::invariant_loopst loops(prog.get_loops()); goto_programt::targett pos=prog.invariant_range.begin; - if (loops.empty()) return pos; + if(loops.empty()) return pos; const declare_programst declare_progs(prog, max_sol_sz, --pos); return std::for_each(loops.begin(), loops.end(), declare_progs).get_pos(); } diff --git a/src/cegis/invariant/symex/learn/instrument_vars.cpp b/src/cegis/invariant/symex/learn/instrument_vars.cpp index b6e43c68b25..798c083cdcd 100644 --- a/src/cegis/invariant/symex/learn/instrument_vars.cpp +++ b/src/cegis/invariant/symex/learn/instrument_vars.cpp @@ -55,11 +55,11 @@ goto_programt::targett link_temp_vars(const symbol_tablet &st, { goto_programt::targett previous_successor(pos); ++previous_successor; - for (size_t i=0; i < num_temps; ++i) + for(size_t i=0; i < num_temps; ++i) { const std::string name=get_cegis_meta_name(get_tmp(i)); pos=set_rops_reference(st, body, pos, name, i); - if (i == 0) move_labels(body, previous_successor, pos); + if(i == 0) move_labels(body, previous_successor, pos); pos=set_ops_reference(st, body, pos, name, i + num_user_vars); } return pos; @@ -82,12 +82,12 @@ void link_user_symbols(const symbol_tablet &st, operand_variable_idst &var_ids, { typedef symbol_tablet::symbolst symbolst; const symbolst &symbols=st.symbols; - for (symbolst::const_iterator it=symbols.begin(); it != symbols.end(); ++it) + for(symbolst::const_iterator it=symbols.begin(); it != symbols.end(); ++it) { const symbolt &symbol=it->second; - if (!is_instrumentable_user_variable(symbol.name, symbol.type)) continue; + if(!is_instrumentable_user_variable(symbol.name, symbol.type)) continue; const bool is_const=is_global_const(symbol.name, symbol.type); - if (is_const == consts) + if(is_const == consts) var_ids.insert(std::make_pair(symbol.name, variable_id++)); } } diff --git a/src/cegis/invariant/symex/learn/replace_operators.cpp b/src/cegis/invariant/symex/learn/replace_operators.cpp index b0031f0c327..7646629311a 100644 --- a/src/cegis/invariant/symex/learn/replace_operators.cpp +++ b/src/cegis/invariant/symex/learn/replace_operators.cpp @@ -45,7 +45,7 @@ class replace_ops_visitort: public expr_visitort { typedef invariant_variable_namest::const_iterator itt; const size_t offset(names.size()); - for (itt it=rnames.begin(); it != rnames.end(); ++it) + for(itt it=rnames.begin(); it != rnames.end(); ++it) this->names.insert(std::make_pair(offset + it->first, it->second)); } virtual ~replace_ops_visitort() @@ -54,20 +54,20 @@ class replace_ops_visitort: public expr_visitort public: virtual void operator()(exprt &expr) { - if (ID_symbol != expr.id()) return; + if(ID_symbol != expr.id()) return; const irep_idt &op_name=to_symbol_expr(expr).get_identifier(); const bool is_res=op_name == rop_name; const bool is_op0=op_name == op0_name; const bool is_op1=op_name == op1_name; const bool is_op2=op_name == op2_name; - if (!is_res && !is_op0 && !is_op1 && !is_op2) return; + if(!is_res && !is_op0 && !is_op1 && !is_op2) return; const invariant_variable_namest &names=is_res ? rnames : this->names; const size_t op=is_res ? instr_idx : is_op0 ? op0 : is_op1 ? op1 : op2; const invariant_variable_namest::const_iterator name=names.find(op); assert(names.end() != name); const symbol_exprt symbol(st.lookup(name->second).symbol_expr()); const typet danger_type(cegis_default_integer_type()); - if (type_eq(danger_type, symbol.type(), ns)) expr=symbol; + if(type_eq(danger_type, symbol.type(), ns)) expr=symbol; else expr=typecast_exprt(symbol, danger_type); // XXX: Change if operations for other types are added. } }; @@ -80,7 +80,7 @@ void replace_ops_in_instr(const symbol_tablet &st, const std::string &func, const size_t instr_idx) { replace_ops_visitort v(st, func, names, rnames, op0, op1, op2, instr_idx); - for (goto_programt::targett it=first; it != last; ++it) + for(goto_programt::targett it=first; it != last; ++it) { goto_programt::instructiont &instr=*it; instr.code.visit(v); @@ -91,6 +91,6 @@ void replace_ops_in_instr(const symbol_tablet &st, const std::string &func, void reverse_invariant_var_ids(invariant_variable_namest &names, const operand_variable_idst &ids) { - for (const auto id : ids) + for(const auto id : ids) names.insert(std::make_pair(id.second, id.first)); } diff --git a/src/cegis/invariant/symex/verify/extract_counterexample.cpp b/src/cegis/invariant/symex/verify/extract_counterexample.cpp index b02412176a0..ab12cc33951 100644 --- a/src/cegis/invariant/symex/verify/extract_counterexample.cpp +++ b/src/cegis/invariant/symex/verify/extract_counterexample.cpp @@ -44,7 +44,7 @@ class extract_counterexamplet { const goto_programt::instructiont::labelst::const_iterator it= find_ceq_label(step.pc); - if (step.pc->labels.end() == it) return false; + if(step.pc->labels.end() == it) return false; const irep_idt &label=*it; const size_t original_size=q.size(); q.erase( @@ -61,7 +61,7 @@ class extract_counterexamplet void finalise() { - for (const goto_programt::targett &pos : q) + for(const goto_programt::targett &pos : q) { const irep_idt &var=get_affected_variable(*pos); const exprt value(from_integer(0, get_affected_type(*pos))); @@ -77,7 +77,7 @@ class extract_counterexamplet void operator()(const goto_trace_stept &step) { - if (!should_extract(step)) return; + if(!should_extract(step)) return; const symbol_exprt &lhs=step.lhs_object; result.insert(std::make_pair(lhs.get_identifier(), step.lhs_object_value)); } @@ -91,7 +91,7 @@ void invariant_extract_counterexample(counterexamplet &result, const goto_tracet::stepst &s=trace.steps; extract_counterexamplet extract(result, quantifiers); typedef goto_tracet::stepst::const_iterator itt; - for (itt it=s.begin(); it != s.end() && !extract.is_done(); ++it) + for(itt it=s.begin(); it != s.end() && !extract.is_done(); ++it) extract(*it); extract.finalise(); const size_t new_entries=result.size() - existing_entries; diff --git a/src/cegis/invariant/symex/verify/insert_program.cpp b/src/cegis/invariant/symex/verify/insert_program.cpp index abed596b164..59d18506d19 100644 --- a/src/cegis/invariant/symex/verify/insert_program.cpp +++ b/src/cegis/invariant/symex/verify/insert_program.cpp @@ -27,10 +27,10 @@ class replace_name_visitort: public expr_visitort virtual void operator()(exprt &expr) { - if (ID_symbol != expr.id()) return; + if(ID_symbol != expr.id()) return; symbol_exprt &symbol=to_symbol_expr(expr); - for (replacementst::const_iterator it=repl.begin(); it != repl.end(); ++it) - if (symbol.get_identifier() == it->first) + for(replacementst::const_iterator it=repl.begin(); it != repl.end(); ++it) + if(symbol.get_identifier() == it->first) symbol.set_identifier(it->second); } }; @@ -64,9 +64,9 @@ void insert_program(goto_programt &body, goto_programt::targett pos, insert_instrt insert_instr(copy_instr, body, pos, replacements); goto_programt::const_targett first=prog.begin(); goto_programt::const_targett last=prog.end(); - if (first == last) return; + if(first == last) return; --last; - for (; first != last; ++first) + for(; first != last; ++first) insert_instr(first); copy_instr.finalize(++pos, last); } diff --git a/src/cegis/invariant/util/copy_instructions.cpp b/src/cegis/invariant/util/copy_instructions.cpp index 6f1c4f62c25..a7ad1057fd5 100644 --- a/src/cegis/invariant/util/copy_instructions.cpp +++ b/src/cegis/invariant/util/copy_instructions.cpp @@ -21,7 +21,7 @@ void copy_instructionst::operator()(const goto_programt::targett &new_target, void copy_instructionst::operator()(goto_programt::instructionst &new_instrs, const goto_programt::instructionst &old_instrs) { - for (goto_programt::const_targett pos=old_instrs.begin(); + for(goto_programt::const_targett pos=old_instrs.begin(); pos != old_instrs.end(); ++pos) { new_instrs.push_back(goto_programt::instructiont()); @@ -36,7 +36,7 @@ goto_programt::targett copy_instructionst::operator()( { assert(!old_instrs.empty()); ++insert_after; - for (goto_programt::const_targett pos=old_instrs.begin(); + for(goto_programt::const_targett pos=old_instrs.begin(); pos != old_instrs.end(); ++pos) { insert_after=new_instrs.insert(insert_after, goto_programt::instructiont()); @@ -112,8 +112,8 @@ class skip_removert void operator()(const goto_programt::targett &target) { const goto_programt::instructiont::labelst &labels=target->labels; - if (labels.empty()) return; - if (id2string(labels.front()) != DANGER_SKIP_LABEL) return; + if(labels.empty()) return; + if(id2string(labels.front()) != DANGER_SKIP_LABEL) return; goto_programt::targett next(target); skips.insert(std::make_pair(target, ++next)); } @@ -121,7 +121,7 @@ class skip_removert void operator()(goto_programt::targett first, const goto_programt::targett &last) { - for (; first != last; ++first) + for(; first != last; ++first) this->operator()(first); } @@ -129,19 +129,19 @@ class skip_removert { goto_programt::targetst &targets=instr.targets; goto_programt::targetst::iterator it; - for (it=targets.begin(); it != targets.end(); ++it) + for(it=targets.begin(); it != targets.end(); ++it) { skipst::const_iterator e=skips.find(*it); - if (skips.end() == e) continue; + if(skips.end() == e) continue; *it=e->second; } } void remove() { - for (goto_programt::instructiont &instr : instrs) + for(goto_programt::instructiont &instr : instrs) replace_targets(instr); - for (const skipst::value_type &skip : skips) + for(const skipst::value_type &skip : skips) instrs.erase(skip.first); } }; @@ -151,7 +151,7 @@ void invariant_make_presentable(goto_programt::instructionst &instrs) { const goto_programt::targett &begin=instrs.begin(); const goto_programt::targett &last=instrs.end(); - if (begin == last) return; + if(begin == last) return; skip_removert op(instrs); op(begin, std::prev(last)); op.remove(); diff --git a/src/cegis/invariant/util/invariant_constraint_variables.cpp b/src/cegis/invariant/util/invariant_constraint_variables.cpp index a6a5bdca28d..378362f85d8 100644 --- a/src/cegis/invariant/util/invariant_constraint_variables.cpp +++ b/src/cegis/invariant/util/invariant_constraint_variables.cpp @@ -32,16 +32,16 @@ bool is_const(const typet &type) bool is_local_or_constant(const symbolt &symbol) { - if (is_local(id2string(symbol.name))) return true; + if(is_local(id2string(symbol.name))) return true; return is_const(symbol.type); } bool is_meta(const irep_idt &id, const typet &type) { - if (ID_code == type.id()) return true; + if(ID_code == type.id()) return true; const std::string &name=id2string(id); - if (std::string::npos != name.find(CEGIS_CONSTANT_PREFIX)) return true; - if (std::string::npos != name.find("#return_value")) return true; + if(std::string::npos != name.find(CEGIS_CONSTANT_PREFIX)) return true; + if(std::string::npos != name.find("#return_value")) return true; return std::string::npos != name.find(CPROVER_PREFIX); } @@ -56,19 +56,19 @@ class counterexample_variable_collectort void operator()(const goto_programt::instructiont &instr) const { - if (goto_program_instruction_typet::DECL != instr.type) return; + if(goto_program_instruction_typet::DECL != instr.type) return; const code_declt &code_decl=to_code_decl(instr.code); const symbol_exprt &symbol=to_symbol_expr(code_decl.symbol()); const typet &type=symbol.type(); - if (is_const(type)) return; - if (is_meta(symbol.get_identifier(), type)) return; + if(is_const(type)) return; + if(is_meta(symbol.get_identifier(), type)) return; vars.insert(symbol); } void operator()(const std::pair &named_symbol) const { const symbolt &symbol=named_symbol.second; - if (is_local_or_constant(symbol) || is_meta(symbol.name, symbol.type)) + if(is_local_or_constant(symbol) || is_meta(symbol.name, symbol.type)) return; vars.insert(symbol.symbol_expr()); } diff --git a/src/cegis/invariant/util/invariant_program_helper.cpp b/src/cegis/invariant/util/invariant_program_helper.cpp index 616b612b41a..9671613355d 100644 --- a/src/cegis/invariant/util/invariant_program_helper.cpp +++ b/src/cegis/invariant/util/invariant_program_helper.cpp @@ -21,9 +21,9 @@ void erase_target(goto_programt::instructionst &body, goto_programt::targett succ=std::next(target); assert(succ != body.end()); - for (goto_programt::instructiont &instr : body) - for (goto_programt::targett &t : instr.targets) - if (target == t) t=succ; + for(goto_programt::instructiont &instr : body) + for(goto_programt::targett &t : instr.targets) + if(target == t) t=succ; body.erase(target); } @@ -32,7 +32,7 @@ void restrict_bv_size(invariant_programt &prog, const size_t width_in_bits) { restrict_bv_size(prog.st, prog.gf, width_in_bits); const invariant_programt::invariant_loopst loops(prog.get_loops()); - for (invariant_programt::invariant_loopt * const loop : loops) + for(invariant_programt::invariant_loopt * const loop : loops) restrict_bv_size(loop->guard, width_in_bits); restrict_bv_size(prog.assertion, width_in_bits); } diff --git a/src/cegis/jsa/converters/counterexample.cpp b/src/cegis/jsa/converters/counterexample.cpp index 71e23f01754..57968fa1803 100644 --- a/src/cegis/jsa/converters/counterexample.cpp +++ b/src/cegis/jsa/converters/counterexample.cpp @@ -77,7 +77,7 @@ void make_zero(structt &value) void read_element(__CPROVER_jsa_concrete_nodet &e, const exprt &value) { - if (ID_struct != value.id()) return make_zero(e); + if(ID_struct != value.id()) return make_zero(e); const struct_exprt::operandst &ops=to_struct_expr(value).operands(); assert(ops.size() > VALUE_COMP_INDEX); e.next=to_integer(ops[NEXT_COMP_INDEX]); @@ -88,7 +88,7 @@ void read_element(__CPROVER_jsa_concrete_nodet &e, const exprt &value) void read_element(__CPROVER_jsa_abstract_nodet &e, const exprt &value) { - if (ID_struct != value.id()) return make_zero(e); + if(ID_struct != value.id()) return make_zero(e); const struct_exprt::operandst &ops=to_struct_expr(value).operands(); assert(ops.size() > VALUE_COMP_INDEX); e.next=to_integer(ops[NEXT_COMP_INDEX]); @@ -99,7 +99,7 @@ void read_element(__CPROVER_jsa_abstract_nodet &e, const exprt &value) void read_element(__CPROVER_jsa_abstract_ranget &e, const exprt &value) { - if (ID_struct != value.id()) return make_zero(e); + if(ID_struct != value.id()) return make_zero(e); const struct_exprt::operandst &ops=to_struct_expr(value).operands(); assert(ops.size() > SIZE_COMP_INDEX); e.min=to_integer(ops[MIN_COMP_INDEX]); @@ -109,7 +109,7 @@ void read_element(__CPROVER_jsa_abstract_ranget &e, const exprt &value) void read_element(__CPROVER_jsa_iteratort &e, const exprt &value) { - if (ID_struct != value.id()) return make_zero(e); + if(ID_struct != value.id()) return make_zero(e); const struct_exprt::operandst &ops=to_struct_expr(value).operands(); assert(ops.size() > ITERATOR_LIST_COMP_INDEX); e.node_id=to_integer(ops[NODE_COMP_INDEX]); @@ -124,7 +124,7 @@ void fill_null(__CPROVER_jsa_concrete_nodet *array, size_t count) assert(__CPROVER_JSA_MAX_CONCRETE_NODES >= count); const __CPROVER_jsa_concrete_nodet null_node={ __CPROVER_jsa_null, __CPROVER_jsa_null, __CPROVER_jsa_null, __CPROVER_jsa_null }; - while (count < __CPROVER_JSA_MAX_CONCRETE_NODES) + while(count < __CPROVER_JSA_MAX_CONCRETE_NODES) array[count++]=null_node; } @@ -145,24 +145,24 @@ void fill_null(__CPROVER_jsa_iteratort *array, size_t count) assert(__CPROVER_JSA_MAX_ITERATORS >= count); const __CPROVER_jsa_iteratort null_it={ __CPROVER_jsa_null, __CPROVER_jsa_null, 0, 0, __CPROVER_jsa_null }; - while (count < __CPROVER_JSA_MAX_ITERATORS) + while(count < __CPROVER_JSA_MAX_ITERATORS) array[count++]=null_it; } void fill_null(__CPROVER_jsa_node_id_t *array, size_t count) { assert(__CPROVER_JSA_MAX_LISTS >= count); - while (count < __CPROVER_JSA_MAX_LISTS) + while(count < __CPROVER_JSA_MAX_LISTS) array[count++]=__CPROVER_jsa_null; } template void read_array(wordt *data, const exprt &value) { - if (ID_array != value.id()) return; + if(ID_array != value.id()) return; size_t index=0; const exprt::operandst &ops=value.operands(); - for (const exprt &op : ops) + for(const exprt &op : ops) read_element(data[index++], op); fill_null(data, ops.size()); } @@ -172,8 +172,8 @@ void remove_padding(struct_exprt::operandst &ops, const typet &type) assert(!ops.empty()); const struct_typet::componentst &comps=to_struct_type(type).components(); assert(comps.size() == ops.size()); - for (int i=ops.size() - 1; i >= 0; --i) - if (comps[i].get_bool(ID_C_is_padding)) + for(int i=ops.size() - 1; i >= 0; --i) + if(comps[i].get_bool(ID_C_is_padding)) ops.erase(std::next(ops.begin(), i)); } } @@ -183,8 +183,8 @@ void retrieve_heaps(const jsa_counterexamplet &ce, { assert(std::is_sorted(ce.begin(), ce.end(), compare_assignment)); size_t index=0; - for (const jsa_counterexamplet::value_type &assignment : ce) - if (is_heap(assignment)) + for(const jsa_counterexamplet::value_type &assignment : ce) + if(is_heap(assignment)) { const struct_exprt &value=to_struct_expr(assignment.second); __CPROVER_jsa_abstract_heapt &heap=heaps[index++]; @@ -218,6 +218,6 @@ void retrieve_words(const jsa_counterexamplet &ce, __CPROVER_jsa_word_t *words) { assert(std::is_sorted(ce.begin(), ce.end(), compare_assignment)); size_t index=0; - for (const jsa_counterexamplet::value_type &assignment : ce) - if (is_word(assignment)) words[index++]=to_integer(assignment.second); + for(const jsa_counterexamplet::value_type &assignment : ce) + if(is_word(assignment)) words[index++]=to_integer(assignment.second); } diff --git a/src/cegis/jsa/converters/replace_operators.cpp b/src/cegis/jsa/converters/replace_operators.cpp index 098a82373f6..567811120a2 100644 --- a/src/cegis/jsa/converters/replace_operators.cpp +++ b/src/cegis/jsa/converters/replace_operators.cpp @@ -41,20 +41,20 @@ class replace_pred_ops_visitort: public expr_visitort virtual void operator()(exprt &expr) { - if (ID_typecast != expr.id()) return; + if(ID_typecast != expr.id()) return; const typecast_exprt &cast=to_typecast_expr(expr); const exprt &cast_op=cast.op(); - if (ID_member != cast_op.id()) return; + if(ID_member != cast_op.id()) return; const member_exprt &member=to_member_expr(cast_op); const exprt &compound=member.compound(); - if (ID_symbol != compound.id()) return; + if(ID_symbol != compound.id()) return; const irep_idt &compound_id=to_symbol_expr(compound).get_identifier(); - if (!is_instr_name(id2string(compound_id))) return; + if(!is_instr_name(id2string(compound_id))) return; const std::string &component=id2string(member.get_component_name()); const typet &type=cast.type(); - if (ROP == component) expr=from_integer(instr.result_op, type); - else if (OP0 == component) expr=from_integer(instr.op0, type); - else if (OP1 == component) expr=from_integer(instr.op1, type); + if(ROP == component) expr=from_integer(instr.result_op, type); + else if(OP0 == component) expr=from_integer(instr.op0, type); + else if(OP1 == component) expr=from_integer(instr.op1, type); else assert(!"Illegal compound member"); } }; @@ -65,7 +65,7 @@ void replace_pred_ops(goto_programt::targett first, const __CPROVER_jsa_pred_instructiont &instr) { replace_pred_ops_visitort visitor(instr); - for (; first != last; ++first) + for(; first != last; ++first) { first->guard.visit(visitor); first->code.visit(visitor); @@ -90,35 +90,35 @@ class replace_query_ops_visitort: public expr_visitort ~replace_query_ops_visitort() { - for (exprt * const expr : heap_occurrences) + for(exprt * const expr : heap_occurrences) *expr=address_of_exprt(get_queried_heap(st)); } void handle_member(member_exprt &member_expr) { const exprt &compound=member_expr.compound(); - if (ID_symbol != compound.id()) return; + if(ID_symbol != compound.id()) return; const std::string &id=id2string(to_symbol_expr(compound).get_identifier()); - if (std::string::npos == id.find(INSTR)) return; + if(std::string::npos == id.find(INSTR)) return; const std::string &member=id2string(member_expr.get_component_name()); exprt &expr=static_cast(member_expr); - if (OP0 == member) expr=from_integer(instr.op0, expr.type()); - else if (OP1 == member) expr=from_integer(instr.op1, expr.type()); - else if (OPCODE == member) expr=from_integer(instr.opcode, expr.type()); + if(OP0 == member) expr=from_integer(instr.op0, expr.type()); + else if(OP1 == member) expr=from_integer(instr.op1, expr.type()); + else if(OPCODE == member) expr=from_integer(instr.opcode, expr.type()); else assert(!"Illegal compound member"); } virtual void operator()(exprt &expr) { const irep_idt &expr_id=expr.id(); - if (ID_member == expr_id) return handle_member(to_member_expr(expr)); - if (ID_symbol != expr_id) return; + if(ID_member == expr_id) return handle_member(to_member_expr(expr)); + if(ID_symbol != expr_id) return; const std::string &id=id2string(to_symbol_expr(expr).get_identifier()); - if (std::string::npos != id.find(LOCAL_HEAP)) heap_occurrences.push_back( + if(std::string::npos != id.find(LOCAL_HEAP)) heap_occurrences.push_back( &expr); - else if (std::string::npos != id.find(LOCAL_LIST)) expr=from_integer( + else if(std::string::npos != id.find(LOCAL_LIST)) expr=from_integer( prefix.opcode, expr.type()); - else if (std::string::npos != id.find(LOCAL_IT)) + else if(std::string::npos != id.find(LOCAL_IT)) expr=from_integer(prefix.op0, expr.type()); } }; @@ -130,7 +130,7 @@ void replace_query_ops(const symbol_tablet &st, goto_programt::targett first, const __CPROVER_jsa_query_instructiont &prefix) { replace_query_ops_visitort visitor(st, instr, prefix); - for (; first != last; ++first) + for(; first != last; ++first) { first->guard.visit(visitor); first->code.visit(visitor); diff --git a/src/cegis/jsa/converters/solution.cpp b/src/cegis/jsa/converters/solution.cpp index 87b789057af..451b33d1bc2 100644 --- a/src/cegis/jsa/converters/solution.cpp +++ b/src/cegis/jsa/converters/solution.cpp @@ -16,7 +16,7 @@ jsa_solutiont convert(const jsa_genetic_solutiont &solution, const jsa_programt &prog) { jsa_solutiont result; - for (const jsa_genetic_solutiont::predicatest::value_type &pred : solution.predicates) + for(const jsa_genetic_solutiont::predicatest::value_type &pred : solution.predicates) { result.predicates.push_back(goto_programt::instructionst()); convert(result.predicates.back(), prog, pred); diff --git a/src/cegis/jsa/converters/translate_to_goto_program.cpp b/src/cegis/jsa/converters/translate_to_goto_program.cpp index 053933ccad8..53ee9ecfe56 100644 --- a/src/cegis/jsa/converters/translate_to_goto_program.cpp +++ b/src/cegis/jsa/converters/translate_to_goto_program.cpp @@ -52,7 +52,7 @@ void convert(goto_programt::instructionst &result, const jsa_programt &prog, const instruction_sett instr_set(get_pred_instruction_set(prog.gf)); assert(__CPROVER_JSA_NUM_PRED_INSTRUCTIONS == instr_set.size()); copy_instructionst copy; - for (const __CPROVER_jsa_pred_instructiont &instr : solution) + for(const __CPROVER_jsa_pred_instructiont &instr : solution) { const instruction_sett::const_iterator it=instr_set.find(instr.opcode); assert(instr_set.end() != it); @@ -73,7 +73,7 @@ void convert(goto_programt::instructionst &result, const jsa_programt &prog, std::vector<__CPROVER_jsa_query_instructiont>::const_iterator instr=solution.begin(); const __CPROVER_jsa_query_instructiont &prefix=*instr++; copy_instructionst copy; - for (; instr != solution.end(); ++instr) + for(; instr != solution.end(); ++instr) { const instruction_sett::const_iterator it=instr_set.begin(); const size_t previous_size=result.size(); diff --git a/src/cegis/jsa/facade/jsa_runner.cpp b/src/cegis/jsa/facade/jsa_runner.cpp index 6b565758941..19f88ff236e 100644 --- a/src/cegis/jsa/facade/jsa_runner.cpp +++ b/src/cegis/jsa/facade/jsa_runner.cpp @@ -43,7 +43,7 @@ std::function get_default_solution( const jsa_programt &prog) { return [&prog](jsa_solutiont &solution) - { if (solution.invariant.empty()) solution=default_jsa_solution(prog);}; + { if(solution.invariant.empty()) solution=default_jsa_solution(prog);}; } template @@ -92,7 +92,7 @@ int run_jsa(optionst &o, mstreamt &result, const symbol_tablet &st, cegis_symex_learnt learn(o, prep, lcfg, get_default_solution(prog)); jsa_symex_verifyt vcfg(prog); cegis_symex_verifyt oracle(o, vcfg); - if (o.get_bool_option(CEGIS_GENETIC)) + if(o.get_bool_option(CEGIS_GENETIC)) return run_with_ga(st, o, result, lcfg, oracle, prep); else return run_cegis_with_statistics_wrapper(result, o, learn, oracle, prep); diff --git a/src/cegis/jsa/genetic/dynamic_jsa_test_runner.cpp b/src/cegis/jsa/genetic/dynamic_jsa_test_runner.cpp index c0a03bb3684..542fbed9922 100644 --- a/src/cegis/jsa/genetic/dynamic_jsa_test_runner.cpp +++ b/src/cegis/jsa/genetic/dynamic_jsa_test_runner.cpp @@ -49,7 +49,7 @@ void dynamic_jsa_test_runnert::run_test(individualt &individual, std::vector<__CPROVER_jsa_query_instructiont> jsa_query; jsa_query.resize(jsa_query_size); size_t index=0; - for (const individualt::queryt::value_type &instr : query) + for(const individualt::queryt::value_type &instr : query) jsa_query[index++]=instr; const individualt::invariantt &invariant=individual.invariant; @@ -70,7 +70,7 @@ void dynamic_jsa_test_runnert::run_test(individualt &individual, for(const individualt::predicatet &pred : preds) { jsa_predicates.push_back(decltype(jsa_predicates)::value_type()); - for (const individualt::predicatet::value_type &instr : pred) + for(const individualt::predicatet::value_type &instr : pred) jsa_predicates.back().push_back(instr); jsa_predicates_arg.push_back(jsa_predicates.back().data()); diff --git a/src/cegis/jsa/genetic/jsa_random.cpp b/src/cegis/jsa/genetic/jsa_random.cpp index 087fc1efdec..7c3457fb606 100644 --- a/src/cegis/jsa/genetic/jsa_random.cpp +++ b/src/cegis/jsa/genetic/jsa_random.cpp @@ -42,14 +42,14 @@ void havoc_size(containert &container, const size_t max, const size_t min=1u) void jsa_randomt::havoc(jsa_genetic_solutiont::predicatest &predicates) const { predicates.resize(get_num_jsa_preds(st)); - for (jsa_genetic_solutiont::predicatet &predicate : predicates) + for(jsa_genetic_solutiont::predicatet &predicate : predicates) havoc(predicate); } void jsa_randomt::havoc(jsa_genetic_solutiont::predicatet &predicate) const { havoc_size(predicate, get_max_pred_size(st)); - for (jsa_genetic_solutiont::predicatet::value_type &instr : predicate) + for(jsa_genetic_solutiont::predicatet::value_type &instr : predicate) havoc(instr); } @@ -65,7 +65,7 @@ void jsa_randomt::havoc( void jsa_randomt::havoc(jsa_genetic_solutiont::invariantt &invariant) const { invariant.resize(get_max_inv_size()); - for (jsa_genetic_solutiont::invariantt::value_type &instr : invariant) + for(jsa_genetic_solutiont::invariantt::value_type &instr : invariant) havoc(instr); } @@ -80,7 +80,7 @@ void jsa_randomt::havoc( void jsa_randomt::havoc(jsa_genetic_solutiont::queryt &query) const { havoc_size(query, get_max_query_size(st), MIN_QUERY_SIZE); - for (size_t i=0; i < query.size(); ++i) + for(size_t i=0; i < query.size(); ++i) havoc(query[i], i); } @@ -89,7 +89,7 @@ void jsa_randomt::havoc(jsa_genetic_solutiont::queryt &query) const void jsa_randomt::havoc(jsa_genetic_solutiont::queryt::value_type &instr, const size_t index) const { - if (index == 0) + if(index == 0) { havoc_list(instr.opcode); havoc_iterator(instr.op0); diff --git a/src/cegis/jsa/genetic/jsa_serialiser.cpp b/src/cegis/jsa/genetic/jsa_serialiser.cpp index 4f948e6adf5..10aedd39268 100644 --- a/src/cegis/jsa/genetic/jsa_serialiser.cpp +++ b/src/cegis/jsa/genetic/jsa_serialiser.cpp @@ -31,7 +31,7 @@ void jsa_serialisert::operator()(irept &sdu, sdu.set(FITNESS, entity.fitness); irept invariant; irept::subt &invariant_instructions=invariant.get_sub(); - for (const jsa_genetic_solutiont::invariantt::value_type &instr : entity.invariant) + for(const jsa_genetic_solutiont::invariantt::value_type &instr : entity.invariant) { irept instruction; instruction.set(OPCODE, instr.opcode); @@ -40,11 +40,11 @@ void jsa_serialisert::operator()(irept &sdu, sdu.set(INVARIANT, invariant); irept predicates; irept::subt &predicates_list=predicates.get_sub(); - for (const jsa_genetic_solutiont::predicatet &predicate : entity.predicates) + for(const jsa_genetic_solutiont::predicatet &predicate : entity.predicates) { irept pred; irept::subt &predicate_instructions=pred.get_sub(); - for (const jsa_genetic_solutiont::predicatet::value_type &instr : predicate) + for(const jsa_genetic_solutiont::predicatet::value_type &instr : predicate) { irept instruction; instruction.set(OPCODE, instr.opcode); @@ -58,7 +58,7 @@ void jsa_serialisert::operator()(irept &sdu, sdu.set(PREDICATES, predicates); irept query; irept::subt &query_instructions=query.get_sub(); - for (const jsa_genetic_solutiont::queryt::value_type &instr : entity.query) + for(const jsa_genetic_solutiont::queryt::value_type &instr : entity.query) { irept instruction; instruction.set(OPCODE, instr.opcode); @@ -77,7 +77,7 @@ void jsa_serialisert::operator()(jsa_genetic_solutiont &entity, typedef irept::named_subt::const_iterator const_iterator; const const_iterator invariant=named_sub.find(INVARIANT); assert(named_sub.end() != invariant); - for (const irept &instruction : invariant->second.get_sub()) + for(const irept &instruction : invariant->second.get_sub()) { jsa_genetic_solutiont::invariantt::value_type instr; instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE)); @@ -85,10 +85,10 @@ void jsa_serialisert::operator()(jsa_genetic_solutiont &entity, } const const_iterator predicates=named_sub.find(PREDICATES); assert(named_sub.end() != predicates); - for (const irept &predicate : predicates->second.get_sub()) + for(const irept &predicate : predicates->second.get_sub()) { jsa_genetic_solutiont::predicatet pred; - for (const irept &instruction : predicate.get_sub()) + for(const irept &instruction : predicate.get_sub()) { jsa_genetic_solutiont::predicatet::value_type instr; instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE)); @@ -101,7 +101,7 @@ void jsa_serialisert::operator()(jsa_genetic_solutiont &entity, } const const_iterator query=named_sub.find(QUERY); assert(named_sub.end() != query); - for (const irept &instruction : query->second.get_sub()) + for(const irept &instruction : query->second.get_sub()) { jsa_genetic_solutiont::queryt::value_type instr; instr.opcode=__CPROVER_jsa_opcodet(instruction.get_long_long(OPCODE)); diff --git a/src/cegis/jsa/genetic/jsa_source_provider.cpp b/src/cegis/jsa/genetic/jsa_source_provider.cpp index 1182317f771..3b4c3c52d3e 100644 --- a/src/cegis/jsa/genetic/jsa_source_provider.cpp +++ b/src/cegis/jsa/genetic/jsa_source_provider.cpp @@ -82,7 +82,7 @@ void add_temp_clean(std::string &result, const symbol_tablet &st) result+="void __CPROVER_jsa_internal__clear_temps(void)\n{\n"; const size_t num_temps=count_tmps(st); assert(num_temps >= 1); - for (size_t i=1; i <= num_temps; ++i) + for(size_t i=1; i <= num_temps; ++i) { result+=" *" JSA_PRED_RES_OPS "["; result+=std::to_string(i); @@ -111,7 +111,7 @@ void add_main_body(std::string &result, const jsa_symex_learnt &lcfg) void fix_return_values(std::string &result) { std::string::size_type pos=result.find(RETURN_VALUE_ASSIGNMENT); - while (std::string::npos != pos) + while(std::string::npos != pos) { const std::string::size_type start=result.rfind(' ', pos); const std::string::size_type value=result.find('=', pos); @@ -122,7 +122,7 @@ void fix_return_values(std::string &result) pos=result.find(RETURN_VALUE_ASSIGNMENT, start); } pos=result.find(RETURN_VALUE_SUFFIX); - while (std::string::npos != pos) + while(std::string::npos != pos) { const std::string::size_type end=result.rfind("= ", pos); const std::string::size_type start=result.rfind(' ', end - 2); @@ -158,7 +158,7 @@ void remove_line_with(std::string &result, const std::string &value) void remove_predicates(std::string &result, const size_t num_preds) { - for (size_t i=0; i < num_preds; ++i) + for(size_t i=0; i < num_preds; ++i) { std::string base_name="__CPROVER_jsa_predicate_"; base_name+=std::to_string(i); @@ -175,7 +175,7 @@ void declare_predicates(std::string &result, const size_t num_preds, const std::string::size_type pos) { std::string source; - for (size_t i=0; i < num_preds; ++i) + for(size_t i=0; i < num_preds; ++i) { std::string base_name("__CPROVER_jsa_predicate_"); base_name+=std::to_string(i); @@ -215,14 +215,14 @@ void insert_counterexample(std::string &result) std::string::size_type pos=result.find(CE_ASSIGNMENT_MARKER); size_t heap_count=0; size_t word_count=0; - while (std::string::npos != pos) + while(std::string::npos != pos) { const std::string::size_type line_start=result.rfind(" ", pos); const std::string::size_type line_end=result.find('\n', pos); const std::string line(result.substr(line_start, line_end - line_start)); const std::string::size_type stmt_end=result.find(';', pos); std::string value("= "); - if (is_heap(line)) + if(is_heap(line)) { value+="__CPROVER_jsa_counterexample_heaps["; value+=std::to_string(heap_count++); @@ -246,7 +246,7 @@ void cleanup(std::string &result) const std::string &jsa_source_providert::operator ()() { - if (!source.empty()) return source; + if(!source.empty()) return source; add_jsa_defines(source, lcfg); add_includes_and_globals(source); add_temp_clean(source, lcfg.get_symbol_table()); diff --git a/src/cegis/jsa/genetic/random_jsa_cross.cpp b/src/cegis/jsa/genetic/random_jsa_cross.cpp index 88e1e5bc224..882f2ed1a7f 100644 --- a/src/cegis/jsa/genetic/random_jsa_cross.cpp +++ b/src/cegis/jsa/genetic/random_jsa_cross.cpp @@ -79,7 +79,7 @@ void check_consistency(const individualt &individual) { assert(individual.invariant.size() == 1); assert(individual.predicates.size() >= 1); - for (const individualt::predicatet &predicate : individual.predicates) + for(const individualt::predicatet &predicate : individual.predicates) assert(predicate.size() >= 1); assert(individual.query.size() >= 1); } @@ -91,19 +91,19 @@ void cross(individualt &offspring, const individualt &father, offspring.query=mother.query; const individualt::invariantt &f_inv=father.invariant; const size_t f_inv_size=f_inv.size(); - if (offset < f_inv_size) + if(offset < f_inv_size) { const individualt::invariantt &m_inv=mother.invariant; return splice(offspring.invariant, f_inv, m_inv, offset, OPERANDS_PER_JSA_INVARIANT_INSTRUCTION); } offset-=f_inv_size; offspring.invariant=father.invariant; - for (size_t pred_index=0; pred_index < father.predicates.size(); ++pred_index) + for(size_t pred_index=0; pred_index < father.predicates.size(); ++pred_index) { const individualt::predicatet &f_pred=father.predicates[pred_index]; const size_t f_pred_size=f_pred.size() * OPERANDS_PER_JSA_PREDICATE_INSTRUCTION; individualt::predicatet &offspring_pred=offspring.predicates[pred_index]; - if (offset >= f_pred_size) + if(offset >= f_pred_size) { offspring_pred=f_pred; offset-=f_pred_size; diff --git a/src/cegis/jsa/genetic/random_jsa_mutate.cpp b/src/cegis/jsa/genetic/random_jsa_mutate.cpp index 0f9d9ddfd06..2623b7aeea7 100644 --- a/src/cegis/jsa/genetic/random_jsa_mutate.cpp +++ b/src/cegis/jsa/genetic/random_jsa_mutate.cpp @@ -22,18 +22,18 @@ void random_jsa_mutatet::operator()(individualt &lhs, lhs=rhs; size_t mutation_index=random.rand() % get_num_genetic_targets(lhs); const size_t num_inv_instrs=lhs.invariant.size(); - if (mutation_index < num_inv_instrs) + if(mutation_index < num_inv_instrs) return random.havoc(lhs.invariant[mutation_index]); mutation_index-=num_inv_instrs; - for (individualt::predicatet &pred : lhs.predicates) + for(individualt::predicatet &pred : lhs.predicates) { const size_t num_instrs=pred.size() * OPERANDS_PER_JSA_PREDICATE_INSTRUCTION; - if (mutation_index >= num_instrs) { mutation_index-=num_instrs; continue; } + if(mutation_index >= num_instrs) { mutation_index-=num_instrs; continue; } individualt::predicatet::value_type &instr=pred[mutation_index / OPERANDS_PER_JSA_PREDICATE_INSTRUCTION]; individualt::predicatet::value_type tmp(instr); random.havoc(tmp); - switch (mutation_index % OPERANDS_PER_JSA_PREDICATE_INSTRUCTION) + switch(mutation_index % OPERANDS_PER_JSA_PREDICATE_INSTRUCTION) { case 0: instr.op0=tmp.op0; return; case 1: instr.op1=tmp.op1; return; diff --git a/src/cegis/jsa/instrument/jsa_meta_data.cpp b/src/cegis/jsa/instrument/jsa_meta_data.cpp index a03412faec0..92f443979a2 100644 --- a/src/cegis/jsa/instrument/jsa_meta_data.cpp +++ b/src/cegis/jsa/instrument/jsa_meta_data.cpp @@ -14,9 +14,9 @@ Author: Daniel Kroening, kroening@kroening.com bool is_jsa_heap(const typet &type) { const irep_idt &type_id=type.id(); - if (ID_symbol == type_id) + if(ID_symbol == type_id) return id2string(to_symbol_type(type).get_identifier()) == JSA_HEAP_TAG; - if (ID_struct != type_id) return false; + if(ID_struct != type_id) return false; const irep_idt tag(to_struct_type(type).get_tag()); return id2string(tag) == JSA_HEAP_TAG; } @@ -53,6 +53,6 @@ source_locationt jsa_builtin_source_location() bool is_jsa_const(const symbol_exprt &symbol) { const std::string &id=id2string(symbol.get_identifier()); - if (std::string::npos != id.find(JSA_CONSTANT_PREFIX)) return true; + if(std::string::npos != id.find(JSA_CONSTANT_PREFIX)) return true; return symbol.type().get_bool(ID_C_constant); } diff --git a/src/cegis/jsa/instrument/temps_helper.cpp b/src/cegis/jsa/instrument/temps_helper.cpp index 7bb7510c2f3..f57ea1fd23e 100644 --- a/src/cegis/jsa/instrument/temps_helper.cpp +++ b/src/cegis/jsa/instrument/temps_helper.cpp @@ -34,9 +34,9 @@ goto_programt::targett zero_jsa_temps(jsa_programt &prog, { symbol_tablet &st=prog.st; goto_functionst &gf=prog.gf; - for (const symbol_tablet::symbolst::value_type &symbol : st.symbols) + for(const symbol_tablet::symbolst::value_type &symbol : st.symbols) { - if (!is_tmp(symbol)) continue; + if(!is_tmp(symbol)) continue; const symbol_exprt lhs(symbol.second.symbol_expr()); pos=jsa_assign(st, gf, pos, lhs, from_integer(0, lhs.type())); } @@ -58,20 +58,20 @@ void add_zero_jsa_temps_to_pred_exec(jsa_programt &prog) source_locationt loc; loc.set_file(JSA_MODULE); loc.set_function(JSA_PRED_EXEC); - for (goto_programt::targett pos=instr.begin(); pos != instr.end(); ++pos) + for(goto_programt::targett pos=instr.begin(); pos != instr.end(); ++pos) { const codet &code=pos->code; - if (ID_assign != code.get_statement()) continue; + if(ID_assign != code.get_statement()) continue; const code_assignt &assign=to_code_assign(code); const exprt &lhs=assign.lhs(); - if (ID_symbol != lhs.id()) continue; + if(ID_symbol != lhs.id()) continue; const symbol_exprt &symbol=to_symbol_expr(lhs); const irep_idt &id=symbol.get_identifier(); - if (std::string::npos == id2string(id).find(RETURN_VALUE_SUFFIX)) continue; + if(std::string::npos == id2string(id).find(RETURN_VALUE_SUFFIX)) continue; const goto_programt::targett return_pos(pos); std::advance(pos, -1); const symbol_exprt ops(st.lookup(JSA_PRED_RES_OPS).symbol_expr()); - for (size_t i=1; i <= num_tmps; ++i) + for(size_t i=1; i <= num_tmps; ++i) { const constant_exprt index(from_integer(i, signed_int_type())); const index_exprt elem(ops, index); diff --git a/src/cegis/jsa/learn/execute_jsa_programs.cpp b/src/cegis/jsa/learn/execute_jsa_programs.cpp index 5e1433c3e14..a32f08bbc14 100644 --- a/src/cegis/jsa/learn/execute_jsa_programs.cpp +++ b/src/cegis/jsa/learn/execute_jsa_programs.cpp @@ -61,7 +61,7 @@ void make_query_call(jsa_programt &prog, const symbol_tablet &st, goto_programt &body=get_entry_body(gf); pos=insert_before_preserve_labels(body, pos); const goto_programt::targett temps_end=zero_jsa_temps(prog, pos); - if (pos != temps_end) + if(pos != temps_end) { move_labels(body, pos, std::next(pos)); body.instructions.erase(pos); diff --git a/src/cegis/jsa/learn/extract_candidate.cpp b/src/cegis/jsa/learn/extract_candidate.cpp index 0a27a48c2bd..fb58a93b827 100644 --- a/src/cegis/jsa/learn/extract_candidate.cpp +++ b/src/cegis/jsa/learn/extract_candidate.cpp @@ -28,7 +28,7 @@ typedef std::vector encoded_programst; inline bool is_integer(const std::string &s) { - if (s.empty() || (!isdigit(s[0]) && s[0] != '-' && s[0] != '+')) return false; + if(s.empty() || (!isdigit(s[0]) && s[0] != '-' && s[0] != '+')) return false; char *p; long result=strtol(s.c_str(), &p, 10); (void)result; // unused as just used for testing string format @@ -38,7 +38,7 @@ inline bool is_integer(const std::string &s) bool is_prog_name(const std::string &var_name, const std::string &prefix) { const std::string::size_type prefix_size=prefix.size(); - if (var_name.substr(0, prefix_size) != prefix) return false; + if(var_name.substr(0, prefix_size) != prefix) return false; const std::string suffix(var_name.substr(prefix_size)); return suffix.empty() || is_integer(suffix); } @@ -49,15 +49,15 @@ bool find_prog(encoded_programt &result, { const goto_tracet::stepst::const_iterator origin(first); const std::string prefix(get_cegis_meta_name(name)); - for (; first != last; ++first) + for(; first != last; ++first) { - if (goto_trace_stept::DECL != first->type) continue; + if(goto_trace_stept::DECL != first->type) continue; const std::string &var_name=id2string(first->lhs_object.get_identifier()); - if (!is_prog_name(var_name, prefix)) continue; + if(!is_prog_name(var_name, prefix)) continue; std::string sz_name(var_name); sz_name+= JSA_SIZE_SUFFIX; goto_tracet::stepst::const_iterator sz; - for (sz=first; id2string(sz->lhs_object.get_identifier()) != sz_name; --sz) + for(sz=first; id2string(sz->lhs_object.get_identifier()) != sz_name; --sz) assert(sz != origin); const bv_arithmetict bv(sz->full_lhs_value); result.first=bv.to_integer().to_ulong(); @@ -71,7 +71,7 @@ std::vector<__CPROVER_jsa_pred_instructiont> to_genetic_pred(const encoded_progr { std::vector<__CPROVER_jsa_pred_instructiont> result(prog.first); const array_exprt::operandst &ops=prog.second.operands(); - for (size_t i=0; i < result.size(); ++i) + for(size_t i=0; i < result.size(); ++i) { const struct_exprt::operandst &members=to_struct_expr(ops[i]).operands(); assert(members.size() == 4u); @@ -89,7 +89,7 @@ std::vector<__CPROVER_jsa_query_instructiont> to_genetic_query(const encoded_pro { std::vector<__CPROVER_jsa_query_instructiont> result(prog.first); const array_exprt::operandst &ops=prog.second.operands(); - for (size_t i=0; i < result.size(); ++i) + for(size_t i=0; i < result.size(); ++i) { const struct_exprt::operandst &members=to_struct_expr(ops[i]).operands(); assert(members.size() == 3u); @@ -106,7 +106,7 @@ std::vector<__CPROVER_jsa_invariant_instructiont> to_genetic_inv(const encoded_p { std::vector<__CPROVER_jsa_invariant_instructiont> result(prog.first); const array_exprt::operandst &ops=prog.second.operands(); - for (size_t i=0; i < result.size(); ++i) + for(size_t i=0; i < result.size(); ++i) { const struct_exprt::operandst &members=to_struct_expr(ops[i]).operands(); assert(members.size() == 1u); @@ -124,7 +124,7 @@ void extract_jsa_genetic_candidate(jsa_genetic_solutiont &solution, const goto_tracet::stepst::const_iterator last(trace.steps.end()); goto_tracet::stepst::const_iterator last_pred; encoded_programt tmp; - while (find_prog(tmp, first, last, JSA_PRED_PREFIX)) + while(find_prog(tmp, first, last, JSA_PRED_PREFIX)) { solution.predicates.push_back(to_genetic_pred(tmp)); last_pred=first; @@ -144,9 +144,9 @@ void post_process(jsa_genetic_solutiont &solution, const pred_op_idst &pred_ops, // Unused predicates need to be zeroed. const __CPROVER_jsa_pred_instructiont zero = { 0, 0, 0, 0 }; const size_t num_ops=pred_ops.size(); - for (jsa_genetic_solutiont::predicatest::value_type &pred : solution.predicates) - for (const __CPROVER_jsa_pred_instructiont &instr : pred) - if (instr.opcode >= __CPROVER_JSA_NUM_PRED_INSTRUCTIONS || + for(jsa_genetic_solutiont::predicatest::value_type &pred : solution.predicates) + for(const __CPROVER_jsa_pred_instructiont &instr : pred) + if(instr.opcode >= __CPROVER_JSA_NUM_PRED_INSTRUCTIONS || instr.result_op >= result_pred_ops.size() || instr.op0 >= num_ops || instr.op1 >= num_ops) { diff --git a/src/cegis/jsa/learn/insert_counterexample.cpp b/src/cegis/jsa/learn/insert_counterexample.cpp index 531c60df191..b7f1e938498 100644 --- a/src/cegis/jsa/learn/insert_counterexample.cpp +++ b/src/cegis/jsa/learn/insert_counterexample.cpp @@ -37,15 +37,15 @@ array_valuest get_array_values(const symbol_tablet &st, const constant_exprt size_expr(get_size_expr(ces.size())); const jsa_counterexamplet &prototype=ces.front(); array_valuest array_values; - for (const jsa_counterexamplet::value_type &value : prototype) + for(const jsa_counterexamplet::value_type &value : prototype) { const typet &org_type=value.second.type(); const typet &element_type=replace_struct_by_symbol_type(st, org_type); const array_typet array_type(element_type, size_expr); array_values.insert(std::make_pair(value.first, array_exprt(array_type))); } - for (const jsa_counterexamplet &ce : ces) - for (const jsa_counterexamplet::value_type &value : ce) + for(const jsa_counterexamplet &ce : ces) + for(const jsa_counterexamplet::value_type &value : ce) array_values[value.first].copy_to_operands(value.second); return array_values; } @@ -66,7 +66,7 @@ void add_array_declarations(jsa_programt &program, const array_valuest array_values(get_array_values(st, ces)); const constant_exprt size_expr(get_size_expr(ces.size())); goto_programt::targett &pos=program.synthetic_variables; - for (const jsa_counterexamplet::value_type &value : prototype) + for(const jsa_counterexamplet::value_type &value : prototype) { const jsa_counterexamplet::value_type::first_type loc_id=value.first; const typet &org_type=value.second.type(); @@ -139,11 +139,11 @@ void assign_ce_values(jsa_programt &prog) { const symbol_tablet &st=prog.st; goto_functionst &gf=prog.gf; - for (const goto_programt::targett &pos : prog.counterexample_locations) + for(const goto_programt::targett &pos : prog.counterexample_locations) { assert(pos->labels.size() == 1u); const index_exprt value(get_array_val_expr(st, pos->labels.front())); - switch (pos->type) + switch(pos->type) { case ASSIGN: to_code_assign(pos->code).rhs()=value; diff --git a/src/cegis/jsa/learn/insert_predicates_and_queries.cpp b/src/cegis/jsa/learn/insert_predicates_and_queries.cpp index 2727450b193..4f226975f5c 100644 --- a/src/cegis/jsa/learn/insert_predicates_and_queries.cpp +++ b/src/cegis/jsa/learn/insert_predicates_and_queries.cpp @@ -73,7 +73,7 @@ void declare_jsa_predicates(jsa_programt &prog, const size_t max_sz) const typet sz_type(signed_int_type()); const exprt zero(from_integer(0, sz_type)); const size_t max_pred_size=get_max_pred_size(st); - for (mp_integer::ullong_t i=0; i < num_preds; ++i) + for(mp_integer::ullong_t i=0; i < num_preds; ++i) { goto_programt::targett &pos=prog.synthetic_variables; std::string base_name(JSA_PRED_PREFIX); diff --git a/src/cegis/jsa/learn/instrument_pred_ops.cpp b/src/cegis/jsa/learn/instrument_pred_ops.cpp index 7f477b1cd2b..fc72db0f6f0 100644 --- a/src/cegis/jsa/learn/instrument_pred_ops.cpp +++ b/src/cegis/jsa/learn/instrument_pred_ops.cpp @@ -30,11 +30,11 @@ bool contains(const std::string &haystack, const char * const needle) bool is_pred_op_decl(const symbol_tablet &st, const goto_programt::targett &pos) { - if (goto_program_instruction_typet::DECL != pos->type) return false; + if(goto_program_instruction_typet::DECL != pos->type) return false; const std::string &id=id2string(get_affected_variable(*pos)); - if (contains(id, JSA_TMP_PREFIX) || contains(id, JSA_LAMBDA_OP) + if(contains(id, JSA_TMP_PREFIX) || contains(id, JSA_LAMBDA_OP) || contains(id, JSA_CONSTANT_PREFIX)) return true; - if (contains(id, CPROVER_PREFIX)) return false; + if(contains(id, CPROVER_PREFIX)) return false; const namespacet ns(st); const typet lhs(jsa_word_type()); return type_eq(lhs, st.lookup(id).type, ns); @@ -47,8 +47,8 @@ goto_programt::targetst collect_pred_ops(jsa_programt &prog) goto_programt::instructionst &body=get_entry_body(prog.gf).instructions; const goto_programt::targett end(prog.body.first); goto_programt::targetst pred_ops; - for (goto_programt::targett it=body.begin(); it != end; ++it) - if (is_pred_op_decl(st, it)) pred_ops.push_back(it); + for(goto_programt::targett it=body.begin(); it != end; ++it) + if(is_pred_op_decl(st, it)) pred_ops.push_back(it); return pred_ops; } @@ -66,7 +66,7 @@ void mark_dead(goto_programt &body, goto_programt::targett pos, const goto_programt::targett end(instrs.end()); pos=std::find_if(pos, end, [&id](const goto_programt::instructiont &instr) { return DEAD == instr.type && id == get_affected_variable(instr);}); - if (end == pos) return; + if(end == pos) return; pos=body.insert_after(pos); pos->type=goto_program_instruction_typet::ASSIGN; pos->source_location=jsa_builtin_source_location(); @@ -85,7 +85,7 @@ void instrument_pred_ops(jsa_programt &prog, const goto_programt::targetst &ops, const typet sz_type(signed_int_type()); size_t op_index=0; size_t res_op_idx=0; - for (const goto_programt::targett &op : ops) + for(const goto_programt::targett &op : ops) { const symbol_exprt var(st.lookup(get_affected_variable(*op)).symbol_expr()); const address_of_exprt var_ptr(var); @@ -94,7 +94,7 @@ void instrument_pred_ops(jsa_programt &prog, const goto_programt::targetst &ops, const index_exprt op_elem(pred_ops, op_index_expr); mark_dead(body, op, op_elem); goto_programt::targett pos=jsa_assign(st, gf, op, op_elem, var_ptr); - if (!is_jsa_const(var)) + if(!is_jsa_const(var)) { op_ids.insert(std::make_pair(res_op_idx, var)); const constant_exprt res_op_idx_expr(from_integer(res_op_idx++, sz_type)); @@ -102,7 +102,7 @@ void instrument_pred_ops(jsa_programt &prog, const goto_programt::targetst &ops, mark_dead(body, op, res_op_elem); pos=jsa_assign(st, gf, pos, res_op_elem, address_of_exprt(var)); } - if (op == prog.synthetic_variables) prog.synthetic_variables=pos; + if(op == prog.synthetic_variables) prog.synthetic_variables=pos; } const symbol_exprt op_count(st.lookup(JSA_PRED_OP_COUNT).symbol_expr()); const constant_exprt op_value(from_integer(op_index, op_count.type())); diff --git a/src/cegis/jsa/learn/jsa_symex_learn.cpp b/src/cegis/jsa/learn/jsa_symex_learn.cpp index eb1fffecb3b..ecea9feea6a 100644 --- a/src/cegis/jsa/learn/jsa_symex_learn.cpp +++ b/src/cegis/jsa/learn/jsa_symex_learn.cpp @@ -31,7 +31,7 @@ void jsa_symex_learnt::process(const counterexamplest &counterexamples, { program=original_program; const goto_programt::targetst pred_ops(collect_pred_ops(program)); - //add_jsa_library(program, max_solution_size, pred_ops); + // add_jsa_library(program, max_solution_size, pred_ops); instrument_pred_ops(program, pred_ops, op_ids, const_op_ids); insert_jsa_constraint(program, true); insert_counterexamples(program, counterexamples); @@ -48,7 +48,7 @@ void jsa_symex_learnt::process(const size_t max_solution_size) const namespacet ns(original_program.st); counterexamplest counterexamples(1); counterexamplet &counterexample=counterexamples.front(); - for (const goto_programt::targett &pos : original_program.counterexample_locations) + for(const goto_programt::targett &pos : original_program.counterexample_locations) { assert(pos->labels.size() == 1u); const irep_idt &key=pos->labels.front(); diff --git a/src/cegis/jsa/preprocessing/add_synthesis_library.cpp b/src/cegis/jsa/preprocessing/add_synthesis_library.cpp index 20d8edb420a..9982ebc86ff 100644 --- a/src/cegis/jsa/preprocessing/add_synthesis_library.cpp +++ b/src/cegis/jsa/preprocessing/add_synthesis_library.cpp @@ -28,7 +28,7 @@ namespace { void add_placenholder(symbol_tablet &st, const irep_idt &id) { - if (st.has_symbol(id)) return; + if(st.has_symbol(id)) return; symbolt symbol; symbol.name=id; symbol.base_name=symbol.name; @@ -43,7 +43,7 @@ void add_placenholder(symbol_tablet &st, const irep_idt &id) std::string get_array_size(const typet &type) { const irep_idt &type_id=type.id(); - if (ID_array == type_id) + if(ID_array == type_id) { const bv_arithmetict bv(to_array_type(type).size()); return std::to_string(bv.to_integer().to_ulong()); @@ -71,14 +71,14 @@ std::string get_sizes(const symbol_tablet &st) std::vector get_functions(const symbol_tablet &st) { std::vector functions; - for (const symbol_tablet::symbolst::value_type &symbol : st.symbols) - if (ID_code == symbol.second.type.id()) functions.push_back(symbol.first); + for(const symbol_tablet::symbolst::value_type &symbol : st.symbols) + if(ID_code == symbol.second.type.id()) functions.push_back(symbol.first); return functions; } bool is_jsa_constant(const symbolt &symbol) { - if (!symbol.is_static_lifetime) return false; + if(!symbol.is_static_lifetime) return false; const std::string &name=id2string(symbol.name); return std::string::npos != name.find(JSA_CONSTANT_PREFIX) || std::string::npos != name.find(JSA_STATIC_META_VAR_PREFIX); @@ -95,8 +95,8 @@ void zero_new_global_vars(const symbol_tablet &st, goto_functionst &gf) goto_programt::targett pos=std::prev(body.instructions.end(), 2); const source_locationt loc(jsa_builtin_source_location()); const namespacet ns(st); - for (const symbol_tablet::symbolst::value_type &symbol : st.symbols) - if (is_jsa_constant(symbol.second)) + for(const symbol_tablet::symbolst::value_type &symbol : st.symbols) + if(is_jsa_constant(symbol.second)) { pos=body.insert_after(pos); pos->type=goto_program_instruction_typet::ASSIGN; @@ -143,7 +143,7 @@ void add_jsa_library(jsa_programt &prog, const size_t max_sz, assert(!linking(st, blank, msg)); goto_functionst &gf=prog.gf; const std::vector new_funcs(get_functions(blank)); - for (const irep_idt &func_name : new_funcs) + for(const irep_idt &func_name : new_funcs) goto_convert(func_name, st, gf, msg); zero_new_global_vars(blank, gf); gf.compute_loop_numbers(); diff --git a/src/cegis/jsa/preprocessing/clone_heap.cpp b/src/cegis/jsa/preprocessing/clone_heap.cpp index ce7247ad04e..46d3290b75a 100644 --- a/src/cegis/jsa/preprocessing/clone_heap.cpp +++ b/src/cegis/jsa/preprocessing/clone_heap.cpp @@ -23,13 +23,13 @@ namespace { bool is_heap_type(const typet &type) { - if (ID_symbol != type.id()) return false; + if(ID_symbol != type.id()) return false; return to_symbol_type(type).get_identifier() == JSA_HEAP_TAG; } bool is_heap(const goto_programt::instructiont &instr) { - if (goto_program_instruction_typet::DECL != instr.type) return false; + if(goto_program_instruction_typet::DECL != instr.type) return false; return is_heap_type(to_code_decl(instr.code).symbol().type()); } } @@ -74,7 +74,7 @@ void clone_heap(jsa_programt &prog) } #define VALID_LIST JSA_PREFIX "assume_valid_list" -//#define VALID_IT JSA_PREFIX "assume_valid_iterator" +// #define VALID_IT JSA_PREFIX "assume_valid_iterator" #define VALID_IT JSA_PREFIX "assume_valid_invariant_iterator" // XXX: TODO: Find a cleaner way. namespace @@ -84,11 +84,11 @@ std::vector collect(goto_programt::targett first, const std::function pred) { std::vector symbols; - for (; first != last; ++first) + for(; first != last; ++first) { - if (goto_program_instruction_typet::DECL != first->type) continue; + if(goto_program_instruction_typet::DECL != first->type) continue; const symbol_exprt symb(to_symbol_expr(to_code_decl(first->code).symbol())); - if (pred(symb.get_identifier())) symbols.push_back(symb); + if(pred(symb.get_identifier())) symbols.push_back(symb); } return symbols; } @@ -113,10 +113,10 @@ goto_programt::targett assume_lists_and_its_valid(const symbol_tablet &st, { const goto_programt::targett first=body.instructions.begin(); const std::vector its(collect(first, pos, is_jsa_iterator)); - for (const symbol_exprt &it : its) + for(const symbol_exprt &it : its) pos=call_assume(st, VALID_IT, heap_ptr, it, body, pos); const std::vector lists(collect(first, pos, is_jsa_list)); - for (const symbol_exprt &list : lists) + for(const symbol_exprt &list : lists) pos=call_assume(st, VALID_LIST, heap_ptr, list, body, pos); return pos; } diff --git a/src/cegis/jsa/preprocessing/collect_variables.cpp b/src/cegis/jsa/preprocessing/collect_variables.cpp index 56594713b7f..0979b39890d 100644 --- a/src/cegis/jsa/preprocessing/collect_variables.cpp +++ b/src/cegis/jsa/preprocessing/collect_variables.cpp @@ -23,7 +23,7 @@ namespace bool is_meta(const goto_programt::const_targett pos) { const std::string &name=id2string(get_affected_variable(*pos)); - if (is_jsa_list(name) || is_jsa_iterator(name)) return false; + if(is_jsa_list(name) || is_jsa_iterator(name)) return false; return contains(name, CPROVER_PREFIX) || is_return_value_name(name); } @@ -40,13 +40,13 @@ void add_inductive_step_renondets(jsa_programt &prog) goto_programt::instructionst &body=get_entry_body(gf).instructions; const goto_programt::targett last=prog.base_case; goto_programt::targett pos=prog.base_case; - for (goto_programt::targett it=body.begin(); it != last; ++it) + for(goto_programt::targett it=body.begin(); it != last; ++it) { - if (goto_program_instruction_typet::DECL != it->type) continue; + if(goto_program_instruction_typet::DECL != it->type) continue; const irep_idt &id=get_affected_variable(*it); - if (is_meta(it)) continue; + if(is_meta(it)) continue; const symbol_exprt symbol(st.lookup(id).symbol_expr()); - if (is_const(symbol)) continue; + if(is_const(symbol)) continue; const typet &type=symbol.type(); pos=jsa_assign(st, gf, pos, symbol, side_effect_expr_nondett(type)); prog.inductive_step_renondets.push_back(pos); diff --git a/src/cegis/jsa/preprocessing/create_temp_variables.cpp b/src/cegis/jsa/preprocessing/create_temp_variables.cpp index 95f552f94b0..8d0503c1c4d 100644 --- a/src/cegis/jsa/preprocessing/create_temp_variables.cpp +++ b/src/cegis/jsa/preprocessing/create_temp_variables.cpp @@ -25,7 +25,7 @@ void create_jsa_temp_variables(jsa_programt &prog, const size_t max_size) goto_programt &body=get_entry_body(gf); const std::string tmp_prefix(JSA_TMP_PREFIX); const typet type(jsa_word_type()); - for (size_t i=0; i < max_size; ++i) + for(size_t i=0; i < max_size; ++i) { pos=body.insert_after(pos); const std::string base_name(tmp_prefix + std::to_string(i)); diff --git a/src/cegis/jsa/preprocessing/default_jsa_constant_strategy.cpp b/src/cegis/jsa/preprocessing/default_jsa_constant_strategy.cpp index 01474a262a8..d0dbbe10bbd 100644 --- a/src/cegis/jsa/preprocessing/default_jsa_constant_strategy.cpp +++ b/src/cegis/jsa/preprocessing/default_jsa_constant_strategy.cpp @@ -33,7 +33,7 @@ goto_programt::targett default_jsa_constant_strategy(symbol_tablet &st, size_t const_index=0u; goto_programt &body=get_entry_body(gf); goto_programt::targett pos=body.instructions.begin(); - for (const constant_exprt &expr : literals) + for(const constant_exprt &expr : literals) { mp_integer value; to_integer(expr, value); diff --git a/src/cegis/jsa/preprocessing/inline_user_program.cpp b/src/cegis/jsa/preprocessing/inline_user_program.cpp index e02f350a6d9..6e492acf569 100644 --- a/src/cegis/jsa/preprocessing/inline_user_program.cpp +++ b/src/cegis/jsa/preprocessing/inline_user_program.cpp @@ -20,24 +20,24 @@ namespace bool is_user_function(const irep_idt &name, const goto_functionst::goto_functiont &func) { - if (std::string::npos != id2string(name).find(id2string(CPROVER_PREFIX))) + if(std::string::npos != id2string(name).find(id2string(CPROVER_PREFIX))) return false; - if (!func.body_available()) return false; + if(!func.body_available()) return false; const goto_programt::instructionst &instrs=func.body.instructions; - if (instrs.empty()) return false; + if(instrs.empty()) return false; return !is_builtin(instrs.front().source_location); } void mark_user_function(const irep_idt &name, goto_functionst::goto_functiont &func) { - if (is_user_function(name, func)) func.type.set_inlined(true); + if(is_user_function(name, func)) func.type.set_inlined(true); } } void inline_jsa_user_program(const symbol_tablet &st, goto_functionst &gf) { - for (goto_functionst::function_mapt::value_type &f : gf.function_map) + for(goto_functionst::function_mapt::value_type &f : gf.function_map) mark_user_function(f.first, f.second); const namespacet ns(st); diff --git a/src/cegis/jsa/value/jsa_solution.cpp b/src/cegis/jsa/value/jsa_solution.cpp index c1434ce66f7..32895832edb 100644 --- a/src/cegis/jsa/value/jsa_solution.cpp +++ b/src/cegis/jsa/value/jsa_solution.cpp @@ -21,7 +21,7 @@ jsa_solutiont ©_instrs(jsa_solutiont &lhs, const jsa_solutiont &rhs) { lhs.predicates.clear(); lhs.predicates.resize(rhs.predicates.size()); - for (size_t i=0; i < lhs.predicates.size(); ++i) + for(size_t i=0; i < lhs.predicates.size(); ++i) copy_instructions(lhs.predicates[i], rhs.predicates[i]); lhs.query.clear(); copy_instructions(lhs.query, rhs.query); diff --git a/src/cegis/jsa/value/jsa_solution_printer.cpp b/src/cegis/jsa/value/jsa_solution_printer.cpp index f9c57297b8f..e279d6f6b16 100644 --- a/src/cegis/jsa/value/jsa_solution_printer.cpp +++ b/src/cegis/jsa/value/jsa_solution_printer.cpp @@ -20,7 +20,7 @@ namespace { void print(messaget::mstreamt &os, const pred_op_idst &op_ids) { - for (const pred_op_idst::value_type &op : op_ids) + for(const pred_op_idst::value_type &op : op_ids) { os << " " << op.first << ""; const irep_idt &id=op.second.get_identifier(); @@ -35,7 +35,7 @@ void print_consts(messaget::mstreamt &os, const jsa_programt &prog) const std::vector values(collect_integer_literals(st, gf)); os << " " << messaget::endl; size_t index=0; - for (const constant_exprt &expr : values) + for(const constant_exprt &expr : values) { mp_integer literal; to_integer(expr, literal); @@ -51,7 +51,7 @@ void print_instructions(messaget::mstreamt &os, const jsa_programt &program, { const goto_programt &prog=get_entry_body(program.gf); const namespacet ns(program.st); - for (goto_programt::const_targett it=instrs.begin(); it != instrs.end(); ++it) + for(goto_programt::const_targett it=instrs.begin(); it != instrs.end(); ++it) prog.output_instruction(ns, "", os, it); } } @@ -60,7 +60,7 @@ void print_jsa_solution(messaget::mstreamt &os, const jsa_programt &program, const jsa_solutiont &solution, const pred_op_idst &op_ids, const pred_op_idst &const_op_ids) { - if (solution.query.empty() || program.st.symbols.empty()) + if(solution.query.empty() || program.st.symbols.empty()) { os << "" << messaget::endl << messaget::eom; return; @@ -77,7 +77,7 @@ void print_jsa_solution(messaget::mstreamt &os, const jsa_programt &program, os << " " << messaget::endl; os << " " << messaget::endl; const jsa_solutiont::predicatest &predicates=solution.predicates; - for (const goto_programt::instructionst &predicate : predicates) + for(const goto_programt::instructionst &predicate : predicates) { os << " " << messaget::endl; print_instructions(os, program, predicate); diff --git a/src/cegis/jsa/verify/extract_counterexample.cpp b/src/cegis/jsa/verify/extract_counterexample.cpp index 3fd5a2f2d2c..d3d6290869e 100644 --- a/src/cegis/jsa/verify/extract_counterexample.cpp +++ b/src/cegis/jsa/verify/extract_counterexample.cpp @@ -22,7 +22,7 @@ void extract(const jsa_programt &prog, jsa_counterexamplet &ce, const namespacet ns(st); const goto_programt::targetst &ce_locs=prog.counterexample_locations; const goto_tracet::stepst &steps=trace.steps; - for (const goto_programt::targett &ce_loc : ce_locs) + for(const goto_programt::targett &ce_loc : ce_locs) { assert(ce_loc->labels.size() == 1u); const irep_idt &id=ce_loc->labels.front(); @@ -32,7 +32,7 @@ void extract(const jsa_programt &prog, jsa_counterexamplet &ce, const goto_programt::instructiont::labelst &labels=step.pc->labels; return labels.end() != std::find(labels.begin(), labels.end(), id); }); - if (steps.end() != it) ce.insert(std::make_pair(id, it->full_lhs_value)); + if(steps.end() != it) ce.insert(std::make_pair(id, it->full_lhs_value)); else assert( !"We need counterexample for each location." diff --git a/src/cegis/jsa/verify/insert_solution.cpp b/src/cegis/jsa/verify/insert_solution.cpp index 0f577968837..8356db7c303 100644 --- a/src/cegis/jsa/verify/insert_solution.cpp +++ b/src/cegis/jsa/verify/insert_solution.cpp @@ -53,7 +53,7 @@ void add_predicates(jsa_programt &prog, const jsa_solutiont::predicatest &preds) std::vector pred_begins; pos=first; size_t idx=0; - for (const jsa_solutiont::predicatest::value_type &pred : preds) + for(const jsa_solutiont::predicatest::value_type &pred : preds) { assert(!pred.empty()); pos=body.insert_after(pos); @@ -75,7 +75,7 @@ void add_predicates(jsa_programt &prog, const jsa_solutiont::predicatest &preds) pos->targets.push_back(end); } assert(pred_begins.size() == preds.size()); - for (auto it=pred_begins.begin(); it != std::prev(pred_begins.end()); ++it) + for(auto it=pred_begins.begin(); it != std::prev(pred_begins.end()); ++it) { const goto_programt::targett &pos=*it; pos->targets.push_back(*std::next(it)); @@ -118,7 +118,7 @@ void insert_sync_call(const symbol_tablet &st, const goto_functionst &gf, const goto_programt::instructionst &query) { assert(!query.empty()); - if (query.empty()) return; + if(query.empty()) return; const exprt &it_arg=get_iterator_arg(query.front().code); code_function_callt sync; code_function_callt::argumentst &sync_args=sync.arguments(); @@ -136,7 +136,7 @@ void make_full_query_call(const symbol_tablet &st, const goto_functionst &gf, goto_programt &body, goto_programt::targett pos, const goto_programt::instructionst &query) { - if (query.empty()) return; + if(query.empty()) return; pos=insert_before_preserve_labels(body, pos); pos->type=goto_program_instruction_typet::FUNCTION_CALL; pos->source_location=jsa_builtin_source_location(); @@ -151,7 +151,7 @@ void make_full_query_call(const symbol_tablet &st, const goto_functionst &gf, void insert_before(jsa_programt &jsa_prog, goto_programt &body, const goto_programt::targett &pos, const goto_programt::instructionst &prog) { - if (prog.empty()) return; + if(prog.empty()) return; const goto_programt::targett insert_after=std::prev(pos); copy_instructions(body.instructions, insert_after, prog); zero_jsa_temps(jsa_prog, insert_after); diff --git a/src/cegis/jsa/verify/jsa_symex_verify.cpp b/src/cegis/jsa/verify/jsa_symex_verify.cpp index f698a34810d..1d63b29de7d 100644 --- a/src/cegis/jsa/verify/jsa_symex_verify.cpp +++ b/src/cegis/jsa/verify/jsa_symex_verify.cpp @@ -27,7 +27,7 @@ void jsa_symex_verifyt::process(const candidatet &cand) { program=original_program; const goto_programt::targetst pred_ops(collect_pred_ops(program)); - //add_jsa_library(program, cand.max_size, pred_ops); + // add_jsa_library(program, cand.max_size, pred_ops); instrument_pred_ops(program, pred_ops); insert_jsa_constraint(program, false); assume_renondet_inputs_valid(program); diff --git a/src/cegis/jsa/verify/renondet_inputs.cpp b/src/cegis/jsa/verify/renondet_inputs.cpp index d02de4a3039..b947a96b6ce 100644 --- a/src/cegis/jsa/verify/renondet_inputs.cpp +++ b/src/cegis/jsa/verify/renondet_inputs.cpp @@ -16,16 +16,16 @@ Author: Daniel Kroening, kroening@kroening.com void assume_renondet_inputs_valid(jsa_programt &prog) { - if (prog.counterexample_locations.empty()) return; + if(prog.counterexample_locations.empty()) return; const symbol_tablet &st=prog.st; goto_programt &body=get_entry_body(prog.gf); - for (const goto_programt::targett &pos : prog.inductive_step_renondets) + for(const goto_programt::targett &pos : prog.inductive_step_renondets) { const irep_idt &id=get_affected_variable(*pos); const symbol_exprt lhs(st.lookup(id).symbol_expr()); const typet &type=lhs.type(); - if (is_jsa_heap(type)) + if(is_jsa_heap(type)) assume_valid_heap(st, body, pos, address_of_exprt(lhs)); } } diff --git a/src/cegis/learn/constraint_helper.cpp b/src/cegis/learn/constraint_helper.cpp index 974cdafcb5c..1ad6d23649a 100644 --- a/src/cegis/learn/constraint_helper.cpp +++ b/src/cegis/learn/constraint_helper.cpp @@ -15,10 +15,10 @@ void transform_asserts_to_assumes(goto_functionst &gf) { typedef goto_functionst::function_mapt fmapt; fmapt &fmap=gf.function_map; - for (fmapt::value_type &entry : fmap) + for(fmapt::value_type &entry : fmap) { - if (!entry.second.body_available()) continue; - for (goto_programt::instructiont &instr : entry.second.body.instructions) - if (ASSERT == instr.type) instr.type=ASSUME; + if(!entry.second.body_available()) continue; + for(goto_programt::instructiont &instr : entry.second.body.instructions) + if(ASSERT == instr.type) instr.type=ASSUME; } } diff --git a/src/cegis/learn/insert_counterexample.cpp b/src/cegis/learn/insert_counterexample.cpp index 9a54bd750ed..35b067bbcb2 100644 --- a/src/cegis/learn/insert_counterexample.cpp +++ b/src/cegis/learn/insert_counterexample.cpp @@ -31,7 +31,7 @@ zero_valuest get_zero_values(const symbol_tablet &st, std::map zero_values; const source_locationt loc(default_cegis_source_location()); const namespacet ns(st); - for (const goto_programt::const_targett pos : ce_locs) + for(const goto_programt::const_targett pos : ce_locs) { const irep_idt &marker=get_counterexample_marker(pos); const typet &type=get_affected_type(*pos); @@ -46,23 +46,23 @@ void normalise(const std::set &ce_keys, const zero_valuest &zv, { const exprt::operandst no_values; std::map sizes; - for (labelled_counterexamplest::value_type &ce : ces) + for(labelled_counterexamplest::value_type &ce : ces) { - for (const irep_idt &loc : ce_keys) + for(const irep_idt &loc : ce_keys) { std::map::iterator sz=sizes.find(loc); - if (sizes.end() == sz) sz=sizes.insert(std::make_pair(loc, 1)).first; + if(sizes.end() == sz) sz=sizes.insert(std::make_pair(loc, 1)).first; size_t &size=sz->second; labelled_assignmentst::const_iterator values=ce.find(loc); - if (ce.end() == values) + if(ce.end() == values) values=ce.insert(std::make_pair(loc, no_values)).first; size=std::max(size, values->second.size()); } assert(ce.size() == zv.size()); } assert(sizes.size() == zv.size()); - for (labelled_counterexamplest::value_type &ce : ces) - for (labelled_counterexamplest::value_type::value_type &ass : ce) + for(labelled_counterexamplest::value_type &ce : ces) + for(labelled_counterexamplest::value_type::value_type &ass : ce) { labelled_assignmentst::value_type::second_type &values=ass.second; const size_t current_size=values.size(); @@ -72,7 +72,7 @@ void normalise(const std::set &ce_keys, const zero_valuest &zv, const size_t target_size=it->second; assert(current_size <= target_size); const size_t missing=target_size - current_size; - if (missing) + if(missing) { const std::map::const_iterator it=zv.find(lbl); assert(zv.end() != it); @@ -110,13 +110,13 @@ array_valuest get_array_values(const labelled_counterexamplest &ces) const typet sz_type(signed_int_type()); const constant_exprt ces_sz_expr(from_integer(ces.size(), sz_type)); array_valuest result; - for (const labelled_assignmentst &ce : ces) - for (const labelled_assignmentst::value_type &ass : ce) + for(const labelled_assignmentst &ce : ces) + for(const labelled_assignmentst::value_type &ass : ce) { const array_exprt ass_values(to_values(ass.second)); const irep_idt &loc=ass.first; array_valuest::iterator it=result.find(loc); - if (result.end() == it) + if(result.end() == it) { const array_typet type(ass_values.type(), ces_sz_expr); it=result.insert(std::make_pair(loc, array_exprt(type))).first; @@ -148,7 +148,7 @@ void add_array_declarations(symbol_tablet &st, goto_functionst &gf, const array_valuest array_values(get_array_values(ces)); const labelled_counterexamplest::value_type &prototype=ces.front(); goto_programt::targett pos=std::prev(begin); - for (const labelled_counterexamplest::value_type::value_type &value : prototype) + for(const labelled_counterexamplest::value_type::value_type &value : prototype) { const labelled_assignmentst::value_type::first_type loc_id=value.first; const array_valuest::const_iterator array_val=array_values.find(loc_id); @@ -174,7 +174,7 @@ void add_array_indexes(const std::set &ce_keys, symbol_tablet &st, const exprt zero(zero_initializer(type, loc, ns)); assign_cegis_meta_variable(st, gf, pos, CE_ARRAY_INDEX, zero); pos=cprover_init; - for (const irep_idt &key : ce_keys) + for(const irep_idt &key : ce_keys) { const std::string label(get_ce_value_index_name(key)); pos=declare_cegis_meta_variable(st, gf, pos, label, type); @@ -231,11 +231,11 @@ void assign_ce_values(symbol_tablet &st, goto_functionst &gf, { const typet sz_type(signed_int_type()); const constant_exprt one(from_integer(1, sz_type)); - for (goto_programt::targett pos : ce_locs) + for(goto_programt::targett pos : ce_locs) { const irep_idt &label=get_counterexample_marker(pos); const index_exprt value(get_array_val_expr(st, pos->labels.front())); - switch (pos->type) + switch(pos->type) { case ASSIGN: to_code_assign(pos->code).rhs()=value; diff --git a/src/cegis/refactor/constraint/constraint_factory.cpp b/src/cegis/refactor/constraint/constraint_factory.cpp index 66f0dd9ab7c..318093a5a79 100644 --- a/src/cegis/refactor/constraint/constraint_factory.cpp +++ b/src/cegis/refactor/constraint/constraint_factory.cpp @@ -38,7 +38,7 @@ void create_or_redirect_entry(symbol_tablet &st, goto_functionst &gf) fmapt &fmap=gf.function_map; const fmapt::const_iterator it=fmap.find(goto_functionst::entry_point()); null_message_handlert msg; - if (fmap.end() == it) + if(fmap.end() == it) { config.main=CONSTRAINT_CALLER; assert(!java_entry_point(st, ID_empty, msg, false, 0)); @@ -54,7 +54,7 @@ void create_or_redirect_entry(symbol_tablet &st, goto_functionst &gf) void add_to_symbol_table(symbol_tablet &st, const std::string &name, const goto_functionst::function_mapt::mapped_type &func) { - if (st.has_symbol(name)) return; + if(st.has_symbol(name)) return; symbolt new_symbol; new_symbol.name=name; new_symbol.type=func.type; @@ -77,7 +77,7 @@ void create_constraint_function_caller(refactor_programt &prog) goto_programt &body=func.body; const source_locationt loc(default_cegis_source_location()); symbol_tablet &st=prog.st; - for (const refactor_programt::sketcht &sketch : prog.sketches) + for(const refactor_programt::sketcht &sketch : prog.sketches) { const symbolt &symbol=st.lookup(sketch.init->function); const code_typet &type=to_code_type(symbol.type); @@ -87,7 +87,7 @@ void create_constraint_function_caller(refactor_programt &prog) code_function_callt call; call.function()=symbol.symbol_expr(); code_function_callt::argumentst &args=call.arguments(); - for (const code_typet::parametert ¶m : type.parameters()) + for(const code_typet::parametert ¶m : type.parameters()) args.push_back(from_integer(0, param.type())); pos->code=call; } @@ -139,7 +139,7 @@ goto_programt::targett nondet_init(const symbol_tablet &st, goto_programt &body, goto_programt::targett pos, const irep_idt &state_var) { const symbolt &symbol=st.lookup(state_var); - if (!is_cegis_primitive(symbol.type)) return pos; // TODO: Handle class types + if(!is_cegis_primitive(symbol.type)) return pos; // TODO: Handle class types pos=insert_after_preserving_source_location(body, pos); pos->type=goto_program_instruction_typet::ASSIGN; const symbol_exprt lhs(symbol.symbol_expr()); @@ -152,7 +152,7 @@ goto_programt::targett havoc_inputs(const symbol_tablet &st, goto_programt &body, const refactor_programt::sketcht &sketch) { goto_programt::targett pos=sketch.init; - for (const irep_idt &state_var : sketch.state_vars) + for(const irep_idt &state_var : sketch.state_vars) pos=nondet_init(st, body, pos, state_var); return pos; } @@ -173,11 +173,11 @@ goto_programt::targett create_snapshot(symbol_tablet &st, goto_programt &body, const std::string &func_name, const std::set &state_vars, goto_programt::targett pos, const char * const suffix) { - for (const irep_idt &state_var : state_vars) + for(const irep_idt &state_var : state_vars) { const symbolt &symbol=st.lookup(state_var); const typet &type=symbol.type; - if (!is_cegis_primitive(type)) continue; // TODO: Handle class types (clone) + if(!is_cegis_primitive(type)) continue; // TODO: Handle class types (clone) const std::string clone_name(get_clone_name(symbol.base_name, suffix)); pos=declare_local_meta_variable(st, func_name, body, pos, clone_name, type); const symbol_exprt rhs(symbol.symbol_expr()); @@ -189,7 +189,7 @@ goto_programt::targett create_snapshot(symbol_tablet &st, goto_programt &body, void create_init_snapshot(symbol_tablet &st, goto_programt &body, const refactor_programt::sketcht &sketch, const goto_programt::targett pos) { - if (sketch.state_vars.empty()) return; + if(sketch.state_vars.empty()) return; const std::string func(id2string(sketch.init->function)); create_snapshot(st, body, func, sketch.state_vars, pos, INIT_SUFFIX); } @@ -207,10 +207,10 @@ void assign_init_snapshot(symbol_tablet &st, goto_programt &body, const refactor_programt::sketcht &sketch, goto_programt::targett pos) { const std::string &func=id2string(sketch.init->function); - for (const irep_idt &var : sketch.state_vars) + for(const irep_idt &var : sketch.state_vars) { const symbolt &symbol=st.lookup(var); - if (!is_cegis_primitive(symbol.type)) continue; // TODO: Handle class types + if(!is_cegis_primitive(symbol.type)) continue; // TODO: Handle class types const symbol_exprt lhs(symbol.symbol_expr()); const irep_idt &base_name=symbol.base_name; const std::string rhs_name(get_clone_id(base_name, func, INIT_SUFFIX)); @@ -236,10 +236,10 @@ void insert_assertion(/*const */symbol_tablet &st, goto_programt &body, { const irep_idt &func_name=sketch.init->function; exprt::operandst clauses; - for (const irep_idt &var : sketch.state_vars) + for(const irep_idt &var : sketch.state_vars) { - if (!is_cegis_primitive(st.lookup(var).type)) continue; // TODO: Handle class types - if (is_refactor_meta_var(var)) continue; + if(!is_cegis_primitive(st.lookup(var).type)) continue; // TODO: Handle class types + if(is_refactor_meta_var(var)) continue; clauses.push_back(equal_to_clone(st, func_name, var)); } goto_programt::targett pos=get_second_range(sketch).second; @@ -253,7 +253,7 @@ void create_refactoring_constraint(refactor_programt &prog) { symbol_tablet &st=prog.st; goto_functionst &gf=prog.gf; - for (const refactor_programt::sketcht &sketch : prog.sketches) + for(const refactor_programt::sketcht &sketch : prog.sketches) { goto_programt &body=get_body(gf, sketch.init); link_refactoring_ranges(body, sketch); diff --git a/src/cegis/refactor/environment/instrument_state_vars.cpp b/src/cegis/refactor/environment/instrument_state_vars.cpp index 89362222b23..176a47bb933 100644 --- a/src/cegis/refactor/environment/instrument_state_vars.cpp +++ b/src/cegis/refactor/environment/instrument_state_vars.cpp @@ -24,8 +24,8 @@ class var_findert: public const_expr_visitort virtual void operator()(const exprt &expr) { - if (ID_symbol != expr.id()) return; - if (ID_code == expr.type().id()) return; + if(ID_symbol != expr.id()) return; + if(ID_code == expr.type().id()) return; // TODO: Follow function calls vars.insert(to_symbol_expr(expr).get_identifier()); } @@ -36,7 +36,7 @@ void collect_state_vars(std::set &result, goto_programt::const_targett first, const goto_programt::const_targett last) { var_findert visitor(result); - for (; first != last; ++first) + for(; first != last; ++first) { first->code.visit(visitor); first->guard.visit(visitor); diff --git a/src/cegis/refactor/instructionset/cegis_instruction_factory.cpp b/src/cegis/refactor/instructionset/cegis_instruction_factory.cpp index e2597b2cc0e..9bf45fd9ec3 100644 --- a/src/cegis/refactor/instructionset/cegis_instruction_factory.cpp +++ b/src/cegis/refactor/instructionset/cegis_instruction_factory.cpp @@ -111,10 +111,10 @@ ordered_instructionst get_instructions_for_types( const cegis_operand_datat &signature) { ordered_instructionst result; - for (const cegis_operand_datat::value_type &typeWithSlots : signature) + for(const cegis_operand_datat::value_type &typeWithSlots : signature) { const typet &type=typeWithSlots.first; - if (!is_cegis_primitive(type)) continue; // TODO: Add support for class types + if(!is_cegis_primitive(type)) continue; // TODO: Add support for class types const arithmetic_instructionst arith(type); insert(result, arith.plus()); insert(result, arith.minus()); diff --git a/src/cegis/refactor/instructionset/cegis_processor_body_factory.cpp b/src/cegis/refactor/instructionset/cegis_processor_body_factory.cpp index a7ccb540296..06161aa4e1d 100644 --- a/src/cegis/refactor/instructionset/cegis_processor_body_factory.cpp +++ b/src/cegis/refactor/instructionset/cegis_processor_body_factory.cpp @@ -26,7 +26,7 @@ namespace { size_t cegis_max_operands(const typet &type) { - if (!is_cegis_primitive(type)) return 0; // TODO: Add support for class types + if(!is_cegis_primitive(type)) return 0; // TODO: Add support for class types return NUM_PRIMITIVE_OPERANDS; } } @@ -34,7 +34,7 @@ size_t cegis_max_operands(const typet &type) size_t cegis_max_operands(const cegis_operand_datat &slots) { size_t max=0; - for (const cegis_operand_datat::value_type &slot : slots) + for(const cegis_operand_datat::value_type &slot : slots) max=std::max(max, cegis_max_operands(slot.first)); return max; } @@ -101,7 +101,7 @@ class body_factoryt goto_programt::targett add_conditional_instr_goto(const size_t opcode, const irep_idt &relation) { - if (last == switch_end) + if(last == switch_end) { switch_end=body.insert_after(pos); switch_end->type=goto_program_instruction_typet::SKIP; @@ -113,7 +113,7 @@ class body_factoryt const constant_exprt rhs(from_integer(opcode, cegis_size_type())); const member_exprt lhs(cegis_opcode(st, func_name)); pos->guard=binary_relation_exprt(lhs, relation, rhs); - if (last != last_case) last_case->set_target(pos); + if(last != last_case) last_case->set_target(pos); last_case=pos; pos=body.insert_after(pos); pos->type=goto_program_instruction_typet::SKIP; @@ -172,7 +172,7 @@ class body_factoryt void finish_instruction_loop() { pos=std::prev(body.instructions.end(), 2); - while (goto_program_instruction_typet::DEAD == pos->type) + while(goto_program_instruction_typet::DEAD == pos->type) pos=std::prev(pos); const char * const base_idx_name=CEGIS_PROC_INSTR_INDEX; const std::string idx(meta_name(base_idx_name)); @@ -191,15 +191,15 @@ class body_factoryt void add_signature_assumptions() { size_t opcode=0; - for (const ordered_instructionst::value_type &entry : ordered_instructions) + for(const ordered_instructionst::value_type &entry : ordered_instructions) { const ordered_instructionst::value_type::second_type &instrs=entry.second; opcode+=instrs.size(); goto_programt::targett pos=add_conditional_instr_goto(opcode, ID_ge); const ordered_instructionst::value_type::first_type &sig=entry.first; - for (size_t op=0; op < sig.size(); ++op) + for(size_t op=0; op < sig.size(); ++op) { - if (SKIP != pos->type) pos=body.insert_after(pos); + if(SKIP != pos->type) pos=body.insert_after(pos); const cegis_operand_datat::const_iterator it=slots.find(sig[op]); assert(slots.end() != it); const member_exprt operand_id(cegis_operand_id(st, func_name, op)); @@ -213,8 +213,8 @@ class body_factoryt { const irep_idt id(ID_notequal); size_t opc=0; - for (const ordered_instructionst::value_type &entry : ordered_instructions) - for (const instruction_descriptiont &instr : entry.second) + for(const ordered_instructionst::value_type &entry : ordered_instructions) + for(const instruction_descriptiont &instr : entry.second) { const goto_programt::targett it=add_conditional_instr_goto(opc++, id); instr(st, func_name, body, it); @@ -228,7 +228,7 @@ void generate_processor_body(symbol_tablet &st, goto_programt &body, const std::string &name, const cegis_operand_datat &slots) { const ordered_instructionst instructions(get_instructions_for_types(slots)); - if (!slots.empty()) + if(!slots.empty()) { body_factoryt factory(slots, instructions, st, body, name); factory.declare_instruction_loop_head(); diff --git a/src/cegis/refactor/instructionset/create_cegis_processor.cpp b/src/cegis/refactor/instructionset/create_cegis_processor.cpp index 0d2d3cb54c1..5df7c1055a0 100644 --- a/src/cegis/refactor/instructionset/create_cegis_processor.cpp +++ b/src/cegis/refactor/instructionset/create_cegis_processor.cpp @@ -27,7 +27,7 @@ namespace bool is_empty(const typet &type) { const irep_idt &id=type.id(); - if (ID_pointer == id) return is_empty(type.subtype()); + if(ID_pointer == id) return is_empty(type.subtype()); return ID_empty == id || id.empty(); } @@ -41,7 +41,7 @@ class type_collectort: public const_expr_visitort virtual void operator()(const exprt &expr) { const typet &type=expr.type(); - if (ID_code != type.id() && !is_empty(type)) types.insert(expr.type()); + if(ID_code != type.id() && !is_empty(type)) types.insert(expr.type()); } }; } @@ -49,7 +49,7 @@ class type_collectort: public const_expr_visitort std::set collect_context_types(const goto_ranget &range) { type_collectort collector; - for (goto_programt::const_targett it(range.first); it != range.second; ++it) + for(goto_programt::const_targett it(range.first); it != range.second; ++it) it->code.visit(collector); return collector.types; } @@ -62,7 +62,7 @@ void create_variable_array(symbol_tablet &st, goto_functionst &gf, const typet &type, const size_t size) { const std::string name(cegis_operand_array_name(st, type)); - if (st.has_symbol(name)) return; + if(st.has_symbol(name)) return; const typet size_type(signed_int_type()); const constant_exprt sz_expr(from_integer(size, size_type)); const array_typet array_type(pointer_typet(type), sz_expr); @@ -94,10 +94,10 @@ void create_variable_array(symbol_tablet &st, goto_functionst &gf, std::string get_next_processor_name(const symbol_tablet &st) { std::string name(CEGIS_PROCESSOR_FUNCTION_PREFIX); - for (size_t index=0; index < MAX_PROCESSORS; ++index) + for(size_t index=0; index < MAX_PROCESSORS; ++index) { name+=std::to_string(index); - if (!st.has_symbol(name)) return name; + if(!st.has_symbol(name)) return name; else name= CEGIS_PROCESSOR_FUNCTION_PREFIX; } assert(!"Exceeded maximum number of CEGIS processors."); @@ -110,7 +110,7 @@ symbol_typet create_instruction_type(symbol_tablet &st, { std::string instr_type_name(func_name); instr_type_name+= INSTR_TYPE_SUFFIX; - if (st.has_symbol(instr_type_name)) return symbol_typet(instr_type_name); + if(st.has_symbol(instr_type_name)) return symbol_typet(instr_type_name); struct_typet type; std::string tag(TAG_PREFIX); tag+=instr_type_name; @@ -121,7 +121,7 @@ symbol_typet create_instruction_type(symbol_tablet &st, comps.push_back(struct_typet::componentt(member_name, opcode_type)); const size_t max_operands=cegis_max_operands(variable_slots_per_context_type); const typet op_type(cegis_operand_type()); - for (size_t i=0; i < max_operands; ++i) + for(size_t i=0; i < max_operands; ++i) { struct_union_typet::componentt comp(cegis_operand_base_name(i), op_type); comps.push_back(comp); @@ -178,7 +178,7 @@ void add_param(symbol_tablet &st, const std::string &func, void add_to_symbol_table(symbol_tablet &st, const std::string &name, const goto_functionst::function_mapt::mapped_type &func) { - if (st.has_symbol(name)) return; + if(st.has_symbol(name)) return; symbolt new_symbol; new_symbol.name=name; new_symbol.type=func.type; @@ -198,7 +198,7 @@ void add_to_symbol_table(symbol_tablet &st, const std::string &name, std::string create_cegis_processor(symbol_tablet &st, goto_functionst &gf, const cegis_operand_datat &slots) { - for (const std::pair &var_slot : slots) + for(const std::pair &var_slot : slots) create_variable_array(st, gf, var_slot.first, var_slot.second); const std::string func_name(get_next_processor_name(st)); const symbol_typet instr_type(create_instruction_type(st, slots, func_name)); diff --git a/src/cegis/refactor/instructionset/execute_cegis_program.cpp b/src/cegis/refactor/instructionset/execute_cegis_program.cpp index 663ddcb8b20..cdf64d359ba 100644 --- a/src/cegis/refactor/instructionset/execute_cegis_program.cpp +++ b/src/cegis/refactor/instructionset/execute_cegis_program.cpp @@ -76,16 +76,16 @@ goto_programt::targett call_processor(const symbol_tablet &st, void set_cegis_processor_sizes(symbol_tablet &st, const size_t size) { const constant_exprt sz_expr(from_integer(size, signed_int_type())); - for (symbol_tablet::symbolst::value_type &entry : st.symbols) + for(symbol_tablet::symbolst::value_type &entry : st.symbols) { typet &type=entry.second.type; - if (ID_array != type.id()) continue; + if(ID_array != type.id()) continue; array_typet &array_type=to_array_type(type); const typet &elem_type=array_type.subtype(); - if (ID_symbol != elem_type.id()) continue; + if(ID_symbol != elem_type.id()) continue; const symbol_typet &symbol_type=to_symbol_type(elem_type); const std::string &type_name=id2string(symbol_type.get_identifier()); - if (ends_with(type_name, INSTR_TYPE_SUFFIX)) array_type.size()=sz_expr; + if(ends_with(type_name, INSTR_TYPE_SUFFIX)) array_type.size()=sz_expr; } } @@ -96,24 +96,24 @@ void set_cegis_processor_sizes(const symbol_tablet &st, const size_t size) { const constant_exprt sz_expr(from_integer(size, cegis_size_type())); - for (; first != last; ++first) + for(; first != last; ++first) { - if (goto_program_instruction_typet::FUNCTION_CALL != first->type) continue; + if(goto_program_instruction_typet::FUNCTION_CALL != first->type) continue; code_function_callt &call=to_code_function_call(first->code); const exprt &func=call.function(); - if (ID_symbol != func.id()) continue; + if(ID_symbol != func.id()) continue; const irep_idt &func_name=to_symbol_expr(func).get_identifier(); - if (!st.has_symbol(func_name)) continue; + if(!st.has_symbol(func_name)) continue; const symbolt &symbol=st.lookup(func_name); const code_typet &code_type=to_code_type(symbol.type); const code_typet::parameterst ¶ms=code_type.parameters(); - if (params.size() != NUM_PROC_CALL_ARGS) continue; + if(params.size() != NUM_PROC_CALL_ARGS) continue; const typet ¶m_ptr_type=params.front().type(); - if (ID_pointer != param_ptr_type.id()) continue; + if(ID_pointer != param_ptr_type.id()) continue; const typet ¶m_type=param_ptr_type.subtype(); - if (ID_symbol != param_type.id()) continue; + if(ID_symbol != param_type.id()) continue; const irep_idt ¶m_id=to_symbol_type(param_type).get_identifier(); - if (!ends_with(id2string(param_id), INSTR_TYPE_SUFFIX)) continue; + if(!ends_with(id2string(param_id), INSTR_TYPE_SUFFIX)) continue; assert(call.arguments().size() == NUM_PROC_CALL_ARGS); call.arguments().back()=sz_expr; } diff --git a/src/cegis/refactor/learn/instrument_counterexamples.cpp b/src/cegis/refactor/learn/instrument_counterexamples.cpp index 4e6051f8283..0dd6b24e1d1 100644 --- a/src/cegis/refactor/learn/instrument_counterexamples.cpp +++ b/src/cegis/refactor/learn/instrument_counterexamples.cpp @@ -27,7 +27,7 @@ goto_programt::targetst unify( const refactor_programt::counterexample_locationst &locs) { goto_programt::targetst result; - for (const refactor_programt::counterexample_locationst::value_type &entry : locs) + for(const refactor_programt::counterexample_locationst::value_type &entry : locs) { const goto_programt::targetst &rhs=entry.second; std::copy(rhs.begin(), rhs.end(), std::back_inserter(result)); @@ -39,7 +39,7 @@ std::set get_all_keys( const refactor_programt::counterexample_locationst &locs) { std::set keys; - for (const refactor_programt::counterexample_locationst::value_type &entry : locs) + for(const refactor_programt::counterexample_locationst::value_type &entry : locs) { const goto_programt::targetst &rhs=entry.second; std::transform(rhs.begin(), rhs.end(), std::inserter(keys, keys.begin()), @@ -52,12 +52,12 @@ std::set get_all_keys( void create_ce_arrays(symbol_tablet &st, goto_functionst &gf, const labelled_counterexamplest &ces) { - if (ces.empty()) return; + if(ces.empty()) return; const typet sz_type(signed_int_type()); const constant_exprt sz_expr(from_integer(ces.size(), sz_type)); const array_valuest array_values(get_array_values(ces)); const labelled_counterexamplest::value_type &prototype=ces.front(); - for (const labelled_counterexamplest::value_type::value_type &value : prototype) + for(const labelled_counterexamplest::value_type::value_type &value : prototype) { const labelled_assignmentst::value_type::first_type loc_id=value.first; const array_valuest::const_iterator array_val=array_values.find(loc_id); @@ -80,7 +80,7 @@ void create_ce_array_indexes(const std::set &ce_keys, pos=init; const source_locationt &loc=pos->source_location; const irep_idt &function=pos->function; - for (const irep_idt &key : ce_keys) + for(const irep_idt &key : ce_keys) { const std::string name(get_ce_value_index_name(key)); declare_global_meta_variable(st, name, zero.type()); @@ -126,13 +126,13 @@ const index_exprt get_array_val_expr(const symbol_tablet &st, void assign_ce_values(symbol_tablet &st, goto_functionst &gf, const refactor_programt::counterexample_locationst &ce_locs) { - for (const refactor_programt::counterexample_locationst::value_type ce_loc : ce_locs) + for(const refactor_programt::counterexample_locationst::value_type ce_loc : ce_locs) { - for (goto_programt::targett pos : ce_loc.second) + for(goto_programt::targett pos : ce_loc.second) { const irep_idt &label=get_counterexample_marker(pos); const index_exprt value(get_array_val_expr(st, label)); - switch (pos->type) + switch(pos->type) { case ASSIGN: to_code_assign(pos->code).rhs()=value; diff --git a/src/cegis/refactor/learn/refactor_candidate_printer.cpp b/src/cegis/refactor/learn/refactor_candidate_printer.cpp index 44a88be1cd9..2e0b215dee8 100644 --- a/src/cegis/refactor/learn/refactor_candidate_printer.cpp +++ b/src/cegis/refactor/learn/refactor_candidate_printer.cpp @@ -23,7 +23,7 @@ namespace bool matches_opcode(const goto_programt::instructiont &instr, const mp_integer &opcode) { - if (!instr.is_goto() || ID_notequal != instr.guard.id()) return false; + if(!instr.is_goto() || ID_notequal != instr.guard.id()) return false; const notequal_exprt &guard=to_notequal_expr(instr.guard); return opcode == bv_arithmetict(guard.rhs()).to_integer(); } @@ -44,10 +44,10 @@ void print_instr(messaget::mstreamt &os, const namespacet &ns, { return matches_opcode(instr, opcode);})); const goto_programt::const_targett last=std::find_if(first, end, std::mem_fun_ref(&goto_programt::instructiont::is_goto)); - for (; first != last; ++first) + for(; first != last; ++first) body.output_instruction(ns, func_name, oss, first); std::string result(oss.str()); - for (size_t i=1; i < ops.size(); ++i) + for(size_t i=1; i < ops.size(); ++i) { std::string nd("*__CPROVER_cegis_variable_array_double[(program + i)->op_"); nd+=std::to_string(i - 1); @@ -66,7 +66,7 @@ void print_program(messaget::mstreamt &os, const namespacet &ns, os << " " << messaget::endl; os << " " << func_name << "" << messaget::endl; os << " " << messaget::endl; - for (const exprt &instr : prog.second.operands()) + for(const exprt &instr : prog.second.operands()) print_instr(os, ns, body, func_name, to_struct_expr(instr)); os << " " << messaget::endl; os << " " << messaget::endl; @@ -79,7 +79,7 @@ void print_refactor_candidate(messaget::mstreamt &os, const symbol_tablet &st, os << "" << messaget::endl; const namespacet ns(st); const goto_functionst::function_mapt &fmap=gf.function_map; - for (const refactor_solutiont::value_type &entry : candidate) + for(const refactor_solutiont::value_type &entry : candidate) { std::string func(id2string(entry.first)); remove_suffix(func, CEGIS_REFACTOR_PROG_SUFFIX); diff --git a/src/cegis/refactor/learn/refactor_symex_learn.cpp b/src/cegis/refactor/learn/refactor_symex_learn.cpp index 98d6cce1807..57e7618dd71 100644 --- a/src/cegis/refactor/learn/refactor_symex_learn.cpp +++ b/src/cegis/refactor/learn/refactor_symex_learn.cpp @@ -32,7 +32,7 @@ void refactor_symex_learnt::process(const counterexamplest &counterexamples, current_program=original_program; symbol_tablet &st=current_program.st; goto_functionst &gf=current_program.gf; - for (const irep_idt &program : current_program.programs) + for(const irep_idt &program : current_program.programs) { symbolt &symbol=st.lookup(program); assign_in_cprover_init(gf, symbol, side_effect_expr_nondett(symbol.type)); @@ -71,11 +71,11 @@ class handle_assignt void operator()(const goto_trace_stept &step) const { - if (!step.is_assignment()) return; + if(!step.is_assignment()) return; const std::string &v=id2string(step.lhs_object.get_identifier()); const auto it=std::find_if(progs.begin(), progs.end(), std::bind(starts_with, v, std::bind(id2string, std::placeholders::_1))); - if (progs.end() == it || !ends_with(v, CEGIS_REFACTOR_PROG_SUFFIX)) return; + if(progs.end() == it || !ends_with(v, CEGIS_REFACTOR_PROG_SUFFIX)) return; const array_exprt &value=to_array_expr(step.full_lhs_value); assert(candidate.insert(std::make_pair(v, value)).second); } diff --git a/src/cegis/refactor/nullobject/nullable_analysis.cpp b/src/cegis/refactor/nullobject/nullable_analysis.cpp index c961a007980..6bf4166d137 100644 --- a/src/cegis/refactor/nullobject/nullable_analysis.cpp +++ b/src/cegis/refactor/nullobject/nullable_analysis.cpp @@ -27,9 +27,9 @@ std::set get_nullable_classes( const refactor_programt::sketcht::typest &types) { std::set result; - for (const typet &type : types) + for(const typet &type : types) { - if (!type.get_bool(CEGIS_NULLED_TYPE_ID)) continue; + if(!type.get_bool(CEGIS_NULLED_TYPE_ID)) continue; const typet &class_type=to_pointer_type(type).subtype(); result.insert(to_symbol_type(class_type).get_identifier()); } @@ -54,18 +54,18 @@ std::set get_nullable_methods(const refactor_programt &prog) { const symbol_tablet::symbolst &symbols=prog.st.symbols; std::set nullable_methods; - for (const refactor_programt::sketcht &sketch : prog.sketches) + for(const refactor_programt::sketcht &sketch : prog.sketches) { const refactor_programt::sketcht::typest &types=sketch.types; const std::set null_cls(get_nullable_classes(types)); - for (const typet &type : types) - if (type.get_bool(CEGIS_NULLED_TYPE_ID)) - for (const symbol_tablet::symbolst::value_type &entry : symbols) + for(const typet &type : types) + if(type.get_bool(CEGIS_NULLED_TYPE_ID)) + for(const symbol_tablet::symbolst::value_type &entry : symbols) { const symbolt &symbol=entry.second; - if (ID_code != symbol.type.id()) continue; + if(ID_code != symbol.type.id()) continue; const irep_idt &name=entry.first; - if (is_member_of_any(null_cls.begin(), null_cls.end(), name)) + if(is_member_of_any(null_cls.begin(), null_cls.end(), name)) nullable_methods.insert(name); } } @@ -77,7 +77,7 @@ cegis_operand_datat slots_per_type(const symbol_tablet &st, { const namespacet ns(st); cegis_operand_datat result; - for (const irep_idt &state_var : state_vars) + for(const irep_idt &state_var : state_vars) ++result[ns.follow(st.lookup(state_var).type)]; return result; } @@ -96,8 +96,8 @@ cegis_operand_datat get_operand_signature(const symbol_tablet &st, cegis_operand_datat result; const code_typet &code_type=to_code_type(st.lookup(method).type); const std::string ret_val_name(get_return_value_name(method)); - if (st.has_symbol(ret_val_name)) result[st.lookup(ret_val_name).type]=1; - for (const code_typet::parameterst::value_type ¶m : code_type.parameters()) + if(st.has_symbol(ret_val_name)) result[st.lookup(ret_val_name).type]=1; + for(const code_typet::parameterst::value_type ¶m : code_type.parameters()) ++result[param.type()]; return result; } @@ -107,9 +107,9 @@ namespace bool calls_method(const goto_programt::instructiont &instr, const irep_idt &method) { - if (goto_program_instruction_typet::FUNCTION_CALL != instr.type) return false; + if(goto_program_instruction_typet::FUNCTION_CALL != instr.type) return false; const exprt &func=to_code_function_call(instr.code).function(); - if (ID_symbol != func.id()) return false; + if(ID_symbol != func.id()) return false; return method == to_symbol_expr(func).get_identifier(); } @@ -123,7 +123,7 @@ std::vector prepare_ops(symbol_tablet &st, const goto_functionst &gf, assert(fmap.end() != it); std::vector result; const std::string ret_val_name(get_return_value_name(method)); - if (st.has_symbol(ret_val_name)) result.push_back(ret_val_name); + if(st.has_symbol(ret_val_name)) result.push_back(ret_val_name); const code_function_callt &call=to_code_function_call(first->code); const symbol_exprt &func=to_symbol_expr(call.function()); const code_function_callt::argumentst &args=call.arguments(); @@ -133,11 +133,11 @@ std::vector prepare_ops(symbol_tablet &st, const goto_functionst &gf, assert(size == params.size()); const source_locationt &loc=first->source_location; goto_programt::targett pos=first; - for (size_t i=0; i < size; ++i) - if (!params[i].get_this()) + for(size_t i=0; i < size; ++i) + if(!params[i].get_this()) { const symbolt &lhs=st.lookup(params[i].get_identifier()); - if (first == pos) + if(first == pos) { pos=insert_before_preserve_labels(body, pos); pos->source_location=loc; @@ -157,15 +157,15 @@ void replace_method_call_by_processor(symbol_tablet &st, goto_functionst &gf, { // TODO: Find topmost class for "method" to uniquely identify it. goto_programt &body=get_body(gf, first); - for (; first != last; ++first) - if (calls_method(*first, meth)) + for(; first != last; ++first) + if(calls_method(*first, meth)) { const std::vector ops(prepare_ops(st, gf, meth, body, first)); - if (!ops.empty()) + if(!ops.empty()) { goto_programt::targett pos=insert_before_preserve_labels(body, first); instrument_cegis_operand(st, *pos, 0, ops.front()); - for (size_t i=1; i < ops.size(); ++i) + for(size_t i=1; i < ops.size(); ++i) pos=instrument_cegis_operand(st, body, pos, i, ops[i]); } call_processor(st, *first, processor, prog); diff --git a/src/cegis/refactor/nullobject/range_collector.cpp b/src/cegis/refactor/nullobject/range_collector.cpp index 01f76a5fdc0..f0e54e12341 100644 --- a/src/cegis/refactor/nullobject/range_collector.cpp +++ b/src/cegis/refactor/nullobject/range_collector.cpp @@ -16,7 +16,7 @@ namespace { bool is_null(const exprt &expr) { - if (ID_constant != expr.id()) return false; + if(ID_constant != expr.id()) return false; return ID_NULL == to_constant_expr(expr).get_value(); } @@ -27,7 +27,7 @@ class is_null_comparisont private: bool extract_nulled_type(const exprt &operand) { - if (ID_typecast == operand.id()) + if(ID_typecast == operand.id()) return extract_nulled_type(to_typecast_expr(operand).op()); nulled_type=to_pointer_type(to_symbol_expr(operand).type()); return true; @@ -36,12 +36,12 @@ class is_null_comparisont bool operator()(const exprt &guard) { const irep_idt &id=guard.id(); - if (ID_equal != id && ID_notequal != id) return false; + if(ID_equal != id && ID_notequal != id) return false; const binary_relation_exprt &binary=to_binary_relation_expr(guard); const exprt &lhs=binary.lhs(); const exprt &rhs=binary.rhs(); - if (is_null(lhs)) return extract_nulled_type(rhs); - else if (is_null(rhs)) return extract_nulled_type(lhs); + if(is_null(lhs)) return extract_nulled_type(rhs); + else if(is_null(rhs)) return extract_nulled_type(lhs); return false; } }; @@ -50,7 +50,7 @@ goto_ranget get_then_range(const goto_programt::targett &else_range_last) { const goto_programt::targett then_range_first(else_range_last); const goto_programt::targett last_else_instr(std::prev(else_range_last)); - if (GOTO != last_else_instr->type) + if(GOTO != last_else_instr->type) return goto_ranget(then_range_first, then_range_first); return goto_ranget(then_range_first, last_else_instr->get_target()); } @@ -58,7 +58,7 @@ goto_ranget get_then_range(const goto_programt::targett &else_range_last) goto_programt::targett get_else_range_last(const goto_programt::targett pos) { const goto_programt::targett prev=std::prev(pos); - if (goto_program_instruction_typet::GOTO != prev->type + if(goto_program_instruction_typet::GOTO != prev->type || prev->is_backwards_goto()) return pos; return prev; } @@ -66,12 +66,12 @@ goto_programt::targett get_else_range_last(const goto_programt::targett pos) void collect_nullobject_ranges(refactor_programt &prog) { - for (instr_iteratort it(prog.gf); it != instr_iteratort::end; ++it) + for(instr_iteratort it(prog.gf); it != instr_iteratort::end; ++it) { - if (goto_program_instruction_typet::GOTO != it->type) continue; + if(goto_program_instruction_typet::GOTO != it->type) continue; const exprt &guard=it->guard; is_null_comparisont is_null_comparison; - if (!is_null_comparison(guard)) continue; + if(!is_null_comparison(guard)) continue; prog.sketches.push_back(refactor_programt::sketcht()); refactor_programt::sketcht &sketch=prog.sketches.back(); sketch.init=it; @@ -79,7 +79,7 @@ void collect_nullobject_ranges(refactor_programt &prog) const goto_programt::targett else_last=get_else_range_last(then_target); const goto_ranget else_range(++it, else_last); const goto_ranget then_range(get_then_range(then_target)); - if (ID_equal == guard.id()) + if(ID_equal == guard.id()) { sketch.spec_range=then_range; sketch.input_range=else_range; diff --git a/src/cegis/refactor/options/refactor_program.cpp b/src/cegis/refactor/options/refactor_program.cpp index c58f17d84a0..0a20f6f6394 100644 --- a/src/cegis/refactor/options/refactor_program.cpp +++ b/src/cegis/refactor/options/refactor_program.cpp @@ -33,7 +33,7 @@ class copy_targett goto_programt::targett operator()(const goto_programt::targett rhs) const { const goto_programt::targett empty; - if (empty == rhs) return empty; + if(empty == rhs) return empty; const std::string &function=id2string(rhs->function); goto_programt &lhs_body=get_body(lhs_func, function); const goto_programt &rhs_body=get_body(rhs_func, function); @@ -69,10 +69,10 @@ refactor_programt ©(refactor_programt &lhs, const refactor_programt &rhs) lhs.gf.copy_from(rhs.gf); const copy_targett copy(lhs.gf, rhs.gf); lhs.counterexample_locations.clear(); - for (const refactor_programt::counterexample_locationst::value_type &entry : rhs.counterexample_locations) + for(const refactor_programt::counterexample_locationst::value_type &entry : rhs.counterexample_locations) copy(lhs.counterexample_locations[entry.first], entry.second); lhs.sketches.resize(rhs.sketches.size()); - for (size_t i=0; i < lhs.sketches.size(); ++i) + for(size_t i=0; i < lhs.sketches.size(); ++i) ::copy(copy, lhs.sketches[i], rhs.sketches[i]); lhs.programs=rhs.programs; return lhs; diff --git a/src/cegis/refactor/options/refactoring_type.cpp b/src/cegis/refactor/options/refactoring_type.cpp index 101c8d6980d..834fe47357a 100644 --- a/src/cegis/refactor/options/refactoring_type.cpp +++ b/src/cegis/refactor/options/refactoring_type.cpp @@ -16,7 +16,7 @@ Author: Daniel Kroening, kroening@kroening.com refactoring_typet get_refactoring_type(const class optionst &options) { - if (options.get_bool_option(CEGIS_NULL_OBJECT_REFACTOR)) + if(options.get_bool_option(CEGIS_NULL_OBJECT_REFACTOR)) return refactoring_typet::NULL_OBJECT; assert(!"Invalid refactoring type selected."); } diff --git a/src/cegis/refactor/preprocessing/collect_counterexamples.cpp b/src/cegis/refactor/preprocessing/collect_counterexamples.cpp index d9d7a5cd41f..58d4bd32b8d 100644 --- a/src/cegis/refactor/preprocessing/collect_counterexamples.cpp +++ b/src/cegis/refactor/preprocessing/collect_counterexamples.cpp @@ -24,10 +24,10 @@ void collect_counterexamples(refactor_programt &prog) refactor_programt::counterexample_locationst &ls=prog.counterexample_locations; typedef goto_functionst::function_mapt fmapt; size_t idx=0; - for (fmapt::value_type &entry : prog.gf.function_map) + for(fmapt::value_type &entry : prog.gf.function_map) { fmapt::value_type::second_type &func=entry.second; - if (!func.body_available()) continue; + if(!func.body_available()) continue; goto_programt::targetst &ce_locs=ls[entry.first]; idx=collect_counterexample_locations(ce_locs, func.body, is_meta, idx); } diff --git a/src/cegis/refactor/preprocessing/refactor_preprocessing.cpp b/src/cegis/refactor/preprocessing/refactor_preprocessing.cpp index b5b6f3d0d5b..9177d1462a1 100644 --- a/src/cegis/refactor/preprocessing/refactor_preprocessing.cpp +++ b/src/cegis/refactor/preprocessing/refactor_preprocessing.cpp @@ -35,29 +35,29 @@ void refactor_preprocessingt::operator()() symbol_tablet &st=original_program.st; goto_functionst &gf=original_program.gf; const refactoring_typet type(get_refactoring_type(options)); - switch (type) + switch(type) { case refactoring_typet::NULL_OBJECT: collect_nullobject_ranges(original_program); break; } create_constraint_function_caller(original_program); - for (refactor_programt::sketcht &s : original_program.sketches) + for(refactor_programt::sketcht &s : original_program.sketches) { collect_state_vars(s.state_vars, s.spec_range.first, s.spec_range.second); collect_state_vars(s.state_vars, s.input_range.first, s.input_range.second); } - switch (type) + switch(type) { case refactoring_typet::NULL_OBJECT: const std::set null_meths(get_nullable_methods(original_program)); - for (const irep_idt &m : null_meths) + for(const irep_idt &m : null_meths) { const cegis_operand_datat op_data(get_operand_signature(st, m)); const std::string proc(create_cegis_processor(st, gf, op_data)); const std::string prog(declare_cegis_program(st, gf, proc)); original_program.programs.insert(prog); - for (refactor_programt::sketcht &s : original_program.sketches) + for(refactor_programt::sketcht &s : original_program.sketches) { const goto_programt::targett first=s.input_range.first; const goto_programt::targett last=s.input_range.second; @@ -84,7 +84,7 @@ void refactor_preprocessingt::operator()(const size_t max_length) current_program=original_program; symbol_tablet &st=current_program.st; set_cegis_processor_sizes(st, max_length); - for (const refactor_programt::sketcht &sketch : current_program.sketches) + for(const refactor_programt::sketcht &sketch : current_program.sketches) { set_cegis_processor_sizes(st, sketch.input_range, max_length); set_cegis_processor_sizes(st, sketch.spec_range, max_length); diff --git a/src/cegis/refactor/verify/refactor_symex_verify.cpp b/src/cegis/refactor/verify/refactor_symex_verify.cpp index 4586b00acaf..3d2655b1943 100644 --- a/src/cegis/refactor/verify/refactor_symex_verify.cpp +++ b/src/cegis/refactor/verify/refactor_symex_verify.cpp @@ -28,11 +28,11 @@ void refactor_symex_verifyt::process(const candidatet &candidate) symbol_tablet &st=current_program.st; goto_functionst &gf=current_program.gf; const namespacet ns(st); - for (const irep_idt &program : current_program.programs) + for(const irep_idt &program : current_program.programs) { symbolt &symbol=st.lookup(program); const candidatet::const_iterator it=candidate.find(program); - if (candidate.end() == it) + if(candidate.end() == it) { const exprt zero(zero_initializer(symbol.type, symbol.location, ns)); assign_in_cprover_init(gf, symbol, zero); diff --git a/src/cegis/runner/cegis_parse_options.cpp b/src/cegis/runner/cegis_parse_options.cpp index ce4b833d9c0..263dfa31c50 100644 --- a/src/cegis/runner/cegis_parse_options.cpp +++ b/src/cegis/runner/cegis_parse_options.cpp @@ -43,7 +43,7 @@ namespace void set_integer_option(optionst &opt, const cmdlinet &cmd, const char * const name, const unsigned int default_value) { - if (!cmd.isset(name)) return opt.set_option(name, default_value); + if(!cmd.isset(name)) return opt.set_option(name, default_value); const std::string text_value(cmd.get_value(name)); const mp_integer::ullong_t value=string2integer(text_value).to_ulong(); opt.set_option(name, static_cast(value)); @@ -69,7 +69,7 @@ void cegis_parse_optionst::get_command_line_options(optionst &options) const bool configure_cegis=cmdline.isset("danger") || cmdline.isset("safety") || cmdline.isset("jsa") || cmdline.isset(CEGIS_CONTROL) || cmdline.isset(CEGIS_REFACTOR); - if (configure_cegis) + if(configure_cegis) { set_integer_option(options, cmdline, "cegis-min-size", 1u); set_integer_option(options, cmdline, "cegis-max-size", 5u); @@ -112,15 +112,15 @@ int cegis_parse_optionst::do_bmc( optionst options; get_command_line_options(options); - if (cmdline.isset("danger")) + if(cmdline.isset("danger")) return run_danger(options, result(), symbol_table, goto_functions); - if (cmdline.isset("safety")) + if(cmdline.isset("safety")) return run_safety(options, result(), symbol_table, goto_functions); - if (cmdline.isset("jsa")) + if(cmdline.isset("jsa")) return run_jsa(options, result(), symbol_table, goto_functions); - if (cmdline.isset(CEGIS_CONTROL)) + if(cmdline.isset(CEGIS_CONTROL)) return run_control(options, result(), symbol_table, goto_functions); - if (cmdline.isset(CEGIS_REFACTOR)) + if(cmdline.isset(CEGIS_REFACTOR)) return run_refactor(options, result(), symbol_table, goto_functions); return cbmc_parse_optionst::do_bmc(bmc, goto_functions); diff --git a/src/cegis/safety/constraint/safety_constraint_factory.cpp b/src/cegis/safety/constraint/safety_constraint_factory.cpp index b05fc243d06..eb6554a9546 100644 --- a/src/cegis/safety/constraint/safety_constraint_factory.cpp +++ b/src/cegis/safety/constraint/safety_constraint_factory.cpp @@ -44,7 +44,7 @@ exprt create_safety_constraint(const size_t number_of_loops) const notequal_exprt A_x(as_bool(get_Ax())); and_exprt root; root.copy_to_operands(as_bool(get_Ix0())); - for (size_t i=0; i < number_of_loops; ++i) + for(size_t i=0; i < number_of_loops; ++i) { const notequal_exprt S0_x(as_bool(get_Ix(i))); const notequal_exprt G0_x(as_bool(get_Gx(i))); diff --git a/src/cegis/safety/facade/safety_runner.cpp b/src/cegis/safety/facade/safety_runner.cpp index cf4656341c3..236bdb159ee 100644 --- a/src/cegis/safety/facade/safety_runner.cpp +++ b/src/cegis/safety/facade/safety_runner.cpp @@ -58,7 +58,7 @@ int configure_ui_and_run(mstreamt &os, const optionst &opt, learnt &learn, { null_seedt seed; const size_t max_prog_size=opt.get_unsigned_int_option(CEGIS_MAX_SIZE); - if (!opt.get_bool_option(CEGIS_STATISTICS)) + if(!opt.get_bool_option(CEGIS_STATISTICS)) return run_cegis(learn, verify, preproc, seed, max_prog_size, os); cegis_statistics_wrappert stat(learn, verify, os, opt); return run_cegis(stat, stat, preproc, seed, max_prog_size, os); @@ -68,7 +68,7 @@ template int configure_backend(mstreamt &os, const optionst &o, const safety_programt &prog, learnt &cfg, verifyt &verify, prept &prep) { - if (!o.get_bool_option(CEGIS_GENETIC)) + if(!o.get_bool_option(CEGIS_GENETIC)) { cegis_symex_learnt learn(o, prep, cfg); return configure_ui_and_run(os, o, learn, verify, prep); @@ -96,7 +96,7 @@ int configure_backend(mstreamt &os, const optionst &o, random_mutatet mutate(rnd, lazy.num_consts_provder()); random_crosst cross(rnd); const size_t symex_head_start=o.get_unsigned_int_option(CEGIS_SYMEX_HEAD_START); - if (o.get_bool_option(CEGIS_MATCH_SELECT)) + if(o.get_bool_option(CEGIS_MATCH_SELECT)) { typedef match_selectt selectt; selectt select(fit.get_test_case_data(), rnd, rounds); @@ -105,7 +105,7 @@ int configure_backend(mstreamt &os, const optionst &o, safety_goto_cet>, safety_fitness_configt> ga_learnt; ga_learnt ga_learn(o, rnd, select, mutate, cross, fit, safety_fitness_config); #ifndef _WIN32 - if (!o.get_bool_option(CEGIS_GENETIC_ONLY)) + if(!o.get_bool_option(CEGIS_GENETIC_ONLY)) { const individual_to_safety_solution_deserialisert deser(prog, info_fac); concurrent_learnt learner(ga_learn, learn, @@ -122,7 +122,7 @@ int configure_backend(mstreamt &os, const optionst &o, safety_goto_cet>, safety_fitness_configt> ga_learnt; ga_learnt ga_learn(o, rnd, select, mutate, cross, fit, safety_fitness_config); #ifndef _WIN32 - if (!o.get_bool_option(CEGIS_GENETIC_ONLY)) + if(!o.get_bool_option(CEGIS_GENETIC_ONLY)) { const individual_to_safety_solution_deserialisert deser(prog, info_fac); concurrent_learnt learner(ga_learn, learn, @@ -135,7 +135,7 @@ int configure_backend(mstreamt &os, const optionst &o, constant_strategyt get_constant_strategy(const optionst &opt) { - if (opt.get_bool_option(CEGIS_GENETIC)) return genetic_constant_strategy; + if(opt.get_bool_option(CEGIS_GENETIC)) return genetic_constant_strategy; return default_constant_strategy; } } diff --git a/src/cegis/safety/genetic/dynamic_safety_test_runner.cpp b/src/cegis/safety/genetic/dynamic_safety_test_runner.cpp index 24a5f8df24a..8cdde344803 100644 --- a/src/cegis/safety/genetic/dynamic_safety_test_runner.cpp +++ b/src/cegis/safety/genetic/dynamic_safety_test_runner.cpp @@ -56,7 +56,7 @@ void dynamic_safety_test_runnert::run_test(individualt &ind, const int argc=args.size(); std::vector argv; argv.resize(argc); - for (int i=0; i < argc; ++i) + for(int i=0; i < argc; ++i) argv[i]=args[i]; on_complete(EXIT_SUCCESS == fitness_tester(argv.data())); diff --git a/src/cegis/safety/options/safety_program_printer.cpp b/src/cegis/safety/options/safety_program_printer.cpp index efd3aa82699..898479edfb1 100644 --- a/src/cegis/safety/options/safety_program_printer.cpp +++ b/src/cegis/safety/options/safety_program_printer.cpp @@ -32,7 +32,7 @@ class program_printert void operator()(const goto_programt::instructionst &prog) { os << "Invariant " << func_count++ << ": " << messaget::endl; - for (goto_programt::const_targett it=prog.begin(); it != prog.end(); ++it) + for(goto_programt::const_targett it=prog.begin(); it != prog.end(); ++it) body_printer.output_instruction(ns, "", os, it); } }; diff --git a/src/cegis/safety/preprocessing/safety_preprocessing.cpp b/src/cegis/safety/preprocessing/safety_preprocessing.cpp index de96e76096a..11ce7386ba4 100644 --- a/src/cegis/safety/preprocessing/safety_preprocessing.cpp +++ b/src/cegis/safety/preprocessing/safety_preprocessing.cpp @@ -43,7 +43,7 @@ namespace { void add_choice_labels(const goto_programt::targetst &choices, size_t offset=0) { - for (const goto_programt::targett &choice : choices) + for(const goto_programt::targett &choice : choices) { goto_programt::instructiont::labelst &labels=choice->labels; std::string label(DANGER_CE_QUANTIFIER_LABEL_PREFIX); @@ -56,7 +56,7 @@ void add_skolem_labels(const invariant_programt &prog) { size_t offset=0; const invariant_programt::const_invariant_loopst loops(prog.get_loops()); - for (const invariant_programt::invariant_loopt * const loop : loops) + for(const invariant_programt::invariant_loopt * const loop : loops) { add_choice_labels(loop->skolem_choices, offset); offset+=loop->skolem_choices.size(); diff --git a/src/cegis/safety/symex/fitness/safety_fitness_config.cpp b/src/cegis/safety/symex/fitness/safety_fitness_config.cpp index 1622eb7010d..e000fa967c1 100644 --- a/src/cegis/safety/symex/fitness/safety_fitness_config.cpp +++ b/src/cegis/safety/symex/fitness/safety_fitness_config.cpp @@ -52,7 +52,7 @@ void fix_quantifiers(const safety_programt &org_prog, safety_programt &new_prog, goto_programt::targett new_off=new_prog.safety_loops.front().meta_variables.Ix; --new_off; goto_programt::targett::difference_type diff; - for (goto_programt::targett &q : quantifiers) + for(goto_programt::targett &q : quantifiers) { diff=std::distance(org_off, static_cast(q)); q=new_off; @@ -63,7 +63,7 @@ void fix_quantifiers(const safety_programt &org_prog, safety_programt &new_prog, void safety_fitness_configt::set_candidate(const candidatet &candidate) { - if (!constraint_inserted) + if(!constraint_inserted) { program_with_constraint=original_program; invariant_insert_constraint(original_quantifiers, program_with_constraint, @@ -79,19 +79,19 @@ void safety_fitness_configt::set_candidate(const candidatet &candidate) void safety_fitness_configt::set_test_case(const counterexamplet &ce) { - if (quantifiers.empty()) return; + if(quantifiers.empty()) return; goto_functionst &gf=program.gf; // TODO: Implement for multiple loops (change constraint, instrumentation) const counterexamplet::assignmentst &ass=ce.x.back(); typedef counterexamplet::assignmentst counterexamplet; - for (goto_programt::targett quantifier : quantifiers) + for(goto_programt::targett quantifier : quantifiers) { const irep_idt &var=get_affected_variable(*quantifier); const counterexamplet::const_iterator it=ass.find(var); - if (ass.end() == it) continue; + if(ass.end() == it) continue; symbol_tablet &st=program.st; - if (program_contains_ce) + if(program_contains_ce) { goto_programt::targett assignment=quantifier; erase_target(get_entry_body(gf).instructions, ++assignment); diff --git a/src/cegis/safety/symex/learn/add_counterexamples.cpp b/src/cegis/safety/symex/learn/add_counterexamples.cpp index 8762c907aca..4b3bcbe7e64 100644 --- a/src/cegis/safety/symex/learn/add_counterexamples.cpp +++ b/src/cegis/safety/symex/learn/add_counterexamples.cpp @@ -22,7 +22,7 @@ void positional_assign(invariant_programt &prog, const std::string &pre) { const counterexamplet &ce_template=values.front(); - for (const goto_programt::targett x0 : vars) + for(const goto_programt::targett x0 : vars) { const irep_idt &id=get_affected_variable(*x0); const counterexamplet::const_iterator it=ce_template.find(id); @@ -37,7 +37,7 @@ void positional_assign(invariant_programt &prog, void safety_add_learned_counterexamples(safety_programt &prog, const safety_goto_cest &ces, constraint_factoryt constraint) { - if (ces.empty()) return; + if(ces.empty()) return; // TODO: Implement for multiple loops (change constraint, instrumentation) counterexamplest x0s; std::transform(ces.begin(), ces.end(), std::back_inserter(x0s), @@ -54,7 +54,7 @@ void safety_add_learned_counterexamples(safety_programt &prog, const size_t sz=ces.size(); const goto_programt::targett loop_end=invariant_add_ce_loop(prog, sz, false); positional_assign(prog, prog.x0_choices, first_loop_only, x0_pre); - for (const goto_programt::targett x0 : prog.x0_choices) + for(const goto_programt::targett x0 : prog.x0_choices) { const irep_idt &id=get_affected_variable(*x0); const counterexamplet &ce_template=x0s.front(); diff --git a/src/cegis/safety/symex/learn/add_variable_refs.cpp b/src/cegis/safety/symex/learn/add_variable_refs.cpp index 1cefa0d63ff..efa358402e5 100644 --- a/src/cegis/safety/symex/learn/add_variable_refs.cpp +++ b/src/cegis/safety/symex/learn/add_variable_refs.cpp @@ -20,7 +20,7 @@ void add_safety_learning_variable_refs(invariant_programt &prog, const size_t num_vars=var_ids.size(); const invariant_programt::const_invariant_loopst loops( static_cast(prog).get_loops()); - for (const invariant_programt::invariant_loopt * const loop : loops) + for(const invariant_programt::invariant_loopt * const loop : loops) { link_result_var(st, gf, num_vars, max_sz, loop->meta_variables.Ix); link_result_var(st, gf, num_vars, max_sz, loop->meta_variables.Ix_prime); diff --git a/src/cegis/safety/symex/learn/safety_learn_config.cpp b/src/cegis/safety/symex/learn/safety_learn_config.cpp index ec8c97de57a..254c84a1238 100644 --- a/src/cegis/safety/symex/learn/safety_learn_config.cpp +++ b/src/cegis/safety/symex/learn/safety_learn_config.cpp @@ -69,17 +69,17 @@ void safety_learn_configt::process(const size_t max_solution_size) counterexamplet dummy_ce; dummy_ce.x.push_back(counterexamplet::assignmentst()); counterexamplet::assignmentst &x=dummy_ce.x.front(); - for (const symbol_exprt &var : ce_vars) + for(const symbol_exprt &var : ce_vars) x.insert(std::make_pair(var.get_identifier(), zero)); // TODO: Implement for multiple loops (change constraint, instrumentation) const safety_programt &prog=original_program; const invariant_programt::const_invariant_loopst loops=prog.get_loops(); assert(!loops.empty()); // XXX: We might have to handle skolem choices explicitly at some point - for (const goto_programt::targett &skolem_choice : loops.front()->skolem_choices) + for(const goto_programt::targett &skolem_choice : loops.front()->skolem_choices) x.insert(std::make_pair(get_affected_variable(*skolem_choice), zero)); counterexamplet::assignmentst &x0=dummy_ce.x0; - for (const goto_programt::targett &x0_choice : original_program.x0_choices) + for(const goto_programt::targett &x0_choice : original_program.x0_choices) x0.insert(std::make_pair(get_affected_variable(*x0_choice), zero)); counterexamplest empty(1, dummy_ce); process(empty, max_solution_size); diff --git a/src/cegis/safety/symex/learn/solution_factory.cpp b/src/cegis/safety/symex/learn/solution_factory.cpp index f5c6e688aca..158467e3270 100644 --- a/src/cegis/safety/symex/learn/solution_factory.cpp +++ b/src/cegis/safety/symex/learn/solution_factory.cpp @@ -44,7 +44,7 @@ void copy_instructions(goto_programt::instructionst &prog, const size_t instr_idx) { copy_instructionst copy_instr; - for (goto_programt::const_targett it=entry.begin(); it != entry.end(); ++it) + for(goto_programt::const_targett it=entry.begin(); it != entry.end(); ++it) { prog.push_back(goto_programt::instructiont()); goto_programt::targett new_instr=prog.end(); @@ -69,7 +69,7 @@ void extract_program(goto_programt::instructionst &prog, const program_individualt::programt &instructions) { size_t instr_idx=0; - for (const program_individualt::instructiont &instr : instructions) + for(const program_individualt::instructiont &instr : instructions) { const program_individualt::instructiont::opcodet opcode=instr.opcode; const instruction_sett::const_iterator instr_entry=instr_set.find(opcode); @@ -94,7 +94,7 @@ void extract_program(goto_programt::instructionst &prog, size_t create_temps(invariant_variable_namest &rnames, const size_t num_tmp) { - for (size_t i=0; i < num_tmp; ++i) + for(size_t i=0; i < num_tmp; ++i) rnames.insert(std::make_pair(i, get_cegis_meta_name(get_tmp(i)))); return num_tmp; } @@ -121,9 +121,9 @@ void create_safety_solution(safety_goto_solutiont &solution, assert(max_sz > 0); const size_t idx=create_temps(result_var_names, max_sz - 1); size_t loop_idx=0; - for (const goto_trace_stept &step : trace.steps) + for(const goto_trace_stept &step : trace.steps) { - if (!is_program_individual_decl(step)) continue; + if(!is_program_individual_decl(step)) continue; const exprt::operandst &instrs=step.full_lhs_value.operands(); set_result_var(result_var_names, idx, loop_idx++); solution.push_back(goto_programt::instructionst()); @@ -143,7 +143,7 @@ void create_safety_solution(safety_goto_solutiont &solution, invariant_variable_namest vars; reverse_invariant_var_ids(vars, var_ids); size_t loop_idx=0; - for (const program_individualt::programt &instrs : ind.programs) + for(const program_individualt::programt &instrs : ind.programs) { invariant_variable_namest rvars; const size_t prog_size=instrs.size(); diff --git a/src/cegis/safety/symex/verify/insert_candidate.cpp b/src/cegis/safety/symex/verify/insert_candidate.cpp index 8315a2a4903..3d9c2da2856 100644 --- a/src/cegis/safety/symex/verify/insert_candidate.cpp +++ b/src/cegis/safety/symex/verify/insert_candidate.cpp @@ -18,7 +18,7 @@ Author: Daniel Kroening, kroening@kroening.com void safety_insert_candidate(safety_programt &program, const safety_goto_solutiont &candidate) { - if (candidate.empty()) return; + if(candidate.empty()) return; const safety_programt::safety_loopst &loops=program.safety_loops; const size_t size=loops.size(); assert(size == candidate.size()); @@ -26,7 +26,7 @@ void safety_insert_candidate(safety_programt &program, const std::string Ix_0(get_cegis_meta_name(get_Ix(0))); const std::string Ix0(get_cegis_meta_name(get_Ix0())); insert_program(body, program.Ix0, candidate.front(), Ix_0, Ix0); - for (size_t i=0; i < size; ++i) + for(size_t i=0; i < size; ++i) { const invariant_programt::invariant_loopt &loop=loops[i]; const goto_programt::instructionst &prog=candidate[i]; diff --git a/src/cegis/safety/symex/verify/safety_verify_config.cpp b/src/cegis/safety/symex/verify/safety_verify_config.cpp index dc46bcc7123..389baf71e0f 100644 --- a/src/cegis/safety/symex/verify/safety_verify_config.cpp +++ b/src/cegis/safety/symex/verify/safety_verify_config.cpp @@ -77,7 +77,7 @@ void safety_verify_configt::show_counterexample(messaget::mstreamt &os, print_assignments(os, st, counterexample.x0); os << " " << messaget::endl; os << " " << messaget::endl; - for (const counterexamplet::assignments_per_loopt::value_type &loop : counterexample.x) + for(const counterexamplet::assignments_per_loopt::value_type &loop : counterexample.x) { os << " " << messaget::endl; print_assignments(os, st, loop); diff --git a/src/cegis/seed/literals_seed.cpp b/src/cegis/seed/literals_seed.cpp index 1c1d4b43cda..d83c7c7c2e7 100644 --- a/src/cegis/seed/literals_seed.cpp +++ b/src/cegis/seed/literals_seed.cpp @@ -39,7 +39,7 @@ class is_same_symbolt bool operator()(const exprt &expr) const { - if (ID_symbol != expr.id()) return false; + if(ID_symbol != expr.id()) return false; return name == to_symbol_expr(expr).get_identifier(); } }; @@ -58,7 +58,7 @@ class add_symbolt void operator()(const exprt &expr) const { - if (ID_symbol != expr.id()) return; + if(ID_symbol != expr.id()) return; keys.insert(to_symbol_expr(expr).get_identifier()); } }; @@ -89,10 +89,10 @@ class add_literalt void operator()(const exprt &expr) const { - if (ID_constant != expr.id()) return; + if(ID_constant != expr.id()) return; const constant_exprt &new_literal=to_constant_expr(expr); const compare_literalt compare(new_literal); - if (values.end() != std::find_if(values.begin(), values.end(), compare)) + if(values.end() != std::find_if(values.begin(), values.end(), compare)) return; values.push_back(new_literal); } @@ -115,9 +115,9 @@ class init_pool_keyst: public const_expr_visitort virtual void operator()(const exprt &expr) { exprt::operandst ops(expr.operands()); - if (ops.size() < 2u) return; + if(ops.size() < 2u) return; const is_same_symbolt pred(var); - if (ops.end() == std::find_if(ops.begin(), ops.end(), pred)) return; + if(ops.end() == std::find_if(ops.begin(), ops.end(), pred)) return; const add_symbolt add(keys); std::for_each(ops.begin(), ops.end(), add); } @@ -135,10 +135,10 @@ typedef std::map pool_storaget; pool_storaget::const_iterator find(const pool_storaget &pool, const irep_idt &id) { - for (pool_storaget::const_iterator it=pool.begin(); it != pool.end(); ++it) + for(pool_storaget::const_iterator it=pool.begin(); it != pool.end(); ++it) { const keyst &keys=it->first; - if (std::find(keys.begin(), keys.end(), id) == keys.end()) continue; + if(std::find(keys.begin(), keys.end(), id) == keys.end()) continue; return it; } return pool.end(); @@ -158,7 +158,7 @@ class create_pool_keyst { const irep_idt &id=var.get_identifier(); pool_storaget::const_iterator it=find(pool, id); - if (pool.end() != it) return; + if(pool.end() != it) return; keyst newKey; newKey.insert(id); const init_pool_keyst add(newKey, id); @@ -185,11 +185,11 @@ class is_keyt bool operator()(const irep_idt &key) const { - for (exprt::operandst::const_iterator it=ops.begin(); ops.end() != it; ++it) + for(exprt::operandst::const_iterator it=ops.begin(); ops.end() != it; ++it) { const exprt &op=*it; - if (ID_symbol != op.id()) continue; - if (key == to_symbol_expr(op).get_identifier()) return true; + if(ID_symbol != op.id()) continue; + if(key == to_symbol_expr(op).get_identifier()) return true; } return false; } @@ -225,9 +225,9 @@ class scrape_literalst: public const_expr_visitort virtual void operator()(const exprt &expr) { const exprt::operandst &ops=expr.operands(); - if (ops.size() < 2u) return; + if(ops.size() < 2u) return; std::deque::const_iterator it=find_key(keys, ops); - if (keys.end() == it) return; + if(keys.end() == it) return; const add_literalt add(pool[*it]); std::for_each(ops.begin(), ops.end(), add); } @@ -266,7 +266,7 @@ class value_poolt size_t size() const { size_t size=0; - for (pool_storaget::const_iterator it=pool.begin(); it != pool.end(); ++it) + for(pool_storaget::const_iterator it=pool.begin(); it != pool.end(); ++it) size=std::max(size, it->second.size()); return size; } @@ -283,10 +283,10 @@ class value_poolt void seed(danger_verify_configt::counterexamplest &counterexamples) const { const size_t sz=size(); - for (size_t i=0; i < sz; ++i) + for(size_t i=0; i < sz; ++i) { danger_verify_configt::counterexamplet ce; - for (constraint_varst::const_iterator v=vs.begin(); v != vs.end(); ++v) + for(constraint_varst::const_iterator v=vs.begin(); v != vs.end(); ++v) { const irep_idt &id=v->get_identifier(); const typet &type=v->type(); @@ -301,7 +301,7 @@ class value_poolt void danger_literals_seedt::operator()( danger_verify_configt::counterexamplest &counterexamples) { - if (seeded) return; + if(seeded) return; constraint_varst vars; get_invariant_constraint_vars(vars, prog); const value_poolt pool(prog, vars); diff --git a/src/cegis/value/assignments_printer.cpp b/src/cegis/value/assignments_printer.cpp index fa57d737a74..6c192728f28 100644 --- a/src/cegis/value/assignments_printer.cpp +++ b/src/cegis/value/assignments_printer.cpp @@ -16,7 +16,7 @@ void print_assignments(messaget::mstreamt &os, const symbol_tablet &st, const std::map &assignments) { const namespacet ns(st); - for (const std::map::value_type &assignment : assignments) + for(const std::map::value_type &assignment : assignments) { os << "" << messaget::endl; os << " " << assignment.first << "" << messaget::endl; diff --git a/src/cegis/value/program_individual_serialisation.cpp b/src/cegis/value/program_individual_serialisation.cpp index 4f72b6cc18c..a9ecb4703a5 100644 --- a/src/cegis/value/program_individual_serialisation.cpp +++ b/src/cegis/value/program_individual_serialisation.cpp @@ -21,11 +21,11 @@ Author: Daniel Kroening, kroening@kroening.com bool is_program_individual_decl(const goto_trace_stept &step) { - if (goto_trace_stept::DECL != step.type) return false; + if(goto_trace_stept::DECL != step.type) return false; const exprt &value=step.full_lhs_value; - if (ID_array != value.id()) return false; + if(ID_array != value.id()) return false; const typet &type=value.type().subtype(); - if (ID_struct != type.id()) return false; + if(ID_struct != type.id()) return false; const std::string &tname=id2string(to_struct_type(type).get_tag()); const char * const danger_tag=CEGIS_INSTRUCTION_TYPE_NAME+4; return std::string::npos != tname.find(danger_tag); @@ -56,11 +56,11 @@ program_individualt to_program_individual(const invariant_programt &prog, { program_individualt individual; individual.fitness=0u; - for (const goto_trace_stept &step : trace.steps) - if (is_program_individual_decl(step)) + for(const goto_trace_stept &step : trace.steps) + if(is_program_individual_decl(step)) { program_individualt::programt prog; - for (const exprt &op : step.full_lhs_value.operands()) + for(const exprt &op : step.full_lhs_value.operands()) { const struct_exprt &instr=to_struct_expr(op); prog.push_back(to_program_individual_instruction(instr)); @@ -76,13 +76,13 @@ program_individualt to_program_individual(const danger_programt &prog, const invariant_programt &inv_prog=prog; program_individualt individual(to_program_individual(inv_prog, trace)); const program_individualt::programt empty; - if (!prog.loops.empty() && prog.loops.front().skolem_choices.empty()) + if(!prog.loops.empty() && prog.loops.front().skolem_choices.empty()) { const size_t num_progs=individual.programs.size(); assert(num_progs == prog.use_ranking ? 2 : 1); individual.programs.push_back(empty); } - if (!prog.use_ranking) + if(!prog.use_ranking) { assert(individual.programs.size() == 2); individual.programs.insert(std::next(individual.programs.begin()), empty); @@ -116,17 +116,17 @@ void serialise(irept &sdu, const program_individualt &individual) { irept programs; irept::subt &program_list=programs.get_sub(); - for (const program_individualt::programt &prog : individual.programs) + for(const program_individualt::programt &prog : individual.programs) { irept program; irept::subt &instr_list=program.get_sub(); - for (const program_individualt::instructiont &instr : prog) + for(const program_individualt::instructiont &instr : prog) { irept instruction; instruction.set(OPCODE, instr.opcode); irept ops; irept::subt &ops_list=ops.get_sub(); - for (const program_individualt::instructiont::opt op : instr.ops) + for(const program_individualt::instructiont::opt op : instr.ops) ops_list.push_back(singleton_irep(op)); instruction.set(OPS, ops); instr_list.push_back(instruction); @@ -136,7 +136,7 @@ void serialise(irept &sdu, const program_individualt &individual) sdu.set(PROGRAMS, programs); irept x0; irept::subt &x0_list=x0.get_sub(); - for (const program_individualt::x0t::value_type value : individual.x0) + for(const program_individualt::x0t::value_type value : individual.x0) x0_list.push_back(singleton_irep(value)); sdu.set(X0, x0); sdu.set(FITNESS, individual.fitness); @@ -148,17 +148,17 @@ void deserialise(program_individualt &individual, const irept &sdu) typedef irept::named_subt::const_iterator const_iterator; const const_iterator programs=named_sub.find(PROGRAMS); assert(named_sub.end() != programs); - for (const irept &program : programs->second.get_sub()) + for(const irept &program : programs->second.get_sub()) { program_individualt::programt prog; - for (const irept &instruction : program.get_sub()) + for(const irept &instruction : program.get_sub()) { program_individualt::instructiont instr; instr.opcode=instruction.get_long_long(OPCODE); const irept::named_subt &named_sub=instruction.get_named_sub(); const const_iterator ops=named_sub.find(OPS); assert(named_sub.end() != ops); - for (const irept &op : ops->second.get_sub()) + for(const irept &op : ops->second.get_sub()) instr.ops.push_back(get_value(op)); prog.push_back(instr); } @@ -166,7 +166,7 @@ void deserialise(program_individualt &individual, const irept &sdu) } const irept::named_subt::const_iterator x0=named_sub.find(X0); assert(named_sub.end() != x0); - for (const irept &value : x0->second.get_sub()) + for(const irept &value : x0->second.get_sub()) individual.x0.push_back(get_value(value)); individual.fitness=sdu.get_long_long(FITNESS); } diff --git a/src/cegis/wordsize/restrict_bv_size.cpp b/src/cegis/wordsize/restrict_bv_size.cpp index a30744f4f40..c821133fd71 100644 --- a/src/cegis/wordsize/restrict_bv_size.cpp +++ b/src/cegis/wordsize/restrict_bv_size.cpp @@ -14,19 +14,19 @@ Author: Daniel Kroening, kroening@kroening.com void restrict_bv_size(symbol_tablet &st, goto_functionst &gf, const size_t width_in_bits) { - for (symbol_tablet::symbolst::value_type &id_and_symbol : st.symbols) + for(symbol_tablet::symbolst::value_type &id_and_symbol : st.symbols) { symbolt &symbol=id_and_symbol.second; restrict_bv_size(symbol.type, width_in_bits); restrict_bv_size(symbol.value, width_in_bits); } - for (goto_functionst::function_mapt::value_type &entry : gf.function_map) + for(goto_functionst::function_mapt::value_type &entry : gf.function_map) { goto_functionst::function_mapt::value_type::second_type &func=entry.second; restrict_bv_size(func.type, width_in_bits); - if (!func.body_available()) continue; + if(!func.body_available()) continue; goto_programt::instructionst &body=func.body.instructions; - for (goto_programt::instructiont &instr : body) + for(goto_programt::instructiont &instr : body) { restrict_bv_size(instr.code, width_in_bits); restrict_bv_size(instr.guard, width_in_bits); @@ -61,15 +61,15 @@ class restrict_bv_size_visitort: public expr_visitort virtual void operator()(exprt &expr) { typet &type=expr.type(); - if (!restrict_bv_size(type, width_in_bits)) return; - if (ID_constant != expr.id()) return; + if(!restrict_bv_size(type, width_in_bits)) return; + if(ID_constant != expr.id()) return; constant_exprt &constant=to_constant_expr(expr); const std::string &value=id2string(constant.get_value()); - if (value.empty()) return; + if(value.empty()) return; assert(width_in_bits < value.size()); std::string new_value(value.substr(value.size() - width_in_bits)); // XXX: Restrict positive constant from being turned negative. Sensible? - if (ID_signedbv == type.id()) new_value[0]=value[0]; + if(ID_signedbv == type.id()) new_value[0]=value[0]; constant.set_value(new_value); } }; @@ -86,7 +86,7 @@ namespace bool restrict_bv_size(code_typet &type, const size_t width_in_bits) { restrict_bv_size(type.return_type(), width_in_bits); - for (code_typet::parametert ¶m : type.parameters()) + for(code_typet::parametert ¶m : type.parameters()) { restrict_bv_size(param, width_in_bits); restrict_bv_size(param.default_value(), width_in_bits); @@ -96,7 +96,7 @@ bool restrict_bv_size(code_typet &type, const size_t width_in_bits) bool restrict_bv_size(struct_union_typet &type, const size_t width_in_bits) { - for (struct_union_typet::componentt &comp : type.components()) + for(struct_union_typet::componentt &comp : type.components()) restrict_bv_size(comp, width_in_bits); return false; } @@ -105,15 +105,15 @@ bool restrict_bv_size(struct_union_typet &type, const size_t width_in_bits) bool restrict_bv_size(typet &type, const size_t width_in_bits) { const irep_idt &type_id=type.id(); - if (ID_code == type_id) + if(ID_code == type_id) return restrict_bv_size(to_code_type(type), width_in_bits); - if (ID_struct == type_id || ID_union == type_id) + if(ID_struct == type_id || ID_union == type_id) return restrict_bv_size(to_struct_union_type(type), width_in_bits); - if (static_cast(type).subtype().is_not_nil()) + if(static_cast(type).subtype().is_not_nil()) restrict_bv_size(type.subtype(), width_in_bits); - if (!is_bv_type(type)) return false; + if(!is_bv_type(type)) return false; bitvector_typet &bvtype=to_bitvector_type(type); - if (width_in_bits >= bvtype.get_width()) return false; + if(width_in_bits >= bvtype.get_width()) return false; to_bitvector_type(type).set_width(width_in_bits); return true; } From 05e44903400c66dab9630ad890e487d648aa14f8 Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:46:29 +0000 Subject: [PATCH 3/7] first pass cpplint fixes in regression/cpp-from-CVS --- regression/cpp-from-CVS/Assignment1/main.cpp | 36 +++--- .../cpp-from-CVS/Comma_Operator1/main.cpp | 2 +- .../ConditionalExpression2/main.cpp | 6 +- .../cpp-from-CVS/Constructor10/main.cpp | 10 +- .../cpp-from-CVS/Constructor11/main.cpp | 6 +- .../cpp-from-CVS/Constructor12/main.cpp | 22 ++-- .../cpp-from-CVS/Constructor13/main.cpp | 36 +++--- .../cpp-from-CVS/Constructor14/main.cpp | 2 +- .../cpp-from-CVS/Constructor16/main.cpp | 2 +- .../cpp-from-CVS/Constructor17/main.cpp | 2 +- regression/cpp-from-CVS/Conversion10/main.cpp | 8 +- regression/cpp-from-CVS/Conversion11/main.cpp | 2 +- regression/cpp-from-CVS/Conversion3/main.cpp | 6 +- regression/cpp-from-CVS/Conversion4/main.cpp | 6 +- regression/cpp-from-CVS/Conversion5/main.cpp | 8 +- regression/cpp-from-CVS/Conversion6/main.cpp | 18 +-- regression/cpp-from-CVS/Conversion7/main.cpp | 10 +- regression/cpp-from-CVS/Conversion8/main.cpp | 12 +- regression/cpp-from-CVS/Conversion9/main.cpp | 2 +- .../Conversion_Operator1/main.cpp | 12 +- .../Conversion_Operator2/main.cpp | 20 ++-- .../Conversion_Operator3/main.cpp | 26 ++--- .../Conversion_Operator4/main.cpp | 14 +-- .../Conversion_Operator5/main.cpp | 30 ++--- .../cpp-from-CVS/Copy_Constructor1/main.cpp | 24 ++-- .../cpp-from-CVS/Copy_Constructor3/main.cpp | 30 ++--- .../cpp-from-CVS/Copy_Operator1/main.cpp | 34 +++--- .../cpp-from-CVS/Copy_Operator2/main.cpp | 8 +- .../cpp-from-CVS/Default_Arguments1/main.cpp | 2 +- .../cpp-from-CVS/Default_Arguments2/main.cpp | 6 +- regression/cpp-from-CVS/Destructor4/main.cpp | 12 +- regression/cpp-from-CVS/Friend3/main.cpp | 12 +- regression/cpp-from-CVS/Friend4/main.cpp | 8 +- regression/cpp-from-CVS/Friend5/main.cpp | 28 ++--- regression/cpp-from-CVS/Friend6/main.cpp | 18 +-- .../cpp-from-CVS/Function_Arguments5/main.cpp | 12 +- .../Implicit_Conversion1/main.cpp | 12 +- .../Implicit_Conversion2/main.cpp | 8 +- .../Implicit_Conversion3/main.cpp | 22 ++-- .../Implicit_Conversion4/main.cpp | 106 +++++++++--------- .../Implicit_Conversion5/main.cpp | 4 +- .../Implicit_Conversion6/main.cpp | 6 +- .../Implicit_Conversion7/main.cpp | 4 +- .../Implicit_Conversion8/main.cpp | 42 +++---- regression/cpp-from-CVS/Inheritance2/main.cpp | 22 ++-- regression/cpp-from-CVS/Inheritance3/main.cpp | 20 ++-- regression/cpp-from-CVS/Inheritance4/main.cpp | 10 +- regression/cpp-from-CVS/Label0/main.cpp | 4 +- regression/cpp-from-CVS/Lvalue1/main.cpp | 32 +++--- .../Multiple_Inheritance1/main.cpp | 14 +-- .../Multiple_Inheritance2/main.cpp | 10 +- .../Multiple_Inheritance4/main.cpp | 4 +- regression/cpp-from-CVS/Mutable1/main.cpp | 16 +-- .../Overloading_Functions2/main.cpp | 8 +- .../Overloading_Increment1/main.cpp | 66 +++++------ .../Overloading_Operators10/main.cpp | 14 +-- .../Overloading_Operators11/main.cpp | 16 +-- .../Overloading_Operators12/main.cpp | 8 +- .../Overloading_Operators13/main.cpp | 12 +- .../Overloading_Operators14/main.cpp | 14 +-- .../Overloading_Operators4/main.cpp | 6 +- .../Overloading_Operators6/main.cpp | 66 +++++------ .../Overloading_Operators7/main.cpp | 2 +- .../Overloading_Operators8/main.cpp | 20 ++-- .../Overloading_Operators9/main.cpp | 28 ++--- .../cpp-from-CVS/Pointer_Conversion3/main.cpp | 12 +- .../cpp-from-CVS/Pointer_To_Member1/main.cpp | 12 +- .../cpp-from-CVS/Pointer_To_Member2/main.cpp | 6 +- .../cpp-from-CVS/Pointer_To_Member3/main.cpp | 8 +- .../cpp-from-CVS/Pointer_To_Member4/main.cpp | 10 +- .../cpp-from-CVS/Pointer_To_Member5/main.cpp | 18 +-- .../cpp-from-CVS/Pointer_To_Member6/main.cpp | 20 ++-- regression/cpp-from-CVS/Protection1/main.cpp | 8 +- regression/cpp-from-CVS/Protection2/main.cpp | 16 +-- regression/cpp-from-CVS/Protection3/main.cpp | 12 +- regression/cpp-from-CVS/Protection4/main.cpp | 10 +- regression/cpp-from-CVS/Protection5/main.cpp | 10 +- regression/cpp-from-CVS/Protection6/main.cpp | 4 +- regression/cpp-from-CVS/Protection7/main.cpp | 12 +- regression/cpp-from-CVS/Protection8/main.cpp | 12 +- regression/cpp-from-CVS/Qualifier1/main.cpp | 10 +- regression/cpp-from-CVS/Qualifier2/main.cpp | 22 ++-- regression/cpp-from-CVS/Qualifier3/main.cpp | 10 +- regression/cpp-from-CVS/Qualifier4/main.cpp | 4 +- regression/cpp-from-CVS/Reference3/main.cpp | 14 +-- regression/cpp-from-CVS/Resolver5/main.cpp | 16 +-- regression/cpp-from-CVS/Resolver6/main.cpp | 8 +- regression/cpp-from-CVS/Resolver7/main.cpp | 6 +- regression/cpp-from-CVS/Resolver8/main.cpp | 10 +- regression/cpp-from-CVS/Resolver9/main.cpp | 4 +- .../cpp-from-CVS/Static_Method1/main.cpp | 8 +- regression/cpp-from-CVS/Templates10/main.cpp | 12 +- regression/cpp-from-CVS/Templates11/main.cpp | 18 +-- regression/cpp-from-CVS/Templates13/main.cpp | 8 +- regression/cpp-from-CVS/Templates14/main.cpp | 16 +-- regression/cpp-from-CVS/Templates17/main.cpp | 8 +- regression/cpp-from-CVS/Templates18/main.cpp | 10 +- regression/cpp-from-CVS/Templates19/main.cpp | 14 +-- regression/cpp-from-CVS/Templates20/main.cpp | 8 +- regression/cpp-from-CVS/Templates22/main.cpp | 8 +- regression/cpp-from-CVS/Templates25/main.cpp | 4 +- regression/cpp-from-CVS/Templates28/main.cpp | 2 +- regression/cpp-from-CVS/Templates29/main.cpp | 2 +- regression/cpp-from-CVS/Templates3/main.cpp | 4 +- regression/cpp-from-CVS/Templates32/main.cpp | 2 +- regression/cpp-from-CVS/Templates5/main.cpp | 14 +-- regression/cpp-from-CVS/Typedef1/main.cpp | 14 +-- regression/cpp-from-CVS/Typedef2/main.cpp | 32 +++--- regression/cpp-from-CVS/Typedef3/main.cpp | 6 +- regression/cpp-from-CVS/Vector1/main.cpp | 6 +- .../cpp-from-CVS/Zero_Initializer1/main.cpp | 2 +- regression/cpp-from-CVS/const_cast1/main.cpp | 14 +-- regression/cpp-from-CVS/extractbits1/main.cpp | 20 ++-- regression/cpp-from-CVS/for1/main.cpp | 2 +- .../cpp-from-CVS/initialization1/main.cpp | 12 +- .../cpp-from-CVS/initialization2/main.cpp | 18 +-- .../cpp-from-CVS/initialization3/main.cpp | 10 +- .../cpp-from-CVS/initialization4/main.cpp | 4 +- .../cpp-from-CVS/initialization5/main.cpp | 8 +- .../cpp-from-CVS/initialization6/main.cpp | 2 +- .../cpp-from-CVS/initialization7/main.cpp | 8 +- regression/cpp-from-CVS/operators/main.cpp | 42 +++---- .../cpp-from-CVS/reinterpret_cast1/main.cpp | 12 +- .../cpp-from-CVS/reinterpret_cast2/main.cpp | 10 +- regression/cpp-from-CVS/static_cast2/main.cpp | 4 +- regression/cpp-from-CVS/static_cast3/main.cpp | 20 ++-- regression/cpp-from-CVS/static_cast4/main.cpp | 6 +- regression/cpp-from-CVS/static_cast5/main.cpp | 14 +-- regression/cpp-from-CVS/virtual10/main.cpp | 12 +- regression/cpp-from-CVS/virtual11/main.cpp | 26 ++--- regression/cpp-from-CVS/virtual12/main.cpp | 14 +-- regression/cpp-from-CVS/virtual13/main.cpp | 2 +- regression/cpp-from-CVS/virtual14/main.cpp | 10 +- regression/cpp-from-CVS/virtual15/main.cpp | 6 +- regression/cpp-from-CVS/virtual3/main.cpp | 8 +- regression/cpp-from-CVS/virtual5/main.cpp | 12 +- regression/cpp-from-CVS/virtual7/main.cpp | 26 ++--- regression/cpp-from-CVS/virtual8/main.cpp | 16 +-- regression/cpp-from-CVS/virtual9/main.cpp | 12 +- 139 files changed, 955 insertions(+), 955 deletions(-) diff --git a/regression/cpp-from-CVS/Assignment1/main.cpp b/regression/cpp-from-CVS/Assignment1/main.cpp index fefebc1fd23..96c88255e0c 100644 --- a/regression/cpp-from-CVS/Assignment1/main.cpp +++ b/regression/cpp-from-CVS/Assignment1/main.cpp @@ -2,36 +2,36 @@ struct A { int i;}; struct B { - int i; - B& operator = (const B& b) - { - i = b.i; - return *this; - } + int i; + B& operator = (const B& b) + { + i = b.i; + return *this; + } }; A funcA() { - A a; - a.i = 10; - return a; + A a; + a.i = 10; + return a; } B funcB() { - B b; - b.i = 10; - return b; + B b; + b.i = 10; + return b; } int main() { - A a; - a.i = 20; - assert((funcA() = a).i == 20); // legal + A a; + a.i = 20; + assert((funcA() = a).i == 20); // legal - B b; - b.i = 20; - assert((funcB() = b).i == 20); // legal + B b; + b.i = 20; + assert((funcB() = b).i == 20); // legal } diff --git a/regression/cpp-from-CVS/Comma_Operator1/main.cpp b/regression/cpp-from-CVS/Comma_Operator1/main.cpp index 6b3fd1e5241..1a768ab5ae6 100644 --- a/regression/cpp-from-CVS/Comma_Operator1/main.cpp +++ b/regression/cpp-from-CVS/Comma_Operator1/main.cpp @@ -2,7 +2,7 @@ int main() { int s=0; int t=0; - t=(s=3,s+2); + t=(s=3, s+2); assert(s==3); assert(t==5); } diff --git a/regression/cpp-from-CVS/ConditionalExpression2/main.cpp b/regression/cpp-from-CVS/ConditionalExpression2/main.cpp index 2652cb8f0f6..46de51d6aff 100644 --- a/regression/cpp-from-CVS/ConditionalExpression2/main.cpp +++ b/regression/cpp-from-CVS/ConditionalExpression2/main.cpp @@ -3,7 +3,7 @@ char b[2]; int main() { - char* c = true ? a : b; - assert(*c == a[0]); - return 0; + char* c = true ? a : b; + assert(*c == a[0]); + return 0; } diff --git a/regression/cpp-from-CVS/Constructor10/main.cpp b/regression/cpp-from-CVS/Constructor10/main.cpp index 21bae609b2c..efd4869d97e 100644 --- a/regression/cpp-from-CVS/Constructor10/main.cpp +++ b/regression/cpp-from-CVS/Constructor10/main.cpp @@ -1,14 +1,14 @@ class A { - public: - int a; - A(int a):a(a){} + public: + int a; + A(int a):a(a){} }; A f() { - return A(0); + return A(0); } -int main(){} +int main() {} diff --git a/regression/cpp-from-CVS/Constructor11/main.cpp b/regression/cpp-from-CVS/Constructor11/main.cpp index b5565833364..2e811b56b4d 100644 --- a/regression/cpp-from-CVS/Constructor11/main.cpp +++ b/regression/cpp-from-CVS/Constructor11/main.cpp @@ -1,10 +1,10 @@ struct A { - A(){}; + A(){}; }; int main() { - A a; - a.A(); + A a; + a.A(); } diff --git a/regression/cpp-from-CVS/Constructor12/main.cpp b/regression/cpp-from-CVS/Constructor12/main.cpp index 7c5b14f39e4..3158f9a553c 100644 --- a/regression/cpp-from-CVS/Constructor12/main.cpp +++ b/regression/cpp-from-CVS/Constructor12/main.cpp @@ -1,22 +1,22 @@ struct A { - int i; - A():i(10){} - private: - A(const A& a); // disabled + int i; + A():i(10) {} + private: + A(const A& a); // disabled }; class B: A { - public: - B(){}; - int get_i(){return i;} - private: - B(B& b); // disabled + public: + B(){}; + int get_i() {return i;} + private: + B(B& b); // disabled }; int main() { - B b; - assert(b.get_i() == 10); + B b; + assert(b.get_i() == 10); } diff --git a/regression/cpp-from-CVS/Constructor13/main.cpp b/regression/cpp-from-CVS/Constructor13/main.cpp index e5a593cd70f..cabf296c968 100644 --- a/regression/cpp-from-CVS/Constructor13/main.cpp +++ b/regression/cpp-from-CVS/Constructor13/main.cpp @@ -1,26 +1,26 @@ int g; class A { - public: - A(int i){g=i;}; - private: - A(); + public: + A(int i){g=i;}; + private: + A(); }; class B: A { - public: - typedef A base_type; - typedef B this_type; - B():base_type(10){} - B(const this_type& b): A(20) {g++;} + public: + typedef A base_type; + typedef B this_type; + B():base_type(10) {} + B(const this_type& b): A(20) {g++;} }; class C: B { - typedef B base_type; - typedef C this_type; - public: - C(): base_type(){} - C(const base_type& b): base_type(b){g++;} + typedef B base_type; + typedef C this_type; + public: + C(): base_type() {} + C(const base_type& b): base_type(b){g++;} }; @@ -28,8 +28,8 @@ C c; int main() { - assert(g==10); - B b; - C c2 = b; - assert(g==22); + assert(g==10); + B b; + C c2 = b; + assert(g==22); } diff --git a/regression/cpp-from-CVS/Constructor14/main.cpp b/regression/cpp-from-CVS/Constructor14/main.cpp index b961a39577d..15c4afaef68 100644 --- a/regression/cpp-from-CVS/Constructor14/main.cpp +++ b/regression/cpp-from-CVS/Constructor14/main.cpp @@ -1,6 +1,6 @@ struct A { - A(int i):i(i){} + A(int i):i(i) {} int i; }; diff --git a/regression/cpp-from-CVS/Constructor16/main.cpp b/regression/cpp-from-CVS/Constructor16/main.cpp index db820ab7a90..75e996d8be2 100644 --- a/regression/cpp-from-CVS/Constructor16/main.cpp +++ b/regression/cpp-from-CVS/Constructor16/main.cpp @@ -15,6 +15,6 @@ class B: public A int main() { - B b1,b2; + B b1, b2; b1 = b2; // not ok } diff --git a/regression/cpp-from-CVS/Constructor17/main.cpp b/regression/cpp-from-CVS/Constructor17/main.cpp index 4d75a2d685a..27db56b5051 100644 --- a/regression/cpp-from-CVS/Constructor17/main.cpp +++ b/regression/cpp-from-CVS/Constructor17/main.cpp @@ -1,7 +1,7 @@ class C { public: - C(int& v):v(v){}; + C(int& v):v(v){} int v; }; diff --git a/regression/cpp-from-CVS/Conversion10/main.cpp b/regression/cpp-from-CVS/Conversion10/main.cpp index 78ebff4a465..7f8155da801 100644 --- a/regression/cpp-from-CVS/Conversion10/main.cpp +++ b/regression/cpp-from-CVS/Conversion10/main.cpp @@ -1,13 +1,13 @@ struct A {}; struct B { - explicit B(A&){} + explicit B(A&){} }; -void test(const B& b){}; +void test(const B& b){} int main() { - A a; - test(a); // conversion error + A a; + test(a); // conversion error } diff --git a/regression/cpp-from-CVS/Conversion11/main.cpp b/regression/cpp-from-CVS/Conversion11/main.cpp index 995120e3b02..09a4d27798d 100644 --- a/regression/cpp-from-CVS/Conversion11/main.cpp +++ b/regression/cpp-from-CVS/Conversion11/main.cpp @@ -1 +1 @@ -char* func(){return (void*)0; } +char* func() {return (void*)0; } diff --git a/regression/cpp-from-CVS/Conversion3/main.cpp b/regression/cpp-from-CVS/Conversion3/main.cpp index 383011072ae..48274d054b7 100644 --- a/regression/cpp-from-CVS/Conversion3/main.cpp +++ b/regression/cpp-from-CVS/Conversion3/main.cpp @@ -1,6 +1,6 @@ int main() { - char c = 'c'; - int& i = c; // ill-formed - i++; + char c = 'c'; + int& i = c; // ill-formed + i++; } diff --git a/regression/cpp-from-CVS/Conversion4/main.cpp b/regression/cpp-from-CVS/Conversion4/main.cpp index 55b116a02c6..d8da7d1fbff 100644 --- a/regression/cpp-from-CVS/Conversion4/main.cpp +++ b/regression/cpp-from-CVS/Conversion4/main.cpp @@ -1,6 +1,6 @@ int main() { - const char c = 'c'; - const int &i = c; - assert(i == 'c'); + const char c = 'c'; + const int &i = c; + assert(i == 'c'); } diff --git a/regression/cpp-from-CVS/Conversion5/main.cpp b/regression/cpp-from-CVS/Conversion5/main.cpp index 7a77dec6234..bac3701b6c7 100644 --- a/regression/cpp-from-CVS/Conversion5/main.cpp +++ b/regression/cpp-from-CVS/Conversion5/main.cpp @@ -1,7 +1,7 @@ int main() { - unsigned i = 1; - unsigned j; - j = i + 1; - assert(j==2); + unsigned i = 1; + unsigned j; + j = i + 1; + assert(j==2); } diff --git a/regression/cpp-from-CVS/Conversion6/main.cpp b/regression/cpp-from-CVS/Conversion6/main.cpp index 4feb9caeb5a..53d3b28d240 100644 --- a/regression/cpp-from-CVS/Conversion6/main.cpp +++ b/regression/cpp-from-CVS/Conversion6/main.cpp @@ -1,25 +1,25 @@ struct A { - int i; + int i; }; struct B: public A { - int j; + int j; }; int func(A a) { - return a.i; + return a.i; } int main() { - B b; - b.i = 1; + B b; + b.i = 1; - assert((* ((A*)&b)).i == 1); // This works fine. + assert((* ((A*)&b)).i == 1); // This works fine. - int bi = func( * ((A*)&b)); // Satabs Ok. - // cbmc error - assert(bi == 1); + int bi = func( * ((A*)&b)); // Satabs Ok. + // cbmc error + assert(bi == 1); } diff --git a/regression/cpp-from-CVS/Conversion7/main.cpp b/regression/cpp-from-CVS/Conversion7/main.cpp index 4ee8e45d5b1..f16cdcbab03 100644 --- a/regression/cpp-from-CVS/Conversion7/main.cpp +++ b/regression/cpp-from-CVS/Conversion7/main.cpp @@ -1,5 +1,5 @@ struct A{ - int i; + int i; }; struct B: public A{ @@ -7,9 +7,9 @@ struct B: public A{ int main() { - B b; - b.i=4; + B b; + b.i=4; - A(b).i++; // Not a lvalue? - assert(b.i==4); + A(b).i++; // Not a lvalue? + assert(b.i==4); } diff --git a/regression/cpp-from-CVS/Conversion8/main.cpp b/regression/cpp-from-CVS/Conversion8/main.cpp index 41f65af3d40..2ae6dca55d8 100644 --- a/regression/cpp-from-CVS/Conversion8/main.cpp +++ b/regression/cpp-from-CVS/Conversion8/main.cpp @@ -1,8 +1,8 @@ int main() { - const char c[1] = {'c'}; - char* pc; - const char** pcc = &pc; //1: not allowed - *pcc = &c; - *pc = 'C'; //2: modifies a const object - assert(c[0]=='c'); + const char c[1] = {'c'}; + char* pc; + const char** pcc = &pc; // 1: not allowed + *pcc = &c; + *pc = 'C'; // 2: modifies a const object + assert(c[0]=='c'); } diff --git a/regression/cpp-from-CVS/Conversion9/main.cpp b/regression/cpp-from-CVS/Conversion9/main.cpp index 9ef031f4757..f59a75fbe89 100644 --- a/regression/cpp-from-CVS/Conversion9/main.cpp +++ b/regression/cpp-from-CVS/Conversion9/main.cpp @@ -6,5 +6,5 @@ struct B: A {}; int main() { - A a = B(); + A a = B(); } diff --git a/regression/cpp-from-CVS/Conversion_Operator1/main.cpp b/regression/cpp-from-CVS/Conversion_Operator1/main.cpp index 757506d1d64..8515bf5de2e 100644 --- a/regression/cpp-from-CVS/Conversion_Operator1/main.cpp +++ b/regression/cpp-from-CVS/Conversion_Operator1/main.cpp @@ -1,15 +1,15 @@ struct Char { - char c; - Char(char c):c(c){} + char c; + Char(char c):c(c){} }; struct Int { - int i; - operator int& (); - Int(int i):i(i){} + int i; + operator int& (); + Int(int i):i(i){} }; -Int::operator int&(){return i;} +Int::operator int&() {return i;} int main() { diff --git a/regression/cpp-from-CVS/Conversion_Operator2/main.cpp b/regression/cpp-from-CVS/Conversion_Operator2/main.cpp index b764899ffa4..8dde5fdee8d 100644 --- a/regression/cpp-from-CVS/Conversion_Operator2/main.cpp +++ b/regression/cpp-from-CVS/Conversion_Operator2/main.cpp @@ -1,22 +1,22 @@ struct B { - int i; + int i; }; struct A { - B b; - A(int i){b.i = i;} - operator B& () - { - return b; - } + B b; + A(int i) {b.i = i;} + operator B& () + { + return b; + } }; -int get_i(const B& b){return b.i;} +int get_i(const B& b) {return b.i;} int main() { - A a(10); - assert(get_i(a)==10); + A a(10); + assert(get_i(a)==10); } diff --git a/regression/cpp-from-CVS/Conversion_Operator3/main.cpp b/regression/cpp-from-CVS/Conversion_Operator3/main.cpp index 5439709770f..08200a3b963 100644 --- a/regression/cpp-from-CVS/Conversion_Operator3/main.cpp +++ b/regression/cpp-from-CVS/Conversion_Operator3/main.cpp @@ -1,22 +1,22 @@ struct A { - int i; + int i; }; struct B { - int i; - operator A () - { - A tmp; - tmp.i = i++; - return tmp; - } + int i; + operator A () + { + A tmp; + tmp.i = i++; + return tmp; + } }; int main() { - B b; - b.i = 1; - A a = b; - assert(a.i==1); - assert(b.i==2); + B b; + b.i = 1; + A a = b; + assert(a.i==1); + assert(b.i==2); } diff --git a/regression/cpp-from-CVS/Conversion_Operator4/main.cpp b/regression/cpp-from-CVS/Conversion_Operator4/main.cpp index 246a6ae82e6..cc76959191c 100644 --- a/regression/cpp-from-CVS/Conversion_Operator4/main.cpp +++ b/regression/cpp-from-CVS/Conversion_Operator4/main.cpp @@ -1,14 +1,14 @@ struct A { - static const int* const i = 0; - operator const int* const ()const - { - return i; - } + static const int* const i = 0; + operator const int* const ()const + { + return i; + } }; int main() { - A a; - assert((const int* const)a == A::i); + A a; + assert((const int* const)a == A::i); } diff --git a/regression/cpp-from-CVS/Conversion_Operator5/main.cpp b/regression/cpp-from-CVS/Conversion_Operator5/main.cpp index 811b5d40d83..ffec9ff65bd 100644 --- a/regression/cpp-from-CVS/Conversion_Operator5/main.cpp +++ b/regression/cpp-from-CVS/Conversion_Operator5/main.cpp @@ -1,23 +1,23 @@ struct B { - int i; - bool operator == (int b) - { - return i == b; - } + int i; + bool operator == (int b) + { + return i == b; + } }; struct A { - int i; - operator B() const - { - B b; - b.i = i; - return b; - } + int i; + operator B() const + { + B b; + b.i = i; + return b; + } }; int main() { - A a; - a.i = 10; - assert( a.operator B() == 10 ); + A a; + a.i = 10; + assert( a.operator B() == 10 ); } diff --git a/regression/cpp-from-CVS/Copy_Constructor1/main.cpp b/regression/cpp-from-CVS/Copy_Constructor1/main.cpp index 12aa305ae53..fba333831b8 100644 --- a/regression/cpp-from-CVS/Copy_Constructor1/main.cpp +++ b/regression/cpp-from-CVS/Copy_Constructor1/main.cpp @@ -1,23 +1,23 @@ class A { - public: - A():i(0){} - virtual int inc(){return ++i;} - int i; + public: + A():i(0) {} + virtual int inc() {return ++i;} + int i; }; class B: public A { - public: - int inc(){return i+=2;} + public: + int inc(){return i+=2;} }; int main() { - B b; - int c = b.inc(); - assert(c==2); - A a=b; - c = a.inc(); - assert(c==3); + B b; + int c = b.inc(); + assert(c==2); + A a=b; + c = a.inc(); + assert(c==3); } diff --git a/regression/cpp-from-CVS/Copy_Constructor3/main.cpp b/regression/cpp-from-CVS/Copy_Constructor3/main.cpp index ebbbbdbc187..8c601e54935 100644 --- a/regression/cpp-from-CVS/Copy_Constructor3/main.cpp +++ b/regression/cpp-from-CVS/Copy_Constructor3/main.cpp @@ -1,27 +1,27 @@ class A { - public: - int ar[2]; - A(){ar[0]=0; ar[1]=1;} + public: + int ar[2]; + A(){ar[0]=0; ar[1]=1;} }; class B { - public: - A as[2]; + public: + A as[2]; }; int main() { - B b1; - b1.as[0].ar[0] += 1; - b1.as[0].ar[1] += 1; - b1.as[1].ar[0] += 2; - b1.as[1].ar[1] += 2; + B b1; + b1.as[0].ar[0] += 1; + b1.as[0].ar[1] += 1; + b1.as[1].ar[0] += 2; + b1.as[1].ar[1] += 2; - B b2(b1); - assert(b2.as[0].ar[0]== 1); - assert(b2.as[0].ar[1] == 2); - assert(b2.as[1].ar[0] == 2); - assert(b2.as[1].ar[1] == 3); + B b2(b1); + assert(b2.as[0].ar[0]== 1); + assert(b2.as[0].ar[1] == 2); + assert(b2.as[1].ar[0] == 2); + assert(b2.as[1].ar[1] == 3); } diff --git a/regression/cpp-from-CVS/Copy_Operator1/main.cpp b/regression/cpp-from-CVS/Copy_Operator1/main.cpp index 45699fc2986..134f610fc5d 100644 --- a/regression/cpp-from-CVS/Copy_Operator1/main.cpp +++ b/regression/cpp-from-CVS/Copy_Operator1/main.cpp @@ -1,27 +1,27 @@ class A { - public: - int ar[2]; - A& operator=(const A& ref) - { - ar[0] = ref.ar[1]; - ar[1] = ref.ar[0]; - return *this; - } + public: + int ar[2]; + A& operator=(const A& ref) + { + ar[0] = ref.ar[1]; + ar[1] = ref.ar[0]; + return *this; + } }; int main() { - A a1; - a1.ar[0]= 1; - a1.ar[1]= 2; + A a1; + a1.ar[0]= 1; + a1.ar[1]= 2; - A a2; - a2.ar[0]= 3; - a2.ar[1]= 4; + A a2; + a2.ar[0]= 3; + a2.ar[1]= 4; - a2 = a1; - assert(a2.ar[0]==a1.ar[1]); - assert(a2.ar[1]==a1.ar[0]); + a2 = a1; + assert(a2.ar[0]==a1.ar[1]); + assert(a2.ar[1]==a1.ar[0]); } diff --git a/regression/cpp-from-CVS/Copy_Operator2/main.cpp b/regression/cpp-from-CVS/Copy_Operator2/main.cpp index ed599f1415e..7751933bd7b 100644 --- a/regression/cpp-from-CVS/Copy_Operator2/main.cpp +++ b/regression/cpp-from-CVS/Copy_Operator2/main.cpp @@ -1,11 +1,11 @@ class A { - const int a; - A():a(0){}; + const int a; + A():a(0){} }; int main() { - A a,b; - a=b; + A a, b; + a=b; } diff --git a/regression/cpp-from-CVS/Default_Arguments1/main.cpp b/regression/cpp-from-CVS/Default_Arguments1/main.cpp index 2e3c96e423d..6c9ae18e7fe 100644 --- a/regression/cpp-from-CVS/Default_Arguments1/main.cpp +++ b/regression/cpp-from-CVS/Default_Arguments1/main.cpp @@ -1,4 +1,4 @@ -//#include +// #include int f(int d=1) { diff --git a/regression/cpp-from-CVS/Default_Arguments2/main.cpp b/regression/cpp-from-CVS/Default_Arguments2/main.cpp index 5c29a683e95..e64102d3251 100644 --- a/regression/cpp-from-CVS/Default_Arguments2/main.cpp +++ b/regression/cpp-from-CVS/Default_Arguments2/main.cpp @@ -1,7 +1,7 @@ -int func(int i = 0){return i;} +int func(int i = 0) {return i;} int main() { - int (*pfunc)(int) = func; - assert((*pfunc)(10) == 10); + int (*pfunc)(int) = func; + assert((*pfunc)(10) == 10); } diff --git a/regression/cpp-from-CVS/Destructor4/main.cpp b/regression/cpp-from-CVS/Destructor4/main.cpp index a8b5b2cccb6..b0f2876e47c 100644 --- a/regression/cpp-from-CVS/Destructor4/main.cpp +++ b/regression/cpp-from-CVS/Destructor4/main.cpp @@ -1,17 +1,17 @@ class A { - public: - int i; - A():i(1){} - ~A(); + public: + int i; + A():i(1) {} + ~A(); }; A::~A() { - i = -1; + i = -1; } int main() { - A a; + A a; } diff --git a/regression/cpp-from-CVS/Friend3/main.cpp b/regression/cpp-from-CVS/Friend3/main.cpp index 17987f5e08e..71a47b40516 100644 --- a/regression/cpp-from-CVS/Friend3/main.cpp +++ b/regression/cpp-from-CVS/Friend3/main.cpp @@ -1,17 +1,17 @@ class A { - friend void inc(A&); - friend int get(const A& a); - int i; + friend void inc(A&); + friend int get(const A& a); + int i; }; -void inc(A& a){a.i++;} +void inc(A& a) {a.i++;} int get(const A& a) {return a.i;} A a; int main() { - inc(a); - assert(get(a)==1); + inc(a); + assert(get(a)==1); } diff --git a/regression/cpp-from-CVS/Friend4/main.cpp b/regression/cpp-from-CVS/Friend4/main.cpp index 3a7366deca2..f9fc322cec6 100644 --- a/regression/cpp-from-CVS/Friend4/main.cpp +++ b/regression/cpp-from-CVS/Friend4/main.cpp @@ -1,15 +1,15 @@ class A { - int i; + int i; }; -void inc(A& a){a.i++;} +void inc(A& a) {a.i++;} int get(const A& a) {return a.i;} A a; int main() { - inc(a); - assert(get(a)==1); + inc(a); + assert(get(a)==1); } diff --git a/regression/cpp-from-CVS/Friend5/main.cpp b/regression/cpp-from-CVS/Friend5/main.cpp index ac5fa72f7da..4ab363bccbe 100644 --- a/regression/cpp-from-CVS/Friend5/main.cpp +++ b/regression/cpp-from-CVS/Friend5/main.cpp @@ -1,26 +1,26 @@ class A { - int i; - friend class B; + int i; + friend class B; }; class B { - public: - static int get(const A& a) - { - return a.i; - } + public: + static int get(const A& a) + { + return a.i; + } - static void set(A& a, int i) - { - a.i = i; - } + static void set(A& a, int i) + { + a.i = i; + } }; int main() { - A a; - B::set(a,10); - assert(B::get(a)==10); + A a; + B::set(a, 10); + assert(B::get(a)==10); } diff --git a/regression/cpp-from-CVS/Friend6/main.cpp b/regression/cpp-from-CVS/Friend6/main.cpp index b5e2148fa08..300ef465299 100644 --- a/regression/cpp-from-CVS/Friend6/main.cpp +++ b/regression/cpp-from-CVS/Friend6/main.cpp @@ -2,22 +2,22 @@ class B; template struct A { - int get_i(B& b); + int get_i(B& b); }; class B { - int i; - public: - B():i(10){}; - friend class A; + int i; + public: + B():i(10){} + friend class A; }; template -int A::get_i(B& b){return b.i;} +int A::get_i(B& b) {return b.i;} int main() { - B b; - A a; - assert(a.get_i(b)==10); + B b; + A a; + assert(a.get_i(b)==10); } diff --git a/regression/cpp-from-CVS/Function_Arguments5/main.cpp b/regression/cpp-from-CVS/Function_Arguments5/main.cpp index 0f6396a054d..c417646b161 100644 --- a/regression/cpp-from-CVS/Function_Arguments5/main.cpp +++ b/regression/cpp-from-CVS/Function_Arguments5/main.cpp @@ -1,10 +1,10 @@ -bool func(const int& i){return false;} -bool func(const int* i){return true;} +bool func(const int& i) {return false;} +bool func(const int* i) {return true;} int main() { - int k; - int& rk = k; - assert(!func(rk)); - assert(func(&k)); + int k; + int& rk = k; + assert(!func(rk)); + assert(func(&k)); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion1/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion1/main.cpp index c6f1e5d79cb..98b0c1b2822 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion1/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion1/main.cpp @@ -1,20 +1,20 @@ struct A { - int i; + int i; }; struct B: public A { - int j; + int j; }; int func(A a) { - return a.i; + return a.i; } int main() { - B b; - b.i = 1; - assert(func(b)==1); + B b; + b.i = 1; + assert(func(b)==1); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion2/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion2/main.cpp index 0ab7eeeae49..6dcdf0a8d06 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion2/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion2/main.cpp @@ -1,14 +1,14 @@ char func1(const char& c) { - return c; + return c; } int main() { - assert(func1((char)10)==10); + assert(func1((char)10)==10); - int i(20); - assert(func1((char)i)==20); + int i(20); + assert(func1((char)i)==20); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion3/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion3/main.cpp index 8d99c21f4c4..0687793c6e5 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion3/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion3/main.cpp @@ -1,26 +1,26 @@ struct A { - int i; - A():i(0){} - A(int i):i(i){} + int i; + A():i(0) {} + A(int i):i(i){} }; struct B { - int j; - B():j(0){} - B(int j): j(j){} - B(const A& a):j(a.i){} + int j; + B():j(0) {} + B(int j): j(j) {} + B(const A& a):j(a.i){} }; B operator+(const B b1, B b2) { - return B( b1.j + b2.j ); + return B( b1.j + b2.j ); } int main() { - A a(10); - B b = a + a; - assert(b.j == 20); + A a(10); + B b = a + a; + assert(b.j == 20); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion4/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion4/main.cpp index 3c97123c83e..7609dfdce9a 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion4/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion4/main.cpp @@ -1,82 +1,82 @@ struct B { - int j; - B(int j):j(j){} + int j; + B(int j):j(j){} }; struct A { - int i; - A(int i): i(i){} - A(const B& b):i(b.j){} + int i; + A(int i): i(i) {} + A(const B& b):i(b.j){} }; struct C: public A { - C(int i): A(i){} + C(int i): A(i){} }; int func1(const A& a) { - return a.i; + return a.i; } int func2(A& a) { - return a.i; + return a.i; } int func3(A a) { - return a.i; + return a.i; } int main() { - A a1(10); - assert(func1(a1)==10); - assert(func2(a1)==10); - assert(func3(a1)==10); - - const A a2(20); - assert(func1(a2)==20); - assert(func3(a2)==20); - - A& r1 = a1; - assert(func1(r1)==10); - assert(func2(r1)==10); - assert(func3(r1)==10); - - const A& r2 = a1; - assert(func1(r2)==10); - assert(func3(r2)==10); - - B b1(30); - assert(func3(b1)==30); - - B& r3 = b1; - assert(func3(r3)==30); - - const B& r4 = b1; - assert(func3(r4)==30); - - C c1(40); - assert(func1(c1)==40); - assert(func2(c1)==40); - assert(func3(c1)==40); - - const C c2(50); - assert(func1(c2)==50); - assert(func3(c2)==50); - - C& r5 = c1; - assert(func1(r5)==40); - assert(func2(r5)==40); - assert(func3(r5)==40); - - const C& r6 = c2; - assert(func1(r6)==50); - assert(func3(r6)==50); + A a1(10); + assert(func1(a1)==10); + assert(func2(a1)==10); + assert(func3(a1)==10); + + const A a2(20); + assert(func1(a2)==20); + assert(func3(a2)==20); + + A& r1 = a1; + assert(func1(r1)==10); + assert(func2(r1)==10); + assert(func3(r1)==10); + + const A& r2 = a1; + assert(func1(r2)==10); + assert(func3(r2)==10); + + B b1(30); + assert(func3(b1)==30); + + B& r3 = b1; + assert(func3(r3)==30); + + const B& r4 = b1; + assert(func3(r4)==30); + + C c1(40); + assert(func1(c1)==40); + assert(func2(c1)==40); + assert(func3(c1)==40); + + const C c2(50); + assert(func1(c2)==50); + assert(func3(c2)==50); + + C& r5 = c1; + assert(func1(r5)==40); + assert(func2(r5)==40); + assert(func3(r5)==40); + + const C& r6 = c2; + assert(func1(r6)==50); + assert(func3(r6)==50); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion5/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion5/main.cpp index b738cd2932e..8c65195f099 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion5/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion5/main.cpp @@ -2,6 +2,6 @@ void f(int); int main() { - char* pc; - f(pc); // invalid conversion + char* pc; + f(pc); // invalid conversion } diff --git a/regression/cpp-from-CVS/Implicit_Conversion6/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion6/main.cpp index 261b43cce8d..dd3549747ac 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion6/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion6/main.cpp @@ -1,7 +1,7 @@ -bool f(const char *){return true;} -bool f(int){return false;} +bool f(const char *) {return true;} +bool f(int) {return false;} int main() { - assert(f("hello")); + assert(f("hello")); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion7/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion7/main.cpp index d618bce66b3..64091308c0e 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion7/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion7/main.cpp @@ -1,5 +1,5 @@ int main() { - int a; - assert(&a); + int a; + assert(&a); } diff --git a/regression/cpp-from-CVS/Implicit_Conversion8/main.cpp b/regression/cpp-from-CVS/Implicit_Conversion8/main.cpp index 2d8bed0470f..2868594a2ef 100644 --- a/regression/cpp-from-CVS/Implicit_Conversion8/main.cpp +++ b/regression/cpp-from-CVS/Implicit_Conversion8/main.cpp @@ -1,39 +1,39 @@ struct Bit { - bool b; - Bit(bool b=false):b(b){} - Bit(const Bit& bit):b(bit.b){} + bool b; + Bit(bool b=false):b(b) {} + Bit(const Bit& bit):b(bit.b) {} -// operator bool() const {return b;} +// operator bool() const {return b;} - Bit& operator=(bool b) - { - this->b = b; - return *this; + Bit& operator=(bool b) + { + this->b = b; + return *this; } Bit& operator =(const Bit& bit) { - this->b = bit.b; - return *this; + this->b = bit.b; + return *this; } - friend const Bit operator ~(const Bit& bit) - { - Bit r; - r.b = ~bit.b; - return r; - } + friend const Bit operator ~(const Bit& bit) + { + Bit r; + r.b = ~bit.b; + return r; + } - friend void b_not( Bit& r, const Bit& a ) - { r = (~a); } + friend void b_not( Bit& r, const Bit& a ) + { r = (~a); } }; int main() { - Bit b1, b2; - b_not(b1,b2); - assert(b1.b != b2.b); + Bit b1, b2; + b_not(b1, b2); + assert(b1.b != b2.b); } diff --git a/regression/cpp-from-CVS/Inheritance2/main.cpp b/regression/cpp-from-CVS/Inheritance2/main.cpp index c75d001b75e..692b7a27f20 100644 --- a/regression/cpp-from-CVS/Inheritance2/main.cpp +++ b/regression/cpp-from-CVS/Inheritance2/main.cpp @@ -16,23 +16,23 @@ class B:public A int i; void f() { - i++; - A::i++; + i++; + A::i++; } }; int main() { - B b; - b.i = 0; - b.B::i++; + B b; + b.i = 0; + b.B::i++; - b.A::i = 10; + b.A::i = 10; - b.f(); - assert(b.i == 2); - assert(b.A::i == 11); + b.f(); + assert(b.i == 2); + assert(b.A::i == 11); - b.A::f(); - assert(b.A::i == 1); + b.A::f(); + assert(b.A::i == 1); } diff --git a/regression/cpp-from-CVS/Inheritance3/main.cpp b/regression/cpp-from-CVS/Inheritance3/main.cpp index 6afd5a28522..ef2b173312a 100644 --- a/regression/cpp-from-CVS/Inheritance3/main.cpp +++ b/regression/cpp-from-CVS/Inheritance3/main.cpp @@ -1,20 +1,20 @@ struct A { - typedef int INT; + typedef int INT; }; struct B: public A { - INT i; - void set(INT i) - { - this->i = i; - } + INT i; + void set(INT i) + { + this->i = i; + } }; int main() { - B b; - b.i = 0; - b.i++; - assert(b.i==1); + B b; + b.i = 0; + b.i++; + assert(b.i==1); } diff --git a/regression/cpp-from-CVS/Inheritance4/main.cpp b/regression/cpp-from-CVS/Inheritance4/main.cpp index 6bf3ddc35ca..58a95de0d34 100644 --- a/regression/cpp-from-CVS/Inheritance4/main.cpp +++ b/regression/cpp-from-CVS/Inheritance4/main.cpp @@ -1,15 +1,15 @@ struct A{ int x; - A(){} + A(){} }; struct B: public A{ - B(){} + B(){} }; int main() { - B b1,b2; - b1 = b2; - assert(b1.x == b2.x); + B b1, b2; + b1 = b2; + assert(b1.x == b2.x); } diff --git a/regression/cpp-from-CVS/Label0/main.cpp b/regression/cpp-from-CVS/Label0/main.cpp index 0d266d45ce3..00025a6820b 100644 --- a/regression/cpp-from-CVS/Label0/main.cpp +++ b/regression/cpp-from-CVS/Label0/main.cpp @@ -1,7 +1,7 @@ int main() { dummy_label: - int i = 0; + int i = 0; - assert(i==0); + assert(i==0); } diff --git a/regression/cpp-from-CVS/Lvalue1/main.cpp b/regression/cpp-from-CVS/Lvalue1/main.cpp index 5c2dbcc2c30..15b0f40f58d 100644 --- a/regression/cpp-from-CVS/Lvalue1/main.cpp +++ b/regression/cpp-from-CVS/Lvalue1/main.cpp @@ -1,26 +1,26 @@ struct A { - int i; - A():i(0){} - int get_i(){return i;} + int i; + A():i(0) {} + int get_i(){return i;} }; -A factory(){ - return A(); +A factory() { + return A(); } int main() { - // Altough the returned value of `factory' is an - // rvalue, gcc accepts to bind it to the `this' - // parameter of the method `get_i'. Note that when used, - // a returned value is stored in a temporary - // (see goto_convertt::remove_function_call). Thus, - // the value returned by a function call can be treated - // as an lvalue. - // - // It's not clear what the best is. Should this code be rejected? - // Is the compatibility with gcc more important? + // Altough the returned value of `factory' is an + // rvalue, gcc accepts to bind it to the `this' + // parameter of the method `get_i'. Note that when used, + // a returned value is stored in a temporary + // (see goto_convertt::remove_function_call). Thus, + // the value returned by a function call can be treated + // as an lvalue. + // + // It's not clear what the best is. Should this code be rejected? + // Is the compatibility with gcc more important? - assert(factory().get_i() == 0); + assert(factory().get_i() == 0); } diff --git a/regression/cpp-from-CVS/Multiple_Inheritance1/main.cpp b/regression/cpp-from-CVS/Multiple_Inheritance1/main.cpp index c10b1255670..802aa5f9683 100644 --- a/regression/cpp-from-CVS/Multiple_Inheritance1/main.cpp +++ b/regression/cpp-from-CVS/Multiple_Inheritance1/main.cpp @@ -1,21 +1,21 @@ struct A { - int i; + int i; }; struct B { - int j; - void setJ(int j){this->j = j;} + int j; + void setJ(int j){this->j = j;} }; struct C: A, B { - int k; + int k; }; int main() { - C c; - c.setJ(10); - assert(c.j==10); + C c; + c.setJ(10); + assert(c.j==10); } diff --git a/regression/cpp-from-CVS/Multiple_Inheritance2/main.cpp b/regression/cpp-from-CVS/Multiple_Inheritance2/main.cpp index cca4f3ce8da..cb076087222 100644 --- a/regression/cpp-from-CVS/Multiple_Inheritance2/main.cpp +++ b/regression/cpp-from-CVS/Multiple_Inheritance2/main.cpp @@ -1,6 +1,6 @@ struct A{ - int i; - A(){}; + int i; + A(){}; }; struct B: virtual A{}; struct C: virtual A{}; @@ -8,7 +8,7 @@ struct D: B, C {}; int main() { - D d; - d.i = 10; - assert(d.i == 10); + D d; + d.i = 10; + assert(d.i == 10); } diff --git a/regression/cpp-from-CVS/Multiple_Inheritance4/main.cpp b/regression/cpp-from-CVS/Multiple_Inheritance4/main.cpp index 4d665ffaf73..e98a8cedcc8 100644 --- a/regression/cpp-from-CVS/Multiple_Inheritance4/main.cpp +++ b/regression/cpp-from-CVS/Multiple_Inheritance4/main.cpp @@ -1,6 +1,6 @@ struct ostream { - ostream(int id): id(id){} + ostream(int id): id(id) {} ostream(const ostream&); // disabled ostream& operator=(const ostream&); // disabled int id; @@ -8,7 +8,7 @@ struct istream { - istream(int id): id(id){} + istream(int id): id(id) {} istream(const istream&); // disabled istream& operator=(const istream&); // disabled int id; diff --git a/regression/cpp-from-CVS/Mutable1/main.cpp b/regression/cpp-from-CVS/Mutable1/main.cpp index cf2832e9b8c..62120d09a7d 100644 --- a/regression/cpp-from-CVS/Mutable1/main.cpp +++ b/regression/cpp-from-CVS/Mutable1/main.cpp @@ -1,15 +1,15 @@ struct A { - mutable int i; - void set(int v) const - { - i = v; - } + mutable int i; + void set(int v) const + { + i = v; + } }; int main() { - const A a; - a.set(99); - assert(a.i==99); + const A a; + a.set(99); + assert(a.i==99); } diff --git a/regression/cpp-from-CVS/Overloading_Functions2/main.cpp b/regression/cpp-from-CVS/Overloading_Functions2/main.cpp index 2fec1d62fc3..56f13da463b 100644 --- a/regression/cpp-from-CVS/Overloading_Functions2/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Functions2/main.cpp @@ -7,11 +7,11 @@ struct B: A { struct C: B { }; -bool f1(A&){return true;} -bool f1(B&){return false;} +bool f1(A&) {return true;} +bool f1(B&) {return false;} int main() { - C c; - assert(f1(c)==false); + C c; + assert(f1(c)==false); } diff --git a/regression/cpp-from-CVS/Overloading_Increment1/main.cpp b/regression/cpp-from-CVS/Overloading_Increment1/main.cpp index bcb5efdd2c5..6fbb8c5269b 100644 --- a/regression/cpp-from-CVS/Overloading_Increment1/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Increment1/main.cpp @@ -1,43 +1,43 @@ struct A { - int a; - A operator++(int zero) - { - A obj(*this); - a++; - return obj; - } + int a; + A operator++(int zero) + { + A obj(*this); + a++; + return obj; + } - A& operator++() - { - a++; - return *this; - } + A& operator++() + { + a++; + return *this; + } - A operator--(int zero) - { - A obj(*this); - a--; - return obj; - } + A operator--(int zero) + { + A obj(*this); + a--; + return obj; + } - A& operator--() - { - a--; - return *this; - } + A& operator--() + { + a--; + return *this; + } }; int main() { - A obj; - obj.a = 0; - A obj2 = obj++; - assert(obj2.a == 0 && obj.a==1); - obj2 = ++obj; - assert(obj2.a == 2 && obj.a==2); - obj2 = obj--; - assert(obj2.a == 2 && obj.a==1); - obj2 = --obj; - assert(obj2.a == 0 && obj.a==0); + A obj; + obj.a = 0; + A obj2 = obj++; + assert(obj2.a == 0 && obj.a==1); + obj2 = ++obj; + assert(obj2.a == 2 && obj.a==2); + obj2 = obj--; + assert(obj2.a == 2 && obj.a==1); + obj2 = --obj; + assert(obj2.a == 0 && obj.a==0); } diff --git a/regression/cpp-from-CVS/Overloading_Operators10/main.cpp b/regression/cpp-from-CVS/Overloading_Operators10/main.cpp index 0016aa5905a..5bb82e98875 100644 --- a/regression/cpp-from-CVS/Overloading_Operators10/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators10/main.cpp @@ -1,22 +1,22 @@ struct A { - bool True(){return true;} + bool True(){return true;} }; struct B { - A a; - A* operator->(){return &a;} + A a; + A* operator->(){return &a;} }; struct C { - B b; - B& operator->(){return b;} + B b; + B& operator->(){return b;} }; int main() { - C c; - assert(c->True()); + C c; + assert(c->True()); } diff --git a/regression/cpp-from-CVS/Overloading_Operators11/main.cpp b/regression/cpp-from-CVS/Overloading_Operators11/main.cpp index c8ab83dbe71..83b333353e8 100644 --- a/regression/cpp-from-CVS/Overloading_Operators11/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators11/main.cpp @@ -1,21 +1,21 @@ struct C { - bool b; - C(bool b):b(b){} + bool b; + C(bool b):b(b){} }; struct A { - C c1; + C c1; - A():c1(false){} - const C* operator->() const {return &c1;} + A():c1(false) {} + const C* operator->() const {return &c1;} }; struct B : A { - bool func() const { return (*this)->b;}; + bool func() const { return (*this)->b;} }; int main() { - const B b1; - assert(b1.func() == false); + const B b1; + assert(b1.func() == false); } diff --git a/regression/cpp-from-CVS/Overloading_Operators12/main.cpp b/regression/cpp-from-CVS/Overloading_Operators12/main.cpp index 90f404643b9..19c84c54078 100644 --- a/regression/cpp-from-CVS/Overloading_Operators12/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators12/main.cpp @@ -1,10 +1,10 @@ struct A { - bool operator << (const A&) const {return true;} - bool func(const A& a)const{ return operator <<(a);} + bool operator << (const A&) const {return true;} + bool func(const A& a)const{ return operator <<(a);} }; int main() { - A a; - assert(a.func(a)==true); + A a; + assert(a.func(a)==true); } diff --git a/regression/cpp-from-CVS/Overloading_Operators13/main.cpp b/regression/cpp-from-CVS/Overloading_Operators13/main.cpp index fd4a5ae6acd..7b18f5d61a0 100644 --- a/regression/cpp-from-CVS/Overloading_Operators13/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators13/main.cpp @@ -1,15 +1,15 @@ struct A { - bool operator[](int index) {return true;} + bool operator[](int index) {return true;} }; struct B { - A a; - bool operator[](int index) {return false;} - bool func(){return a[0];} + A a; + bool operator[](int index) {return false;} + bool func(){return a[0];} }; int main() { - B b; - assert(b.func()==true); + B b; + assert(b.func()==true); } diff --git a/regression/cpp-from-CVS/Overloading_Operators14/main.cpp b/regression/cpp-from-CVS/Overloading_Operators14/main.cpp index 713294861eb..5a7244a4f6b 100644 --- a/regression/cpp-from-CVS/Overloading_Operators14/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators14/main.cpp @@ -1,14 +1,14 @@ struct A { - typedef int INT; - int i; - operator INT() { return i;} - INT value(){return operator INT();} + typedef int INT; + int i; + operator INT() { return i;} + INT value(){return operator INT();} }; int main() { - A a; - a.i = 20; - assert( a.value() == 20); + A a; + a.i = 20; + assert( a.value() == 20); } diff --git a/regression/cpp-from-CVS/Overloading_Operators4/main.cpp b/regression/cpp-from-CVS/Overloading_Operators4/main.cpp index 74851a8b218..f557ef63832 100644 --- a/regression/cpp-from-CVS/Overloading_Operators4/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators4/main.cpp @@ -15,9 +15,9 @@ struct X bool func() { - X x1, x2; - x1.i = 2; - return x1 == x2; + X x1, x2; + x1.i = 2; + return x1 == x2; } }; diff --git a/regression/cpp-from-CVS/Overloading_Operators6/main.cpp b/regression/cpp-from-CVS/Overloading_Operators6/main.cpp index cd79b851225..bb957c3f9ef 100644 --- a/regression/cpp-from-CVS/Overloading_Operators6/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators6/main.cpp @@ -1,46 +1,46 @@ struct A { - int i; - A():i(1){} + int i; + A():i(1) {} - int& operator* () {return i;} - int operator+ (int j){return i+j;} - int operator~ (){return ~i;} - int operator[] (int k){return i;} - int operator== (int k){return i=i;} + int& operator* () {return i;} + int operator+ (int j) {return i+j;} + int operator~ () {return ~i;} + int operator[] (int k) {return i;} + int operator== (int k) {return i=i;} - void func1() - { - A a; - assert(*a == 1); - assert(*a + 1 == 2); - assert(~a == ~1); - assert(a[2] == *a); - assert(a == 1); - } + void func1() + { + A a; + assert(*a == 1); + assert(*a + 1 == 2); + assert(~a == ~1); + assert(a[2] == *a); + assert(a == 1); + } - void func2() - { - A a; - assert((*this) == 1); - assert((*this) + 1 == 2); - assert(~(*this) == ~1); - assert((*this)[2] == *(*this)); - assert((*this) == 1); - } + void func2() + { + A a; + assert((*this) == 1); + assert((*this) + 1 == 2); + assert(~(*this) == ~1); + assert((*this)[2] == *(*this)); + assert((*this) == 1); + } }; int main() { - A o; - assert(*o == 1); - assert(*o + 1 == 2); - assert(~o == ~1); - assert(o[2] == *o); - assert(o == 1); + A o; + assert(*o == 1); + assert(*o + 1 == 2); + assert(~o == ~1); + assert(o[2] == *o); + assert(o == 1); - o.func1(); - o.func2(); + o.func1(); + o.func2(); } diff --git a/regression/cpp-from-CVS/Overloading_Operators7/main.cpp b/regression/cpp-from-CVS/Overloading_Operators7/main.cpp index 0f2f795019c..0b09d0f9624 100644 --- a/regression/cpp-from-CVS/Overloading_Operators7/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators7/main.cpp @@ -3,7 +3,7 @@ int g; struct A { int i; - A(int i):i(i){} + A(int i):i(i) {} friend bool operator==(const A& a1, const A& a2) { diff --git a/regression/cpp-from-CVS/Overloading_Operators8/main.cpp b/regression/cpp-from-CVS/Overloading_Operators8/main.cpp index 02c520b09df..fe018e737b6 100644 --- a/regression/cpp-from-CVS/Overloading_Operators8/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators8/main.cpp @@ -1,20 +1,20 @@ struct A { - int i; + int i; }; A& operator <<(A& a1, A& a2) { - a1.i=a2.i; - a2.i=0; - return a1; + a1.i=a2.i; + a2.i=0; + return a1; } int main() { - A a1, a2; - a2.i = 400; - A a3(a1 << a2); - assert(a2.i==0); - assert(a3.i==a1.i); - assert(a1.i==400); + A a1, a2; + a2.i = 400; + A a3(a1 << a2); + assert(a2.i==0); + assert(a3.i==a1.i); + assert(a1.i==400); } diff --git a/regression/cpp-from-CVS/Overloading_Operators9/main.cpp b/regression/cpp-from-CVS/Overloading_Operators9/main.cpp index 2ad8eac075d..f7007039bd8 100644 --- a/regression/cpp-from-CVS/Overloading_Operators9/main.cpp +++ b/regression/cpp-from-CVS/Overloading_Operators9/main.cpp @@ -1,30 +1,30 @@ struct C { - int d; + int d; }; struct B { - C c; - C* operator->() - { - return &c; - } + C c; + C* operator->() + { + return &c; + } }; struct A { - B b; - B& operator->() - { - return b; - } + B b; + B& operator->() + { + return b; + } }; int main() { - A a; - a->d = 2; - assert(a.b.c.d==2); + A a; + a->d = 2; + assert(a.b.c.d==2); } diff --git a/regression/cpp-from-CVS/Pointer_Conversion3/main.cpp b/regression/cpp-from-CVS/Pointer_Conversion3/main.cpp index 7a39cde597d..e7a36e59709 100644 --- a/regression/cpp-from-CVS/Pointer_Conversion3/main.cpp +++ b/regression/cpp-from-CVS/Pointer_Conversion3/main.cpp @@ -1,17 +1,17 @@ struct A { - int i; + int i; }; struct B { - int j; - int k; + int j; + int k; }; int main() { - A* pa; - B* pb; - pb = static_cast(pa); // ill-formed + A* pa; + B* pb; + pb = static_cast(pa); // ill-formed } diff --git a/regression/cpp-from-CVS/Pointer_To_Member1/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member1/main.cpp index e0b789c540d..62e9d88feb8 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member1/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member1/main.cpp @@ -1,16 +1,16 @@ class A { - public: - int f(char i){return i+1;} + public: + int f(char i){return i+1;} }; A a; int (A::* paf)(char) = &A::f; int main() { - int v1 = (a.*paf)(0); - int v2 = ((&a)->*paf)(1); + int v1 = (a.*paf)(0); + int v2 = ((&a)->*paf)(1); - assert(v1 == 1); - assert(v2 == 2); + assert(v1 == 1); + assert(v2 == 2); } diff --git a/regression/cpp-from-CVS/Pointer_To_Member2/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member2/main.cpp index f79df4446bb..f28348526ab 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member2/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member2/main.cpp @@ -1,11 +1,11 @@ class A { - int a; + int a; }; -int f(A* pa, char i){return i+1;} +int f(A* pa, char i) {return i+1;} int main() { - int (A::* paf)(char) = &f; // ill-formed + int (A::* paf)(char) = &f; // ill-formed } diff --git a/regression/cpp-from-CVS/Pointer_To_Member3/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member3/main.cpp index 1716b813482..f674920c66c 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member3/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member3/main.cpp @@ -1,12 +1,12 @@ class A { - public: - int a; - int f(char i){return i+1;} + public: + int a; + int f(char i){return i+1;} }; int main() { - int (* pf)(A*, char) = &A::f; // ill-formed + int (* pf)(A*, char) = &A::f; // ill-formed } diff --git a/regression/cpp-from-CVS/Pointer_To_Member4/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member4/main.cpp index 877832e735b..5b36451b909 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member4/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member4/main.cpp @@ -1,12 +1,12 @@ class A { - public: - int f(){return 1;} + public: + int f(){return 1;} }; int main() { - int (A::* paf)() = &A::f; - A a; - (*paf)(&a); // ill-formed + int (A::* paf)() = &A::f; + A a; + (*paf)(&a); // ill-formed } diff --git a/regression/cpp-from-CVS/Pointer_To_Member5/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member5/main.cpp index 7aa906ae1de..f79f05c3c46 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member5/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member5/main.cpp @@ -1,21 +1,21 @@ struct A { - int i; - int func(){return i;} + int i; + int func(){return i;} }; struct B { - A* pa; - int (A::* pmethod)(); - B(A* pa, int (A::* pmethod)()):pa(pa),pmethod(pmethod){} - int eval(){return (pa->*pmethod)();} + A* pa; + int (A::* pmethod)(); + B(A* pa, int (A::* pmethod)()):pa(pa), pmethod(pmethod) {} + int eval(){return (pa->*pmethod)();} }; int main() { - A a; - B b(&a, &A::func); - assert(b.eval() == a.i); + A a; + B b(&a, &A::func); + assert(b.eval() == a.i); } diff --git a/regression/cpp-from-CVS/Pointer_To_Member6/main.cpp b/regression/cpp-from-CVS/Pointer_To_Member6/main.cpp index 1f05ba06ea2..3ab65447e5d 100644 --- a/regression/cpp-from-CVS/Pointer_To_Member6/main.cpp +++ b/regression/cpp-from-CVS/Pointer_To_Member6/main.cpp @@ -1,21 +1,21 @@ struct A { - int i; - void func(){i = 10;} + int i; + void func(){i = 10;} }; struct B: public A { - void (A::* pmeth)(); - B(): - pmeth(&A::func) - { - (this->*pmeth)(); - } + void (A::* pmeth)(); + B(): + pmeth(&A::func) + { + (this->*pmeth)(); + } }; int main() { - B b; - assert(b.i == 10); + B b; + assert(b.i == 10); } diff --git a/regression/cpp-from-CVS/Protection1/main.cpp b/regression/cpp-from-CVS/Protection1/main.cpp index cdecf5b6c59..5b0131782dc 100644 --- a/regression/cpp-from-CVS/Protection1/main.cpp +++ b/regression/cpp-from-CVS/Protection1/main.cpp @@ -1,9 +1,9 @@ class A { - int i; - A(int i):i(i){} - private: - A(); // disabled + int i; + A(int i):i(i) {} + private: + A(); // disabled }; class B: A diff --git a/regression/cpp-from-CVS/Protection2/main.cpp b/regression/cpp-from-CVS/Protection2/main.cpp index 93158ce913e..02885d9e419 100644 --- a/regression/cpp-from-CVS/Protection2/main.cpp +++ b/regression/cpp-from-CVS/Protection2/main.cpp @@ -1,19 +1,19 @@ struct A { - protected: - int i; + protected: + int i; }; class B: A { - public: - void set(int i){this->i = i;} - int get() const {return i;} + public: + void set(int i) {this->i = i;} + int get() const {return i;} }; int main() { - B b; - b.set(0); - assert(b.get()== 0); + B b; + b.set(0); + assert(b.get()== 0); } diff --git a/regression/cpp-from-CVS/Protection3/main.cpp b/regression/cpp-from-CVS/Protection3/main.cpp index 4938a6831ca..aa745b53f35 100644 --- a/regression/cpp-from-CVS/Protection3/main.cpp +++ b/regression/cpp-from-CVS/Protection3/main.cpp @@ -1,10 +1,10 @@ class A { - int i; + int i; - public: - class B - { - int get(const A& a){return a.i;} - }; + public: + class B + { + int get(const A& a){return a.i;} + }; }; diff --git a/regression/cpp-from-CVS/Protection4/main.cpp b/regression/cpp-from-CVS/Protection4/main.cpp index 08bf0c0a00a..edb5b11ead1 100644 --- a/regression/cpp-from-CVS/Protection4/main.cpp +++ b/regression/cpp-from-CVS/Protection4/main.cpp @@ -1,12 +1,12 @@ struct A { - private: - int i; + private: + int i; }; class B: public A { - public: - void set(int i){this->i = i;} - int get() const {return i;} + public: + void set(int i) {this->i = i;} + int get() const {return i;} }; diff --git a/regression/cpp-from-CVS/Protection5/main.cpp b/regression/cpp-from-CVS/Protection5/main.cpp index 0922af3797d..e654089c391 100644 --- a/regression/cpp-from-CVS/Protection5/main.cpp +++ b/regression/cpp-from-CVS/Protection5/main.cpp @@ -1,7 +1,7 @@ class A { - public: - int i; + public: + int i; }; class B: A @@ -11,11 +11,11 @@ class B: A void set_one(A& a) { - a.i = 1; + a.i = 1; } int main() { - B b; - set_one(b); + B b; + set_one(b); } diff --git a/regression/cpp-from-CVS/Protection6/main.cpp b/regression/cpp-from-CVS/Protection6/main.cpp index ae2a646f168..72f33b28e54 100644 --- a/regression/cpp-from-CVS/Protection6/main.cpp +++ b/regression/cpp-from-CVS/Protection6/main.cpp @@ -1,8 +1,8 @@ class A { - static void func(){} + static void func(){} }; int main() { - A::func(); + A::func(); } diff --git a/regression/cpp-from-CVS/Protection7/main.cpp b/regression/cpp-from-CVS/Protection7/main.cpp index a96487a2ed3..6194604583f 100644 --- a/regression/cpp-from-CVS/Protection7/main.cpp +++ b/regression/cpp-from-CVS/Protection7/main.cpp @@ -1,20 +1,20 @@ struct A { - int i; - A(){}; - protected: - A(int i):i(i){}; + int i; + A(){}; + protected: + A(int i):i(i){} }; struct B: A { - B():A(0){} + B():A(0){} }; B b; int main() { - assert(b.i==0); + assert(b.i==0); } diff --git a/regression/cpp-from-CVS/Protection8/main.cpp b/regression/cpp-from-CVS/Protection8/main.cpp index 6db34b0320e..b0b2de06b11 100644 --- a/regression/cpp-from-CVS/Protection8/main.cpp +++ b/regression/cpp-from-CVS/Protection8/main.cpp @@ -1,21 +1,21 @@ struct A { - protected: - int i; - int get_i(){return i;} + protected: + int i; + int get_i() {return i;} - A(int i):i(i){}; + A(int i):i(i){} }; struct B: A { - B():A(0){} + B():A(0){} }; B b; int main() { - assert(b.get_i()==0); + assert(b.get_i()==0); } diff --git a/regression/cpp-from-CVS/Qualifier1/main.cpp b/regression/cpp-from-CVS/Qualifier1/main.cpp index 674220824a9..d2219dc9ef9 100644 --- a/regression/cpp-from-CVS/Qualifier1/main.cpp +++ b/regression/cpp-from-CVS/Qualifier1/main.cpp @@ -1,12 +1,12 @@ struct A { - int a; + int a; }; struct B { - void f() - { - A::a = 1; // ill-formed + void f() + { + A::a = 1; // ill-formed - } + } }; diff --git a/regression/cpp-from-CVS/Qualifier2/main.cpp b/regression/cpp-from-CVS/Qualifier2/main.cpp index 1fff2ce8662..d51626ee97c 100644 --- a/regression/cpp-from-CVS/Qualifier2/main.cpp +++ b/regression/cpp-from-CVS/Qualifier2/main.cpp @@ -1,24 +1,24 @@ struct A { - static int i; + static int i; }; struct B: public A { - static int i; + static int i; }; int main() { - A::i = 0; - B::i = 1; - assert(A::i == 0); - assert(B::i == 1); + A::i = 0; + B::i = 1; + assert(A::i == 0); + assert(B::i == 1); - B obj; - obj.i++; - assert(B::i == 2); - obj.A::i++; - assert(A::i == 1); + B obj; + obj.i++; + assert(B::i == 2); + obj.A::i++; + assert(A::i == 1); } diff --git a/regression/cpp-from-CVS/Qualifier3/main.cpp b/regression/cpp-from-CVS/Qualifier3/main.cpp index 08af31b80e1..e3d723784e8 100644 --- a/regression/cpp-from-CVS/Qualifier3/main.cpp +++ b/regression/cpp-from-CVS/Qualifier3/main.cpp @@ -1,12 +1,12 @@ struct A { - int f(); + int f(); }; struct B { - int g() - { - A::f(); // ill-formed - } + int g() + { + A::f(); // ill-formed + } }; diff --git a/regression/cpp-from-CVS/Qualifier4/main.cpp b/regression/cpp-from-CVS/Qualifier4/main.cpp index 18478c7e5ea..7c8722b0aca 100644 --- a/regression/cpp-from-CVS/Qualifier4/main.cpp +++ b/regression/cpp-from-CVS/Qualifier4/main.cpp @@ -1,9 +1,9 @@ struct A { - int f(); + int f(); }; int main() { - int i = (int) A::f; + int i = (int) A::f; } diff --git a/regression/cpp-from-CVS/Reference3/main.cpp b/regression/cpp-from-CVS/Reference3/main.cpp index a94a828901f..052233e98c7 100644 --- a/regression/cpp-from-CVS/Reference3/main.cpp +++ b/regression/cpp-from-CVS/Reference3/main.cpp @@ -2,17 +2,17 @@ class A { public: int& i; - A(int &i):i(i){} + A(int &i):i(i) {} private: A& operator=(const A&); }; int main() { - int var; - int& ref =var; - var = 10; - A a(var); - a.i = 20; - assert(var==20); + int var; + int& ref =var; + var = 10; + A a(var); + a.i = 20; + assert(var==20); } diff --git a/regression/cpp-from-CVS/Resolver5/main.cpp b/regression/cpp-from-CVS/Resolver5/main.cpp index f0584280047..df0f977a404 100644 --- a/regression/cpp-from-CVS/Resolver5/main.cpp +++ b/regression/cpp-from-CVS/Resolver5/main.cpp @@ -1,18 +1,18 @@ namespace n1 { - struct A { - int i; - }; + struct A { + int i; + }; - int func(A a){return a.i;} + int func(A a) {return a.i;} } int main() { - n1::A obj1; - obj1.i = 200; + n1::A obj1; + obj1.i = 200; - assert(func(obj1) == 200); // Argument-dependant name lookup + assert(func(obj1) == 200); // Argument-dependant name lookup - return 0; + return 0; } diff --git a/regression/cpp-from-CVS/Resolver6/main.cpp b/regression/cpp-from-CVS/Resolver6/main.cpp index ebadaa574bc..61685b4db15 100644 --- a/regression/cpp-from-CVS/Resolver6/main.cpp +++ b/regression/cpp-from-CVS/Resolver6/main.cpp @@ -1,15 +1,15 @@ bool f(char c) { - return false; + return false; } bool f(int i, int j = 0) { - return true; + return true; } int main() { - assert(f(5)); - return 0; + assert(f(5)); + return 0; } diff --git a/regression/cpp-from-CVS/Resolver7/main.cpp b/regression/cpp-from-CVS/Resolver7/main.cpp index f6bd1a2e7f5..2b3035def8c 100644 --- a/regression/cpp-from-CVS/Resolver7/main.cpp +++ b/regression/cpp-from-CVS/Resolver7/main.cpp @@ -1,11 +1,11 @@ extern const char hello []; -bool func(const char* str){return true;} -bool func(char* ){return false;} +bool func(const char* str) {return true;} +bool func(char* ) {return false;} int main() { - assert(func(hello)); + assert(func(hello)); } const char hello[] = "hello"; diff --git a/regression/cpp-from-CVS/Resolver8/main.cpp b/regression/cpp-from-CVS/Resolver8/main.cpp index bff2111885a..f1d7300996e 100644 --- a/regression/cpp-from-CVS/Resolver8/main.cpp +++ b/regression/cpp-from-CVS/Resolver8/main.cpp @@ -1,13 +1,13 @@ -bool func(){return true;} +bool func() {return true;} bool func(int i) { - if(i==0) - return false; - return func(); + if(i==0) + return false; + return func(); } int main() { - assert(func(1)); + assert(func(1)); } diff --git a/regression/cpp-from-CVS/Resolver9/main.cpp b/regression/cpp-from-CVS/Resolver9/main.cpp index 6e85ba34ed3..259d94951fb 100644 --- a/regression/cpp-from-CVS/Resolver9/main.cpp +++ b/regression/cpp-from-CVS/Resolver9/main.cpp @@ -1,11 +1,11 @@ struct A { - typedef int INT; + typedef int INT; }; struct B: A{}; int main() { - B::INT i; + B::INT i; } diff --git a/regression/cpp-from-CVS/Static_Method1/main.cpp b/regression/cpp-from-CVS/Static_Method1/main.cpp index 919afcc3d94..630ef1979ee 100644 --- a/regression/cpp-from-CVS/Static_Method1/main.cpp +++ b/regression/cpp-from-CVS/Static_Method1/main.cpp @@ -1,11 +1,11 @@ struct A { - static int Value(int v){return v;} - static int Value(int v1, int v2){return 1;} + static int Value(int v) {return v;} + static int Value(int v1, int v2){return 1;} }; int main() { - A a; - assert(a.Value(0) == 0); + A a; + assert(a.Value(0) == 0); } diff --git a/regression/cpp-from-CVS/Templates10/main.cpp b/regression/cpp-from-CVS/Templates10/main.cpp index 97b554d59e0..663719a98f0 100644 --- a/regression/cpp-from-CVS/Templates10/main.cpp +++ b/regression/cpp-from-CVS/Templates10/main.cpp @@ -1,24 +1,24 @@ template int func() { - return 0; + return 0; } template <> int func() { - return 1; + return 1; } template <> int func() { - return 2; + return 2; } int main() { - assert(func() == 0); - assert(func() == 1); - assert(func() == 2); + assert(func() == 0); + assert(func() == 1); + assert(func() == 2); } diff --git a/regression/cpp-from-CVS/Templates11/main.cpp b/regression/cpp-from-CVS/Templates11/main.cpp index 33c6feaf304..a4009d36437 100644 --- a/regression/cpp-from-CVS/Templates11/main.cpp +++ b/regression/cpp-from-CVS/Templates11/main.cpp @@ -1,22 +1,22 @@ template -bool func(T t){return false;} +bool func(T t) {return false;} template <> -bool func(int t){return true;} +bool func(int t) {return true;} template struct Test { - bool f() - { - A a; - return func(a); - } + bool f() + { + A a; + return func(a); + } }; int main() { - Test t1; - assert(t1.f()==true); + Test t1; + assert(t1.f()==true); } diff --git a/regression/cpp-from-CVS/Templates13/main.cpp b/regression/cpp-from-CVS/Templates13/main.cpp index 1df8f73fcb4..ec872c10100 100644 --- a/regression/cpp-from-CVS/Templates13/main.cpp +++ b/regression/cpp-from-CVS/Templates13/main.cpp @@ -1,16 +1,16 @@ template -bool func(){ - return func(); +bool func() { + return func(); } template <> bool func() { - return true; + return true; } int main() { - assert(func()); + assert(func()); } diff --git a/regression/cpp-from-CVS/Templates14/main.cpp b/regression/cpp-from-CVS/Templates14/main.cpp index e7d358a60c2..05ee58aef23 100644 --- a/regression/cpp-from-CVS/Templates14/main.cpp +++ b/regression/cpp-from-CVS/Templates14/main.cpp @@ -1,20 +1,20 @@ namespace n1 { - template - struct A{ - S a; - }; + template + struct A{ + S a; + }; } template struct B{ - n1::A b; + n1::A b; }; int main() { - B o; - o.b.a = true; - assert(o.b.a==true); + B o; + o.b.a = true; + assert(o.b.a==true); }; diff --git a/regression/cpp-from-CVS/Templates17/main.cpp b/regression/cpp-from-CVS/Templates17/main.cpp index 1cd893b8b0e..7a537e5f5c0 100644 --- a/regression/cpp-from-CVS/Templates17/main.cpp +++ b/regression/cpp-from-CVS/Templates17/main.cpp @@ -2,8 +2,8 @@ template struct A { - bool b; - A(){} + bool b; + A(){} }; template <> @@ -15,6 +15,6 @@ struct A{bool b;}; int main() { - A a; - a.b = false; + A a; + a.b = false; } diff --git a/regression/cpp-from-CVS/Templates18/main.cpp b/regression/cpp-from-CVS/Templates18/main.cpp index f113591bbb7..71520e99e0a 100644 --- a/regression/cpp-from-CVS/Templates18/main.cpp +++ b/regression/cpp-from-CVS/Templates18/main.cpp @@ -4,7 +4,7 @@ struct A; template struct A { - A(){} + A(){} }; @@ -12,13 +12,13 @@ struct A template <> struct A { - int b; - A(){} + int b; + A(){} }; int main() { - A a; - a.b = false; + A a; + a.b = false; } diff --git a/regression/cpp-from-CVS/Templates19/main.cpp b/regression/cpp-from-CVS/Templates19/main.cpp index 1d9374970c7..1c608e1c39c 100644 --- a/regression/cpp-from-CVS/Templates19/main.cpp +++ b/regression/cpp-from-CVS/Templates19/main.cpp @@ -1,22 +1,22 @@ template struct A { - T i; + T i; }; template T get_i(const A a1) { - return a1.i; + return a1.i; } int main() { - A a2; - a2.i = 10; - assert (a2.i == 10); - assert(get_i(a2) == 10); - get_i(a2); + A a2; + a2.i = 10; + assert (a2.i == 10); + assert(get_i(a2) == 10); + get_i(a2); } diff --git a/regression/cpp-from-CVS/Templates20/main.cpp b/regression/cpp-from-CVS/Templates20/main.cpp index 980e2315551..9b0217e9ee3 100644 --- a/regression/cpp-from-CVS/Templates20/main.cpp +++ b/regression/cpp-from-CVS/Templates20/main.cpp @@ -3,7 +3,7 @@ struct A { int i; - A():i(10){} + A():i(10) {} private: A(const A& a); // disabled @@ -14,7 +14,7 @@ class B: A { public: T t; B(){}; - int get_i(){return i;} + int get_i() {return i;} private: B(B& b); // disabled }; @@ -24,8 +24,8 @@ template <> class B: A { public: bool b; - B():b(true){}; - int get_i(){return i;} + B():b(true){} + int get_i() {return i;} private: B(B& b); // disabled }; diff --git a/regression/cpp-from-CVS/Templates22/main.cpp b/regression/cpp-from-CVS/Templates22/main.cpp index 54f21dbead6..49a57fbd5fe 100644 --- a/regression/cpp-from-CVS/Templates22/main.cpp +++ b/regression/cpp-from-CVS/Templates22/main.cpp @@ -1,11 +1,11 @@ template -T func(T* t){return *t;} +T func(T* t) {return *t;} template -T func(T t){ return t;} +T func(T t) { return t;} int main() { - int x = 10; - assert(func(&x) == func(x)); + int x = 10; + assert(func(&x) == func(x)); } diff --git a/regression/cpp-from-CVS/Templates25/main.cpp b/regression/cpp-from-CVS/Templates25/main.cpp index d13cd4aa0ad..205eaeb8be7 100644 --- a/regression/cpp-from-CVS/Templates25/main.cpp +++ b/regression/cpp-from-CVS/Templates25/main.cpp @@ -1,7 +1,7 @@ template -bool True(){return true;} +bool True() {return true;} int main() { - assert(True()==true); + assert(True()==true); } diff --git a/regression/cpp-from-CVS/Templates28/main.cpp b/regression/cpp-from-CVS/Templates28/main.cpp index aa7d7610c18..ec4c4b48074 100644 --- a/regression/cpp-from-CVS/Templates28/main.cpp +++ b/regression/cpp-from-CVS/Templates28/main.cpp @@ -13,6 +13,6 @@ struct B int main() { - B<5,4> b; + B<5, 4> b; assert(b.a.func() == 14); } diff --git a/regression/cpp-from-CVS/Templates29/main.cpp b/regression/cpp-from-CVS/Templates29/main.cpp index c9a11bda8d1..2faec6cde7f 100644 --- a/regression/cpp-from-CVS/Templates29/main.cpp +++ b/regression/cpp-from-CVS/Templates29/main.cpp @@ -10,7 +10,7 @@ struct A struct B : N::A { B(int i): N::A(i) {} - void func(){}; + void func(){} int b; }; diff --git a/regression/cpp-from-CVS/Templates3/main.cpp b/regression/cpp-from-CVS/Templates3/main.cpp index 13250692098..4ce1d69707e 100644 --- a/regression/cpp-from-CVS/Templates3/main.cpp +++ b/regression/cpp-from-CVS/Templates3/main.cpp @@ -6,8 +6,8 @@ class int_array int read(unsigned int x) { - assert(x class A { public: - A():v(V){} + A():v(V) {} T v; }; diff --git a/regression/cpp-from-CVS/Templates5/main.cpp b/regression/cpp-from-CVS/Templates5/main.cpp index 414c48cd9f2..4b2178ac1d4 100644 --- a/regression/cpp-from-CVS/Templates5/main.cpp +++ b/regression/cpp-from-CVS/Templates5/main.cpp @@ -2,18 +2,18 @@ template class Y { public: void f() { T::A++; // T::A is not a type name! - } + } }; class B { - public: - static int A; + public: + static int A; }; int B::A = 0; -int main(){ - Y y; - y.f(); - assert(B::A == 1); +int main() { + Y y; + y.f(); + assert(B::A == 1); } diff --git a/regression/cpp-from-CVS/Typedef1/main.cpp b/regression/cpp-from-CVS/Typedef1/main.cpp index 2334f1d7933..b273f0029d7 100644 --- a/regression/cpp-from-CVS/Typedef1/main.cpp +++ b/regression/cpp-from-CVS/Typedef1/main.cpp @@ -1,17 +1,17 @@ struct A { - int i; - A(int i):i(i){} + int i; + A(int i):i(i){} }; class B: public A { - public: - typedef A _A; - B():_A(0){} + public: + typedef A _A; + B():_A(0){} }; int main() { - B b; - assert(b.i==0); + B b; + assert(b.i==0); } diff --git a/regression/cpp-from-CVS/Typedef2/main.cpp b/regression/cpp-from-CVS/Typedef2/main.cpp index d8c21b6e77f..dd83b1ef5f2 100644 --- a/regression/cpp-from-CVS/Typedef2/main.cpp +++ b/regression/cpp-from-CVS/Typedef2/main.cpp @@ -1,27 +1,27 @@ struct A { - int i; + int i; }; struct B: A { - typedef A _A; - int i; - void set(int i) - { - _A::i = i; - } - int get() - { - return _A::i; - } + typedef A _A; + int i; + void set(int i) + { + _A::i = i; + } + int get() + { + return _A::i; + } }; int main() { - B b; - b.i = 0; - b.set(3); - assert(b.i==0); - assert(b.get()== 3); + B b; + b.i = 0; + b.set(3); + assert(b.i==0); + assert(b.get()== 3); } diff --git a/regression/cpp-from-CVS/Typedef3/main.cpp b/regression/cpp-from-CVS/Typedef3/main.cpp index 70feeb058d5..4e447e886cf 100644 --- a/regression/cpp-from-CVS/Typedef3/main.cpp +++ b/regression/cpp-from-CVS/Typedef3/main.cpp @@ -1,11 +1,11 @@ struct B { - typedef struct { typedef int INT; } A; + typedef struct { typedef int INT; } A; }; int main() { - B::A::INT i = 1; - assert(i == 1); + B::A::INT i = 1; + assert(i == 1); } diff --git a/regression/cpp-from-CVS/Vector1/main.cpp b/regression/cpp-from-CVS/Vector1/main.cpp index 57a16592dd9..d8a07707392 100644 --- a/regression/cpp-from-CVS/Vector1/main.cpp +++ b/regression/cpp-from-CVS/Vector1/main.cpp @@ -30,9 +30,9 @@ void sort(vector& c) */ int main() { - vector vec; - vec.resize(0); - __CPROVER_assert(vec.size()==0, "vec size == 0"); + vector vec; + vec.resize(0); + __CPROVER_assert(vec.size()==0, "vec size == 0"); /* vec.push_back(2); vec.push_back(1); vec.push_back(4); diff --git a/regression/cpp-from-CVS/Zero_Initializer1/main.cpp b/regression/cpp-from-CVS/Zero_Initializer1/main.cpp index 505283aba81..f0c08a8babf 100644 --- a/regression/cpp-from-CVS/Zero_Initializer1/main.cpp +++ b/regression/cpp-from-CVS/Zero_Initializer1/main.cpp @@ -7,7 +7,7 @@ struct } s; struct B { - static int x; + static int x; }; int B::x; diff --git a/regression/cpp-from-CVS/const_cast1/main.cpp b/regression/cpp-from-CVS/const_cast1/main.cpp index 88c1c4af3cb..a9c87d2d255 100644 --- a/regression/cpp-from-CVS/const_cast1/main.cpp +++ b/regression/cpp-from-CVS/const_cast1/main.cpp @@ -1,11 +1,11 @@ int main() { - int i = 10; - const int& ri = i; - const_cast(ri) = 11; - assert(i == 11); + int i = 10; + const int& ri = i; + const_cast(ri) = 11; + assert(i == 11); - const int* pi = &i; - *const_cast(pi) = 12; - assert(i==12); + const int* pi = &i; + *const_cast(pi) = 12; + assert(i==12); } diff --git a/regression/cpp-from-CVS/extractbits1/main.cpp b/regression/cpp-from-CVS/extractbits1/main.cpp index 483f13d99d0..cd531089c81 100644 --- a/regression/cpp-from-CVS/extractbits1/main.cpp +++ b/regression/cpp-from-CVS/extractbits1/main.cpp @@ -2,16 +2,16 @@ // require the cpp frontend to be compiled with the CPP_SYSTEMC_EXTENSION flag int main() { - unsigned a = 6; - unsigned b = 12; - unsigned a21 = a.range(2,1); - unsigned b32 = b.range(3,2); - assert( a21 == b32); + unsigned a = 6; + unsigned b = 12; + unsigned a21 = a.range(2, 1); + unsigned b32 = b.range(3, 2); + assert( a21 == b32); - a.range(4,3) = a.range(2,1); - assert( a.range(4,3) == b.range(3,2)); + a.range(4, 3) = a.range(2,1); + assert( a.range(4, 3) == b.range(3,2)); - a[0] = b.range(3,3); - bool a0 = a[0]; - assert(a0 == true); + a[0] = b.range(3, 3); + bool a0 = a[0]; + assert(a0 == true); } diff --git a/regression/cpp-from-CVS/for1/main.cpp b/regression/cpp-from-CVS/for1/main.cpp index 4db76dd1179..fceefb1d29a 100644 --- a/regression/cpp-from-CVS/for1/main.cpp +++ b/regression/cpp-from-CVS/for1/main.cpp @@ -1,7 +1,7 @@ int main() { int i; - for (i=0; i<10; i++) + for(i=0; i<10; i++) { assert(i<10); } diff --git a/regression/cpp-from-CVS/initialization1/main.cpp b/regression/cpp-from-CVS/initialization1/main.cpp index 0a03ee20771..ae1152193e3 100644 --- a/regression/cpp-from-CVS/initialization1/main.cpp +++ b/regression/cpp-from-CVS/initialization1/main.cpp @@ -2,16 +2,16 @@ int g1; class One { - public: - int o; - One():o(1){} + public: + int o; + One():o(1){} }; class A { - public: - static One one; - A() { assert(one.o == 1); } + public: + static One one; + A() { assert(one.o == 1); } }; One A::one; diff --git a/regression/cpp-from-CVS/initialization2/main.cpp b/regression/cpp-from-CVS/initialization2/main.cpp index b5d34ad9d8a..32f8ef37077 100644 --- a/regression/cpp-from-CVS/initialization2/main.cpp +++ b/regression/cpp-from-CVS/initialization2/main.cpp @@ -1,18 +1,18 @@ class A { - public: - int a; - int b; - A(const A& r){b =~r.b;} - A(){}; + public: + int a; + int b; + A(const A& r) {b =~r.b;} + A(){}; }; A a1; A a2 = a1; int main() { - assert(a1.a==0); - assert(a2.a==0); - assert(a1.b==0); - assert(a2.b==~0); + assert(a1.a==0); + assert(a2.a==0); + assert(a1.b==0); + assert(a2.b==~0); }; diff --git a/regression/cpp-from-CVS/initialization3/main.cpp b/regression/cpp-from-CVS/initialization3/main.cpp index 4e752e1df0f..49fa931c550 100644 --- a/regression/cpp-from-CVS/initialization3/main.cpp +++ b/regression/cpp-from-CVS/initialization3/main.cpp @@ -1,12 +1,12 @@ class A { - public: - int i; - A(){} + public: + int i; + A(){} }; int main() { - A a; - assert(a.i==0); + A a; + assert(a.i==0); } diff --git a/regression/cpp-from-CVS/initialization4/main.cpp b/regression/cpp-from-CVS/initialization4/main.cpp index b7a21d7d8fd..6edc3266d8f 100644 --- a/regression/cpp-from-CVS/initialization4/main.cpp +++ b/regression/cpp-from-CVS/initialization4/main.cpp @@ -10,6 +10,6 @@ const int a = gen(); int main() { - assert(a==1); - assert(b==0); + assert(a==1); + assert(b==0); } diff --git a/regression/cpp-from-CVS/initialization5/main.cpp b/regression/cpp-from-CVS/initialization5/main.cpp index 8b7d4b8139c..f96693bcda3 100644 --- a/regression/cpp-from-CVS/initialization5/main.cpp +++ b/regression/cpp-from-CVS/initialization5/main.cpp @@ -1,14 +1,14 @@ int a[__CPROVER::constant_infinity_uint]; struct A { - int i[__CPROVER::constant_infinity_uint]; + int i[__CPROVER::constant_infinity_uint]; }; A o; int main() { - unsigned x; - assert(o.i[x] == 0); - assert(a[x] == 0); + unsigned x; + assert(o.i[x] == 0); + assert(a[x] == 0); } diff --git a/regression/cpp-from-CVS/initialization6/main.cpp b/regression/cpp-from-CVS/initialization6/main.cpp index edb7abb70ec..a53fcd3d06b 100644 --- a/regression/cpp-from-CVS/initialization6/main.cpp +++ b/regression/cpp-from-CVS/initialization6/main.cpp @@ -2,5 +2,5 @@ extern "C" int g; int main() { - assert(g==0); + assert(g==0); } diff --git a/regression/cpp-from-CVS/initialization7/main.cpp b/regression/cpp-from-CVS/initialization7/main.cpp index 8655f20a81c..ba04d9820e2 100644 --- a/regression/cpp-from-CVS/initialization7/main.cpp +++ b/regression/cpp-from-CVS/initialization7/main.cpp @@ -1,10 +1,10 @@ union { - int a; - char b; + int a; + char b; }; int main() { - assert(a == 0); - assert(b == 0); + assert(a == 0); + assert(b == 0); } diff --git a/regression/cpp-from-CVS/operators/main.cpp b/regression/cpp-from-CVS/operators/main.cpp index 1cc8f08f57d..b19aa87829a 100644 --- a/regression/cpp-from-CVS/operators/main.cpp +++ b/regression/cpp-from-CVS/operators/main.cpp @@ -1,28 +1,28 @@ class I { - int i; - public: - int get(){return i;} - void set(int i){this->i=i;} - I& operator<<=(const I& ref){i <<= ref.i; return *this;} - I& operator>>=(const I& ref){i >>= ref.i; return *this;} - I& operator+=(const I& ref){i += ref.i; return *this;} - I& operator-=(const I& ref){i -= ref.i; return *this;} + int i; + public: + int get() {return i;} + void set(int i) {this->i=i;} + I& operator<<=(const I& ref) {i <<= ref.i; return *this;} + I& operator>>=(const I& ref) {i >>= ref.i; return *this;} + I& operator+=(const I& ref) {i += ref.i; return *this;} + I& operator-=(const I& ref){i -= ref.i; return *this;} }; int main() { - I i1, i2; - i1.set(1); - i2.set(2); - i2+=i1; - assert(i2.get()==3); - i2-=i1; - assert(i2.get()==2); - i2 <<= i1; - assert(i2.get()==4); - i2 >>= i1; - assert(i2.get()==2); - i2 = i1; - assert(i2.get()== 1); + I i1, i2; + i1.set(1); + i2.set(2); + i2+=i1; + assert(i2.get()==3); + i2-=i1; + assert(i2.get()==2); + i2 <<= i1; + assert(i2.get()==4); + i2 >>= i1; + assert(i2.get()==2); + i2 = i1; + assert(i2.get()== 1); } diff --git a/regression/cpp-from-CVS/reinterpret_cast1/main.cpp b/regression/cpp-from-CVS/reinterpret_cast1/main.cpp index abbbb42c067..d27456e556c 100644 --- a/regression/cpp-from-CVS/reinterpret_cast1/main.cpp +++ b/regression/cpp-from-CVS/reinterpret_cast1/main.cpp @@ -1,9 +1,9 @@ int main() { - int v = 256; - int *i= &v; - char *c = reinterpret_cast(i); - *c == 0; - int *j = reinterpret_cast(c); - assert(j==i); + int v = 256; + int *i= &v; + char *c = reinterpret_cast(i); + *c == 0; + int *j = reinterpret_cast(c); + assert(j==i); } diff --git a/regression/cpp-from-CVS/reinterpret_cast2/main.cpp b/regression/cpp-from-CVS/reinterpret_cast2/main.cpp index bfe183eeaab..c4a91859383 100644 --- a/regression/cpp-from-CVS/reinterpret_cast2/main.cpp +++ b/regression/cpp-from-CVS/reinterpret_cast2/main.cpp @@ -1,15 +1,15 @@ struct A { - int* pi; + int* pi; }; int main() { - A a; - const A* cpa = &a; + A a; + const A* cpa = &a; - int* ptr = reinterpret_cast(cpa->pi); + int* ptr = reinterpret_cast(cpa->pi); - return 0; + return 0; } diff --git a/regression/cpp-from-CVS/static_cast2/main.cpp b/regression/cpp-from-CVS/static_cast2/main.cpp index 18930fca937..5a4f1667259 100644 --- a/regression/cpp-from-CVS/static_cast2/main.cpp +++ b/regression/cpp-from-CVS/static_cast2/main.cpp @@ -1,5 +1,5 @@ int main() { - int x; - static_cast(x)++; // not ok + int x; + static_cast(x)++; // not ok } diff --git a/regression/cpp-from-CVS/static_cast3/main.cpp b/regression/cpp-from-CVS/static_cast3/main.cpp index 72c01c11d25..fdb99bbec65 100644 --- a/regression/cpp-from-CVS/static_cast3/main.cpp +++ b/regression/cpp-from-CVS/static_cast3/main.cpp @@ -1,26 +1,26 @@ struct A { - int i; + int i; }; struct B { - char j; + char j; }; struct C: A, B { - bool k; + bool k; }; int main() { - C c; - c.k = true; + C c; + c.k = true; - B& b = c; - assert((static_cast(b)).k == true); + B& b = c; + assert((static_cast(b)).k == true); - B* pb = &c; - static_cast(pb)->k = false; - assert(c.k==false); + B* pb = &c; + static_cast(pb)->k = false; + assert(c.k==false); } diff --git a/regression/cpp-from-CVS/static_cast4/main.cpp b/regression/cpp-from-CVS/static_cast4/main.cpp index 8b6d928815a..08ba6d6578c 100644 --- a/regression/cpp-from-CVS/static_cast4/main.cpp +++ b/regression/cpp-from-CVS/static_cast4/main.cpp @@ -2,7 +2,7 @@ struct A { int i;}; struct B: A { char j;}; int main() { - A a; - const A& ra = a; - static_cast(ra); //not ok + A a; + const A& ra = a; + static_cast(ra); // not ok } diff --git a/regression/cpp-from-CVS/static_cast5/main.cpp b/regression/cpp-from-CVS/static_cast5/main.cpp index 9804e34bbd5..e324d8604e8 100644 --- a/regression/cpp-from-CVS/static_cast5/main.cpp +++ b/regression/cpp-from-CVS/static_cast5/main.cpp @@ -1,6 +1,6 @@ struct A { - int i; + int i; }; struct B: A @@ -9,21 +9,21 @@ struct B: A int get_i1(A& a) { - return static_cast(&a)->i; + return static_cast(&a)->i; } int get_i2(A* pa) { - return static_cast(pa)->i; + return static_cast(pa)->i; } int main() { - B b; - b.i = 10; - int tmp1 = get_i1(b); + B b; + b.i = 10; + int tmp1 = get_i1(b); assert(tmp1 == 10); - int tmp2 = get_i2(&b); + int tmp2 = get_i2(&b); assert(tmp2 == 10); } diff --git a/regression/cpp-from-CVS/virtual10/main.cpp b/regression/cpp-from-CVS/virtual10/main.cpp index f550454ac60..43d5480fd12 100644 --- a/regression/cpp-from-CVS/virtual10/main.cpp +++ b/regression/cpp-from-CVS/virtual10/main.cpp @@ -1,13 +1,13 @@ struct A { - virtual bool func() const {return true;} - virtual bool func() {return false;} + virtual bool func() const {return true;} + virtual bool func() {return false;} }; int main() { - const A a1; - assert(a1.func()== true); - A a2; - assert(a2.func()== false); + const A a1; + assert(a1.func()== true); + A a2; + assert(a2.func()== false); } diff --git a/regression/cpp-from-CVS/virtual11/main.cpp b/regression/cpp-from-CVS/virtual11/main.cpp index 36ee282a99e..86d443c1d05 100644 --- a/regression/cpp-from-CVS/virtual11/main.cpp +++ b/regression/cpp-from-CVS/virtual11/main.cpp @@ -1,27 +1,27 @@ struct A { - int i; - virtual operator int() const - { - return i; - } + int i; + virtual operator int() const + { + return i; + } }; struct B : A { - operator int() const - { - return i+1; - } + operator int() const + { + return i+1; + } }; int get_i(const A& a) { - return a; + return a; } int main() { - B b; - b.i = 10; - assert(get_i(b)==11); + B b; + b.i = 10; + assert(get_i(b)==11); } diff --git a/regression/cpp-from-CVS/virtual12/main.cpp b/regression/cpp-from-CVS/virtual12/main.cpp index cf0f7811141..51c6053ef29 100644 --- a/regression/cpp-from-CVS/virtual12/main.cpp +++ b/regression/cpp-from-CVS/virtual12/main.cpp @@ -1,17 +1,17 @@ struct A { - virtual int func(){return 1;} + virtual int func(){return 1;} }; struct B: A { - int func(){return 2;} + int func(){return 2;} }; -int call_func1(A a){return a.func();} -int call_func2(A& a){return a.func();} +int call_func1(A a) {return a.func();} +int call_func2(A& a) {return a.func();} int main() { - B b; - assert(call_func1(b)==1); - assert(call_func2(b)==2); + B b; + assert(call_func1(b)==1); + assert(call_func2(b)==2); } diff --git a/regression/cpp-from-CVS/virtual13/main.cpp b/regression/cpp-from-CVS/virtual13/main.cpp index 8484831ef0c..ac89c2df9ee 100644 --- a/regression/cpp-from-CVS/virtual13/main.cpp +++ b/regression/cpp-from-CVS/virtual13/main.cpp @@ -1,6 +1,6 @@ struct A { virtual int f(){ return 1; } }; struct B { virtual int f(){ return 2;} }; -struct C: A,B { virtual int f(){ return 3;} }; +struct C: A, B { virtual int f(){ return 3;} }; int main(int argc, char* argv[]) diff --git a/regression/cpp-from-CVS/virtual14/main.cpp b/regression/cpp-from-CVS/virtual14/main.cpp index 6ad37fe5b20..699a2459ab2 100644 --- a/regression/cpp-from-CVS/virtual14/main.cpp +++ b/regression/cpp-from-CVS/virtual14/main.cpp @@ -47,19 +47,19 @@ int main(int argc, char* argv[]) t1.x = 10; t1.y = 20; - a.f(t1,t2); + a.f(t1, t2); assert(t2.x == t1.x && t2.y == t1.y); t2.x = t2.y = 0; - b.f(t1,t2); + b.f(t1, t2); assert(t2.x == t1.y && t2.y == t1.x); t2.x = t2.y = 0; - c.f(t1,t2); + c.f(t1, t2); assert(t2.x == t1.x+1 && t2.y == t1.y+1); t2.x = t2.y = 0; - ((A*)&c)->f(t1,t2); + ((A*)&c)->f(t1, t2); assert(t2.x == t1.x+1 && t2.y == t1.y+1); t2.x = t2.y = 0; @@ -67,7 +67,7 @@ int main(int argc, char* argv[]) c.b = 1; assert(((B*)&c)->b == 1); - ((B*)&c)->f(t1,t2); + ((B*)&c)->f(t1, t2); assert(t2.x == t1.x+1 && t2.y == t1.y+1); t2.x = t2.y = 0; diff --git a/regression/cpp-from-CVS/virtual15/main.cpp b/regression/cpp-from-CVS/virtual15/main.cpp index 79deca660e3..db02c2bdccf 100644 --- a/regression/cpp-from-CVS/virtual15/main.cpp +++ b/regression/cpp-from-CVS/virtual15/main.cpp @@ -1,8 +1,8 @@ -//#include -//#include +// #include +// #include struct A { - virtual int f(){return 1;} + virtual int f() {return 1;} virtual int g(){return 1;} }; diff --git a/regression/cpp-from-CVS/virtual3/main.cpp b/regression/cpp-from-CVS/virtual3/main.cpp index b6dcdeddd42..f2ebce99677 100644 --- a/regression/cpp-from-CVS/virtual3/main.cpp +++ b/regression/cpp-from-CVS/virtual3/main.cpp @@ -6,12 +6,12 @@ class B{ void toBr(B& b) { - assert(b.f()==0); + assert(b.f()==0); } int main() { - B b; -// assert(b.f()==0); - toBr(b); + B b; +// assert(b.f()==0); + toBr(b); } diff --git a/regression/cpp-from-CVS/virtual5/main.cpp b/regression/cpp-from-CVS/virtual5/main.cpp index 80f8dcfe3d8..cb138ba2819 100644 --- a/regression/cpp-from-CVS/virtual5/main.cpp +++ b/regression/cpp-from-CVS/virtual5/main.cpp @@ -1,19 +1,19 @@ class B { public: - virtual int f() const {return 0;} + virtual int f() const {return 0;} }; class A: public B { public: - int f() {return 1;} + int f() {return 1;} }; int main() { - A a; - B b = (B) a; - assert(b.f()==0); - assert(a.f()==1); + A a; + B b = (B) a; + assert(b.f()==0); + assert(a.f()==1); } diff --git a/regression/cpp-from-CVS/virtual7/main.cpp b/regression/cpp-from-CVS/virtual7/main.cpp index e0c72f26b00..baebdf96571 100644 --- a/regression/cpp-from-CVS/virtual7/main.cpp +++ b/regression/cpp-from-CVS/virtual7/main.cpp @@ -1,24 +1,24 @@ class A { - public: - virtual int number(){return 0;} + public: + virtual int number(){return 0;} }; class B: A { - public: - int number(){return 1;} - void test() - { - int n1 = number(); - assert(n1==1); - int n2 = ::A::number(); - assert(n2 == 0); - } + public: + int number() {return 1;} + void test() + { + int n1 = number(); + assert(n1==1); + int n2 = ::A::number(); + assert(n2 == 0); + } }; int main() { - B b; - b.test(); + B b; + b.test(); } diff --git a/regression/cpp-from-CVS/virtual8/main.cpp b/regression/cpp-from-CVS/virtual8/main.cpp index e4b046f0c87..8db08084016 100644 --- a/regression/cpp-from-CVS/virtual8/main.cpp +++ b/regression/cpp-from-CVS/virtual8/main.cpp @@ -3,20 +3,20 @@ int g2; class A { - public: - virtual ~A(){g1 = g2+1;} + public: + virtual ~A(){g1 = g2+1;} }; class B: public A { - public: - ~B(){g2 = 1;} + public: + ~B(){g2 = 1;} }; int main() { - A* pA = new B(); - delete pA; - assert(g2==1); - assert(g1==2); + A* pA = new B(); + delete pA; + assert(g2==1); + assert(g1==2); } diff --git a/regression/cpp-from-CVS/virtual9/main.cpp b/regression/cpp-from-CVS/virtual9/main.cpp index 6dbb6d56d2e..5562e35c41a 100644 --- a/regression/cpp-from-CVS/virtual9/main.cpp +++ b/regression/cpp-from-CVS/virtual9/main.cpp @@ -1,14 +1,14 @@ struct A { - virtual int& func(int& i){return i;} + virtual int& func(int& i){return i;} }; int main() { - A a; - int i = 0; - int j = 1; + A a; + int i = 0; + int j = 1; - a.func(i) = j; - assert(i==j); + a.func(i) = j; + assert(i==j); } From fd1eed774f7a8ffe90999314e63294e2eb13b34a Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:46:29 +0000 Subject: [PATCH 4/7] first pass cpplint fixes in regression/cpp --- regression/cpp/Decltype3/main.cpp | 12 +++++------ regression/cpp/Function_Bodies1/main.cpp | 12 +++++------ regression/cpp/List_initialization1/main.cpp | 2 +- regression/cpp/Resolver10/main.cpp | 20 +++++++++---------- regression/cpp/Resolver12/main.cpp | 4 ++-- regression/cpp/Resolver2/main.cpp | 6 +++--- regression/cpp/Resolver3/main.cpp | 8 ++++---- regression/cpp/Resolver4/main.cpp | 4 ++-- .../cpp/Template_Instantiation1/main.cpp | 2 +- .../cpp/Template_Instantiation3/main.cpp | 6 +++--- .../cpp/Template_Instantiation4/main.cpp | 2 +- .../cpp/Template_Instantiation5/main.cpp | 6 +++--- regression/cpp/Templates7/main.cpp | 6 +++--- .../cpp/type_traits_essentials1/main.cpp | 2 +- regression/cpp/union3/main.cpp | 10 +++++----- regression/cpp/virtual1/main.cpp | 4 ++-- 16 files changed, 53 insertions(+), 53 deletions(-) diff --git a/regression/cpp/Decltype3/main.cpp b/regression/cpp/Decltype3/main.cpp index e0a95f38b00..89693194480 100644 --- a/regression/cpp/Decltype3/main.cpp +++ b/regression/cpp/Decltype3/main.cpp @@ -4,14 +4,14 @@ template struct whatever { - int f00 (const B b) { - typedef decltype(static_cast(b)) T; - T z; - return 1; - } + int f00 (const B b) { + typedef decltype(static_cast(b)) T; + T z; + return 1; + } }; -whatever thing; +whatever thing; int main() { diff --git a/regression/cpp/Function_Bodies1/main.cpp b/regression/cpp/Function_Bodies1/main.cpp index 9a86a7e2d88..1fbf860e067 100644 --- a/regression/cpp/Function_Bodies1/main.cpp +++ b/regression/cpp/Function_Bodies1/main.cpp @@ -1,17 +1,17 @@ template struct A { - A(T i):i(i){}; - T i; + A(T i):i(i){} + T i; }; class B { - int get(){return i;} - A func(); - int i; + int get() {return i;} + A func(); + int i; }; int main() { - B b; + B b; } diff --git a/regression/cpp/List_initialization1/main.cpp b/regression/cpp/List_initialization1/main.cpp index dca62671139..a120da004dd 100644 --- a/regression/cpp/List_initialization1/main.cpp +++ b/regression/cpp/List_initialization1/main.cpp @@ -26,7 +26,7 @@ int main() int y { 1 }; x={ 1 }; x=int { 1 }; - x=(int){ 1 }; + x=(int){ 1 } p=new int { 1 }; some_function({1}); } diff --git a/regression/cpp/Resolver10/main.cpp b/regression/cpp/Resolver10/main.cpp index d5ec28f92fd..e27e8524bf9 100644 --- a/regression/cpp/Resolver10/main.cpp +++ b/regression/cpp/Resolver10/main.cpp @@ -1,21 +1,21 @@ struct A { - int i; - A():i(0){}; + int i; + A():i(0){} }; struct B: A { - void test() - { - i = 1; - A(); - assert(i==1); - } + void test() + { + i = 1; + A(); + assert(i==1); + } }; int main() { - B b; - b.test(); + B b; + b.test(); } diff --git a/regression/cpp/Resolver12/main.cpp b/regression/cpp/Resolver12/main.cpp index a21acbceadc..9b6eba20894 100644 --- a/regression/cpp/Resolver12/main.cpp +++ b/regression/cpp/Resolver12/main.cpp @@ -2,6 +2,6 @@ struct A{}; int x; int main() { - A a; - a.x; // bad + A a; + a.x; // bad } diff --git a/regression/cpp/Resolver2/main.cpp b/regression/cpp/Resolver2/main.cpp index 3e81c22e5bd..c5b9fee8a7b 100644 --- a/regression/cpp/Resolver2/main.cpp +++ b/regression/cpp/Resolver2/main.cpp @@ -1,7 +1,7 @@ class A { - void f(int i){} - void f(){f(0);} + void f(int i) {} + void f(){f(0);} }; -int main(){} +int main() {} diff --git a/regression/cpp/Resolver3/main.cpp b/regression/cpp/Resolver3/main.cpp index 2bd8d3018c0..98f082b1473 100644 --- a/regression/cpp/Resolver3/main.cpp +++ b/regression/cpp/Resolver3/main.cpp @@ -1,8 +1,8 @@ class A { - public: - void f(int i){} - void f(){A::f(0);} + public: + void f(int i) {} + void f(){A::f(0);} }; -int main(){} +int main() {} diff --git a/regression/cpp/Resolver4/main.cpp b/regression/cpp/Resolver4/main.cpp index 2e862e9a04b..f2785477f6f 100644 --- a/regression/cpp/Resolver4/main.cpp +++ b/regression/cpp/Resolver4/main.cpp @@ -1,9 +1,9 @@ class A{ public: - void f(int i){}; + void f(int i){} }; int main() { - A::f(0); + A::f(0); } diff --git a/regression/cpp/Template_Instantiation1/main.cpp b/regression/cpp/Template_Instantiation1/main.cpp index 892abe3bdf5..a353da1975d 100644 --- a/regression/cpp/Template_Instantiation1/main.cpp +++ b/regression/cpp/Template_Instantiation1/main.cpp @@ -5,7 +5,7 @@ class bitVector { } }; -//#define WORKS +// #define WORKS #ifdef WORKS typedef bitVector sbv; diff --git a/regression/cpp/Template_Instantiation3/main.cpp b/regression/cpp/Template_Instantiation3/main.cpp index 0e01d2f2adf..4d689bf7fc4 100644 --- a/regression/cpp/Template_Instantiation3/main.cpp +++ b/regression/cpp/Template_Instantiation3/main.cpp @@ -7,10 +7,10 @@ struct sc_ufixed { } - sc_ufixed multiply (const sc_ufixed &op) const + sc_ufixed multiply (const sc_ufixed &op) const { unsigned int result = this->value * op.value; - return sc_ufixed(result); + return sc_ufixed(result); } }; @@ -18,7 +18,7 @@ struct sc_ufixed const sc_ufixed<1, 1> one(1U); int main (void) { - //const sc_ufixed<1, 1> one(1U); + // const sc_ufixed<1, 1> one(1U); one.multiply(one); return 0; } diff --git a/regression/cpp/Template_Instantiation4/main.cpp b/regression/cpp/Template_Instantiation4/main.cpp index 36746126b0b..4cb0f0f488d 100644 --- a/regression/cpp/Template_Instantiation4/main.cpp +++ b/regression/cpp/Template_Instantiation4/main.cpp @@ -17,7 +17,7 @@ X<1> x; int main() { - //x.some_func(); + // x.some_func(); } // also works with function templates diff --git a/regression/cpp/Template_Instantiation5/main.cpp b/regression/cpp/Template_Instantiation5/main.cpp index 1d71d999e69..e8362a832dc 100644 --- a/regression/cpp/Template_Instantiation5/main.cpp +++ b/regression/cpp/Template_Instantiation5/main.cpp @@ -1,4 +1,4 @@ -//#include +// #include template class template_test @@ -11,14 +11,14 @@ class template_test } T get(void) { - //printf ("elem is '%c' \n", elem); + // printf ("elem is '%c' \n", elem); return elem; } void add(void) { int c = elem + elem; - //printf ("c = %d \n", c); + // printf ("c = %d \n", c); return; } diff --git a/regression/cpp/Templates7/main.cpp b/regression/cpp/Templates7/main.cpp index ca6dba97a0d..46aa7fef87c 100644 --- a/regression/cpp/Templates7/main.cpp +++ b/regression/cpp/Templates7/main.cpp @@ -1,11 +1,11 @@ template class A { - T t; + T t; }; int main() { - A > a1; - A > a2; + A > a1; + A > a2; } diff --git a/regression/cpp/type_traits_essentials1/main.cpp b/regression/cpp/type_traits_essentials1/main.cpp index 10ca6962945..d6dc32cd51e 100644 --- a/regression/cpp/type_traits_essentials1/main.cpp +++ b/regression/cpp/type_traits_essentials1/main.cpp @@ -8,7 +8,7 @@ struct F }; template -struct F +struct F { }; diff --git a/regression/cpp/union3/main.cpp b/regression/cpp/union3/main.cpp index 84b03b32e61..30e9c2b78c5 100644 --- a/regression/cpp/union3/main.cpp +++ b/regression/cpp/union3/main.cpp @@ -1,8 +1,8 @@ struct A { - static union // static is not allowed here - { - int a; - char b; - }; + static union // static is not allowed here + { + int a; + char b; + }; }; diff --git a/regression/cpp/virtual1/main.cpp b/regression/cpp/virtual1/main.cpp index 650441ecaf1..ab787903597 100644 --- a/regression/cpp/virtual1/main.cpp +++ b/regression/cpp/virtual1/main.cpp @@ -2,7 +2,7 @@ class base { public: - virtual ~base(){} + virtual ~base() {} virtual int func(void) { printf ("In base, returning 1"); @@ -13,7 +13,7 @@ class base class derived : public base { public: - virtual ~derived(){} + virtual ~derived() {} virtual int func(void) { printf ("In derived, returning 2"); From e3a0418f76648d29267fc013a3dbf37df1c76136 Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:48:16 +0000 Subject: [PATCH 5/7] second pass cpplint fixes in src/cegis --- .../danger/preprocess/add_ranking_and_skolem_variables.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp b/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp index 2771384dbe2..e676b50a800 100644 --- a/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp +++ b/src/cegis/danger/preprocess/add_ranking_and_skolem_variables.cpp @@ -68,7 +68,7 @@ class create_danger_meta_variables_for_loopt goto_programt::targett pos=im.Gx; ++pos; const size_t ranking_count=1; // XXX: Lexicographical ranking? - if(use_ranking) for (size_t i=0; i < ranking_count; ++i) + if(use_ranking) for(size_t i=0; i < ranking_count; ++i) { pos=declare_cegis_meta_variable(st, gf, pos, get_Rx(loop_id, i), type); dm.Rx.push_back(pos); @@ -77,7 +77,7 @@ class create_danger_meta_variables_for_loopt const create_skolem_meta_variablest create_sklm(st, gf, loop_id, dm, pos); std::for_each(sklm.begin(), sklm.end(), create_sklm); pos=im.Ix_prime; - if(use_ranking) for (size_t i=0; i < ranking_count; ++i) + if(use_ranking) for(size_t i=0; i < ranking_count; ++i) { const std::string rx_prime(get_Rx_prime(loop_id, i)); pos=declare_cegis_meta_variable(st, gf, pos, rx_prime, type); From 67cbee1aac90f5095fce34ca1bc9709f584ba156 Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:48:16 +0000 Subject: [PATCH 6/7] second pass cpplint fixes in regression/cpp-from-CVS --- regression/cpp-from-CVS/Constructor17/main.cpp | 2 +- regression/cpp-from-CVS/Conversion10/main.cpp | 2 +- regression/cpp-from-CVS/Friend6/main.cpp | 2 +- regression/cpp-from-CVS/Templates20/main.cpp | 2 +- regression/cpp-from-CVS/Templates29/main.cpp | 2 +- regression/cpp-from-CVS/extractbits1/main.cpp | 4 ++-- 6 files changed, 7 insertions(+), 7 deletions(-) diff --git a/regression/cpp-from-CVS/Constructor17/main.cpp b/regression/cpp-from-CVS/Constructor17/main.cpp index 27db56b5051..abcec93d2c1 100644 --- a/regression/cpp-from-CVS/Constructor17/main.cpp +++ b/regression/cpp-from-CVS/Constructor17/main.cpp @@ -1,7 +1,7 @@ class C { public: - C(int& v):v(v){} + C(int& v):v(v) {} int v; }; diff --git a/regression/cpp-from-CVS/Conversion10/main.cpp b/regression/cpp-from-CVS/Conversion10/main.cpp index 7f8155da801..90acac074fc 100644 --- a/regression/cpp-from-CVS/Conversion10/main.cpp +++ b/regression/cpp-from-CVS/Conversion10/main.cpp @@ -4,7 +4,7 @@ struct B { explicit B(A&){} }; -void test(const B& b){} +void test(const B& b) {} int main() { diff --git a/regression/cpp-from-CVS/Friend6/main.cpp b/regression/cpp-from-CVS/Friend6/main.cpp index 300ef465299..5690728f38f 100644 --- a/regression/cpp-from-CVS/Friend6/main.cpp +++ b/regression/cpp-from-CVS/Friend6/main.cpp @@ -8,7 +8,7 @@ struct A { class B { int i; public: - B():i(10){} + B():i(10) {} friend class A; }; diff --git a/regression/cpp-from-CVS/Templates20/main.cpp b/regression/cpp-from-CVS/Templates20/main.cpp index 9b0217e9ee3..cfef1b4ae8c 100644 --- a/regression/cpp-from-CVS/Templates20/main.cpp +++ b/regression/cpp-from-CVS/Templates20/main.cpp @@ -24,7 +24,7 @@ template <> class B: A { public: bool b; - B():b(true){} + B():b(true) {} int get_i() {return i;} private: B(B& b); // disabled diff --git a/regression/cpp-from-CVS/Templates29/main.cpp b/regression/cpp-from-CVS/Templates29/main.cpp index 2faec6cde7f..a79184a3292 100644 --- a/regression/cpp-from-CVS/Templates29/main.cpp +++ b/regression/cpp-from-CVS/Templates29/main.cpp @@ -10,7 +10,7 @@ struct A struct B : N::A { B(int i): N::A(i) {} - void func(){} + void func() {} int b; }; diff --git a/regression/cpp-from-CVS/extractbits1/main.cpp b/regression/cpp-from-CVS/extractbits1/main.cpp index cd531089c81..f38e3d0247b 100644 --- a/regression/cpp-from-CVS/extractbits1/main.cpp +++ b/regression/cpp-from-CVS/extractbits1/main.cpp @@ -8,8 +8,8 @@ int main() unsigned b32 = b.range(3, 2); assert( a21 == b32); - a.range(4, 3) = a.range(2,1); - assert( a.range(4, 3) == b.range(3,2)); + a.range(4, 3) = a.range(2, 1); + assert( a.range(4, 3) == b.range(3, 2)); a[0] = b.range(3, 3); bool a0 = a[0]; From addc5ee5e7830a9237cbda39a5b293033b30fa39 Mon Sep 17 00:00:00 2001 From: "Robert (Jamie) Munro" Date: Mon, 20 Feb 2017 11:48:16 +0000 Subject: [PATCH 7/7] second pass cpplint fixes in regression/cpp --- regression/cpp/Function_Bodies1/main.cpp | 2 +- regression/cpp/List_initialization1/main.cpp | 2 +- regression/cpp/Template_Instantiation3/main.cpp | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/regression/cpp/Function_Bodies1/main.cpp b/regression/cpp/Function_Bodies1/main.cpp index 1fbf860e067..dd1186c14f9 100644 --- a/regression/cpp/Function_Bodies1/main.cpp +++ b/regression/cpp/Function_Bodies1/main.cpp @@ -1,6 +1,6 @@ template struct A { - A(T i):i(i){} + A(T i):i(i) {} T i; }; diff --git a/regression/cpp/List_initialization1/main.cpp b/regression/cpp/List_initialization1/main.cpp index a120da004dd..690461a7b0e 100644 --- a/regression/cpp/List_initialization1/main.cpp +++ b/regression/cpp/List_initialization1/main.cpp @@ -26,7 +26,7 @@ int main() int y { 1 }; x={ 1 }; x=int { 1 }; - x=(int){ 1 } + x=(int) { 1 } p=new int { 1 }; some_function({1}); } diff --git a/regression/cpp/Template_Instantiation3/main.cpp b/regression/cpp/Template_Instantiation3/main.cpp index 4d689bf7fc4..be625a91a2d 100644 --- a/regression/cpp/Template_Instantiation3/main.cpp +++ b/regression/cpp/Template_Instantiation3/main.cpp @@ -7,7 +7,7 @@ struct sc_ufixed { } - sc_ufixed multiply (const sc_ufixed &op) const + sc_ufixed multiply (const sc_ufixed &op) const { unsigned int result = this->value * op.value; return sc_ufixed(result);