-- This file is part of SmartEiffel The GNU Eiffel Compiler. -- Copyright (C) 1994-2002 LORIA - INRIA - U.H.P. Nancy 1 - FRANCE -- Dominique COLNET and Suzanne COLLIN - SmartEiffel@loria.fr -- http://SmartEiffel.loria.fr -- SmartEiffel is free software; you can redistribute it and/or modify it -- under the terms of the GNU General Public License as published by the Free -- Software Foundation; either version 2, or (at your option) any later -- version. SmartEiffel is distributed in the hope that it will be useful,but -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- for more details. You should have received a copy of the GNU General -- Public License along with SmartEiffel; see the file COPYING. If not, -- write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, -- Boston, MA 02111-1307, USA. -- class E_LOOP -- -- The Eiffel instruction : "from ... until ... loop ... end". -- inherit INSTRUCTION creation make feature start_position: POSITION -- Of letter 'f' of "from". initialize: COMPOUND invariant_clause: LOOP_INVARIANT variant_clause: LOOP_VARIANT until_expression: EXPRESSION loop_body: COMPOUND is_pre_computable: BOOLEAN is false end_mark_comment: BOOLEAN is true afd_check is do if loop_check then if variant_clause /= Void then variant_clause.afd_check end if invariant_clause /= Void then invariant_clause.afd_check end end if initialize /= Void then initialize.afd_check end until_expression.afd_check if loop_body /= Void then loop_body.afd_check end end safety_check is do if initialize /= Void then initialize.safety_check end until_expression.safety_check if loop_body /= Void then loop_body.safety_check end end collect_c_tmp is do end compile_to_c is local need_se_tmp, variant_flag, invariant_flag: BOOLEAN do if loop_check and then variant_clause /= Void then cpp.put_string(once "{int c=0;int v=0;%N") variant_flag := true end if initialize /= Void then initialize.compile_to_c end if loop_check and then invariant_clause /= Void then invariant_clause.compile_to_c invariant_flag := true end until_expression.collect_c_tmp need_se_tmp := cpp.se_tmp_open_declaration cpp.put_string(once "while (!(") if ace.no_check then cpp.trace_boolean_expression(until_expression) else until_expression.compile_to_c end cpp.put_string(once "))%N{%N") if variant_flag then cpp.variant_check(variant_clause.expression) end if loop_body /= Void then loop_body.compile_to_c end if invariant_flag then invariant_clause.compile_to_c end cpp.put_string(once "}%N") if need_se_tmp then cpp.se_tmp_close_declaration end if variant_flag then cpp.put_string(fz_12) end end compile_to_jvm is local until_point, exit_point: INTEGER ca: like code_attribute counter, previous: INTEGER do ca := code_attribute if loop_check then counter := ca.extra_local_size1 ca.opcode_iconst_0 ca.opcode_istore(counter) previous := ca.extra_local_size1 ca.opcode_iconst_0 ca.opcode_istore(previous) end if initialize /= Void then initialize.compile_to_jvm end if loop_check then if invariant_clause /= Void then invariant_clause.compile_to_jvm(true) ca.opcode_pop end end until_point := ca.program_counter exit_point := until_expression.jvm_branch_if_true if loop_check then if variant_clause /= Void then ca.opcode_iload(counter) ca.opcode_iload(previous) ca.runtime_check_loop_variant(variant_clause.expression) ca.opcode_istore(previous) end end if loop_body /= Void then loop_body.compile_to_jvm end if loop_check then if invariant_clause /= Void then invariant_clause.compile_to_jvm(true) ca.opcode_pop end end if loop_check then ca.opcode_iinc(counter,1) end ca.opcode_goto_backward(until_point) ca.resolve_u2_branch(exit_point) end use_current: BOOLEAN is do if loop_check and then variant_clause /= Void then Result := Result or else variant_clause.use_current end if initialize /= Void then Result := Result or else initialize.use_current end Result := Result or else until_expression.use_current if loop_check and then invariant_clause /= Void then Result := Result or else invariant_clause.use_current end if loop_body /= Void then Result := Result or else loop_body.use_current end end stupid_switch(run_time_set: RUN_TIME_SET): BOOLEAN is do Result := (initialize = Void or else initialize.stupid_switch(run_time_set)) and then until_expression.stupid_switch(run_time_set) and then (loop_body = Void or else loop_body.stupid_switch(run_time_set)) end to_runnable(ct: E_TYPE): like Current is local ue: like until_expression do if current_type = Void then current_type := ct loop_check := ct.base_class.loop_check if initialize /= Void then initialize := initialize.to_runnable(ct) if initialize = Void then error(start_position,"Bad initialisation part.") end end if loop_check and then invariant_clause /= Void then invariant_clause := invariant_clause.to_runnable(ct) if invariant_clause = Void then error(start_position,"Bad invariant.") end end if loop_check and then variant_clause /= Void then variant_clause := variant_clause.to_runnable(ct) if variant_clause = Void then error(start_position,"Bad variant for this loop.") end end ue := until_expression.to_runnable(ct) if ue /= Void then if not ue.result_type.is_boolean then error(ue.start_position, "Expression of until must be BOOLEAN.") error_handler.add_type(ue.result_type,fz_is_not_boolean) error_handler.print_as_error end until_expression := ue else error(start_position, "This loop has an invalid expression.") end if loop_body /= Void then loop_body := loop_body.to_runnable(ct) if loop_body = Void then error(start_position,"Invalid loop body.") end end if nb_errors = 0 then Result := Current end else !!Result.make(start_position,initialize,invariant_clause, variant_clause,until_expression,loop_body) Result := Result.to_runnable(ct) end end pretty_print is local semi_colon_flag: BOOLEAN do pretty_printer.indent pretty_printer.keyword(fz_from) if initialize /= Void then initialize.pretty_print end if invariant_clause /= Void then invariant_clause.pretty_print end if variant_clause /= Void then pretty_printer.indent pretty_printer.keyword(fz_variant) pretty_printer.level_incr semi_colon_flag := pretty_printer.semi_colon_flag pretty_printer.set_semi_colon_flag(false) variant_clause.pretty_print pretty_printer.set_semi_colon_flag(semi_colon_flag) pretty_printer.level_decr end pretty_printer.indent pretty_printer.keyword(fz_until) pretty_printer.level_incr pretty_printer.indent pretty_printer.set_semi_colon_flag(false) until_expression.pretty_print pretty_printer.level_decr pretty_printer.indent pretty_printer.keyword(fz_loop) pretty_printer.indent if loop_body /= Void then loop_body.pretty_print end pretty_printer.indent pretty_printer.keyword(once "end;") if pretty_printer.print_end_loop then pretty_printer.put_end(fz_loop) end end feature {COMPOUND,INSTRUCTION_WITH_COMMENT} verify_scoop(allowed: FORMAL_ARG_LIST) is local dummy: BOOLEAN do if initialize /= Void then initialize.verify_scoop(allowed) end if invariant_clause /= Void then invariant_clause.verify_scoop(allowed) end if variant_clause /= Void then variant_clause.verify_scoop(allowed) end dummy := until_expression.verify_scoop(allowed) if loop_body /= Void then loop_body.verify_scoop(allowed) end end feature {NONE} current_type: E_TYPE loop_check: BOOLEAN make(sp: like start_position i: like initialize ic : like invariant_clause vc: like variant_clause ue : like until_expression lb : like loop_body) is require not sp.is_unknown ue /= Void do start_position := sp initialize := i invariant_clause := ic variant_clause := vc until_expression := ue loop_body := lb ensure start_position = sp initialize = i invariant_clause = ic variant_clause = vc until_expression = ue loop_body = lb end invariant not start_position.is_unknown until_expression /= Void end -- E_LOOP