Automatic generation produced by ISE Eiffel

Classes
Clusters
Cluster hierarchy
Chart
Relations
Text
Flat
Contracts
Flat contracts
Go to: 
indexing
	description: "[
		Objects representing delayed calls to a procedure.
		with some operands possibly still open.
	]"
	note: "[
		Features are the same as those of ROUTINE,
		with `apply' made effective, and no further
		redefinition of `is_equal' and `copy'.
	]"
	status: "See notice at end of class"
	date: "$Date: 2001-11-16 20:32:23 +0000 (Fri, 16 Nov 2001) $"
	revision: "$Revision: 51435 $"

class 
	PROCEDURE [BASE_TYPE, OPEN_ARGS -> TUPLE]

feature -- Initialization

	adapt (other: ROUTINE [ANY, OPEN_ARGS]) is
			-- Initialize from other.
			-- Useful in descendants.
			-- (from ROUTINE)
		require -- from ROUTINE
			other_exists: other /= void
			conforming: conforms_to (other)
		local
			null_ptr: POINTER
		do
			if rout_cargs /= null_ptr then
				rout_obj_free_args (rout_cargs)
				rout_cargs := null_ptr
			end
			operands := other.operands
			operands_set_by_user := other.operands_set_by_user
			closed_operands := other.closed_operands
			open_map := other.open_map
			closed_map := other.closed_map
			rout_disp := other.rout_disp
		ensure -- from ROUTINE
			same_call_status: other.callable implies callable
		end
	
feature -- Access

	hash_code: INTEGER is
			-- Hash code value.
			-- (from ROUTINE)
		do
			Result := rout_disp.hash_code
		ensure -- from HASHABLE
			good_hash_value: Result >= 0
		end

	open_operand_type (i: INTEGER): INTEGER is
			-- Type of ith open operand.
			-- (from ROUTINE)
		require -- from ROUTINE
			positive: i >= 1
			within_bounds: i <= open_count
		do
			if open_types = void then
				create open_types.make (1, open_map.count)
			end
			Result := open_types.item (i)
			if Result = 0 then
				Result := eif_gen_param_id (- 1, eif_gen_create ($Current, 2), i)
				open_types.force (Result, i)
			end
		end

	operands: OPEN_ARGS
			-- Open operands.
			-- (from ROUTINE)

	postcondition (args: like operands): BOOLEAN is
			-- Does current state satisfy routine's
			-- postcondition for args?
			-- (from ROUTINE)
		do
			Result := True
		end

	precondition (args: like operands): BOOLEAN is
			-- Do args satisfy routine's precondition
			-- in current state?
			-- (from ROUTINE)
		do
			Result := True
		end

	target: ANY is
			-- Target of call.
			-- (from ROUTINE)
		do
			if closed_map.count > 0 and then closed_map.item (closed_map.lower) = 0 then
				Result := closed_operands.item (closed_operands.lower)
			elseif operands /= void and then operands.count > 0 then
				Result := operands.item (operands.lower)
			end
		end
	
feature {NONE} -- Access

	C_memory: INTEGER is 2
			-- Code for the C memory managed
			-- by the garbage collector
			-- (from MEM_CONST)

	Eiffel_memory: INTEGER is 1
			-- Code for the Eiffel memory managed
			-- by the garbage collector
			-- (from MEM_CONST)

	Full_collector: INTEGER is 0
			-- Statistics for full collections
			-- (from MEM_CONST)

	Incremental_collector: INTEGER is 1
			-- Statistics for incremental collections
			-- (from MEM_CONST)

	Total_memory: INTEGER is 0
			-- Code for all the memory managed
			-- by the garbage collector
			-- (from MEM_CONST)
	
feature -- Measurement

	open_count: INTEGER is
			-- Number of open operands.
			-- (from ROUTINE)
		do
			if open_map /= void then
				Result := open_map.count
			end
		end
	
feature {NONE} -- Measurement

	gc_statistics (collector_type: INTEGER): GC_INFO is
			-- Garbage collection information for collector_type.
			-- (from MEMORY)
		require -- from MEMORY
			type_ok: collector_type = full_collector or collector_type = incremental_collector
		do
			create Result.make (collector_type)
		end

	memory_statistics (memory_type: INTEGER): MEM_INFO is
			-- Memory usage information for memory_type
			-- (from MEMORY)
		require -- from MEMORY
			type_ok: memory_type = total_memory or memory_type = eiffel_memory or memory_type = c_memory
		do
			create Result.make (memory_type)
		end
	
feature -- Status report

	callable: BOOLEAN is
			-- Can routine be called on current object?
			-- (from ROUTINE)
		local
			null_ptr: POINTER
		do
			Result := (rout_disp /= null_ptr)
		end

	is_equal (other: like Current): BOOLEAN is
			-- Is associated routine the same as the one
			-- associated with other.
			-- (from ROUTINE)
		require -- from ANY
			other_not_void: other /= void
		do
			Result := equal (operands, other.operands) and then equal (closed_operands, other.closed_operands) and then equal (open_map, other.open_map) and then equal (closed_map, other.closed_map) and then (rout_disp = other.rout_disp)
		ensure -- from ANY
			symmetric: Result implies other.is_equal (Current)
			consistent: standard_is_equal (other) implies Result
		end

	is_hashable: BOOLEAN is
			-- May current object be hashed?
			-- (True if it is not its type's default.)
			-- (from HASHABLE)
		do
			Result := (Current /= default)
		ensure -- from HASHABLE
			ok_if_not_default: Result implies (Current /= default)
		end

	valid_operands (args: OPEN_ARGS): BOOLEAN is
			-- Are args valid operands for this routine?
			-- (from ROUTINE)
		local
			i: INTEGER
			mismatch: BOOLEAN
			arg: ANY
			arg_type_code: CHARACTER
			open_arg_type_code: CHARACTER
			a_boolean_ref: BOOLEAN_REF
			a_character_ref: CHARACTER_REF
			a_double_ref: DOUBLE_REF
			an_integer_ref: INTEGER_REF
			a_pointer_ref: POINTER_REF
			a_real_ref: REAL_REF
			int: INTERNAL
		do
			if args = void or open_map = void then
				Result := (open_map = void)
			elseif open_map /= void and then args.count >= open_map.count then
				from
					create int
					i := 1
				until
					i > open_map.count or mismatch
				loop
					arg := args.item (i)
					arg_type_code := args.arg_item_code (i)
					open_arg_type_code := open_type_codes.item (i + 1)
					if arg_type_code = 'r' then
						inspect open_arg_type_code
						when 'b' then 
							a_boolean_ref ?= arg;
							mismatch := a_boolean_ref = void
						when 'c' then 
							a_character_ref ?= arg;
							mismatch := a_character_ref = void
						when 'd' then 
							a_double_ref ?= arg;
							mismatch := a_double_ref = void
						when 'i' then 
							an_integer_ref ?= arg;
							mismatch := an_integer_ref = void
						when 'p' then 
							a_pointer_ref ?= arg;
							mismatch := a_pointer_ref = void
						when 'f' then 
							a_real_ref ?= arg;
							mismatch := a_real_ref = void
						when 'r' then 
							if arg /= void and then not eif_gen_conf (int.dynamic_type (arg), open_operand_type (i)) then
								mismatch := True
							end
						end
					else
						if arg_type_code /= open_arg_type_code and (open_arg_type_code = 'r' implies open_operand_type (i) > 0) then
							mismatch := True
						end
					end
					i := i + 1
				end;
				Result := not mismatch
			end
		end
	
feature {NONE} -- Status report

	chunk_size: INTEGER is
			-- Minimal size of a memory chunk. The run-time always
			-- allocates a multiple of this size.
			-- If the environment variable EIF_MEMORY_CHUNK
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_get_chunk_size"
		end

	coalesce_period: INTEGER is
			-- Period of full coalesce (in number of collections)
			-- If the environment variable EIF_FULL_COALESCE_PERIOD
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- If null, no full coalescing is launched.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_coalesce_period"
		end

	collecting: BOOLEAN is
			-- Is garbage collection enabled?
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"gc_ison"
		end

	collection_period: INTEGER is
			-- Period of full collection.
			-- If the environment variable EIF_FULL_COLLECTION_PERIOD
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- If null, no full collection is launched.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_pget"
		end

	generation_object_limit: INTEGER is
			-- Maximum size of object in generational scavenge zone.
			-- If the environment variable EIF_GS_LIMIT
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_generation_object_limit"
		end

	largest_coalesced_block: INTEGER is
			-- Size of largest coalesced block since last call to
			-- largest_coalesced; 0 if none.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_largest"
		end

	max_mem: INTEGER is
			-- Maximum amount of bytes the run-time can allocate.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_get_max_mem"
		end

	memory_threshold: INTEGER is
			-- Minimum amount of bytes to be allocated before
			-- starting an automatic garbage collection.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_tget"
		end

	referers (an_object: ANY): ARRAY [ANY] is
			-- Objects that refer to an_object.
			-- (from MEMORY)
		local
			a: ANY
		do
			create Result.make (0, 200)
			a := Result.area
			find_referers ($an_object, $a, Result.count)
		end

	scavenge_zone_size: INTEGER is
			-- Size of generational scavenge zone.
			-- If the environment variable EIF_MEMORY_SCAVENGE
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_scavenge_zone_size"
		end

	tenure: INTEGER is
			-- Maximum age of object before being considered
			-- as old (old objects are not scanned during
			-- partial collection).
			-- If the environment variable EIF_TENURE_MAX
			-- is defined, it is set to the closest reasonable
			-- value from it.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"eif_tenure"
		end
	
feature {NONE} -- Status setting

	allocate_compact is
			-- Enter `memory' mode: will try to compact memory
			-- before requesting more from the operating system.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_slow"
		end

	allocate_fast is
			-- Enter `speed' mode: will optimize speed of memory
			-- allocation rather than memory usage.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_speed"
		end

	allocate_tiny is
			-- Enter `tiny' mode: will enter `memory' mode
			-- after having freed as much memory as possible.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_tiny"
		end

	collection_off is
			-- Disable garbage collection.
			-- (from MEMORY)
		external
			"C | %"eif_garcol.h%""
		alias
			"gc_stop"
		end

	collection_on is
			-- Enable garbage collection.
			-- (from MEMORY)
		external
			"C | %"eif_garcol.h%""
		alias
			"gc_run"
		end

	disable_time_accounting is
			-- Disable GC time accounting (default).
			-- (from MEMORY)
		do
			gc_monitoring (False)
		end

	enable_time_accounting is
			-- Enable GC time accouting, accessible in gc_statistics.
			-- (from MEMORY)
		do
			gc_monitoring (True)
		end

	set_coalesce_period (value: INTEGER) is
			-- Set coalesce_period. Every value collection,
			-- the Garbage Collector will coalesce
			-- the whole memory.
			-- (from MEMORY)
		require -- from MEMORY
			positive_value: value >= 0
		external
			"C | %"eif_memory.h%""
		alias
			"eif_set_coalesce_period"
		end

	set_collection_period (value: INTEGER) is
			-- Set collection_period. Every value collection,
			-- the Garbage collector will perform a collection
			-- on the whole memory (full collection), otherwise
			-- a simple partial collection is done.
			-- (from MEMORY)
		require -- from MEMORY
			positive_value: value >= 0
		external
			"C | %"eif_memory.h%""
		alias
			"mem_pset"
		end

	set_max_mem (value: INTEGER) is
			-- Set the maximum amount of memory the run-time can allocate.
			-- (from MEMORY)
		require -- from MEMORY
			positive_value: value > 0
		external
			"C | %"eif_memory.h%""
		alias
			"eif_set_max_mem"
		end

	set_memory_threshold (value: INTEGER) is
			-- Set a new memory_threshold in bytes. Whenever the memory
			-- allocated for Eiffel reaches this value, an automatic
			-- collection is performed.
			-- (from MEMORY)
		require -- from MEMORY
			positive_value: value > 0
		external
			"C | %"eif_memory.h%""
		alias
			"mem_tset"
		end
	
feature -- Element change

	set_operands (args: OPEN_ARGS) is
			-- Use args as operands for next call.
			-- (from ROUTINE)
		require -- from ROUTINE
			valid_operands: valid_operands (args)
		do
			operands := args
			operands_set_by_user := True
		end
	
feature {NONE} -- Removal

	collect is
			-- Force a partial collection cycle if garbage
			-- collection is enabled; do nothing otherwise.
			-- (from MEMORY)
		external
			"C | %"eif_eiffel.h%""
		end

	free (object: ANY) is
			-- Free object, by-passing garbage collection.
			-- Erratic behavior will result if the object is still
			-- referenced.
			-- (from MEMORY)
		do
			mem_free ($object)
		end

	full_coalesce is
			-- Coalesce the whole memory: merge adjacent free
			-- blocks to reduce fragmentation. Useful, when
			-- a lot of memory is allocated with garbage collector off.
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"mem_coalesc"
		end

	full_collect is
			-- Force a full collection cycle if garbage
			-- collection is enabled; do nothing otherwise.
			-- (from MEMORY)
		external
			"C | %"eif_garcol.h%""
		alias
			"plsc"
		end

	mem_free (addr: POINTER) is
			-- Free memory of object at addr.
			-- (Preferred interface is free.)
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		end
	
feature -- Duplication

	copy (other: like Current) is
			-- Use same routine as other.
			-- (from ROUTINE)
		require -- from ANY
			other_not_void: other /= void
			type_identity: same_type (other)
		local
			null_ptr: POINTER
		do
			if rout_cargs /= null_ptr then
				rout_obj_free_args (rout_cargs)
				rout_cargs := null_ptr
			end
			operands := other.operands
			operands_set_by_user := other.operands_set_by_user
			closed_operands := other.closed_operands
			open_map := other.open_map
			closed_map := other.closed_map
			rout_disp := other.rout_disp
		ensure -- from ANY
			is_equal: is_equal (other)
		ensure then -- from ROUTINE
			same_call_status: other.callable implies callable
		end
	
feature -- Basic operations

	call (args: OPEN_ARGS) is
			-- Call routine with operands args.
			-- (from ROUTINE)
		require -- from ROUTINE
			valid_operands: valid_operands (args)
			callable: callable
		do
			operands := args
			apply
			if not operands_set_by_user then
				operands := void
			end
		end
	
feature -- Obsolete

	adapt_from (other: like Current) is
		obsolete "Please use `adapt' instead (it's also a creation procedure)"
			-- Adapt from other. Useful in descendants.
			-- (from ROUTINE)
		require -- from ROUTINE
			other_exists: other /= void
			conforming: conforms_to (other)
		do
			adapt (other)
		ensure -- from ROUTINE
			same_call_status: other.callable implies callable
		end

	arguments: OPEN_ARGS is
		obsolete "use operands"
			-- (from ROUTINE)
		do
			Result := operands
		end

	set_arguments (args: OPEN_ARGS) is
		obsolete "use set_operands"
			-- (from ROUTINE)
		do
			set_operands (args)
		end

	valid_arguments (args: OPEN_ARGS): BOOLEAN is
		obsolete "use valid_operands"
			-- (from ROUTINE)
		do
			Result := valid_operands (args)
		end
	
feature {NONE} -- Implementation

	dispose is
			-- Free routine argument union structure
			-- (from ROUTINE)
		local
			null_ptr: POINTER
		do
			if rout_cargs /= null_ptr then
				rout_obj_free_args (rout_cargs)
				rout_cargs := null_ptr
			end
		end

	find_referers (target: POINTER; esult: POINTER; result_size: INTEGER) is
			-- (from MEMORY)
		external
			"C | %"eif_traverse.h%""
		end

	gc_monitoring (flag: BOOLEAN) is
			-- Set up GC monitoring according to flag
			-- (from MEMORY)
		external
			"C | %"eif_memory.h%""
		alias
			"gc_mon"
		end

	frozen internal_closed_type_codes: STRING
			-- (from ROUTINE)

	frozen internal_open_type_codes: STRING
			-- (from ROUTINE)

	frozen rout_cargs: POINTER
			-- Routine operands
			-- (from ROUTINE)

	rout_obj_call_procedure (rout: POINTER; args: POINTER) is
			-- Perform call to rout with args.
		external
			"C [macro %"eif_rout_obj.h%"]"
		end

	frozen rout_set_cargs is
			-- Allocate and fill argument structure
			-- (from ROUTINE)
		local
			new_args: POINTER
			i, j, ocnt, ccnt: INTEGER
			code: CHARACTER
			ref_arg: ANY
			null_ptr: POINTER
			was_on: BOOLEAN
			loc_open_map: like open_map
			loc_closed_map: like closed_map
			loc_operands: like operands
			loc_closed_operands: like closed_operands
			loc_open_type_codes: like open_type_codes
			loc_closed_type_codes: like closed_type_codes
		do
			was_on := collecting
			collection_off
			loc_open_map := open_map
			if loc_open_map /= void then
				ocnt := loc_open_map.count
				loc_open_type_codes := open_type_codes
				loc_operands := operands
			end
			loc_closed_map := closed_map
			if loc_closed_map /= void then
				ccnt := loc_closed_map.count
				loc_closed_type_codes := closed_type_codes
				loc_closed_operands := closed_operands
			end
			if rout_cargs = null_ptr then
				new_args := rout_obj_new_args (ocnt + ccnt + 1)
				rout_cargs := new_args
			else
				new_args := rout_cargs
			end
			from
				i := 1
			until
				i > ocnt
			loop
				code := loc_open_type_codes.item (i + 1)
				check
					loc_operands /= void
				end
				if code = eif_real_code then
					ref_arg := loc_operands.real_item (i)
				else
					ref_arg := loc_operands.item (i)
				end
				j := loc_open_map.item (i)
				inspect code
				when eif_boolean_code then 
					rout_obj_putb (new_args, j, $ref_arg)
				when eif_character_code then 
					rout_obj_putc (new_args, j, $ref_arg)
				when eif_double_code then 
					rout_obj_putd (new_args, j, $ref_arg)
				when eif_integer_8_code then 
					rout_obj_puti8 (new_args, j, $ref_arg)
				when eif_integer_16_code then 
					rout_obj_puti16 (new_args, j, $ref_arg)
				when eif_integer_code then 
					rout_obj_puti32 (new_args, j, $ref_arg)
				when eif_integer_64_code then 
					rout_obj_puti64 (new_args, j, $ref_arg)
				when eif_pointer_code then 
					rout_obj_putp (new_args, j, $ref_arg)
				when eif_real_code then 
					rout_obj_putf (new_args, j, $ref_arg)
				when eif_wide_char_code then 
					rout_obj_putwc (new_args, j, $ref_arg)
				else
					rout_obj_putr (new_args, j, $ref_arg)
				end
				i := i + 1
			end
			from
				i := 1
			until
				i > ccnt
			loop
				code := loc_closed_type_codes.item (i)
				check
					loc_closed_operands /= void
				end
				if code = eif_real_code then
					ref_arg := loc_closed_operands.real_item (i)
				else
					ref_arg := loc_closed_operands.item (i)
				end
				j := loc_closed_map.item (i)
				inspect code
				when eif_boolean_code then 
					rout_obj_putb (new_args, j, $ref_arg)
				when eif_character_code then 
					rout_obj_putc (new_args, j, $ref_arg)
				when eif_double_code then 
					rout_obj_putd (new_args, j, $ref_arg)
				when eif_integer_8_code then 
					rout_obj_puti8 (new_args, j, $ref_arg)
				when eif_integer_16_code then 
					rout_obj_puti16 (new_args, j, $ref_arg)
				when eif_integer_code then 
					rout_obj_puti32 (new_args, j, $ref_arg)
				when eif_integer_64_code then 
					rout_obj_puti64 (new_args, j, $ref_arg)
				when eif_pointer_code then 
					rout_obj_putp (new_args, j, $ref_arg)
				when eif_real_code then 
					rout_obj_putf (new_args, j, $ref_arg)
				when eif_wide_char_code then 
					rout_obj_putwc (new_args, j, $ref_arg)
				else
					rout_obj_putr (new_args, j, $ref_arg)
				end
				i := i + 1
			end
			if was_on then
				collection_on
			end
		rescue
			if was_on then
				collection_on
			end
		end
	
feature {ROUTINE, E_FEATURE} -- Implementation

	frozen closed_map: ARRAY [INTEGER]
			-- Index map for closed arguments
			-- (from ROUTINE)

	frozen closed_operands: TUPLE
			-- Closed arguments provided at creation time
			-- (from ROUTINE)

	closed_type_codes: STRING is
			-- Type codes for closed arguments
			-- (from ROUTINE)
		do
			if closed_operands /= void and internal_closed_type_codes = void then
				internal_closed_type_codes := eif_gen_tuple_typecode_str ($closed_operands)
			end
			Result := internal_closed_type_codes
		end

	frozen eiffel_rout_disp: POINTER
			-- Eiffel routine dispatcher
			-- (from ROUTINE)

	frozen open_map: ARRAY [INTEGER]
			-- Index map for open arguments
			-- (from ROUTINE)

	open_type_codes: STRING is
			-- Type codes for open arguments
			-- (from ROUTINE)
		do
			if internal_open_type_codes = void then
				internal_open_type_codes := eif_gen_typecode_str ($Current)
			end
			Result := internal_open_type_codes
		end

	frozen open_types: ARRAY [INTEGER]
			-- Types of open operands
			-- (from ROUTINE)

	frozen operands_set_by_user: BOOLEAN
			-- Are operands set throug call to set_operands.
			-- If not, we can delete them after routine call for
			-- later collection.
			-- (from ROUTINE)

	frozen rout_disp: POINTER
			-- Routine dispatcher
			-- (from ROUTINE)

	frozen set_rout_args (closed_args: TUPLE; omap, cmap: ARRAY [INTEGER]) is
			-- Initialize object.
			-- (from ROUTINE)
		require -- from ROUTINE
			consistent_args: (closed_args = void and cmap = void) or else (closed_args /= void and cmap /= void) and then (closed_args.count >= cmap.count)
			valid_maps: not (omap = void and cmap = void)
		do
			closed_operands := closed_args
			open_map := omap
			closed_map := cmap
		end

	frozen set_rout_disp (p: POINTER; tp: POINTER; closed_args: TUPLE; omap, cmap: ARRAY [INTEGER]) is
			-- Initialize object.
			-- (from ROUTINE)
		require -- from ROUTINE
			p_not_void: p /= default_pointer
			tp_not_void: tp /= default_pointer
			consistent_args: (closed_args = void and cmap = void) or else (closed_args /= void and cmap /= void) and then (closed_args.count >= cmap.count)
			valid_maps: not (omap = void and cmap = void)
		do
			rout_disp := p
			eiffel_rout_disp := tp
			closed_operands := closed_args
			open_map := omap
			closed_map := cmap
		end
	
feature -- Calls

	apply is
			-- Call procedure with operands as last set.
		require -- from ROUTINE
			valid_operands: valid_operands (operands)
			callable: callable
		do
			rout_set_cargs
			rout_obj_call_procedure (rout_disp, rout_cargs)
		end
	
feature {NONE} -- Externals

	eif_gen_conf (type1, type2: INTEGER): BOOLEAN is
			-- Does type1 conform to type2?
			-- (from ROUTINE)
		external
			"C (int16, int16): EIF_BOOLEAN | %"eif_gen_conf.h%""
		end

	eif_gen_create (obj: POINTER; pos: INTEGER): POINTER is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C | %"eif_gen_conf.h%""
		end

	eif_gen_param_id (stype: INTEGER; obj: POINTER; pos: INTEGER): INTEGER is
			-- Type of generic parameter in obj at position pos.
			-- (from ROUTINE)
		external
			"C (int16, EIF_REFERENCE, int): EIF_INTEGER | %"eif_gen_conf.h%""
		end

	eif_gen_tuple_typecode_str (obj: POINTER): STRING is
			-- Code name for generic parameter pos in obj.
			-- (from ROUTINE)
		external
			"C | %"eif_gen_conf.h%""
		end

	eif_gen_typecode (obj: POINTER; pos: INTEGER): CHARACTER is
			-- Code for generic parameter pos in obj.
			-- (from ROUTINE)
		external
			"C | %"eif_gen_conf.h%""
		end

	eif_gen_typecode_str (obj: POINTER): STRING is
			-- Code name for generic parameter pos in obj.
			-- (from ROUTINE)
		external
			"C | %"eif_gen_conf.h%""
		end

	rout_obj_free_args (args: POINTER) is
			-- Free args.
			-- (from ROUTINE)
		external
			"C | %"eif_rout_obj.h%""
		end

	rout_obj_new_args (cnt: INTEGER): POINTER is
			-- Initialize for new operands.
			-- (from ROUTINE)
		external
			"C | %"eif_rout_obj.h%""
		end

	rout_obj_putb (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putc (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putd (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putf (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_puti16 (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_puti32 (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_puti64 (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_puti8 (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putp (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putr (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end

	rout_obj_putwc (args: POINTER; idx: INTEGER; val: POINTER) is
			-- Adapt args for idx and val.
			-- (from ROUTINE)
		external
			"C[macro %"eif_rout_obj.h%"]"
		end
	
feature {NONE} -- Runtime constants

	Eif_boolean_code: CHARACTER is 'b'
			-- (from ROUTINE)

	Eif_character_code: CHARACTER is 'c'
			-- (from ROUTINE)

	Eif_double_code: CHARACTER is 'd'
			-- (from ROUTINE)

	Eif_integer_16_code: CHARACTER is 'k'
			-- (from ROUTINE)

	Eif_integer_64_code: CHARACTER is 'l'
			-- (from ROUTINE)

	Eif_integer_8_code: CHARACTER is 'j'
			-- (from ROUTINE)

	Eif_integer_code: CHARACTER is 'i'
			-- (from ROUTINE)

	Eif_pointer_code: CHARACTER is 'p'
			-- (from ROUTINE)

	Eif_real_code: CHARACTER is 'f'
			-- (from ROUTINE)

	Eif_reference_code: CHARACTER is 'r'
			-- (from ROUTINE)

	Eif_wide_char_code: CHARACTER is 'u'
			-- Type constants used by runtime to recognize types
			-- needed to perform call
			-- (from ROUTINE)
	
invariant

		-- from ANY
	reflexive_equality: standard_is_equal (Current)
	reflexive_conformance: conforms_to (Current)

indexing
	library: "[
			EiffelBase: Library of reusable components for Eiffel.
	]"
	status: "[
			Copyright 1986-2001 Interactive Software Engineering (ISE).
			For ISE customers the original versions are an ISE product
			covered by the ISE Eiffel license and support agreements.
	]"
	license: "[
			EiffelBase may now be used by anyone as FREE SOFTWARE to
			develop any product, public-domain or commercial, without
			payment to ISE, under the terms of the ISE Free Eiffel Library
			License (IFELL) at http://eiffel.com/products/base/license.html.
	]"
	source: "[
			Interactive Software Engineering Inc.
			ISE Building
			360 Storke Road, Goleta, CA 93117 USA
			Telephone 805-685-1006, Fax 805-685-6869
			Electronic mail <info@eiffel.com>
			Customer support http://support.eiffel.com
	]"
	info: "[
			For latest info see award-winning pages: http://eiffel.com
	]"

end -- class PROCEDURE


Classes
Clusters
Cluster hierarchy
Chart
Relations
Text
Flat
Contracts
Flat contracts
Go to: 

-- Generated by ISE Eiffel --
For more details: www.eiffel.com