/[eiffelstudio]/FreeELKS/trunk/library/kernel/routine.e
ViewVC logotype

Diff of /FreeELKS/trunk/library/kernel/routine.e

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 91476 by ericb, Fri Mar 3 10:19:32 2006 UTC revision 91477 by ericb, Sun Jan 14 09:47:13 2007 UTC
# Line 28  feature -- Initialization Line 28  feature -- Initialization
28                          other_exists: other /= Void                          other_exists: other /= Void
29                          conforming: conforms_to (other)                          conforming: conforms_to (other)
30                  do                  do
                         internal_operands := other.internal_operands  
                         open_map := other.open_map  
31                          rout_disp := other.rout_disp                          rout_disp := other.rout_disp
32                          eiffel_rout_disp := other.eiffel_rout_disp                          encaps_rout_disp := other.encaps_rout_disp
33                          is_cleanup_needed := other.is_cleanup_needed                          calc_rout_addr := other.calc_rout_addr
34                  ensure                          closed_operands := other.closed_operands
35                          same_call_status: other.callable implies callable                          operands := other.operands
36                            class_id := other.class_id
37                            feature_id := other.feature_id
38                            is_precompiled := other.is_precompiled
39                            is_basic := other.is_basic
40                            is_target_closed := other.is_target_closed
41                            is_inline_agent := other.is_inline_agent
42                            open_count := other.open_count
43                  end                  end
44    
45  feature -- Access  feature -- Access
46    
47          operands: OPEN_ARGS is          frozen operands: OPEN_ARGS
                         -- Open operands.  
                 local  
                         i, nb: INTEGER  
                         l_open_map: like open_map  
                         l_internal: like internal_operands  
                 do  
                         l_open_map := open_map  
                         if l_open_map /= Void then  
                                 from  
                                         create Result  
                                         i := 0  
                                         nb := l_open_map.count - 1  
                                         l_internal := internal_operands  
                                 until  
                                         i > nb  
                                 loop  
                                         Result.put (l_internal.item (l_open_map.item (i)), i + 1)  
                                         i := i + 1  
                                 end  
                         end  
                 end  
48    
49          target: ANY is          target: ANY is
50                          -- Target of call.                          -- Target of call.
51                  do                  do
52                          Result := internal_operands.item (1)                          if is_target_closed then
53                                    Result := closed_operands.item (1)
54                            elseif operands /= Void and then operands.count > 0 then
55                                    Result := operands.item (1)
56                            end
57                  end                  end
58    
59          hash_code: INTEGER is          hash_code: INTEGER is
60                          -- Hash code value.                          -- Hash code value.
61                  do                  do
62                          Result := rout_disp.hash_code                          Result := rout_disp.hash_code.bit_xor (
63                                    class_id.hash_code).bit_xor (
64                                            feature_id.hash_code)
65                  end                  end
66    
67          precondition (args: like operands): BOOLEAN is          precondition (args: like operands): BOOLEAN is
# Line 97  feature -- Access Line 87  feature -- Access
87                  ensure                  ensure
88                          empty_operands_not_void: Result /= Void                          empty_operands_not_void: Result /= Void
89                  end                  end
90                    
91  feature -- Status report  feature -- Status report
92    
93          callable: BOOLEAN is          callable: BOOLEAN is True
94                          -- Can routine be called on current object?                          -- Can routine be called on current object?
                 local  
                         null_ptr: POINTER  
                 do  
                         Result := (rout_disp /= null_ptr)  
                 end  
95    
96          is_equal (other: like Current): BOOLEAN is          is_equal (other: like Current): BOOLEAN is
97                          -- Is associated routine the same as the one                          -- Is associated routine the same as the one
98                          -- associated with `other'.                          -- associated with `other'.
99                  do                  do
100                          --| Do not compare implementation data                          --| Do not compare implementation data
101                          Result := equal (internal_operands, other.internal_operands)                          Result := equal (closed_operands, other.closed_operands)
102                                    and then equal (operands, other.operands)
103                                  and then equal (open_map, other.open_map)                                  and then equal (open_map, other.open_map)
104                                  and then (rout_disp = other.rout_disp)                                  and then (rout_disp = other.rout_disp)
105                                  and then (eiffel_rout_disp = other.eiffel_rout_disp)                                  and then (class_id = other.class_id)
106                                  and then (is_cleanup_needed = other.is_cleanup_needed)                                  and then (feature_id = other.feature_id)
107                                    and then (encaps_rout_disp = other.encaps_rout_disp)
108                                    and then (calc_rout_addr = other.calc_rout_addr)
109                  end                  end
110    
111          valid_operands (args: OPEN_ARGS): BOOLEAN is          valid_operands (args: OPEN_ARGS): BOOLEAN is
# Line 129  feature -- Status report Line 117  feature -- Status report
117                          open_type_codes: STRING                          open_type_codes: STRING
118                  do                  do
119                          create int                          create int
120                          if args = Void or open_map = Void then                          if args = Void then
121                                          -- Void operands are only allowed                                          -- Void operands are only allowed
122                                          -- if object has no open operands.                                          -- if object has no open operands.
123                                  Result := (open_map = Void)                                  Result := (open_count = 0)
124                          elseif open_map /= Void and then int.generic_count (args) >= open_map.count then                          elseif int.generic_count (args) >= open_count then
125                                  from                                  from
126                                          Result := True                                          Result := True
127                                          open_type_codes := eif_gen_typecode_str ($Current)                                          open_type_codes := eif_gen_typecode_str ($Current)
128                                          i := 1                                          i := 1
129                                  until                                  until
130                                          i > open_map.count or not Result                                          i > open_count or not Result
131                                  loop                                  loop
132                                          arg_type_code := args.item_code (i)                                          arg_type_code := args.item_code (i)
133                                          Result := arg_type_code = open_type_codes.item (i + 1).code                                          Result := arg_type_code = open_type_codes.item (i + 1).code
# Line 151  feature -- Status report Line 139  feature -- Status report
139                                          i := i + 1                                          i := i + 1
140                                  end                                  end
141                          end                          end
142                            if Result and then not is_target_closed then
143                                    Result := args.item (1) /= Void
144                            end
145                  end                  end
146    
147  feature -- Measurement          valid_target (args: TUPLE): BOOLEAN is
148                            -- Is the first element of tuple `args' a valid target
         open_count: INTEGER is  
                         -- Number of open operands.  
149                  do                  do
150                          if open_map /= Void then                          if args /= Void and then args.count > 0 then
151                                  Result := open_map.count                                  if args.is_reference_item (1) then
152                                            Result := args.reference_item (1) /= Void
153                                    else
154                                            Result := True
155                                    end
156                          end                          end
157                  end                  end
158    
159    feature -- Measurement
160    
161            open_count: INTEGER
162                            -- Number of open operands.
163    
164  feature -- Settings  feature -- Settings
165    
166          frozen set_operands (args: OPEN_ARGS) is          frozen set_operands (args: OPEN_ARGS) is
167                          -- Use `args' as operands for next call.                          -- Use `args' as operands for next call.
168                  require                  require
169                          valid_operands: valid_operands (args)                          valid_operands: valid_operands (args)
                 local  
                         i, nb: INTEGER  
                         l_open_map: like open_map  
                         l_internal: like internal_operands  
170                  do                  do
171                          l_open_map := open_map                          operands := args
                         if l_open_map /= Void then  
                                 from  
                                         i := 0  
                                         nb := l_open_map.count - 1  
                                         l_internal := internal_operands  
                                 until  
                                         i > nb  
                                 loop  
                                         rout_tuple_item_copy ($l_internal, l_open_map.item (i), $args, i + 1)  
                                         i := i + 1  
                                 end  
                         end  
172                  ensure                  ensure
173                          operands_set: (operands /= Void implies equal (operands, args)) or                          operands_set: (operands /= Void implies equal (operands, args)) or
174                                  (operands = Void implies (args = Void or else args.is_empty))                                  (operands = Void implies (args = Void or else args.is_empty))
# Line 197  feature -- Duplication Line 179  feature -- Duplication
179          copy (other: like Current) is          copy (other: like Current) is
180                          -- Use same routine as `other'.                          -- Use same routine as `other'.
181                  do                  do
                         internal_operands := other.internal_operands  
182                          open_map := other.open_map                          open_map := other.open_map
183                          rout_disp := other.rout_disp                          rout_disp := other.rout_disp
184                          eiffel_rout_disp := other.eiffel_rout_disp                          calc_rout_addr := other.calc_rout_addr
185                          is_cleanup_needed := other.is_cleanup_needed                          encaps_rout_disp := other.encaps_rout_disp
186                            class_id := other.class_id
187                            feature_id := other.feature_id
188                            is_precompiled := other.is_precompiled
189                            is_basic := other.is_basic
190                            is_target_closed := other.is_target_closed
191                            is_inline_agent := other.is_inline_agent
192                            closed_operands := other.closed_operands
193                            open_count := other.open_count
194                  ensure then                  ensure then
195                          same_call_status: other.callable implies callable                          same_call_status: other.callable implies callable
196                  end                  end
# Line 209  feature -- Duplication Line 198  feature -- Duplication
198  feature -- Basic operations  feature -- Basic operations
199    
200          call (args: OPEN_ARGS) is          call (args: OPEN_ARGS) is
201                          -- Call routine with operands `args'.                          -- Call routine with `args'.
202                  require                  require
203                          valid_operands: valid_operands (args)                          valid_operands: valid_operands (args)
204                          callable: callable                  deferred
                 do  
                         set_operands (args)  
                         apply  
                         if is_cleanup_needed then  
                                 remove_gc_reference  
                         end  
205                  end                  end
206    
207          apply is          apply is
208                          -- Call routine with `args' as last set.                          -- Call routine with `operands' as last set.
209                  require                  require
210                          valid_operands: valid_operands (operands)                          valid_operands: valid_operands (operands)
                         callable: callable  
211                  deferred                  deferred
212                  end                  end
213    
# Line 240  feature -- Obsolete Line 222  feature -- Obsolete
222                          conforming: conforms_to (other)                          conforming: conforms_to (other)
223                  do                  do
224                          adapt (other)                          adapt (other)
                 ensure  
                         same_call_status: other.callable implies callable  
225                  end                  end
226    
227  feature {ROUTINE, E_FEATURE} -- Implementation  feature {ROUTINE} -- Implementation
228    
229          frozen internal_operands: TUPLE          frozen closed_operands: TUPLE
230                          -- All open and closed arguments provided at creation time                          -- All closed arguments provided at creation time
231    
232          frozen open_map: SPECIAL [INTEGER]          closed_count: INTEGER is
233                          -- Index map for open arguments                          -- The number of closed operands (including the target if it is closed)
234                    do
235                            if closed_operands /= Void then
236                                    Result := closed_operands.count
237                            end
238                    end
239    
240          frozen rout_disp: POINTER          frozen rout_disp: POINTER
241                          -- Routine dispatcher                          -- Routine dispatcher
242    
243          frozen eiffel_rout_disp: POINTER          frozen calc_rout_addr: POINTER
244                            -- Address of the final routine
245    
246            frozen open_map: SPECIAL [INTEGER]
247                            -- Index map for open arguments
248    
249            frozen encaps_rout_disp: POINTER
250                          -- Eiffel routine dispatcher                          -- Eiffel routine dispatcher
251    
252          frozen is_cleanup_needed: BOOLEAN          frozen class_id: INTEGER
253                          -- If open arguments contain some references, we need  
254                          -- to clean them up after call.          frozen feature_id: INTEGER
255    
256          frozen set_rout_disp (p: POINTER; tp: POINTER; args: TUPLE;          frozen is_precompiled: BOOLEAN
257                                                   omap: ARRAY [INTEGER]) is  
258                          -- Initialize object.          frozen is_basic: BOOLEAN
259    
260            frozen is_target_closed: BOOLEAN
261    
262            frozen is_inline_agent: BOOLEAN
263    
264            frozen set_rout_disp (a_rout_disp, a_encaps_rout_disp, a_calc_rout_addr: POINTER
265                                                      a_class_id, a_feature_id: INTEGER; a_open_map: SPECIAL [INTEGER]
266                                                      a_is_precompiled, a_is_basic, a_is_target_closed, a_is_inline_agent: BOOLEAN
267                                                      a_closed_operands: TUPLE; a_open_count: INTEGER) is
268                            -- Initialize object.
269                  require                  require
270                          p_not_void: p /= Default_pointer                          target_valid: a_is_target_closed implies valid_target (a_closed_operands)
271                          tp_not_void: tp /= Default_pointer                  do
272                          args_not_void: args /= Void                          set_rout_disp_int (a_rout_disp, a_encaps_rout_disp, a_calc_rout_addr, a_class_id, a_feature_id,
273                  do                                                             a_open_map, a_is_precompiled, a_is_basic, a_is_target_closed,
274                          rout_disp := p                                                             a_is_inline_agent, a_closed_operands, a_open_count)
275                          eiffel_rout_disp := tp                  end
276                          internal_operands := args  
277                          if omap /= Void then          frozen set_rout_disp_final (a_rout_disp, a_encaps_rout_disp, a_calc_rout_addr: POINTER
278                                  open_map := omap.area                                                                  a_closed_operands: TUPLE; a_is_target_closed: BOOLEAN; a_open_count: INTEGER) is
279                          else                          -- Initialize object.
280                                  open_map := Void                  do
281                          end                          rout_disp := a_rout_disp
282                          compute_is_cleanup_needed                          encaps_rout_disp := a_encaps_rout_disp
283                            calc_rout_addr := a_calc_rout_addr
284                            closed_operands := a_closed_operands
285                            is_target_closed := a_is_target_closed
286                            open_count := a_open_count
287                    end
288    
289            frozen set_rout_disp_int (a_rout_disp, a_encaps_rout_disp, a_calc_rout_addr: POINTER
290                                                              a_class_id, a_feature_id: INTEGER; a_open_map: SPECIAL [INTEGER]
291                                                              a_is_precompiled, a_is_basic, a_is_target_closed, a_is_inline_agent: BOOLEAN
292                                                              a_closed_operands: TUPLE; a_open_count: INTEGER) is
293                            -- Initialize object.
294                    require
295                            a_class_id_valid: a_class_id > -1
296                            a_feature_id_valid: a_feature_id > -1
297                    do
298                            rout_disp := a_rout_disp
299                            encaps_rout_disp := a_encaps_rout_disp
300                            calc_rout_addr := a_calc_rout_addr
301                            class_id := a_class_id
302                            feature_id := a_feature_id
303                            open_map := a_open_map
304                            is_precompiled := a_is_precompiled
305                            is_basic := a_is_basic
306                            is_target_closed := a_is_target_closed
307                            is_inline_agent := a_is_inline_agent
308                            closed_operands := a_closed_operands
309                            open_count := a_open_count
310                  ensure                  ensure
311                          rout_disp_set: rout_disp = p                          rout_disp_set: rout_disp = a_rout_disp
312                          eiffel_rout_disp_set: eiffel_rout_disp = tp                          encaps_rout_disp_set: encaps_rout_disp = a_encaps_rout_disp
313                          internal_operands_set: internal_operands = args                          calc_rout_addr_set: calc_rout_addr = a_calc_rout_addr
314                          open_map_set: (omap = Void and open_map = Void) or                          class_id_set: class_id = a_class_id
315                                  (omap /= Void and then open_map = omap.area)                          feature_id_set: feature_id = a_feature_id
316                            open_map_set: open_map = a_open_map
317                            is_target_closed_set: is_target_closed = a_is_target_closed
318                            is_precompiled_set: is_precompiled = a_is_precompiled
319                            is_basic_set: is_basic = a_is_basic
320                            is_inline_agent_set: is_inline_agent = a_is_inline_agent
321                            closed_operands_set: closed_operands = a_closed_operands
322                            open_count_set: open_count = a_open_count
323                  end                  end
324    
325  feature {NONE} -- Implementation  feature {NONE} -- Implementation
326    
327          frozen open_types: ARRAY [INTEGER]          frozen open_types: ARRAY [INTEGER]
328                          -- Types of open operands                          -- Types of open operands
                           
         frozen remove_gc_reference is  
                         -- Remove all references from `internal_operands' so that GC  
                         -- can collect them if necessary.  
                 require  
                         is_cleanup_needed: is_cleanup_needed  
                         has_open_operands: open_map /= Void  
                 local  
                         l_open_map: like open_map  
                         i, nb, l_pos: INTEGER  
                         l_internal: like internal_operands  
                 do  
                         l_open_map := open_map  
                         from  
                                 i := 0  
                                 nb := l_open_map.count - 1  
                                 l_internal := internal_operands  
                         until  
                                 i > nb  
                         loop  
                                 l_pos := l_open_map.item (i)  
                                         -- We only need to clean up references so that GC  
                                         -- can collect them if necessary.  
                                 if l_internal.is_reference_item (l_pos) then  
                                         l_internal.put_reference (Void, l_pos)  
                                 end  
                                 i := i + 1  
                         end  
                 end  
                   
         frozen compute_is_cleanup_needed is  
                         -- Set `is_cleanup_needed' to True if some open arguments are references.  
                 local  
                         l_open_map: like open_map  
                         i, nb, l_pos: INTEGER  
                         l_internal: like internal_operands  
                 do  
                         is_cleanup_needed := False  
                         l_open_map := open_map  
                         if l_open_map /= Void then  
                                 from  
                                         i := 0  
                                         nb := l_open_map.count - 1  
                                         l_internal := internal_operands  
                                 until  
                                         i > nb or is_cleanup_needed  
                                 loop  
                                         l_pos := l_open_map.item (i)  
                                                 -- We only need to clean up references so that GC  
                                                 -- can collect them if necessary.  
                                         is_cleanup_needed := l_internal.is_reference_item (l_pos)  
                                         i := i + 1  
                                 end  
                         end  
                 end  
329    
330          open_operand_type (i: INTEGER): INTEGER is          open_operand_type (i: INTEGER): INTEGER is
331                          -- Type of `i'th open operand.                          -- Type of `i'th open operand.
# Line 356  feature {NONE} -- Implementation Line 336  feature {NONE} -- Implementation
336                          l_internal: INTERNAL                          l_internal: INTERNAL
337                  do                  do
338                          if open_types = Void then                          if open_types = Void then
339                                  create open_types.make (1, open_map.count)                                  create open_types.make (1, open_count)
340                          end                          end
341                          Result := open_types.item (i)                          Result := open_types.item (i)
342                          if Result = 0 then                          if Result = 0 then
# Line 369  feature {NONE} -- Implementation Line 349  feature {NONE} -- Implementation
349    
350  feature {NONE} -- Externals  feature {NONE} -- Externals
351    
         rout_tuple_item_copy (a_target: POINTER; a_target_pos: INTEGER; a_source: POINTER; a_source_pos: INTEGER) is  
                         -- Copy tuple element at position `a_source_pos' in `a_source' to position  
                         -- `a_target_pos' in `a_target'.  
                 external  
                         "C macro use %"eif_rout_obj.h%""  
                 end  
   
352          eif_gen_typecode_str (obj: POINTER): STRING is          eif_gen_typecode_str (obj: POINTER): STRING is
353                          -- Code name for generic parameter `pos' in `obj'.                          -- Code name for generic parameter `pos' in `obj'.
354                  external                  external

Legend:
Removed from v.91476  
changed lines
  Added in v.91477

  ViewVC Help
Powered by ViewVC 1.1.23