note
	description: "Eiffel class instanciated and used from the Eiffel runtime."
	status: "See notice at end of class."
	legal: "See notice at end of class."
	date: "$Date: 2019-03-20 17:08:56 +0000 (Wed, 20 Mar 2019) $"
	revision: "$Revision: 102984 $"

class 
	RT_EXTENSION

create 
	default_create

feature {NONE} -- Initialization

	default_create
			-- Process instances of classes with no creation clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		end
	
feature -- Access

	generating_type: TYPE [detachable RT_EXTENSION]
			-- Type of current object
			-- (type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generating_type_not_void: Result /= Void
		end

	generator: STRING_8
			-- Name of current object's generating class
			-- (base class of the type of which it is a direct instance)
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			generator_not_void: Result /= Void
			generator_not_empty: not Result.is_empty
		end
	
feature -- Comparison

	frozen deep_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void
			-- or attached to isomorphic object structures?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_deep_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			shallow_implies_deep: standard_equal (a, b) implies Result
			both_or_none_void: (a = Void) implies (Result = (b = Void))
			same_type: (Result and (a /= Void)) implies (b /= Void and then a.same_type (b))
			symmetric: Result implies deep_equal (b, a)
		end

	frozen equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached
			-- to objects considered equal?
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.is_equal (b))
		end

	frozen is_deep_equal (other: RT_EXTENSION): BOOLEAN
			-- Are Current and other attached to isomorphic object structures?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			shallow_implies_deep: standard_is_equal (other) implies Result
			same_type: Result implies same_type (other)
			symmetric: Result implies other.is_deep_equal (Current)
		end

	is_equal (other: RT_EXTENSION): BOOLEAN
			-- Is other attached to an object considered
			-- equal to current object?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			symmetric: Result implies other ~ Current
			consistent: standard_is_equal (other) implies Result
		end

	frozen standard_equal (a: detachable ANY; b: like arg #1): BOOLEAN
			-- Are a and b either both void or attached to
			-- field-by-field identical objects of the same type?
			-- Always uses default object comparison criterion.
			-- (from ANY)
		do
			if a = Void then
				Result := b = Void
			else
				Result := b /= Void and then a.standard_is_equal (b)
			end
		ensure -- from ANY
			instance_free: class
			definition: Result = (a = Void and b = Void) or else ((a /= Void and b /= Void) and then a.standard_is_equal (b))
		end

	frozen standard_is_equal (other: RT_EXTENSION): BOOLEAN
			-- Is other attached to an object of the same type
			-- as current object, and field-by-field identical to it?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			same_type: Result implies same_type (other)
			symmetric: Result implies other.standard_is_equal (Current)
		end
	
feature -- Status report

	conforms_to (other: ANY): BOOLEAN
			-- Does type of current object conform to type
			-- of other (as per Eiffel: The Language, chapter 13)?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		end

	same_type (other: ANY): BOOLEAN
			-- Is type of current object identical to type of other?
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		external
			"built_in"
		ensure -- from ANY
			definition: Result = (conforms_to (other) and other.conforms_to (Current))
		end
	
feature -- Duplication

	frozen clone (other: detachable ANY): like other
		obsolete "Use `twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- equal to other
			--
			-- For non-void other, clone calls copy;
			-- to change copying/cloning semantics, redefine copy.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.twin
			end
		ensure -- from ANY
			instance_free: class
			equal: Result ~ other
		end

	copy (other: RT_EXTENSION)
			-- Update current object using fields of object attached
			-- to other, so as to yield equal objects.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_equal: Current ~ other
		end

	frozen deep_clone (other: detachable ANY): like other
		obsolete "Use `deep_twin' instead. [2017-05-31]"
			-- Void if other is void: otherwise, new object structure
			-- recursively duplicated from the one attached to other
			-- (from ANY)
		do
			if other /= Void then
				Result := other.deep_twin
			end
		ensure -- from ANY
			instance_free: class
			deep_equal: deep_equal (other, Result)
		end

	frozen deep_copy (other: RT_EXTENSION)
			-- Effect equivalent to that of:
			--		copy (other . deep_twin)
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
		do
			copy (other.deep_twin)
		ensure -- from ANY
			deep_equal: deep_equal (Current, other)
		end

	frozen deep_twin: RT_EXTENSION
			-- New object structure recursively duplicated from Current.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			deep_twin_not_void: Result /= Void
			deep_equal: deep_equal (Current, Result)
		end

	frozen standard_clone (other: detachable ANY): like other
		obsolete "Use `standard_twin' instead. [2017-05-31]"
			-- Void if other is void; otherwise new object
			-- field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		do
			if other /= Void then
				Result := other.standard_twin
			end
		ensure -- from ANY
			instance_free: class
			equal: standard_equal (Result, other)
		end

	frozen standard_copy (other: RT_EXTENSION)
			-- Copy every field of other onto corresponding field
			-- of current object.
			-- (from ANY)
		require -- from ANY
			other_not_void: other /= Void
			type_identity: same_type (other)
		external
			"built_in"
		ensure -- from ANY
			is_standard_equal: standard_is_equal (other)
		end

	frozen standard_twin: RT_EXTENSION
			-- New object field-by-field identical to other.
			-- Always uses default copying semantics.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			standard_twin_not_void: Result /= Void
			equal: standard_equal (Result, Current)
		end

	frozen twin: RT_EXTENSION
			-- New object equal to Current
			-- twin calls copy; to change copying/twinning semantics, redefine copy.
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			twin_not_void: Result /= Void
			is_equal: Result ~ Current
		end
	
feature -- Basic operations

	frozen as_attached: attached RT_EXTENSION
		obsolete "Remove calls to this feature. [2017-05-31]"
			-- Attached version of Current.
			-- (Can be used during transitional period to convert
			-- non-void-safe classes to void-safe ones.)
			-- (from ANY)
		do
			Result := Current
		end

	frozen default: detachable RT_EXTENSION
			-- Default value of object's type
			-- (from ANY)
		do
		end

	frozen default_pointer: POINTER
			-- Default value of type POINTER
			-- (Avoid the need to write p.default for
			-- some p of type POINTER.)
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end

	default_rescue
			-- Process exception for routines with no Rescue clause.
			-- (Default: do nothing.)
			-- (from ANY)
		do
		end

	frozen do_nothing
			-- Execute a null action.
			-- (from ANY)
		do
		ensure -- from ANY
			instance_free: class
		end
	
feature -- Debugger helper

	debugger_type_string (a_obj: detachable ANY): detachable STRING_8
			-- Return the evaluation of a.generating_type.out
			-- (from RT_EXTENSION_GENERAL)
		do
			if a_obj /= Void then
				Result := a_obj.generating_type.out
			end
		end
	
feature -- Evaluation helper

	equal_sign_evaluation (a, b: detachable ANY): BOOLEAN
			-- Return the evaluation of a = b
			-- (from RT_EXTENSION_GENERAL)
		do
			Result := a = b
		end

	is_equal_evaluation (a, b: ANY): BOOLEAN
			-- Return the evaluation of a.is_equal (b)	
			-- (from RT_EXTENSION_GENERAL)
		require -- from RT_EXTENSION_GENERAL
			a_b_attached: a /= Void and b /= Void
		do
			Result := a.is_equal (b)
		end

	tilda_equal_evaluation (a, b: detachable ANY): BOOLEAN
			-- Return the evaluation of a ~ b
			-- (from RT_EXTENSION_GENERAL)
		do
			Result := a ~ b
		end
	
feature {NONE} -- Execution replay

	events_assign_argument: TUPLE [ref: detachable ANY; a_dep: INTEGER_32; a_pos: INTEGER_32; a_type: INTEGER_32; a_xpm_info: INTEGER_32]
			-- Argument for process_*_assign.
			-- used only as anchor for type declaration
		do
			check
					False
			then
			end
		ensure
				False
		end

	events_feature_argument: TUPLE [ref: detachable ANY; cid: INTEGER_32; fid: INTEGER_32; a_dep: INTEGER_32]
			-- Argument for process_*_feature.
			-- used only as anchor for type declaration
		do
			check
					False
			then
			end
		ensure
				False
		end

	execution_recorder: detachable like new_execution_recorder
			-- Once per thread record.
		do
			Result := Execution_recorder_cell.item
		end

	Execution_recorder_cell: CELL [detachable RT_DBG_EXECUTION_RECORDER]
			-- Cell containing the once per thread recorder, if activated.
		once ("THREAD")
			create Result.put (Void)
		ensure
			result_attached: Result /= Void
		end

	Execution_recorder_parameters: separate RT_DBG_EXECUTION_PARAMETERS
			-- Once per process record parameters.
		once ("PROCESS")
			create Result.make
		ensure
			result_attached: Result /= Void
		end

	new_execution_recorder: RT_DBG_EXECUTION_RECORDER
			-- New Execution recorder.
			-- You can overwrite default parameters in this feature.
			-- Check {RT_DBG_EXECUTION_RECORDER}.make to see the default values.
		do
			create Result.make (Execution_recorder_parameters)
		ensure
			result_attached: Result /= Void
		end

	process_enter_feature (a_data: like events_feature_argument)
			-- Execution enters a feature
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
		do
			if attached execution_recorder as r then
				if attached {ANY} a_data.ref as ref then
					r.enter_feature (ref, a_data.cid, a_data.fid, a_data.a_dep)
				else
					check
						ref_should_not_be_void: False
					end
				end
			end
		end

	process_leave_feature (a_data: like events_feature_argument)
			-- Execution leaves a feature
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
		do
			if attached execution_recorder as r then
				if attached {ANY} a_data.ref as ref then
					r.leave_feature (ref, a_data.cid, a_data.fid, a_data.a_dep)
				else
					check
						ref_should_not_be_void: False
					end
				end
			end
		end

	process_rescue_feature (a_data: like events_feature_argument)
			-- Execution enters a feature
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
		do
			if attached execution_recorder as r then
				if attached {ANY} a_data.ref as ref then
					r.enter_rescue (ref, a_data.cid, a_data.fid, a_data.a_dep)
				else
					check
						ref_should_not_be_void: False
					end
				end
			end
		end

	process_rt_assign_attrib (a_data: like events_assign_argument)
			-- Local variable assignment event
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
		do
			if attached execution_recorder as r and then r.recording_values and then attached a_data.ref as ot_ref then
				r.notify_rt_assign_attribute (a_data.a_dep, ot_ref, a_data.a_pos, a_data.a_type.to_natural_32, a_data.a_xpm_info)
			end
		end

	process_rt_assign_local (a_data: like events_assign_argument)
			-- Local variable assignment event
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
			no_ref: a_data.ref = Void
		do
			if attached execution_recorder as r and then r.recording_values then
				r.notify_rt_assign_local (a_data.a_dep, a_data.a_pos, a_data.a_type.to_natural_32, a_data.a_xpm_info)
			end
		end

	process_rt_hook (a_data: TUPLE [unused_ref: detachable ANY; a_dep: INTEGER_32; bp_i: INTEGER_32; bp_ni: INTEGER_32])
			-- Execution reach a RTHOOK or RTNHOOK point
		require
			a_data_attached: a_data /= Void
			execution_recording_not_void: execution_recorder /= Void
		do
			if attached execution_recorder as r then
				r.notify_rt_hook (a_data.a_dep, a_data.bp_i, a_data.bp_ni)
			end
		end

	reset_events_assign_argument (t: TUPLE)
			-- Reset argument for process_*_feature.
		require
			t_attached: t /= Void
		do
			if attached {like events_assign_argument} t as ot then
				ot.ref := Void
				ot.a_dep := 0
				ot.a_pos := 0
				ot.a_type := 0
				ot.a_xpm_info := 0
			end
		end

	reset_events_feature_argument (t: TUPLE)
			-- Reset argument for process_*_feature.
		require
			t_attached: t /= Void
		do
			if attached {like events_feature_argument} t as ot then
				ot.ref := Void
				ot.cid := 0
				ot.fid := 0
				ot.a_dep := 0
			end
		end

	set_execution_recorder_parameters (a_maximum_record_count: INTEGER_32; a_flatten_when_closing: BOOLEAN; a_keep_calls_record: BOOLEAN; a_recording_values: BOOLEAN)
			-- Set execution recorder parameters
		local
			p: like Execution_recorder_parameters
		do
			p := Execution_recorder_parameters
			set_execution_recorder_parameters_to (a_maximum_record_count, a_flatten_when_closing, a_keep_calls_record, a_recording_values, p)
			if attached execution_recorder as r then
				r.update_parameters (p)
			end
		end

	set_execution_recorder_parameters_to (a_maximum_record_count: INTEGER_32; a_flatten_when_closing: BOOLEAN; a_keep_calls_record: BOOLEAN; a_recording_values: BOOLEAN; p: like Execution_recorder_parameters)
			-- Set execution recorder parameters to p.
		do
			p.set_maximum_record_count (a_maximum_record_count)
			p.set_flatten_when_closing (a_flatten_when_closing)
			p.set_keep_calls_records (a_keep_calls_record)
			p.set_recording_values (a_recording_values)
		end
	
feature -- Execution replay		

	activate_execution_replay_recording (b: BOOLEAN; ref: ANY; cid: INTEGER_32; fid: INTEGER_32; dep: INTEGER_32; break_index: INTEGER_32)
			-- Start or Stop execution replay recording
		require
			ref_attached: ref /= Void
		local
			r: like execution_recorder
		do
			if b then
				check
						execution_recorder = Void
				end
				r := new_execution_recorder
				Execution_recorder_cell.replace (r)
				r.start_recording (ref, cid, fid, dep, break_index)
			else
				r := execution_recorder
				if r /= Void then
					r.stop_recording
				end
				Execution_recorder_cell.replace (Void)
			end
		ensure
			recorder_if_on: b implies execution_recorder /= Void
			no_recorder_if_off: not b implies execution_recorder = Void
		end
	
feature -- Notification

	Cached_arguments: ARRAY [detachable TUPLE]
			-- Cached argument to use less temporary objects
		once ("THREAD")
			create Result.make_filled (Void, Op_enter_feature, Op_rt_assign_local)
		ensure
			result_attached: Result /= Void
		end

	notify (a_id: INTEGER_32; a_data: TUPLE)
			-- Notify operation a_id with data a_data
		require
			a_data_attached: a_data /= Void
		local
			retried: BOOLEAN
		do
			if not retried then
				inspect a_id
				when Op_enter_feature then
					if attached {like events_feature_argument} a_data as t_ef then
						process_enter_feature (t_ef)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_feature_argument (a_data)
				when Op_leave_feature then
					if attached {like events_feature_argument} a_data as t_lf then
						process_leave_feature (t_lf)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_feature_argument (a_data)
				when Op_rescue_feature then
					if attached {like events_feature_argument} a_data as t_rf then
						process_rescue_feature (t_rf)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_feature_argument (a_data)
				when Op_rt_hook then
					if attached {like events_feature_argument} a_data as t_rh then
						process_rt_hook (t_rh)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_feature_argument (a_data)
				when Op_rt_assign_attrib then
					if attached {like events_assign_argument} a_data as t_att then
						process_rt_assign_attrib (t_att)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_assign_argument (a_data)
				when Op_rt_assign_local then
					if attached {like events_assign_argument} a_data as t_loc then
						process_rt_assign_local (t_loc)
					else
						check
							valid_tuple_data: False
						end
					end
					reset_events_assign_argument (a_data)
				else
					debug ("rt_extension")
						dtrace ("Error: " + out + " ->" + a_id.out + "%N")
					end
				end
			end
		rescue
			dtrace ("Error: Rescue -> RT_EXTENSION.notify (" + a_id.out + ", a_data)%N")
			retried := True
			retry
		end

	notify_argument (a_id: INTEGER_32): detachable TUPLE
			-- Empty argument container for operation a_id.
		local
			retried: BOOLEAN
		do
			if not retried then
				Result := Cached_arguments [a_id]
				if Result = Void then
					inspect a_id
					when Op_enter_feature, Op_leave_feature, Op_rescue_feature, Op_rt_hook then
						create {like events_feature_argument} Result
					when Op_rt_assign_attrib, Op_rt_assign_local then
						create {like events_assign_argument} Result
					else
						debug ("rt_extension")
							dtrace ("Error: RT_EXTENSION.notify_argument (" + a_id.out + "): unmatched id !%N")
						end
					end
					Cached_arguments [a_id] := Result
				end
			end
		rescue
			dtrace ("Error: Rescue -> RT_EXTENSION.notify_argument (" + a_id.out + ")%N")
			retried := True
			retry
		end
	
feature -- Object storage Access

	object_loaded_from (r: detachable ANY; fn: READABLE_STRING_GENERAL): detachable ANY
			-- Loaded object from file fn.
			-- if r is Void return a new object
			-- else load into r
			-- If failure then results Void object.
			-- (from RT_EXTENSION_GENERAL)
		require -- from RT_EXTENSION_GENERAL
			fn_attached: fn /= Void
		local
			o: detachable ANY
			file: RAW_FILE
			retried: BOOLEAN
		do
			if not retried then
				create file.make_with_name (fn)
				if file.exists and then file.is_readable then
					file.open_read
					o := file.retrieved
					file.close
					if attached {ANY} r as o1 then
						if attached {ANY} o as o2 and then o1.same_type (o2) then
							o1.standard_copy (o2)
							Result := o1
						end
					else
						Result := o
					end
				else
					Result := Void
				end
			else
				Result := r
			end
		rescue
			retried := True
			retry
		end

	object_runtime_info (r: detachable ANY): STRING_8
			-- Representation of the internal information for object r.
			-- (from RT_EXTENSION_GENERAL)
		local
			int: INTERNAL
		do
			if r /= Void then
				create Result.make (0)
				Result.append ("class_name=")
				Result.append (r.generator)
				Result.append (";")
				Result.append ("type_name=")
				Result.append (r.generating_type.name)
				Result.append (";")
				create int
				Result.append ("dynamic_type=")
				Result.append_integer (int.dynamic_type (r))
				Result.append (";")
				Result.append ("field_count=")
				Result.append_integer (int.field_count (r))
				Result.append (";")
				Result.append ("deep_physical_size=")
				Result.append_natural_64 (int.deep_physical_size_64 (r))
				Result.append (";")
				Result.append ("physical_size=")
				Result.append_natural_64 (int.physical_size_64 (r))
			else
				create Result.make_empty
			end
		end

	saved_object_to (r: detachable ANY; fn: READABLE_STRING_GENERAL): detachable ANY
			-- Save object r into file fn
			-- (from RT_EXTENSION_GENERAL)
		require -- from RT_EXTENSION_GENERAL
			fn_attached: fn /= Void
		local
			file: RAW_FILE
		do
			create file.make_with_name (fn)
			if r /= Void and then (not file.exists or else file.is_writable) then
				file.create_read_write
				file.independent_store (r)
				file.close
				Result := r
			else
				Result := Void
			end
		end
	
feature -- Output

	Io: STD_FILES
			-- Handle to standard file setup
			-- (from ANY)
		once
			create Result
			Result.set_output_default
		ensure -- from ANY
			instance_free: class
			io_not_void: Result /= Void
		end

	out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		do
			Result := tagged_out
		ensure -- from ANY
			out_not_void: Result /= Void
		end

	print (o: detachable ANY)
			-- Write terse external representation of o
			-- on standard output.
			-- (from ANY)
		do
			if o /= Void then
				Io.put_string (o.out)
			end
		ensure -- from ANY
			instance_free: class
		end

	frozen tagged_out: STRING_8
			-- New string containing terse printable representation
			-- of current object
			-- (from ANY)
		external
			"built_in"
		ensure -- from ANY
			tagged_out_not_void: Result /= Void
		end
	
feature -- Platform

	Operating_environment: OPERATING_ENVIRONMENT
			-- Objects available from the operating system
			-- (from ANY)
		once
			create Result
		ensure -- from ANY
			instance_free: class
			operating_environment_not_void: Result /= Void
		end
	
feature -- RT extension identifiers (check eif_debug.h uses the same values)

	Op_enter_feature: INTEGER_32 = 10
			-- (from RT_EXTENSION_GENERAL)

	Op_leave_feature: INTEGER_32 = 11
			-- (from RT_EXTENSION_GENERAL)

	Op_rescue_feature: INTEGER_32 = 12
			-- (from RT_EXTENSION_GENERAL)

	Op_rt_assign_attrib: INTEGER_32 = 14
			-- (from RT_EXTENSION_GENERAL)

	Op_rt_assign_local: INTEGER_32 = 15
			-- (from RT_EXTENSION_GENERAL)

	Op_rt_hook: INTEGER_32 = 13
			-- (from RT_EXTENSION_GENERAL)
	
feature {NONE} -- Retrieval

	frozen internal_correct_mismatch
			-- Called from runtime to perform a proper dynamic dispatch on correct_mismatch
			-- from MISMATCH_CORRECTOR.
			-- (from ANY)
		local
			l_msg: STRING_8
			l_exc: EXCEPTIONS
		do
			if attached {MISMATCH_CORRECTOR} Current as l_corrector then
				l_corrector.correct_mismatch
			else
				create l_msg.make_from_string ("Mismatch: ")
				create l_exc
				l_msg.append (generating_type.name)
				l_exc.raise_retrieval_exception (l_msg)
			end
		end
	
feature -- SCOOP Access	

	scoop_processor_id_from_object (a_object: ANY): INTEGER_32
			-- SCOOP Processor id for object a_object.
		external
			"C inline use %"eif_scoop.h%""
		alias
			"RTS_PID(eif_access($a_object))"
		end
	
feature -- Trace

	dtrace (m: STRING_8)
			-- note: might be be removed with 6.2	
			-- (from RT_EXTENSION_COMMON)
		require -- from RT_EXTENSION_COMMON
			m_attached: m /= Void
		do
			Io.Error.put_string (m)
		end

	dtrace_indent (n: INTEGER_32)
			-- note: might be removed with 6.2
			-- (from RT_EXTENSION_COMMON)
		do
			Io.Error.put_string (create {STRING_8}.make_filled (' ', 2 * n))
		end
	
feature -- debug purpose: to remove

	frozen c_activate_recording
		external
			"C inline use %"eif_main.h%""
		alias
			"[
				#ifdef WORKBENCH
					EIF_GET_CONTEXT
					is_inside_rt_eiffel_code = 0;
					exec_recording_enabled = 1;
					set_debug_mode (1);
				#endif
			]"
		end

	frozen c_is_inside_rt_eiffel_code: INTEGER_32
		external
			"C inline use %"eif_debug.h%""
		alias
			"[
				#ifdef WORKBENCH
					EIF_GET_CONTEXT
					return is_inside_rt_eiffel_code;
				#else
					return 0;
				#endif
			]"
		end

	test_activate_recording (ref: ANY; fid: INTEGER_32; dep: INTEGER_32; bpline: INTEGER_32)
		require
			ref_attached: ref /= Void
		do
			activate_execution_replay_recording (True, ref, ref.generating_type.type_id, fid, dep, bpline)
			c_activate_recording
		end
	
invariant
	no_attribute: (create {REFLECTED_REFERENCE_OBJECT}.make (Current)).field_count = 0

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

note
	library: "EiffelBase: Library of reusable components for Eiffel."
	copyright: "Copyright (c) 1984-2019, Eiffel Software and others"
	license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
	source: "[
		Eiffel Software
		5949 Hollister Ave., Goleta, CA 93117 USA
		Telephone 805-685-1006, Fax 805-685-6869
		Website http://www.eiffel.com
		Customer support http://support.eiffel.com
	]"

end -- class RT_EXTENSION

Generated by ISE EiffelStudio