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
compile_routines
effective procedure
{}
Try to give the best order to the C output.
show_profile
effective procedure
{}
define_extern_tables
effective procedure
{}
initialize_size_table
effective procedure
{}
initialize se_strucT
initialize_path_table_of (ct: CLASS_TEXT)
effective procedure
{}
initialize_path_table
effective procedure
{}
initialize_generator_of (ct: CLASS_TEXT)
effective procedure
{}
initialize_generator
effective procedure
{}
initialize_generating_type
effective procedure
{}
initialize_profile
effective procedure
{}
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.
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.
eiffel_parser_stamp_push (eiffel_parser_stamp: INTEGER_32)
effective procedure
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}
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.
put_target_as_value
effective procedure
{ANY}
Produce C code for a simple access to the stacked target.
put_error0 (msg: STRING)
effective procedure
{ANY}
Print msg and then stop execution.
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
{}
echo_information
effective procedure
{}
customize_runtime
effective procedure
{}
defined_agent_creation: FAST_ARRAY[STRING]
once function
customize_thread_pool_runtime
effective procedure
{}
fs_status_name: HASHED_STRING
once function
{}
customize_agent_pool_runtime_1
effective procedure
{}
customize_agent_pool_runtime_2
effective procedure
{}
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
{}
agent_pool_has_only_one_case_for (launcher_type: TYPE, agent_result: TYPE): BOOLEAN
effective function
{}
agent_pool_call_in (buffer: STRING, mold_id: STRING, launcher_type: TYPE, agent_result: TYPE, agent_creation_type: TYPE)
effective procedure
{}
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.
arguments_cannot_be_dropped: BOOLEAN
effective function
True when arguments cannot be dropped.
cannot_drop_all: BOOLEAN
effective function
Result is True when something (target or one argument) cannot be dropped.
put_arguments (arguments_count: INTEGER_32)
effective procedure
{ANY}
Produce code to access to the whole effective arguments list.
put_ith_argument (index: INTEGER_32)
effective procedure
{ANY}
Produce code to access to the ith argument.
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.
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
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
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
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.
inside_twin (type: TYPE, cpy: RUN_FEATURE)
effective procedure
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.
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}
variant_check (type: TYPE, loop_variant: EXPRESSION)
effective procedure
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.
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.
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).
start_assignment (assignment: ASSIGNMENT_INSTRUCTION, type: TYPE)
effective procedure
Called just before compiling the left (written to) expression of an assignment
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.
end_assignment (assignment: ASSIGNMENT_INSTRUCTION, type: TYPE)
effective procedure
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.
put_c_file (tfr: TEXT_FILE_READ)
effective procedure
put_h_file (tfr: TEXT_FILE_READ)
effective procedure
recompilation_comment (lt: LIVE_TYPE)
effective procedure
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.
c_frame_descriptor_closure_in (type_mark: TYPE_MARK, buffer: STRING)
effective procedure
Update c_frame_descriptor_format accordingly (for closure locals and arguments).
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)
define_initialize_eiffel_runtime (rf3: RUN_FEATURE_3)
effective procedure
{}
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.
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.
path_h: STRING
effective function
{}
path_c: STRING
effective function
{}
path_make: STRING
effective function
{}
add_first_include (the_first_include: STRING)
effective procedure
{}
put_banner (output: TEXT_FILE_WRITE)
effective procedure
{}
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
{}
really_define_c_main (rf3: RUN_FEATURE_3)
effective procedure
{}
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.
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
se_ums_c_call_in (buffer: STRING, ms: MANIFEST_STRING)
effective procedure
manifest_string_trace (ms: MANIFEST_STRING, buffer: STRING): BOOLEAN
effective function
start_profile_class_invariant (t: LIVE_TYPE)
effective procedure
start_profile_agent_creation (ac: AGENT_CREATION)
effective procedure
start_profile_agent_switch (t: TYPE)
effective procedure
has_c_plus_plus: BOOLEAN
writable attribute
c_plus_plus_registered (native: NATIVE_C_PLUS_PLUS): BOOLEAN
effective function
c_plus_plus_register (native: NATIVE_C_PLUS_PLUS, rf: RUN_FEATURE)
effective procedure
c_registered (native: NATIVE_C): BOOLEAN
effective function
c_register (native: NATIVE_C, rf: RUN_FEATURE)
effective procedure
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.
c_init_closure_locals (local_var_list: LOCAL_VAR_LIST, type: TYPE)
effective procedure
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
{}
right_hand_side_can_only_be_void
effective procedure
{}
c_define_manifest_generic_functions
effective procedure
{}
c_define_manifest_generic_for (manifest_generic: MANIFEST_GENERIC)
effective procedure
{}
c_define_for_user_generic (manifest_generic: MANIFEST_GENERIC)
effective procedure
{}
c_define_for_native_array (native_array: TYPE)
effective procedure
{}
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.
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.
c_pre_compute_once_function (rf: RUN_FEATURE, bf: ANONYMOUS_FEATURE)
effective procedure
{}
once_flag (mark: STRING): BOOLEAN
effective function
{}
Flag used to avoid double C definition of globals C variables for once routines.
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.
c_define_o_result (rf: RUN_FEATURE)
effective procedure
c_test_o_flag (rf: RUN_FEATURE)
effective procedure
c_test_o_flag_recursion (rf: RUN_FEATURE)
effective procedure
c_test_o_flag_introspect (rf: RUN_FEATURE)
effective procedure
cecil_define
effective procedure
{}
cecil_define_users_for_file (cecil_file: CECIL_FILE)
effective procedure
{}
cecil_define_users_for_entry (cecil_file: CECIL_FILE, cecil_entry: CECIL_ENTRY)
effective procedure
{}
_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.
stack_top: CODE_CONTEXT
effective function
{}
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.
unused_contexts: ARRAY[FAST_ARRAY[CODE_CONTEXT]]
writable attribute
{}
reserve_context (code: INTEGER_32): CODE_CONTEXT
effective function
{}
free_context (ctx: CODE_CONTEXT)
effective procedure
{}
pop
effective procedure
{ANY}
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
push_precursor (type: TYPE, rf: RUN_FEATURE, args: EFFECTIVE_ARG_LIST)
effective procedure
stack_not_full: BOOLEAN
effective function
stack_overflow
effective procedure
{}
new_context (code: INTEGER_32): CODE_CONTEXT
effective function
{}
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}
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
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}
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}
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).%%%%%%%%
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}
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.
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.
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
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
{}