Amiga ACS 1998 #4/amigaacscoverdisc1998-041998.iso/utilities/shareware/dev/ppcsmalleiffel/lib_se/run_feature_3.e

Text File | 1998-01-16 | 12.6 KB | 552 lines

--          This file is part of SmallEiffel The GNU Eiffel Compiler.
--          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
--            Dominique COLNET and Suzanne COLLIN - [e-mail]
--                       http://www.loria.fr/SmallEiffel
-- SmallEiffel 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. SmallEiffel 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  SmallEiffel;  see the file COPYING.  If not,
-- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-- Boston, MA 02111-1307, USA.
--
class RUN_FEATURE_3

inherit RUN_FEATURE redefine base_feature end;

creation {PROCEDURE} make

feature

   base_feature: PROCEDURE;

   local_vars: LOCAL_VAR_LIST;
     -- Runnable local var list if any.

feature

   is_static: BOOLEAN is false;

   static_value_mem: INTEGER is 0;

   can_be_dropped: BOOLEAN is false

   is_pre_computable: BOOLEAN is
      do
     if arguments = Void then
        if routine_body = Void then
           Result := true;
        else
           if local_vars = Void then
          Result := routine_body.is_pre_computable;
           end;
        end;
     end;
      end;

   afd_check is
      do
     routine_afd_check;
      end;

   is_empty_or_null_body: BOOLEAN is
      do
     if isa_in_line then
        Result := in_line_status = C_empty_or_null_body;
     end;
      end;

   is_attribute_writer: SIMPLE_FEATURE_NAME is
      local
     a: ASSIGNMENT;
      do
     if isa_in_line then
        if in_line_status = C_attribute_writer then
           a ?= routine_body.first;
           Result ?= a.left_side;
        end;
     end;
      end;

   mapping_c is
      do
     if isa_in_line then
        in_line;
     elseif use_current then
        default_mapping_procedure;
     else
        if cpp.target_cannot_be_dropped then
           cpp.put_string(fz_14);
        end;
        mapping_name;
        cpp.put_character('(');
        if arg_count > 0 then
           cpp.put_arguments;
        end;
        cpp.put_string(fz_14);
     end;
      end;

   c_define is
      do
     if isa_in_line then
        cpp.incr_inlined_procedure_count;
        nothing_comment;
     else
        if use_current then
           cpp.incr_procedure_count;
        else
           cpp.incr_real_procedure_count;
        end;
        define_prototype;
        define_opening;
        if routine_body /= Void then
           routine_body.compile_to_c;
        end;
        define_closing;
        cpp.put_string(fz_12);
     end;
      end;

feature {NONE}

   initialize is
      do
     arguments := base_feature.arguments;
     if arguments /= Void then
        arguments := arguments.to_runnable(current_type);
     end;
     local_vars := base_feature.local_vars;
     if local_vars /= Void then
        local_vars := local_vars.to_runnable(current_type);
     end;
     routine_body := base_feature.routine_body;
     if routine_body /= Void then
        routine_body := routine_body.to_runnable(current_type);
     end;
     if run_control.require_check then
        require_assertion := base_feature.run_require(Current);
     end;
     if run_control.ensure_check then
        ensure_assertion := base_feature.run_ensure(Current);
     end;
      end;

   in_line_status: INTEGER;
     -- Value 0 means not computed.
     -- Value -1 means not `isa_in_line'.

   isa_in_line: BOOLEAN is
      do
     if run_control.boost then
        inspect
           in_line_status
        when -1 then
        when 0 then
           Result := true;
               if us_copy = name.to_string then
          in_line_status := -1;
          Result := false;
           elseif empty_or_null_body then
          in_line_status := C_empty_or_null_body;
           elseif do_not_use_current then
          in_line_status := C_do_not_use_current;
           elseif attribute_writer then
          in_line_status := C_attribute_writer;
           elseif direct_call then
          in_line_status := C_direct_call;
          -- *** UTILISER AUSSI isa_dca_inline ... pour la
          -- -0.85
          -- ****  IDEM DANS RUN_FEATURE_4
           elseif dca then
          in_line_status := C_dca;
           elseif one_pc then
          in_line_status := C_one_pc;
           else
          in_line_status := -1;
          Result := false;
           end;
        else
           Result := true;
        end;
     end;
      end;

   in_line is
      require
     isa_in_line;
      local
     flag: BOOLEAN;
     a: ASSIGNMENT;
     w: FEATURE_NAME;
     e: EXPRESSION;
     pc: PROC_CALL;
     rf: RUN_FEATURE;
      do
     cpp.put_string("/*[IRF3.");
     cpp.put_integer(in_line_status);
     cpp.put_string(name.to_string);
     cpp.put_string(fz_close_c_comment);
     inspect
        in_line_status
     when C_empty_or_null_body then
        if cpp.cannot_drop_all then
           cpp.put_string(fz_14);
        end;
        if need_local_vars then
           cpp.put_character('{');
           define_opening;
           define_closing;
           cpp.put_character('}');
        end;
     when C_do_not_use_current then
        if cpp.target_cannot_be_dropped then
           cpp.put_string(fz_14);
        end;
        flag := need_local_vars;
        if flag then
           cpp.put_character('{');
           define_opening;
        end;
        routine_body.compile_to_c;
        if flag then
           define_closing;
           cpp.put_character('}');
        end;
     when C_attribute_writer then
        flag := need_local_vars;
        if flag then
           cpp.put_character('{');
           define_opening;
        end;
        a ?= routine_body.first;
        w ?= a.left_side;
        w := w.name_in(current_type.base_class);
        cpp.put_character('(');
        cpp.put_character('(');
        cpp.put_character('(');
        current_type.mapping_cast;
        cpp.put_character('(');
        cpp.put_target_as_target;
        cpp.put_string(fz_13);
        cpp.put_string(fz_b5);
        cpp.put_string(w.to_string);
        cpp.put_character(')');
        cpp.put_character('=');
        cpp.put_character('(');
        e := a.right_side;
        if arguments = Void then
           e.compile_to_c;
        else
           cpp.put_arguments;
        end;
        cpp.put_character(')');
        cpp.put_string(fz_00);
        if flag then
           define_closing;
           cpp.put_character('}');
        end;
     when C_direct_call then
        flag := need_local_vars;
        if flag then
           cpp.put_character('{');
           define_opening;
        end;
        pc ?= routine_body.first;
        rf := pc.run_feature;
        cpp.push_same_target(rf,pc.arguments);
        rf.mapping_c;
        cpp.pop;
        if flag then
           define_closing;
           cpp.put_character('}');
        end;
     when C_dca then
        pc ?= routine_body.first;
        pc.finalize;
        cpp.push_inline_dca(Current,pc);
        pc.run_feature.mapping_c;
        cpp.pop;
     when C_one_pc then
        if not use_current then
           if cpp.target_cannot_be_dropped then
          cpp.put_string(fz_14);
           end;
        end;
        cpp.put_character('{');
        if use_current then
           tmp_string.clear;
           current_type.c_type_for_target_in(tmp_string);
           tmp_string.extend(' ');
           cpp.put_string(tmp_string);
           cpp.inline_level_incr;
           cpp.print_current;
           cpp.inline_level_decr;
           cpp.put_character('=');
           cpp.put_target_as_target;
           cpp.put_string(fz_00);
        end;
        if arguments /= Void then
           arguments.inline_one_pc;
        end;
        if need_local_vars then
           local_vars.inline_one_pc;
           cpp.inline_level_incr;
           local_vars.initialize_expanded;
           cpp.inline_level_decr;
        end;
        cpp.push_inline_one_pc;
        cpp.inline_level_incr;
        routine_body.compile_to_c;
        cpp.inline_level_decr;
        cpp.pop;
        cpp.put_character('}');
     end;
     cpp.put_string("/*]*/%N");
      end;

feature {NONE}

   compute_use_current is
      do
     if current_type.is_reference and then run_control.no_check then
        use_current_state := ucs_true;
     else
        std_compute_use_current;
     end;
      end;

feature {NONE}

   empty_or_null_body: BOOLEAN is
     -- The body is empty or has only unreacheable code.
      local
     rb: COMPOUND;
      do
     rb := routine_body;
     Result := (rb = Void or else rb.empty_or_null_body);
      end;

   do_not_use_current: BOOLEAN is
      do
     if not routine_body.use_current then
        Result := arguments = Void;
     end;
      end;

   attribute_writer: BOOLEAN is
     -- True when body as only one instruction is of
     -- the form :
     --            feature_name := <expression>;
     -- And when <expression> is an argument or a statically
     -- computable value.
      local
     rb: like routine_body;
     a: ASSIGNMENT;
     args: like arguments;
     an2: ARGUMENT_NAME2;
     wa: SIMPLE_FEATURE_NAME;
      do
     rb := routine_body;
     args := arguments;
     if rb /= Void and then rb.count = 1 then
        a ?= rb.first;
        if a /= Void then
           wa ?= a.left_side;
           if wa /= Void then
          if args = Void then
             Result := not a.right_side.use_current;
          elseif args.count = 1 then
             an2 ?= a.right_side;
             Result := an2 /= Void;
          end;
           end;
        end;
     end;
      end;

   direct_call: BOOLEAN is
     -- True when the procedure has no arguments, no locals,
     -- and when the body has only one instruction of the
     -- form : foo(<args>);
     -- Where <args> can be an empty list or a statically
     -- computable one and where `foo' is a RUN_FEATURE_3.
      local
     rb: like routine_body;
     pc: PROC_CALL;
     args: EFFECTIVE_ARG_LIST;
     rf3: RUN_FEATURE_3;
      do
     rb := routine_body;
     if rb /= Void and then
        rb.count = 1 and then
        arguments = Void and then
        local_vars = Void
      then
        pc ?= rb.first;
        if pc /= Void then
           if pc.target.is_current then
          rf3 ?= pc.run_feature;
          if rf3 /= Void then
             args := pc.arguments;
             if args = Void then
            Result := true;
             else
            Result := args.is_static;
             end;
          end;
           end;
        end;
     end;
      end;

   dca: BOOLEAN is
      local
     pc: PROC_CALL;
     rf: RUN_FEATURE;
     args: EFFECTIVE_ARG_LIST;
      do
     pc := body_one_dpca;
     if pc /= Void and then local_vars = Void then
        rf := pc.run_feature;
        if rf /= Current then
           args := pc.arguments;
           if args = Void then
          Result := arg_count = 0;
           else
          Result := args.isa_dca_inline(Current,rf);
           end;
        end;
     end;
      end;

   one_pc: BOOLEAN is
      local
     rb: like routine_body;
     pc: PROC_CALL;
     rf: RUN_FEATURE;
     r: ARRAY[RUN_CLASS];
      do
     rb := routine_body;
     if rb /= Void and then rb.count = 1 then
        pc ?= rb.first;
        if pc /= Void then
           rf := pc.run_feature;
           if rf /= Void and then rf /= Current then
          r := rf.run_class.running;
          if r /= Void and then r.count = 1 then
             Result := true;
          end;
           end;
        end;
     end;
      end;

   body_one_dpca: PROC_CALL is
     -- Gives Void or the only one direct PROC_CALL on
     -- an attribute of Current target.
      local
     rb: like routine_body;
     pc: PROC_CALL;
     c0c: CALL_0_C;
     rf2: RUN_FEATURE_2;
     r: ARRAY[RUN_CLASS];
      do
     if local_vars = Void then
        rb := routine_body;
        if rb /= Void and then rb.count = 1 then
           pc ?= rb.first;
           if pc /= Void then
          c0c ?= pc.target;
          if c0c /= Void and then c0c.target.is_current then
             rf2 ?= c0c.run_feature;
             if rf2 /= Void then
            r := rf2.run_class.running;
            if r /= Void and then r.count = 1 then
               r := pc.run_feature.run_class.running;
               if r /= Void and then r.count = 1 then
                  Result := pc;
               end;
            end;
             end;
          end;
           end;
        end;
     end;
      end;

   need_local_vars: BOOLEAN is
      do
     if local_vars /= Void then
        Result := local_vars.produce_c;
     end;
      end;

feature {NONE}

   tmp_string: STRING is
      once
     !!Result.make(32);
      end;

feature {NONE}

   C_empty_or_null_body : INTEGER is 1;
   C_do_not_use_current : INTEGER is 2;
   C_attribute_writer   : INTEGER is 3;
   C_direct_call        : INTEGER is 4;
   C_dca                : INTEGER is 5;
   C_one_pc             : INTEGER is 6;

feature {RUN_CLASS}

   jvm_field_or_method is
      do
     jvm.add_method(Current);
      end;

feature

   mapping_jvm is
      do
     routine_mapping_jvm;
      end;

feature {JVM}

   jvm_define is
      do
     method_info_start;
     jvm_define_opening;
     if routine_body /= Void then
        routine_body.compile_to_jvm;
     end;
     jvm_define_closing;
     code_attribute.opcode_return;
     method_info.finish;
      end;

feature {NONE}

   update_tmp_jvm_descriptor is
      do
     routine_update_tmp_jvm_descriptor;
      end;

feature {SMALL_EIFFEL}

   do_not_inline is
      do
     in_line_status := -1;
      end;

invariant

   result_type = Void;

end -- RUN_FEATURE_3