AmigActive 3/AACD03.BIN/AACD/Programming/sofa/archive/SmallEiffel.lha/SmallEiffel/lib_se/expression.e

Text File | 1999-06-05 | 12KB | 439 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://SmallEiffel.loria.fr
-- 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.
--
deferred class EXPRESSION
   --
   -- Any kind of Eiffel expression.
   --

inherit GLOBALS;

feature

   start_position: POSITION is
         -- Of the expression if any.
      deferred
      end;

   is_current: BOOLEAN is
         -- Is it a `Current' like expression (really written
         -- `Current' or some implicit non-written `Current') ?
      deferred
      end;

   is_manifest_string: BOOLEAN is
         -- Is it a manifest string ?
      deferred
      end;

   is_void: BOOLEAN is
         -- Is it the built-in Void ?
      deferred
      end;

   is_result: BOOLEAN is
         -- Is it the pseudo local variable `Result' ?
      deferred
      end;

   is_writable: BOOLEAN is
         -- Is is something that one can find on the left-hand-side
         -- of the := operator ?
      deferred
      end;

   static_result_base_class: BASE_CLASS is
         -- The static BASE_CLASS of the `result_type' (according to the
         -- `start_position').
         -- Void when it is too difficult to compute, when some error
         -- occurs or when this is the class NONE.
      deferred
      end;

   result_type: TYPE is
         -- The `result_type' is available only when the expression
         -- has been checked (see `to_runnable').
      deferred
      ensure
         Result /= Void
      end;

   use_current: BOOLEAN is
         -- True if `Current' is used.
         -- As for `result_type', available only for checked expression.
      require
         small_eiffel.is_ready
      deferred
      end;

   to_runnable(ct: TYPE): like Current is
         -- Gives the corresponding expression checked in `ct'.
      require
         ct.run_type = ct;
         ct.run_class /= Void
      deferred
      ensure
         nb_errors = 0 implies Result.result_type.is_run_type
      end;

feature

   isa_dca_inline_argument: INTEGER is
         -- Interpretation of the Result :
         --    -1 : yes and no ARGUMENT_NAME used
         --     0 : not inlinable
         --   > 0 : inlinable and ARGUMENT_NAME rank is used.
      require
         run_control.boost and small_eiffel.is_ready
      deferred
      ensure
         Result >= -1
      end;

   dca_inline_argument(formal_arg_type: TYPE) is
      require
         formal_arg_type /= Void;
         isa_dca_inline_argument /= 0
      deferred
      end;

   assertion_check(tag: CHARACTER) is
         -- Assume the current code in inside some assertion (a
         -- require clause or some class invariant for example)..
         -- The `tag' mangling is :
         --   'R' when we are inside some require clause.
         --   'E' when we are inside some ensure clause.
         --   '_' for all other assertions.
         -- This flag is used to check VAPE and VEEN as well.
      require
         run_control.no_check;
         ("RE_").has(tag)
      deferred
      end;

feature  -- Handling of precedence (priority of expressions) :

   precedence: INTEGER is
      deferred
      ensure
         1 <= Result and Result <= atomic_precedence
      end;

feature

   frozen add_comment(c: COMMENT): EXPRESSION is
         -- Attach `c' to the receiver.
      do
         if c = Void or else c.count = 0 then
            Result := Current;
         else
            !EXPRESSION_WITH_COMMENT!Result.make(Current,c);
         end;
      end;

   frozen base_class_written: BASE_CLASS is
      do
         Result := written_in.base_class;
      end;

   frozen written_in: CLASS_NAME is
         -- The name of the base class where the expression is
         -- written if any.
      local
         sp: like start_position;
      do
         sp := start_position;
         if sp /= Void then
            Result := sp.base_class_name;
         end;
      end;

   afd_check is
         -- After Falling Down Check.
      deferred
      end;

feature -- To produce C code :

   collect_c_tmp is
         -- Traverse the expression to collect needed C tmp variables
         -- just before `compile_to_c'.
      require
         small_eiffel.is_ready
      deferred
      end;

   compile_to_c is
         -- Produce C code to access the value of the Current
         -- expression : user's expanded are no longuer pointer.
      require
         small_eiffel.is_ready;
         cpp.on_c
      deferred
      ensure
         cpp.on_c
      end;

   mapping_c_target(formal_type: TYPE) is
         -- Produce C code in order to pass Current expression as
         -- the target of a feature call.
         -- When it is needed, C code to check invariant is
         -- automatically added as well as a C cast according to
         -- the destination `formal_type'.
      require
         small_eiffel.is_ready;
         formal_type.at_run_time
      deferred
      end;

   mapping_c_arg(formal_arg_type: TYPE) is
         -- Produce C code in order to pass Current expression as an
         -- argument of the feature called.
         -- Thus, it is the same jobs as `mapping_c_target' without
         -- the invariant call.
      require
         small_eiffel.is_ready
      deferred
      end;

   c_declare_for_old is
         -- Produce C code to declare `old' expression variables.
      require
         small_eiffel.is_ready;
         cpp.on_c
      deferred
      ensure
         cpp.on_c
      end;

   compile_to_c_old is
         -- Produce C code to memorize `old' expression values.
      require
         small_eiffel.is_ready;
         cpp.on_c
      deferred
      ensure
         cpp.on_c
      end;

feature  -- To produce C code :

   c_simple: BOOLEAN is
         -- True when the C code of `compile_c' has no side effect at
         -- and `compile_to_c' on the corresponding simple expression
         -- can be called more than once without any problem.
      deferred
      end;

   can_be_dropped: BOOLEAN is
         -- True if evaluation of current expression has NO possible
         -- side effects. Thus, in such a case, an unused expression
         -- can be dropped (for example target of real procedure or
         -- real function).
      require
         small_eiffel.is_ready
      deferred
      end;

feature  -- Finding `int' Constant C expression :

   is_static: BOOLEAN is
         -- True if expression has always the same static
         -- value: INTEGER or BOOLEAN value is always the same
         -- or when reference is always the same (Void or the
         -- same manifest string for example).
      require
         small_eiffel.is_ready
      deferred
      end;

   static_value: INTEGER is
         -- Note: the result could be an EXPRESSION ... it seems
         -- to be a good idea.
      require
         is_static
      deferred
      end;

   is_pre_computable: BOOLEAN is
         -- Can the current expression be pre-computed in main
         -- function to speed up a once function ?
      require
         small_eiffel.is_ready
      deferred
      end;

feature -- For `compile_to_jvm' :

   compile_to_jvm is
         -- Produce Java byte code in order to push expression value
         -- on the jvm stack.
      require
         small_eiffel.is_ready
      deferred
      end;

   compile_target_to_jvm is
         -- Same as `compile_to_jvm', but add class invariant check
         -- when needed.
      require
         small_eiffel.is_ready
      deferred
      end;

   compile_to_jvm_old is
         -- Produce Java byte code to memorize `old' expression values.
      require
         small_eiffel.is_ready
      deferred
      end;

   compile_to_jvm_into(dest: TYPE): INTEGER is
         -- Assume `result_type' conforms to `dest'.
         -- Produce Java byte code in order to convert the expression
         -- into `dest' (comparisons = and /=, argument passing and
         -- assignment).
         -- Result gives the space in the JVM stack.
      require
         conversion_check(dest,result_type)
      deferred
      ensure
         Result >= 1
      end;

feature {NONE}

   frozen standard_compile_target_to_jvm is
      do
         compile_to_jvm;
         result_type.jvm_check_class_invariant;
      end;

   frozen standard_compile_to_jvm_into(dest: TYPE): INTEGER is
      require
         conversion_check(dest,result_type)
      do
         compile_to_jvm;
         Result := result_type.run_type.jvm_convert_to(dest);
      ensure
         Result >= 1
      end;

feature

   conversion_check(dest, rt: TYPE): BOOLEAN is
      do
         Result := true;
         if rt.is_a(dest) then
         else
            eh.cancel;
            if dest.is_a(rt) then
            else
               warning(start_position,
                ". Impossible conversion (EXPRESSION).");
            end;
         end;
      end;

   jvm_branch_if_false: INTEGER is
         -- Gives the `program_counter' to be resolved.
      require
         result_type.is_boolean
      deferred
      end;

   jvm_branch_if_true: INTEGER is
         -- Gives the `program_counter' to be resolved.
      require
         result_type.is_boolean
      deferred
      end;

   jvm_assign is
         -- Basic assignment using value on top of stack.
      require
         is_writable
      deferred
      end;

feature {NONE}

   frozen jvm_standard_branch_if_false: INTEGER is
         -- Gives the `program_counter' to be resolved.
      require
         result_type.is_boolean
      do
         compile_to_jvm;
         Result := code_attribute.opcode_ifeq;
      end;

   frozen jvm_standard_branch_if_true: INTEGER is
         -- Gives the `program_counter' to be resolved.
      require
         result_type.is_boolean
      do
         compile_to_jvm;
         Result := code_attribute.opcode_ifne
      end;

feature

   to_integer: INTEGER is
      do
         error(start_position,fz_iinaiv);
      end;

feature -- Pretty printing :

   pretty_print is
         -- Start the `pretty_print' process.
      require
         fmt.indent_level >= 1;
      deferred
      ensure
         fmt.indent_level = old fmt.indent_level;
      end;

   print_as_target is
         -- Print the expression viewed as a target plus the
         -- corresponding dot when it is necessary.
      deferred
      end;

   bracketed_pretty_print is
         -- Add bracket only when it is necessary.
      deferred
      end;

feature -- For `short' :

   short is
      deferred
      end;

   short_target is
         -- A target with the following dot if needed.
      deferred
      end;

   frozen bracketed_short is
      do
         short_print.hook_or("open_b","(");
         short;
         short_print.hook_or("close_b",")");
      end;

end -- EXPRESSION