class C_PRETTY_PRINTER
Summary
Singleton in charge of handling C code pretty printing. This singleton is shared via the GLOBALS.cpp once function.
Direct parents
Inherit list: CODE_PRINTER
Insert list: PLATFORM, STRING_HANDLER, UNICODE_STRING_HANDLER
Class invariant
Overview
Creation features
{ANY}
Features
Code generators
{ANY}
C-related type properties
{ANY}
{}
{SMART_EIFFEL}
  • compile
    The real output is done here
{}
Set of features to bufferize the next C function to be generated:
{ANY}
{COMPOUND, C_CODE_COMPILER}
Low-level set of feature to be used when one cannot use the pending_c_function mode, i.e. when one is not defining some code inside some C function:
{ANY}
{ANY}
{SMART_EIFFEL, MANIFEST_STRING_POOL, MEMORY_HANDLER, MANIFEST_GENERIC_POOL}
{C_COMPILATION_MIXIN}
{}
{C_SPLITTER}
{ANY}
{}
{C_LIVE_TYPE_COMPILER}
Threading
{}
{}
{C_COMPILATION_MIXIN}
{ANY}
{C_EXPRESSION_COMPILATION_MIXIN}
{C_COMPILATION_MIXIN}
{CECIL_FILE}
{C_MAPPER}
{C_COMPILATION_MIXIN}
{CREATE_INSTRUCTION, LOCAL_VAR_LIST, ONCE_ROUTINE_POOL, CECIL_POOL, C_COMPILATION_MIXIN}
{C_COMPILATION_MIXIN}
{C_COMPILATION_MIXIN}
{}
Printing Current, local or argument :
{ANY}
{C_COMPILATION_MIXIN}
{ANY}
{ANY}
{}
{FEATURE_CALL, C_EXPRESSION_COMPILATION_MIXIN}
{C_CODE_COMPILER}
{}
{ANY}
{ANY}
{PLUGIN}
{MEMORY, LIVE_TYPE, RUN_FEATURE, C_COMPILATION_MIXIN, MEMORY_HANDLER}
{NATIVE}
{ANY}
{C_COMPILATION_MIXIN}
{}
{C_EXPRESSION_COMPILATION_MIXIN}
{}
{}
{C_CODE_COMPILER}
{C_COMPILATION_MIXIN}
{}
{}
{C_EXPRESSION_COMPILATION_MIXIN}
{RUN_FEATURE, ASSERTION_LIST, AGENT_CREATION, AGENT_ARGS, C_COMPILATION_MIXIN}
{C_NATIVE_FUNCTION_MAPPER, C_NATIVE_PROCEDURE_MAPPER}
{NATIVE_C_PLUS_PLUS}
{}
{C_COMPILATION_MIXIN}
{}
{C_COMPILATION_MIXIN}
{}
{}
{}
{RUN_FEATURE_5, RUN_FEATURE_6, C_COMPILATION_MIXIN}
{}
{}
{}
{ANY}
Context stacks:
{}
{ANY}
{}
{PRECURSOR_CALL}
{PRECURSOR_CALL}
{RUN_FEATURE_3}
{}
{}
{ANY}
{ACE}
  • is_launcher: BOOLEAN
    If True, the clusters list will not be retrieved (it means that the tool is only used to start other tools; it does not load classes itself)
{SE, COMPILE}
{}
{SMART_EIFFEL, SYSTEM_TOOLS, VISITOR}
{ANY}
an option to minimize generic types
{}
Hard-coded class names:
{}
Hard coded feature names:
{}
Operator/Infix/Prefix/Alias list:
{}
Other names:
{}
The keywords section:
{}
Most of them are message parts:
{}
Some other names:
{}
The known keys of the INI file:
{}
{}
Maximum:
{}
Minimum:
{}
Bits:
{}
header_pass_0: C_HEADER_PASS_0
writable attribute
{ANY}
header_pass_1: C_HEADER_PASS_1
writable attribute
{ANY}
header_pass_2: C_HEADER_PASS_2
writable attribute
{ANY}
header_pass_3: C_HEADER_PASS_3
writable attribute
{ANY}
header_pass_4: C_HEADER_PASS_4
writable attribute
{ANY}
live_type_compiler: C_LIVE_TYPE_COMPILER
writable attribute
{ANY}
mapper: C_MAPPER
writable attribute
{ANY}
initializer: C_INITIALIZER
writable attribute
{ANY}
target_mapper: C_TARGET_MAPPER
writable attribute
{ANY}
arg_mapper: C_ARG_MAPPER
writable attribute
{ANY}
code_compiler: C_CODE_COMPILER
writable attribute
{ANY}
compound_expression_compiler: C_COMPOUND_EXPRESSION_COMPILER
writable attribute
{ANY}
writable attribute
{ANY}
native_function_mapper: C_NATIVE_FUNCTION_MAPPER
writable attribute
{ANY}
native_procedure_mapper: C_NATIVE_PROCEDURE_MAPPER
writable attribute
{ANY}
native_c_definition: C_NATIVE_C_DEFINITION
writable attribute
{ANY}
introspection_function: C_INTROSPECTION_FUNCTION
writable attribute
{ANY}
introspection_display: C_INTROSPECTION_DISPLAY
writable attribute
{ANY}
target_type: C_TYPE_FOR_TARGET
writable attribute
{ANY}
result_type: C_TYPE_FOR_RESULT
writable attribute
{ANY}
external_type: C_TYPE_FOR_EXTERNAL
writable attribute
{ANY}
argument_type: C_TYPE_FOR_ARGUMENT
writable attribute
{ANY}
va_arg_type: C_TYPE_FOR_VA_ARG
writable attribute
{ANY}
need_struct: C_NEED_STRUCT
writable attribute
{ANY}
native_need_wrapper: C_NATIVE_NEED_WRAPPER
writable attribute
{ANY}
make
effective procedure
{}
compile
effective procedure
The real output is done here
live_type_map: TRAVERSABLE[LIVE_TYPE]
effective function
{}
agent_switches: FAST_ARRAY[TYPE]
effective function
{}
agent_creations: FAST_ARRAY[AGENT_CREATION]
effective function
{}
class_invariants: FAST_ARRAY[LIVE_TYPE]
effective function
{}
run_features: FAST_ARRAY[RUN_FEATURE]
effective function
{}
prepare_introspection
effective procedure
{}
Creates the introspection features
require
compile_routines
effective procedure
{}
Try to give the best order to the C output.
require
show_profile
effective procedure
{}
require
define_extern_tables
effective procedure
{}
initialize_size_table
effective procedure
{}
initialize se_strucT
require ensure
initialize_path_table_of (ct: CLASS_TEXT)
effective procedure
{}
initialize_path_table
effective procedure
{}
require
initialize_generator_of (ct: CLASS_TEXT)
effective procedure
{}
initialize_generator
effective procedure
{}
initialize_generating_type
effective procedure
{}
initialize_profile
effective procedure
{}
require
c_code: STRING
once function
{}
pending_c_function: BOOLEAN
writable attribute
{ANY}
Indicates that a new C function is being prepared.
has_closures: BOOLEAN
writable attribute
{ANY}
Indicates that the new C function creates closures (locals are not generated in the same way)
pending_c_function_signature: STRING
once function
{ANY}
The signature of the pending_c_function being prepared.
pending_c_function_body: STRING
once function
{ANY}
The body of the pending_c_function being prepared.
pending_c_function_counter: INTEGER_32
writable attribute
{ANY}
Changed each time a new pending_c_function is generated.
prepare_c_function
effective procedure
{ANY}
Start the preparation of the next C function.
Information about the next function to generate is bufferized until dump_pending_c_function is called.
require ensure
dump_pending_c_function (shared: BOOLEAN)
effective procedure
{ANY}
Actually dump the pending_c_function on out_h / out_c.
pending_c_function_lock_local (type: TYPE, tag: STRING): INTERNAL_C_LOCAL
effective function
{ANY}
Reuse some un-locked variable of the pending_c_function_locals or add/create a new one.
When possible, the caller is supposed to call feature unlock of INTERNAL_C_LOCAL.
require
  • type /= Void
  • tag /= Void
ensure
  • Result /= Void
eiffel_parser_stamp_push (eiffel_parser_stamp: INTEGER_32)
effective procedure
require
  • eiffel_parser_stamp > 0
eiffel_parser_stamp_pop
effective procedure
out_h_buffer: STRING
once function
{ANY}
Common buffer to write on the *.h file.
write_out_h_buffer
effective procedure
{ANY}
Actually write the out_h_buffer.
out_c_buffer: STRING
once function
{ANY}
Common buffer to write on the *.c file.
write_out_c_buffer
effective procedure
{ANY}
Actually write the out_c_buffer.
prepare_memory
effective procedure
{ANY}
require ensure
split_c_file_padding_here
effective procedure
Must be called only if we are sure that we will output something after that call.
assertion_checks_disabled: BOOLEAN
writable attribute
set_assertion_checks_disabled (i: BOOLEAN)
effective procedure
split_c_file_now (features_count: INTEGER_32)
effective procedure
set_live_type (a_live_type: LIVE_TYPE)
effective procedure
function_count_in_file: INTEGER_32
writable attribute
{}
begin_c_file
effective procedure
end_c_file
effective procedure
write_extern_0 (type_variable: STRING)
effective procedure
{ANY}
write_extern_1 (type_variable: STRING)
effective procedure
{ANY}
write_extern_2 (type_variable: STRING, init: STRING)
effective procedure
{ANY}
write_extern_array_1 (type_variable: STRING, array_size: INTEGER_32, array_content: STRING)
effective procedure
{ANY}
write_extern_array_2 (type_variable: STRING, array_size: INTEGER_32)
effective procedure
{ANY}
put_position (p: POSITION)
effective procedure
{ANY}
put_position_in_ds (p: POSITION)
effective procedure
{ANY}
put_target_as_target (target_formal_type: TYPE)
effective procedure
{ANY}
Produce C code to pass the current stacked target as a target of a new call: user expanded are passed by address and class invariant code is produced.
      • Choisir un nouveau nom pour cette methode et voir si *** stack_top.static_type ***
      • sert encore. Dom April 30 th 2008 ***
require
put_target_as_value
effective procedure
{ANY}
Produce C code for a simple access to the stacked target.
User's expanded values are not given using a pointer. There is no C code to check the class invariant.
require
put_error0 (msg: STRING)
effective procedure
{ANY}
Print msg and then stop execution.
Also print stack when not -boost.
require
put_position_comment (p: POSITION)
effective procedure
{ANY}
define_main (rf3: RUN_FEATURE_3)
effective procedure
{ANY}
se_string (c_string: STRING)
effective procedure
{}
array_access (array_name: CHARACTER, value: INTEGER_32)
effective procedure
{}
get_started
effective procedure
{}
require
echo_information
effective procedure
{}
customize_runtime
effective procedure
{}
defined_agent_creation: FAST_ARRAY[STRING]
once function
customize_thread_pool_runtime
effective procedure
{}
require
fs_status_name: HASHED_STRING
once function
{}
customize_agent_pool_runtime_1
effective procedure
{}
customize_agent_pool_runtime_2
effective procedure
{}
require
define_agent_launcher_args (agent_args: AGENT_ARGS)
effective procedure
{}
define_agent_launcher_heading (agent_args: AGENT_ARGS, tag: STRING)
effective procedure
{}
agent_pool_switch_in (buffer: STRING, agent_args: AGENT_ARGS, launcher_type: TYPE, agent_result: TYPE)
effective procedure
{}
require
  • agent_result = launcher_type.agent_result
agent_pool_has_only_one_case_for (launcher_type: TYPE, agent_result: TYPE): BOOLEAN
effective function
{}
require
agent_pool_call_in (buffer: STRING, mold_id: STRING, launcher_type: TYPE, agent_result: TYPE, agent_creation_type: TYPE)
effective procedure
{}
require
  • agent_creation_type.can_be_assigned_to(launcher_type)
target_cannot_be_dropped: BOOLEAN
effective function
True when top target cannot be dropped because we are not sure that target is non Void or that target has no side effects.
When Result is True, printed C code is : "(((void)(<target>))"
require
arguments_cannot_be_dropped: BOOLEAN
effective function
True when arguments cannot be dropped.
Printed C code looks like:
 "(((void)<exp1>), ((void)<exp2>), ...((void)<expN>)"
cannot_drop_all: BOOLEAN
effective function
Result is True when something (target or one argument) cannot be dropped.
Thus when something cannot be dropped, Result is True and C code is printed :
 "(((void)<exp1>), ((void)<exp2>), ...((void)<expN>)"
put_arguments (arguments_count: INTEGER_32)
effective procedure
{ANY}
Produce code to access to the whole effective arguments list.
require
  • smart_eiffel.is_ready
  • arguments_count > 0
  • current_call_has_arguments: stack_top.effective_arguments /= Void
put_ith_argument (index: INTEGER_32)
effective procedure
{ANY}
Produce code to access to the ith argument.
require
args_compile_to_c_ith (type: TYPE, args: EFFECTIVE_ARG_LIST, fal: FORMAL_ARG_LIST, index: INTEGER_32)
effective procedure
Produce C code for expression index.
require
  • args /= Void and then args.count = fal.count
  • args /= Void and then index.in_range(1, args.count)
put_c_inline_h (code: STRING)
effective procedure
put_trace_switch
effective procedure
The {ANY}.trace_switch feature
put_sedb_breakpoint
effective procedure
put_target_generating_type (type_of_current: TYPE)
effective procedure
put_target_generator (type_of_current: TYPE)
effective procedure
target_position_in_error_handler
effective procedure
Add the target position into the error_handler.
put_object_size (t: TYPE)
effective procedure
require
connect_cecil_out_h (user_path_h: STRING)
effective procedure
disconnect_cecil_out_h
effective procedure
use_c_function_call_for_attribute_read: BOOLEAN
effective function
require
push_inside_some_wrapper (af: ANONYMOUS_FEATURE)
effective procedure
push_create_expression (type: TYPE, fs: FEATURE_STAMP, internal_c_local: INTERNAL_C_LOCAL)
effective procedure
require
  • type /= Void
  • fs /= Void
push_cecil_create (type: TYPE, rf: RUN_FEATURE)
effective procedure
push_create_instruction (type: TYPE, rf: RUN_FEATURE, args: EFFECTIVE_ARG_LIST, internal_c_local: INTERNAL_C_LOCAL)
effective procedure
Where internal_c_local holds the newly allocated object.
require
  • type /= Void
  • rf /= Void
inside_twin (type: TYPE, cpy: RUN_FEATURE)
effective procedure
require
  • type /= Void
  • cpy /= Void
check_assertion (type: TYPE, e: EXPRESSION, check_assertion_mode: STRING, tag_name: STRING)
effective procedure
Produce a standard C instruction to check a mandatory ASSERTION.
require
  • pending_c_function
  • e.resolve_in(type).is_boolean
  • avoid_useless_code: not e
  • not check_assertion_mode.is_empty
  • not tag_name.is_empty
inspect_local_push (expression: EXPRESSION)
effective procedure
inspect_local_pop
effective procedure
inspect_local_compile_to_c (type: TYPE)
effective procedure
inspect_local_type (type: TYPE)
effective procedure
inspect_local_stack: STACK[EXPRESSION]
once function
{}
print_current
effective procedure
{ANY}
print_argument (rank: INTEGER_32)
effective procedure
{ANY}
print_local (name: STRING)
effective procedure
{ANY}
require
variant_check (type: TYPE, loop_variant: EXPRESSION)
effective procedure
require
current_class_invariant (type_of_current: TYPE)
effective procedure
Add some C code to check class invariant with Current at the end of a routine for Current.
require
  • type_of_current /= Void
class_invariant_call_opening (type_of_target: TYPE, extra_cast_flag: BOOLEAN): INTEGER_32
effective function
{ANY}
Add extra code to call the class invariant when type_of_target actually has an invariant.
A 0 Result indicate that there is no invariant.
require
  • type_of_target /= Void
class_invariant_call_closing (integer_flag: INTEGER_32, semicolon_flag: BOOLEAN)
effective procedure
{ANY}
macro_def (str: STRING, id: INTEGER_32)
effective procedure
{ANY}
write_make_file
effective procedure
{}
do_write_make_file
effective procedure
{}
put_monomorphic_or_void_call (type: TYPE, feature_stamp: FEATURE_STAMP, target: EXPRESSION, arguments: EFFECTIVE_ARG_LIST)
effective procedure
Unfortunately, because simplify can reduce the number of elements in RUN_TIME_SET objects, long after inline_dynamic_dispatch_, we still have this special case for Void in the back-end (the best way would be to create VOID_PROC_CALL and VOID_CALL objects far before).
When assigned_to then the call is the expression of a variable to write to.
require
  • type /= Void
  • feature_stamp /= Void
  • target /= Void
start_assignment (assignment: ASSIGNMENT_INSTRUCTION, type: TYPE)
effective procedure
Called just before compiling the left (written to) expression of an assignment
require ensure
check_assignment: BOOLEAN
effective function
Called after having compiled the left (written to) expression of an assignment to know if the assignment should be completed by compiling the right expression.
If an evobt was raised then the right expression will not be compiled (see put_monomorphic_or_void_call).
require ensure
end_assignment (assignment: ASSIGNMENT_INSTRUCTION, type: TYPE)
effective procedure
require ensure
in_assignment: BOOLEAN
writable attribute
assignment_evobt: BOOLEAN
writable attribute
{}
put_direct (type: TYPE, dynamic_feature: RUN_FEATURE, target: EXPRESSION, arguments: EFFECTIVE_ARG_LIST)
effective procedure
{ANY}
sys_runtime_h_and_c (name: STRING)
effective procedure
{ANY}
Inline corresponding SmartEiffel/sys/runtime/name.[hc] file.
At least, one file should be found.
put_c_file (tfr: TEXT_FILE_READ)
effective procedure
require
  • not tfr.end_of_input
ensure
  • not tfr.is_connected
put_h_file (tfr: TEXT_FILE_READ)
effective procedure
require
  • not tfr.end_of_input
ensure
  • not tfr.is_connected
recompilation_comment (lt: LIVE_TYPE)
effective procedure
require
  • lt /= Void
include_register (origin: POSITION, include_name: STRING)
effective procedure
set_dump_stack_top_for (t: TYPE, ds: STRING, comment: STRING)
effective procedure
{ANY}
stop_recursive_assertion_opening (inside_feature_flag: BOOLEAN)
effective procedure
stop_recursive_assertion_closing (inside_feature_flag: BOOLEAN)
effective procedure
c_frame_descriptor_in (type_mark: TYPE_MARK, buffer: STRING)
effective procedure
Update c_frame_descriptor_format accordingly.
require
  • type_mark.is_static
  • buffer /= Void
c_frame_descriptor_closure_in (type_mark: TYPE_MARK, buffer: STRING)
effective procedure
Update c_frame_descriptor_format accordingly (for closure locals and arguments).
require
  • type_mark.is_static
  • buffer /= Void
begin_c_linkage (output: TEXT_FILE_WRITE)
effective procedure
{}
Begin wrap for C linkage
end_c_linkage (output: TEXT_FILE_WRITE)
effective procedure
{}
End wrap for C linkage
c_plus_plus_definitions
effective procedure
{}
effective function
{}
The current *.c output file.
writable attribute
{}
The *.h output file.
writable attribute
{}
The *.h, when copied in the symbols file
out_make: TEXT_FILE_WRITE
once function
{}
The *.make output file.
c_inline_h_mem: FAST_ARRAY[STRING]
once function
{}
se_evobt (return_type: TYPE_MARK, type: TYPE, target: EXPRESSION, is_target: BOOLEAN)
effective procedure
is_target is False when compiling an argument, True otherwise (i.e. when compiling a target)
require
  • target /= Void
define_initialize_eiffel_runtime (rf3: RUN_FEATURE_3)
effective procedure
{}
require
  • rf3.is_root
c_call_initialize_manifest_strings
effective procedure
{}
check_id (type: TYPE, e: EXPRESSION, id: INTEGER_32)
effective procedure
{}
Produce a C expression checking that e is not Void and that e is really of type id.
The result of the C expression is the pointer to the corresponding Object.
require
  • e.resolve_in(type).is_reference
  • id > 0
tmp_string: STRING
once function
{}
need_invariant (type_of_target: TYPE): LIVE_TYPE
effective function
{}
Give the corresponding LIVE_TYPE when type_of_target actually needs some class invariant checking.
require
  • type_of_target /= Void
path_h: STRING
effective function
{}
ensure
path_c: STRING
effective function
{}
ensure
path_make: STRING
effective function
{}
ensure
add_first_include (the_first_include: STRING)
effective procedure
{}
put_banner (output: TEXT_FILE_WRITE)
effective procedure
{}
require
  • output.is_connected
c_code_saved: BOOLEAN
writable attribute
{}
h_connect (h_path: STRING)
effective procedure
{}
executable_is_up_to_date: BOOLEAN
writable attribute
{}
When the executable seems to be already correct (no C compilation and no linking is to be done).
common_put_target
effective procedure
{}
put_file (tfr: TEXT_FILE_READ, output: TEXT_FILE_WRITE)
effective procedure
{}
require
  • not tfr.end_of_input
ensure
  • not tfr.is_connected
really_define_c_main (rf3: RUN_FEATURE_3)
effective procedure
{}
require
  • not ace.no_main
include_memory: SET[STRING]
writable attribute
{}
put_position_comment_on (output: TEXT_FILE_WRITE, p: POSITION)
effective procedure
{}
put_position_comment_in (buffer: STRING, p: POSITION)
effective procedure
internal_c_local_stamps_stack: FAST_ARRAY[INTEGER_32]
once function
internal_c_local_list: INTERNAL_C_LOCAL_LIST
once function
string_to_c_code (s: STRING, buffer: STRING)
effective procedure
Add in the buffer the C language view of the Eiffel s STRING.
(Replace all strange characters of s with the appropriate C backslash escape sequences).
native_array_to_c_code (capacity: INTEGER_32, storage: NATIVE_ARRAY[CHARACTER], buffer: STRING)
effective procedure
{}
character_to_c_code (c: CHARACTER, buffer: STRING)
effective procedure
{}
c_define1_manifest_string_pool
effective procedure
{}
nb_ms_per_function: INTEGER_32
is 50
constant attribute
{}
c_define2_manifest_string_pool
effective procedure
{}
se_ms_c_call_in (buffer: STRING, ms: MANIFEST_STRING)
effective procedure
require
  • not ms.unicode_flag
se_ums_c_call_in (buffer: STRING, ms: MANIFEST_STRING)
effective procedure
require
  • ms.unicode_flag
manifest_string_trace (ms: MANIFEST_STRING, buffer: STRING): BOOLEAN
effective function
require
require
start_profile_class_invariant (t: LIVE_TYPE)
effective procedure
require
start_profile_agent_creation (ac: AGENT_CREATION)
effective procedure
require
start_profile_agent_switch (t: TYPE)
effective procedure
require
require
has_c_plus_plus: BOOLEAN
writable attribute
c_plus_plus_registered (native: NATIVE_C_PLUS_PLUS): BOOLEAN
effective function
require
  • native /= Void
c_plus_plus_register (native: NATIVE_C_PLUS_PLUS, rf: RUN_FEATURE)
effective procedure
require ensure
c_registered (native: NATIVE_C): BOOLEAN
effective function
require
  • native /= Void
c_register (native: NATIVE_C, rf: RUN_FEATURE)
effective procedure
require ensure
add_include (include: STRING)
effective procedure
add_include_on (output: TEXT_FILE_WRITE, include: STRING)
effective procedure
{}
c_declare_locals (local_var_list: LOCAL_VAR_LIST, type: TYPE, volatile_flag: BOOLEAN)
effective procedure
Generate the C code for the declaration part.
The volatile_flag indicates that an extra volatile C keyword must be generated because we are in the case of a routine with a rescue clause.
c_init_closure_locals (local_var_list: LOCAL_VAR_LIST, type: TYPE)
effective procedure
require
c_declare_local (local_name: LOCAL_NAME_DEF, type: TYPE, volatile_flag: BOOLEAN)
effective procedure
{}
C declaration of the local.
c_init_closure_local (local_name: LOCAL_NAME_DEF, type: TYPE)
effective procedure
{}
C declaration of the local.
external_prototype_in (formal_arg_list: FORMAL_ARG_LIST, str: STRING, tgt_type: TYPE)
effective procedure
c_define_assignment_test_functions
effective procedure
{}
c_define_assignment_test_for (left_type: TYPE, right_type: TYPE)
effective procedure
{}
require
  • must_be_simplified_in_boost: ace.boost implies not right_type.can_be_assigned_to(left_type)
right_hand_side_can_only_be_void
effective procedure
{}
c_define_manifest_generic_functions
effective procedure
{}
require
c_define_manifest_generic_for (manifest_generic: MANIFEST_GENERIC)
effective procedure
{}
c_define_for_user_generic (manifest_generic: MANIFEST_GENERIC)
effective procedure
{}
require
  • manifest_generic.created_type.live_type /= Void
  • not manifest_generic.created_type.is_native_array
c_define_for_native_array (native_array: TYPE)
effective procedure
{}
require
  • native_array.live_type /= Void
  • native_array.is_native_array
va_type_in (buffer: STRING, va_type: TYPE_MARK)
effective procedure
{}
c_variables_for_precomputable_routines
effective procedure
{}
Generate the C code for once routine which are precomputable.
c_define_o_result_for (non_void_no_dispatch: NON_VOID_NO_DISPATCH)
effective procedure
{}
c_code_for_precomputable_routines
effective procedure
{}
Generate the C code for once routine which are precomputable.
require
c_code_for_precomputable_routine (non_void_no_dispatch: NON_VOID_NO_DISPATCH, unique_id_set: HASHED_SET[STRING])
effective procedure
{}
Generate the C code for once routine which are precomputable.
require
c_pre_compute_once_function (rf: RUN_FEATURE, bf: ANONYMOUS_FEATURE)
effective procedure
{}
require
once_flag (mark: STRING): BOOLEAN
effective function
{}
Flag used to avoid double C definition of globals C variables for once routines.
require ensure
once_mark_list: FAST_ARRAY[STRING]
writable attribute
{}
When the tag is in the list, the corresponding routine does not use Current and C code is already written.
c_define_o_flag (rf: RUN_FEATURE)
effective procedure
Add the definition/initialization of the corresponding o_flag if not yet done.
require
  • rf.is_once_routine
c_define_o_result (rf: RUN_FEATURE)
effective procedure
require
  • rf.is_once_function
c_test_o_flag (rf: RUN_FEATURE)
effective procedure
require
  • rf.is_once_routine
c_test_o_flag_recursion (rf: RUN_FEATURE)
effective procedure
require
  • rf.is_once_routine
c_test_o_flag_introspect (rf: RUN_FEATURE)
effective procedure
require
  • rf.is_once_routine
cecil_define
effective procedure
{}
cecil_define_users_for_file (cecil_file: CECIL_FILE)
effective procedure
{}
require
cecil_define_users_for_entry (cecil_file: CECIL_FILE, cecil_entry: CECIL_ENTRY)
effective procedure
{}
require
_inline_agent6
frozen
effective procedure
{}
_inline_agent7
frozen
effective procedure
{}
_inline_agent8 (rf: RUN_FEATURE, native: NATIVE): BOOLEAN
frozen
effective function
{}
procedure_count: INTEGER_32
writable attribute
{}
function_count: INTEGER_32
writable attribute
{}
precursor_routine_count: INTEGER_32
writable attribute
{}
real_procedure_count: INTEGER_32
writable attribute
{}
real_function_count: INTEGER_32
writable attribute
{}
static_expression_count: INTEGER_32
writable attribute
{}
incr_real_procedure_count
effective procedure
{ANY}
incr_procedure_count
effective procedure
{ANY}
incr_real_function_count
effective procedure
{ANY}
incr_function_count
effective procedure
{ANY}
incr_precursor_routine_count
effective procedure
{ANY}
writable attribute
{}
Index for top of followings stacks.
context_stack: FAST_ARRAY[CODE_CONTEXT]
once function
{}
The indicating stack.
It contains only one of the following unique code.
stack_top: CODE_CONTEXT
effective function
{}
require ensure
  • Result.valid
stack_first_size: INTEGER_32
is 12
constant attribute
{}
stack_push (code: INTEGER_32)
effective procedure
{}
Push the code and resize all stacks if needed.
ensure
unused_contexts: ARRAY[FAST_ARRAY[CODE_CONTEXT]]
writable attribute
{}
reserve_context (code: INTEGER_32): CODE_CONTEXT
effective function
{}
ensure
  • Result.code = code
  • Result.valid
free_context (ctx: CODE_CONTEXT)
effective procedure
{}
require
  • ctx.valid
ensure
  • not ctx.valid
pop
effective procedure
{ANY}
ensure
  • old top = top + 1
  • context_stack.valid_index(top) implies stack_top.valid
        • not (old stack_top).valid
        • Well, at time being, the previous assertion cannot be compiled....
        • Dom. june 8th 2008 ***

check_top (st: CODE_CONTEXT): BOOLEAN
effective function
{}
To make checks coherent, the stack must be cleaned
push_direct (rf: RUN_FEATURE, type: TYPE, target: EXPRESSION, args: EFFECTIVE_ARG_LIST)
effective procedure
require
  • rf /= Void
  • type /= Void
push_precursor (type: TYPE, rf: RUN_FEATURE, args: EFFECTIVE_ARG_LIST)
effective procedure
require
  • rf /= Void
stack_not_full: BOOLEAN
effective function
stack_overflow
effective procedure
{}
new_context (code: INTEGER_32): CODE_CONTEXT
effective function
{}
ensure
  • not Result.valid
smart_eiffel: SMART_EIFFEL
frozen
once function
{ANY}
eiffel_parser: EIFFEL_PARSER
frozen
once function
{ANY}
ace: ACE
frozen
once function
{ANY}
ini_parser: INI_PARSER
frozen
once function
{ANY}
plugin_config: INI_PARSER
frozen
once function
{ANY}
error_handler: ERROR_HANDLER
frozen
once function
{ANY}
string_aliaser: STRING_ALIASER
frozen
once function
{ANY}
cpp: C_PRETTY_PRINTER
frozen
once function
{ANY}
pretty_printer: PRETTY_PRINTER
frozen
once function
{ANY}
mini_buffer: MINI_BUFFER
frozen
once function
{ANY}
nb_errors: INTEGER_32
effective function
{ANY}
ensure
  • Result >= 0
system_tools: SYSTEM_TOOLS
frozen
once function
{ANY}
introspection_handler: INTROSPECTION_HANDLER
frozen
once function
{ANY}
assignment_test_pool: ASSIGNMENT_TEST_POOL
frozen
once function
{ANY}
precomputable_routine_detector: PRECOMPUTABLE_ROUTINE_DETECTOR
frozen
once function
{ANY}
feature_accumulator: FEATURE_ACCUMULATOR
frozen
once function
{ANY}
live_type_extra_collectors: FAST_ARRAY[LIVE_TYPE_EXTRA_COLLECTOR]
frozen
once function
{ANY}
is_launcher: BOOLEAN
effective function
{ACE}
If True, the clusters list will not be retrieved (it means that the tool is only used to start other tools; it does not load classes itself)
set_launcher
effective procedure
ensure
is_launcher_memory: REFERENCE[BOOLEAN]
once function
{}
parser_buffer: PARSER_BUFFER
frozen
once function
id_provider: ID_PROVIDER
frozen
once function
{ANY}
manifest_string_pool: MANIFEST_STRING_POOL
frozen
once function
{ANY}
manifest_generic_pool: MANIFEST_GENERIC_POOL
frozen
once function
{ANY}
once_routine_pool: ONCE_ROUTINE_POOL
frozen
once function
{ANY}
agent_pool: AGENT_POOL
frozen
once function
{ANY}
cecil_pool: CECIL_POOL
frozen
effective function
{ANY}
cecil_pool_memory: REFERENCE[CECIL_POOL]
frozen
once function
{ANY}
set_cecil_pool
frozen
once procedure
{ANY}
ensure
short_printer: SHORT_PRINTER
frozen
once function
{ANY}
echo: ECHO
frozen
once function
{ANY}
assignment_handler: ASSIGNMENT_HANDLER
frozen
once function
{ANY}
thread_pool: THREAD_POOL
frozen
once function
{ANY}
exceptions: EXCEPTIONS
frozen
writable attribute
{ANY}
exceptions_handler: EXCEPTIONS_HANDLER
frozen
once function
{ANY}
nb_warnings: INTEGER_32
effective function
{ANY}
ensure
  • Result >= 0
tmp_path: STRING
once function
{ANY}
tmp_file_read: TEXT_FILE_READ
once function
{ANY}
class_any: CLASS_TEXT
once function
{ANY}
omitted_client_list: CLIENT_LIST
frozen
once function
{ANY}
(To avoid multiple creation(s).)
any_default_create_fs: FEATURE_STAMP
once function
{ANY}
any_default_rescue_fs: FEATURE_STAMP
once function
{ANY}
any_copy_fs: FEATURE_STAMP
once function
{ANY}
any_is_equal_fs: FEATURE_STAMP
once function
{ANY}
any_deep_twin_fs: FEATURE_STAMP
once function
{ANY}
any_is_deep_equal_fs: FEATURE_STAMP
once function
{ANY}
boolean_and_then_fs: FEATURE_STAMP
once function
{ANY}
manifest_make_name: HASHED_STRING
once function
{ANY}
manifest_put_name: HASHED_STRING
once function
{ANY}
manifest_semicolon_check_name: HASHED_STRING
once function
{ANY}
manifest_initialize_name: HASHED_STRING
once function
{ANY}
calloc_name: HASHED_STRING
once function
{ANY}
put_name: HASHED_STRING
once function
{ANY}
item_name: HASHED_STRING
once function
{ANY}
is_empty_name: HASHED_STRING
once function
{ANY}
make_name: HASHED_STRING
once function
{ANY}
from_external_sized_copy_name: HASHED_STRING
once function
{ANY}
count_name: HASHED_STRING
once function
{ANY}
storage_name: HASHED_STRING
once function
{ANY}
capacity_name: HASHED_STRING
once function
{ANY}
storage_lower_name: HASHED_STRING
once function
{ANY}
mark_item_name: HASHED_STRING
once function
{ANY}
mark_native_arrays_name: HASHED_STRING
once function
{ANY}
and_then_name: HASHED_STRING
once function
{ANY}
or_else_name: HASHED_STRING
once function
{ANY}
twin_name: HASHED_STRING
once function
{ANY}
copy_name: HASHED_STRING
once function
{ANY}
is_equal_name: HASHED_STRING
once function
{ANY}
deep_twin_name: HASHED_STRING
once function
{ANY}
deep_twin_from_name: HASHED_STRING
once function
{ANY}
is_deep_equal_name: HASHED_STRING
once function
{ANY}
deep_memcmp_name: HASHED_STRING
once function
{ANY}
se_atexit_name: HASHED_STRING
once function
{ANY}
default_rescue_name: HASHED_STRING
once function
{ANY}
default_create_name: HASHED_STRING
once function
{ANY}
flush_name: HASHED_STRING
once function
{ANY}
clear_all_name: HASHED_STRING
once function
{ANY}
from_pointer_name: HASHED_STRING
once function
{ANY}
no_errors: BOOLEAN
effective function
{ANY}
character_coding (c: CHARACTER, str: STRING)
effective procedure
{ANY}
Append in str the Eiffel coding of the character (Table in chapter 25 of ETL, page 423).%%%%%%%%
When the % letter notation exists, it is returned in priority: '%N' gives "%N", '%T' gives "%T", etc. When % letter notation does not exists (not in the ETL table), numbered coding used ("%/1/", "%/2/" etc).
eiffel_suffix: STRING
is ".e"
constant attribute
{ANY}
Eiffel Source file suffix.
c_suffix: STRING
is ".c"
constant attribute
{ANY}
C files suffix.
h_suffix: STRING
is ".h"
constant attribute
{ANY}
Heading C files suffix.
c_plus_plus_suffix: STRING
is ".cpp"
constant attribute
{ANY}
C++ files suffix.
backup_suffix: STRING
is ".bak"
constant attribute
{ANY}
Backup suffix for command pretty.
class_suffix: STRING
is ".class"
constant attribute
{ANY}
dot_precedence: INTEGER_32
is 12
constant attribute
{ANY}
The highest precedence value according to ETL.
atomic_precedence: INTEGER_32
is 13
constant attribute
{ANY}
Used for atomic elements.
append_u1 (str: STRING, u1: INTEGER_32)
effective procedure
{ANY}
append_u2 (str: STRING, u2: INTEGER_32)
effective procedure
{ANY}
append_u4 (str: STRING, u4: INTEGER_32)
effective procedure
{ANY}
is_install: BOOLEAN
effective function
{ANY}
set_install
effective procedure
{ANY}
ensure
install_memory: REFERENCE[BOOLEAN]
once function
{ANY}
unrelated_code: INTEGER_8
is 0
constant attribute
{ANY}
inserts_code: INTEGER_8
is 1
constant attribute
{ANY}
inherits_code: INTEGER_8
is 2
constant attribute
{ANY}
once function
{ANY}
shrink_generic_types: BOOLEAN
effective function
{}
shrink_generic_types_memory: REFERENCE[BOOLEAN]
once function
{}
Set the item to True if you want less generic type duplication
as_any: STRING
is "ANY"
constant attribute
{}
as_array: STRING
is "ARRAY"
constant attribute
{}
as_boolean: STRING
is "BOOLEAN"
constant attribute
{}
as_character: STRING
is "CHARACTER"
constant attribute
{}
as_disposable: STRING
is "DISPOSABLE"
constant attribute
{}
as_exceptions: STRING
is "EXCEPTIONS"
constant attribute
{}
as_fixed_array: STRING
is "FAST_ARRAY"
constant attribute
{}
as_function: STRING
is "FUNCTION"
constant attribute
{}
as_integer_general: STRING
is "INTEGER_GENERAL"
constant attribute
{}
as_integer_8: STRING
is "INTEGER_8"
constant attribute
{}
as_integer_16: STRING
is "INTEGER_16"
constant attribute
{}
as_integer_32: STRING
is "INTEGER_32"
constant attribute
{}
as_integer: STRING
is "INTEGER"
constant attribute
{}
as_integer_64: STRING
is "INTEGER_64"
constant attribute
{}
as_internals: STRING
is "INTERNALS"
constant attribute
{}
as_internals_handler: STRING
is "INTERNALS_HANDLER"
constant attribute
{}
as_native_array: STRING
is "NATIVE_ARRAY"
constant attribute
{}
as_native_array_collector: STRING
is "NATIVE_ARRAY_COLLECTOR"
constant attribute
{}
as_native_array_internals: STRING
is "NATIVE_ARRAY_INTERNALS"
constant attribute
{}
as_natural: STRING
is "NATURAL"
constant attribute
{}
as_natural_8: STRING
is "NATURAL_8"
constant attribute
{}
as_natural_16: STRING
is "NATURAL_16"
constant attribute
{}
as_natural_32: STRING
is "NATURAL_32"
constant attribute
{}
as_natural_64: STRING
is "NATURAL_64"
constant attribute
{}
as_natural_general: STRING
is "NATURAL_GENERAL"
constant attribute
{}
as_platform: STRING
is "PLATFORM"
constant attribute
{}
as_pointer: STRING
is "POINTER"
constant attribute
{}
as_predicate: STRING
is "PREDICATE"
constant attribute
{}
as_procedure: STRING
is "PROCEDURE"
constant attribute
{}
as_real_general: STRING
is "REAL_GENERAL"
constant attribute
{}
as_real_32: STRING
is "REAL_32"
constant attribute
{}
as_real: STRING
is "REAL"
constant attribute
{}
as_real_64: STRING
is "REAL_64"
constant attribute
{}
as_real_80: STRING
is "REAL_80"
constant attribute
{}
as_real_128: STRING
is "REAL_128"
constant attribute
{}
as_real_extended: STRING
is "REAL_EXTENDED"
constant attribute
{}
as_routine: STRING
is "ROUTINE"
constant attribute
{}
as_set: STRING
is "SET"
constant attribute
{}
as_string: STRING
is "STRING"
constant attribute
{}
as_text_file_read: STRING
is "TEXT_FILE_READ"
constant attribute
{}
as_text_file_write: STRING
is "TEXT_FILE_WRITE"
constant attribute
{}
as_thread_context: STRING
is "THREAD_CONTEXT"
constant attribute
{}
as_thread_lock: STRING
is "THREAD_LOCK"
constant attribute
{}
as_tuple: STRING
is "TUPLE"
constant attribute
{}
as_type: STRING
is "TYPE"
constant attribute
{}
as_typed_internals: STRING
is "TYPED_INTERNALS"
constant attribute
{}
as_unicode_string: STRING
is "UNICODE_STRING"
constant attribute
{}
as_weak_reference: STRING
is "WEAK_REFERENCE"
constant attribute
{}
as_a1: STRING
is "a1"
constant attribute
{}
as_add_last: STRING
is "add_last"
constant attribute
{}
as_agent: STRING
is "agent"
constant attribute
{}
as_allocated_bytes: STRING
is "allocated_bytes"
constant attribute
{}
as_alloc_native_data: STRING
is "alloc_native_data"
constant attribute
{}
as_as_16_ne: STRING
is "as_16_ne"
constant attribute
{}
as_as_32_ne: STRING
is "as_32_ne"
constant attribute
{}
as_atan2: STRING
is "atan2"
constant attribute
{}
as_blank: STRING
is "blank"
constant attribute
{}
as_bit_clear: STRING
is "bit_clear"
constant attribute
{}
as_bit_put: STRING
is "bit_put"
constant attribute
{}
as_bit_rotate: STRING
is "bit_rotate"
constant attribute
{}
as_bit_set: STRING
is "bit_set"
constant attribute
{}
as_bit_xor: STRING
is "bit_xor"
constant attribute
{}
as_boolean_bits: STRING
is "Boolean_bits"
constant attribute
{}
as_call: STRING
is "call"
constant attribute
{}
as_calloc: STRING
is "calloc"
constant attribute
{}
as_capacity: STRING
is "capacity"
constant attribute
{}
as_ceiling: STRING
is "ceiling"
constant attribute
{}
as_character_bits: STRING
is "Character_bits"
constant attribute
{}
as_clear_all: STRING
is "clear_all"
constant attribute
{}
as_count: STRING
is "count"
constant attribute
{}
as_code: STRING
is "code"
constant attribute
{}
as_collecting: STRING
is "collecting"
constant attribute
{}
as_collection_off: STRING
is "collection_off"
constant attribute
{}
as_collection_on: STRING
is "collection_on"
constant attribute
{}
as_collector_counter: STRING
is "collector_counter"
constant attribute
{}
as_copy: STRING
is "copy"
constant attribute
{}
as_c_inline_c: STRING
is "c_inline_c"
constant attribute
{}
as_c_inline_h: STRING
is "c_inline_h"
constant attribute
{}
as_default_create: STRING
is "default_create"
constant attribute
{}
as_default_rescue: STRING
is "default_rescue"
constant attribute
{}
as_deep_memcmp: STRING
is "deep_memcmp"
constant attribute
{}
as_deep_twin: STRING
is "deep_twin"
constant attribute
{}
as_deep_twin_from: STRING
is "deep_twin_from"
constant attribute
{}
as_dispose: STRING
is "dispose"
constant attribute
{}
as_die_with_code: STRING
is "die_with_code"
constant attribute
{}
as_element_sizeof: STRING
is "element_sizeof"
constant attribute
{}
as_exception: STRING
is "exception"
constant attribute
{}
as_for_object: STRING
is "for_object"
constant attribute
{}
as_type_can_be_assigned_to_attribute: STRING
is "type_can_be_assigned_to_attribute"
constant attribute
{}
as_type_can_be_assigned_to_item: STRING
is "type_can_be_assigned_to_item"
constant attribute
{}
as_type_attribute_count: STRING
is "type_attribute_count"
constant attribute
{}
as_type_attribute_generator: STRING
is "type_attribute_generator"
constant attribute
{}
as_type_attribute_generating_type: STRING
is "type_attribute_generating_type"
constant attribute
{}
as_type_attribute_is_expanded: STRING
is "type_attribute_is_expanded"
constant attribute
{}
as_type_attribute_name: STRING
is "type_attribute_name"
constant attribute
{}
as_fifth: STRING
is "fifth"
constant attribute
{}
as_first: STRING
is "first"
constant attribute
{}
as_floor: STRING
is "floor"
constant attribute
{}
as_flush: STRING
is "flush"
constant attribute
{}
as_fourth: STRING
is "fourth"
constant attribute
{}
as_force_to_integer_16: STRING
is "force_to_integer_16"
constant attribute
{}
as_force_to_integer_32: STRING
is "force_to_integer_32"
constant attribute
{}
as_force_to_integer_64: STRING
is "force_to_integer_64"
constant attribute
{}
as_force_to_natural_16: STRING
is "force_to_natural_16"
constant attribute
{}
as_force_to_natural_32: STRING
is "force_to_natural_32"
constant attribute
{}
as_force_to_natural_64: STRING
is "force_to_natural_64"
constant attribute
{}
as_force_to_real_32: STRING
is "force_to_real_32"
constant attribute
{}
as_force_to_real_64: STRING
is "force_to_real_64"
constant attribute
{}
as_free_native_data: STRING
is "free_native_data"
constant attribute
{}
as_from_external_sized_copy: STRING
is "from_external_sized_copy"
constant attribute
{}
as_from_pointer: STRING
is "from_pointer"
constant attribute
{}
as_full_collect: STRING
is "full_collect"
constant attribute
{}
as_generating_type: STRING
is "generating_type"
constant attribute
{}
as_generator: STRING
is "generator"
constant attribute
{}
as_io: STRING
is "io"
constant attribute
{}
as_integer_bits: STRING
is "Integer_bits"
constant attribute
{}
as_internals_from_generating_type: STRING
is "internals_from_generating_type"
constant attribute
{}
as_is_basic_expanded_type: STRING
is "is_basic_expanded_type"
constant attribute
{}
as_is_deep_equal: STRING
is "is_deep_equal"
constant attribute
{}
as_is_equal: STRING
is "is_equal"
constant attribute
{}
as_do_at_exit: STRING
is "do_at_exit"
constant attribute
{}
as_is_empty: STRING
is "is_empty"
constant attribute
{}
as_is_finished: STRING
is "is_finished"
constant attribute
{}
as_is_infinity: STRING
is "is_infinity"
constant attribute
{}
as_is_locked: STRING
is "is_locked"
constant attribute
{}
as_is_normal: STRING
is "is_normal"
constant attribute
{}
as_is_not_a_number: STRING
is "is_not_a_number"
constant attribute
{}
as_is_not_null: STRING
is "is_not_null"
constant attribute
{}
as_is_started: STRING
is "is_started"
constant attribute
{}
as_is_subnormal: STRING
is "is_subnormal"
constant attribute
{}
as_item: STRING
is "item"
constant attribute
{}
as_last: STRING
is "last"
constant attribute
{}
as_lock: STRING
is "lock"
constant attribute
{}
as_lower: STRING
is "lower"
constant attribute
{}
as_low_8: STRING
is "low_8"
constant attribute
{}
as_low_16: STRING
is "low_16"
constant attribute
{}
as_low_32: STRING
is "low_32"
constant attribute
{}
as_native_array_internals_from_generating_type: STRING
is "native_array_internals_from_generating_type"
constant attribute
{}
as_make: STRING
is "make"
constant attribute
{}
as_make_blank: STRING
is "make_blank"
constant attribute
{}
as_mark_item: STRING
is "mark_item"
constant attribute
{}
as_mark_native_arrays: STRING
is "mark_native_arrays"
constant attribute
{}
as_minimum_character_code: STRING
is "Minimum_character_code"
constant attribute
{}
as_minimum_double: STRING
is "Minimum_double"
constant attribute
{}
as_minimum_real: STRING
is "Minimum_real"
constant attribute
{}
as_manifest_creation: STRING
is "manifest_creation"
constant attribute
{}
as_manifest_initialize: STRING
is "manifest_initialize"
constant attribute
{}
as_manifest_make: STRING
is "manifest_make"
constant attribute
{}
as_manifest_put: STRING
is "manifest_put"
constant attribute
{}
as_manifest_semicolon_check: STRING
is "manifest_semicolon_check"
constant attribute
{}
as_maximum_character_code: STRING
is "Maximum_character_code"
constant attribute
{}
as_maximum_double: STRING
is "Maximum_double"
constant attribute
{}
as_maximum_real: STRING
is "Maximum_real"
constant attribute
{}
as_native_data: STRING
is "native_data"
constant attribute
{}
as_notify: STRING
is "notify"
constant attribute
{}
as_notify_all: STRING
is "notify_all"
constant attribute
{}
as_object_as_pointer: STRING
is "object_as_pointer"
constant attribute
{}
as_object_attribute: STRING
is "object_attribute"
constant attribute
{}
as_object_invariant: STRING
is "object_invariant"
constant attribute
{}
as_object_memory: STRING
is "object_memory"
constant attribute
{}
as_object_size: STRING
is "object_size"
constant attribute
{}
as_pointer_bits: STRING
is "Pointer_bits"
constant attribute
{}
as_pow_postfix: STRING
is "pow"
constant attribute
{}
as_print: STRING
is "print"
constant attribute
{}
as_print_on: STRING
is "print_on"
constant attribute
{}
as_print_run_time_stack: STRING
is "print_run_time_stack"
constant attribute
{}
as_put: STRING
is "put"
constant attribute
{}
as_put_0: STRING
is "put_0"
constant attribute
{}
as_put_1: STRING
is "put_1"
constant attribute
{}
as_put_16_be: STRING
is "put_16_be"
constant attribute
{}
as_put_16_le: STRING
is "put_16_le"
constant attribute
{}
as_put_16_ne: STRING
is "put_16_ne"
constant attribute
{}
as_put_32_be: STRING
is "put_32_be"
constant attribute
{}
as_put_32_le: STRING
is "put_32_le"
constant attribute
{}
as_put_32_ne: STRING
is "put_32_ne"
constant attribute
{}
as_raise_exception: STRING
is "raise_exception"
constant attribute
{}
as_real_bits: STRING
is "Real_bits"
constant attribute
{}
as_realloc: STRING
is "realloc"
constant attribute
{}
as_rounded: STRING
is "rounded"
constant attribute
{}
as_run: STRING
is "run"
constant attribute
{}
as_same_dynamic_type: STRING
is "same_dynamic_type"
constant attribute
{}
as_second: STRING
is "second"
constant attribute
{}
as_se_argc: STRING
is "se_argc"
constant attribute
{}
as_se_argv: STRING
is "se_argv"
constant attribute
{}
as_se_atexit: STRING
is "se_atexit"
constant attribute
{}
as_se_fault: STRING
is "se_fault"
constant attribute
{}
as_sedb_breakpoint: STRING
is "sedb_breakpoint"
constant attribute
{}
as_set_item: STRING
is "set_item"
constant attribute
{}
as_set_object_attribute: STRING
is "set_object_attribute"
constant attribute
{}
as_signal_number: STRING
is "signal_number"
constant attribute
{}
as_slice_copy: STRING
is "slice_copy"
constant attribute
{}
as_standard_copy: STRING
is "standard_copy"
constant attribute
{}
as_standard_is_equal: STRING
is "standard_is_equal"
constant attribute
{}
as_standard_twin: STRING
is "standard_twin"
constant attribute
{}
as_status: STRING
is "status"
constant attribute
{}
as_std_error: STRING
is "std_error"
constant attribute
{}
as_std_input: STRING
is "std_input"
constant attribute
{}
as_std_output: STRING
is "std_output"
constant attribute
{}
as_stderr: STRING
is "stderr"
constant attribute
{}
as_stdin: STRING
is "stdin"
constant attribute
{}
as_stdout: STRING
is "stdout"
constant attribute
{}
as_storage: STRING
is "storage"
constant attribute
{}
as_storage_lower: STRING
is "storage_lower"
constant attribute
{}
as_third: STRING
is "third"
constant attribute
{}
as_timed_wait: STRING
is "timed_wait"
constant attribute
{}
as_to_character: STRING
is "to_character"
constant attribute
{}
as_to_integer_8: STRING
is "to_integer_8"
constant attribute
{}
as_to_integer_16: STRING
is "to_integer_16"
constant attribute
{}
as_to_integer_32: STRING
is "to_integer_32"
constant attribute
{}
as_to_integer_64: STRING
is "to_integer_64"
constant attribute
{}
as_to_internals: STRING
is "to_internals"
constant attribute
{}
as_to_natural_8: STRING
is "to_natural_8"
constant attribute
{}
as_to_natural_16: STRING
is "to_natural_16"
constant attribute
{}
as_to_natural_32: STRING
is "to_natural_32"
constant attribute
{}
as_to_natural_64: STRING
is "to_natural_64"
constant attribute
{}
as_to_pointer: STRING
is "to_pointer"
constant attribute
{}
as_trace_switch: STRING
is "trace_switch"
constant attribute
{}
as_twin: STRING
is "twin"
constant attribute
{}
as_type_generating_type: STRING
is "type_generating_type"
constant attribute
{}
as_type_generator: STRING
is "type_generator"
constant attribute
{}
as_type_is_expanded: STRING
is "type_is_expanded"
constant attribute
{}
as_type_item_generating_type: STRING
is "type_item_generating_type"
constant attribute
{}
as_type_item_generator: STRING
is "type_item_generator"
constant attribute
{}
as_type_item_is_expanded: STRING
is "type_item_is_expanded"
constant attribute
{}
as_unlock: STRING
is "unlock"
constant attribute
{}
as_upper: STRING
is "upper"
constant attribute
{}
as_valid_generating_type_for_internals: STRING
is "valid_generating_type_for_internals"
constant attribute
{}
as_valid_generating_type_for_native_array_internals: STRING
is "valid_generating_type_for_native_array_internals"
constant attribute
{}
as_wait: STRING
is "wait"
constant attribute
{}
as_with_capacity: STRING
is "with_capacity"
constant attribute
{}
as_and: STRING
is "and"
constant attribute
{}
as_and_then: STRING
is "and then"
constant attribute
{}
as_at: STRING
is "@"
constant attribute
{}
as_backslash_backslash: STRING
is "\\"
constant attribute
{}
as_bit_and: STRING
is "&"
constant attribute
{}
as_bit_not: STRING
is "~"
constant attribute
{}
as_bit_or: STRING
is "|"
constant attribute
{}
as_bit_rotate_left: STRING
is "#<<"
constant attribute
{}
as_bit_rotate_right: STRING
is "#>>"
constant attribute
{}
as_bit_shift_right_unsigned: STRING
is "|>>>"
constant attribute
{}
as_brackets: STRING
is "[]"
constant attribute
{}
as_eq: STRING
is "="
constant attribute
{}
as_ge: STRING
is ">="
constant attribute
{}
as_gt: STRING
is ">"
constant attribute
{}
as_implies: STRING
is "implies"
constant attribute
{}
as_le: STRING
is "<="
constant attribute
{}
as_lt: STRING
is "<"
constant attribute
{}
as_minus: STRING
is "-"
constant attribute
{}
as_muls: STRING
is "*"
constant attribute
{}
as_neq: STRING
is "/="
constant attribute
{}
as_not: STRING
is "not"
constant attribute
{}
as_or: STRING
is "or"
constant attribute
{}
as_or_else: STRING
is "or else"
constant attribute
{}
as_parentheses: STRING
is "()"
constant attribute
{}
as_plus: STRING
is "+"
constant attribute
{}
as_pow: STRING
is "^"
constant attribute
{}
as_sharp_backslash_backslash: STRING
is "#\\"
constant attribute
{}
as_sharp_minus: STRING
is "#-"
constant attribute
{}
as_sharp_muls: STRING
is "#*"
constant attribute
{}
as_sharp_plus: STRING
is "#+"
constant attribute
{}
as_sharp_slash_slash: STRING
is "#//"
constant attribute
{}
as_bit_shift_left: STRING
is "|<<"
constant attribute
{}
as_bit_shift_right: STRING
is "|>>"
constant attribute
{}
as_slash: STRING
is "/"
constant attribute
{}
as_slash_slash: STRING
is "//"
constant attribute
{}
as_xor: STRING
is "xor"
constant attribute
{}
as_arguments: STRING
is "arguments"
constant attribute
{}
as_current: STRING
is "Current"
constant attribute
{}
as_native_array_character: STRING
is "NATIVE_ARRAY[CHARACTER]"
constant attribute
{}
as_last_result: STRING
is "last_result"
constant attribute
{}
as_like_current: STRING
is "like Current"
constant attribute
{}
as_method: STRING
is "method"
constant attribute
{}
as_open_arguments: STRING
is "open_arguments"
constant attribute
{}
as_open_argument_indices: STRING
is "open_argument_indices"
constant attribute
{}
as_open_argument_index: STRING
is "open_argument_index"
constant attribute
{}
as_open_argument_count: STRING
is "open_argument_count"
constant attribute
{}
as_precursor: STRING
is "Precursor"
constant attribute
{}
as_result: STRING
is "Result"
constant attribute
{}
as_target: STRING
is "target"
constant attribute
{}
as_void: STRING
is "Void"
constant attribute
{}
fz_adapt: STRING
is "adapt"
constant attribute
{}
fz_alias: STRING
is "alias"
constant attribute
{}
fz_all: STRING
is "all"
constant attribute
{}
fz_as: STRING
is "as"
constant attribute
{}
fz_assertion: STRING
is "assertion"
constant attribute
{}
fz_assertion_flat_check: STRING
is "assertion_flat_check"
constant attribute
{}
fz_assign: STRING
is "assign"
constant attribute
{}
fz_begin_c_compile: STRING
is "# Beginning of parallelizable section"
constant attribute
{}
fz_boost: STRING
is "boost"
constant attribute
{}
fz_check: STRING
is "check"
constant attribute
{}
fz_class: STRING
is "class"
constant attribute
{}
fz_cluster: STRING
is "cluster"
constant attribute
{}
fz_convert: STRING
is "convert"
constant attribute
{}
fz_create: STRING
is "create"
constant attribute
{}
fz_creation: STRING
is "creation"
constant attribute
{}
fz_debug: STRING
is "debug"
constant attribute
{}
fz_default: STRING
is "default"
constant attribute
{}
fz_deferred: STRING
is "deferred"
constant attribute
{}
fz_do: STRING
is "do"
constant attribute
{}
fz_else: STRING
is "else"
constant attribute
{}
fz_elseif: STRING
is "elseif"
constant attribute
{}
fz_end: STRING
is "end"
constant attribute
{}
fz_end_c_compile: STRING
is "# End of parallelizable section"
constant attribute
{}
fz_ensure: STRING
is "ensure"
constant attribute
{}
fz_exclude: STRING
is "exclude"
constant attribute
{}
fz_expanded: STRING
is "expanded"
constant attribute
{}
fz_export: STRING
is "export"
constant attribute
{}
fz_external: STRING
is "external"
constant attribute
{}
fz_false: STRING
is "False"
constant attribute
{}
fz_feature: STRING
is "feature"
constant attribute
{}
fz_from: STRING
is "from"
constant attribute
{}
fz_frozen: STRING
is "frozen"
constant attribute
{}
fz_generate: STRING
is "generate"
constant attribute
{}
fz_if: STRING
is "if"
constant attribute
{}
fz_include: STRING
is "include"
constant attribute
{}
fz_indexing: STRING
is "indexing"
constant attribute
{}
fz_infix: STRING
is "infix"
constant attribute
{}
fz_inherit: STRING
is "inherit"
constant attribute
{}
fz_insert: STRING
is "insert"
constant attribute
{}
fz_inline: STRING
is "inline"
constant attribute
{}
fz_inspect: STRING
is "inspect"
constant attribute
{}
fz_invariant: STRING
is "invariant"
constant attribute
{}
fz_is: STRING
is "is"
constant attribute
{}
fz_like: STRING
is "like"
constant attribute
{}
fz_local: STRING
is "local"
constant attribute
{}
fz_loop: STRING
is "loop"
constant attribute
{}
fz_no: STRING
is "no"
constant attribute
{}
fz_note: STRING
is "note"
constant attribute
{}
fz_obsolete: STRING
is "obsolete"
constant attribute
{}
fz_old: STRING
is "old"
constant attribute
{}
fz_once: STRING
is "once"
constant attribute
{}
fz_option: STRING
is "option"
constant attribute
{}
fz_prefix: STRING
is "prefix"
constant attribute
{}
fz_redefine: STRING
is "redefine"
constant attribute
{}
fz_rename: STRING
is "rename"
constant attribute
{}
fz_require: STRING
is "require"
constant attribute
{}
fz_rescue: STRING
is "rescue"
constant attribute
{}
fz_retry: STRING
is "retry"
constant attribute
{}
fz_runtime: STRING
is "runtime"
constant attribute
{}
fz_separate: STRING
is "separate"
constant attribute
{}
fz_reference: STRING
is "reference"
constant attribute
{}
fz_then: STRING
is "then"
constant attribute
{}
fz_trace: STRING
is "trace"
constant attribute
{}
fz_true: STRING
is "True"
constant attribute
{}
fz_undefine: STRING
is "undefine"
constant attribute
{}
fz_unique: STRING
is "unique"
constant attribute
{}
fz_until: STRING
is "until"
constant attribute
{}
fz_use: STRING
is "use"
constant attribute
{}
fz_variant: STRING
is "variant"
constant attribute
{}
fz_when: STRING
is "when"
constant attribute
{}
fz_yes: STRING
is "yes"
constant attribute
{}
fz_cad: STRING
is "Cyclic anchored definition."
constant attribute
{}
fz_dtideena: STRING
is " has no compiler-defined `deep_twin' or `is_deep_equal' because the corresponding allocated size is not part of the NATIVE_ARRAY object. The client class of this NATIVE_ARRAY type is supposed to use a `capacity' attribute which contains the corresponding number of allocated items (see STRING or ARRAY for example)."
constant attribute
{}
fz_error_stars: STRING
is "****** "
constant attribute
{}
fz_vuar4: STRING
is "The $ operator must be followed by the final name of a feature which is not a constant attribute or by the name of some local variable as well."
constant attribute
{}
fz_bin: STRING
is "bin"
constant attribute
{}
fz_c_shift_left: STRING
is "<<"
constant attribute
{}
fz_c_shift_right: STRING
is ">>"
constant attribute
{}
fz_install: STRING
is "install"
constant attribute
{}
fz_jobs: STRING
is "jobs"
constant attribute
{}
fz_no_check: STRING
is "no_check"
constant attribute
{}
fz_none: STRING
is "none"
constant attribute
{}
fz_libertyeiffel: STRING
is "LibertyEiffel"
constant attribute
{}
fz_seconf: STRING
is "LIBERTY_CONF"
constant attribute
{}
The environment name pointing to the config file.
fz_conf_general: STRING
is "General"
constant attribute
{}
fz_conf_loadpath: STRING
is "Loadpath"
constant attribute
{}
fz_conf_environment: STRING
is "Environment"
constant attribute
{}
since version 2
fz_conf_se_tools: STRING
is "Tools"
constant attribute
{}
since version 3
fz_conf_bin: STRING
is "bin"
constant attribute
{}
fz_conf_lib: STRING
is "lib"
constant attribute
{}
fz_conf_sys: STRING
is "sys"
constant attribute
{}
fz_conf_short: STRING
is "short"
constant attribute
{}
fz_conf_tools: STRING
is "tools"
constant attribute
{}
fz_conf_os: STRING
is "os"
constant attribute
{}
fz_conf_flavor: STRING
is "flavor"
constant attribute
{}
fz_conf_jobs: STRING
is "jobs"
constant attribute
{}
fz_conf_boost: STRING
is "boost"
constant attribute
{}
fz_conf_no_check: STRING
is "no_check"
constant attribute
{}
fz_conf_require_check: STRING
is "require_check"
constant attribute
{}
fz_conf_ensure_check: STRING
is "ensure_check"
constant attribute
{}
fz_conf_invariant_check: STRING
is "invariant_check"
constant attribute
{}
fz_conf_loop_check: STRING
is "loop_check"
constant attribute
{}
fz_conf_all_check: STRING
is "all_check"
constant attribute
{}
fz_conf_debug_check: STRING
is "debug_check"
constant attribute
{}
fz_conf_flat_check: STRING
is "flat_check"
constant attribute
{}
fz_conf_smarteiffel_options: STRING
is "smarteiffel_options"
constant attribute
{}
fz_conf_undefined: STRING
is "undefined"
constant attribute
{}
fz_conf_tag: STRING
is "tag"
constant attribute
{}
fz_conf_compiler_type: STRING
is "c_compiler_type"
constant attribute
{}
fz_conf_compiler_path: STRING
is "c_compiler_path"
constant attribute
{}
fz_conf_linker_path: STRING
is "c_linker_path"
constant attribute
{}
fz_conf_strip_path: STRING
is "c_strip_path"
constant attribute
{}
fz_conf_compiler_options: STRING
is "c_compiler_options"
constant attribute
{}
fz_conf_linker_options: STRING
is "c_linker_options"
constant attribute
{}
fz_conf_cpp_compiler_type: STRING
is "cpp_compiler_type"
constant attribute
{}
fz_conf_cpp_compiler_path: STRING
is "cpp_compiler_path"
constant attribute
{}
fz_conf_cpp_compiler_options: STRING
is "cpp_compiler_options"
constant attribute
{}
fz_conf_cpp_linker_path: STRING
is "cpp_linker_path"
constant attribute
{}
fz_conf_cpp_strip_path: STRING
is "cpp_strip_path"
constant attribute
{}
fz_conf_cpp_linker_options: STRING
is "cpp_linker_options"
constant attribute
{}
C_direct_call: INTEGER_32
is 5
constant attribute
{}
Target is sure not to be Void and there is only one possible type (target often Current, a manifest string or some expanded).
C_create_instruction: INTEGER_32
is 6
constant attribute
{}
Target has just been created with a create instruction and needs to be initialised with some create procedure call.
C_create_expression: INTEGER_32
is 7
constant attribute
{}
Target has just been created with a create expression and needs to be initialized inside the create function.
C_inside_twin: INTEGER_32
is 8
constant attribute
{}
In order to call the user's copy.
C_precursor: INTEGER_32
is 9
constant attribute
{}
For Precursor calls.
C_inside_some_wrapper: INTEGER_32
is 10
constant attribute
{}
The feature to be called is inside some wrapper using the most general convention.
C_cecil_create: INTEGER_32
is 11
constant attribute
{}
The target has just been created, the create instruction is called via CECIL
Maximum_character_code: INTEGER_16
{}
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
Number of bits in a value of type POINTER.