class SMART_EIFFEL
Summary
Singleton object to handle general purpose information about the Liberty Eiffel global compilation process. (This singleton is shared via the GLOBALS.smart_eiffel once function.)
Direct parents
Insert list: GLOBALS, LIBERTY_VERSION, SINGLETON
Class invariant
Overview
Features
{ANY}
{CLUSTER}
{}
{ANY}
{RESULT, ONCE_FUNCTION}
{MEMORY_HANDLER, CODE_PRINTER}
{PRETTY, PRETTY_PRINTER_HANDLER}
{FINDER, EIFFELDOC_SHORTER_CLASSDOC}
{CLASS_CHECKER}
{COMMAND_LINE_TOOLS}
{PRETTY, PRETTY_PRINTER_HANDLER}
{}
{ANY}
{COMMAND_LINE_TOOLS}
  • compile (back_end: CODE_PRINTER)
    Produce some code for all know pairs of root_class_name, root_procedure_name.
{}
{CODE_PRINTER}
{ANY}
{ASSIGNMENT_HANDLER}
{ANY}
{FEATURE_CALL, WRITABLE_ATTRIBUTE_NAME, MANIFEST_STRING_POOL, CREATION_CLAUSE, ADDRESS_OF, ONCE_FUNCTION, MANIFEST_GENERIC, BUILT_IN_EQ_NEQ, CECIL_ENTRY, NATIVE_BUILT_IN}
{LOCAL_VAR_LIST, ANONYMOUS_FEATURE}
{BASE_TYPE_CONSTANT}
{EXTERNAL_FUNCTION}
{ASSERTION}
{AGENT_CREATION, ADDRESS_OF}
{LIVE_TYPE}
{LIVE_TYPE, PROCEDURE_CALL_0}
{LIVE_TYPE, PROCEDURE_CALL_0, C_PRETTY_PRINTER}
{}
{NON_VOID_NO_DISPATCH}
{ONCE_ROUTINE_POOL}
{TYPE_MARK}
{AGENT_POOL, CREATE_SUPPORT, ASSIGNMENT, ASSIGNMENT_ATTEMPT, CREATE_WRITABLE, EFFECTIVE_ARG_LIST, CECIL_ENTRY}
{ANONYMOUS_FEATURE, RUN_FEATURE, ARGUMENT_NAME_REF, LOCAL_NAME_REF, RESULT, E_OLD, INSPECT_STATEMENT, AGENT_CREATION}
{ANONYMOUS_FEATURE, FEATURE_STAMP, RUN_FEATURE, C_LIVE_TYPE_COMPILER}
{}
{LIVE_TYPE}
{CODE_PRINTER}
{LOCAL_ARGUMENT_REF, ANONYMOUS_FEATURE, INTROSPECTION_HANDLER, THREAD_POOL}
{ANONYMOUS_FEATURE, INTROSPECTION_HANDLER, THREAD_POOL}
{}
{}
To get a TYPE:
{ANY}
{CLASS_TYPE_MARK}
{}
{INTROSPECTION_HANDLER}
{LIVE_TYPE}
{MANIFEST_GENERIC}
{TYPE}
{}
{CLASS_CHECK, MOCK}
{ID_PROVIDER}
{FEATURE_CALL}
{E_OLD}
{}
{RUN_FEATURE}
{}
{NATIVE_PLUG_IN}
{LIVE_TYPE}
{NATIVE_BUILT_IN}
{RUN_FEATURE_8, EXTERNAL_FUNCTION, GENERATOR_GENERATING_TYPE}
{CLUSTER}
{RUN_FEATURE}
{RUN_FEATURE, LIVE_TYPE}
{COMMAND_LINE_TOOLS}
{CODE_PRINTER}
{E_FUNCTION, CALL_INFIX_POWER}
{CODE_PRINTER, MEMORY_HANDLER}
  • is_at_run_time (a_class_name: STRING): BOOLEAN
    query to know if the type a_class_name is used at runtime The class name must be the one of a basic type because the cluster information is not appended
{}
{AGENT_CREATION}
{FUNCTION_CALL, PROCEDURE_CALL}
{}
{ACE}
{}
{}
{INSPECT_STATEMENT}
{C_PRETTY_PRINTER}
{LIVE_TYPE}
{PROCEDURE_CALL}
{FUNCTION_CALL}
{C_CODE_COMPILER}
{C_PRETTY_PRINTER}
{}
{}
{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:
{}
{ANY}
  • is_equal (other: SMART_EIFFEL): BOOLEAN
    Is other attached to an object considered equal to current object?
{}
{ANY}
{ANY}
{}
Implementation of ARGUMENTS (do not use directly):
{}
liberty_authors: STRING
is "C.ADRIAN, P.REDAELLI, R.MACK and others, see AUTHORS file"
constant attribute
{ANY}
liberty_dates: STRING
is "2011-2022"
constant attribute
{ANY}
copyright: ABSTRACT_STRING
once function
{ANY}
status: STATUS
once function
{ANY}
is_ready: BOOLEAN
effective function
{ANY}
Is all the live code already gathered
short_or_class_check_flag: BOOLEAN
writable attribute
{ANY}
True when command short or command class_check is running.
pretty_flag: BOOLEAN
writable attribute
{ANY}
True when command pretty is running.
no_id: BOOLEAN
writable attribute
{ANY}
True when the ids file has not to be read.
cluster_of (class_name: CLASS_NAME): CLUSTER
effective function
{ANY}
Retrieve the cluster of the class name.
If more than one class exists with the same name, the closest to where the class name is written is returned.
require
  • class_name /= Void
ensure
  • Result = Void implies class_name.allow_missing
cluster_named (cluster_name: STRING): CLUSTER
effective function
{ANY}
Retrieve the cluster by its name
require
  • not cluster_name.is_empty
  • string_aliaser.registered_one(cluster_name)
ensure
  • Result /= Void implies Result.name.is_equal(cluster_name)
class_text (class_name: CLASS_NAME): CLASS_TEXT
effective function
{ANY}
Retrieve the corresponding memorized one or launch the eiffel_parser if the class_name class is not yet loaded.
When the class_name.allow_missing flag is True, no error occurs even when the class is not found. (See also loaded_class_text.)
require
  • class_name /= Void
ensure
  • Result = Void implies class_name.allow_missing
loaded_class_text (class_name: CLASS_NAME): CLASS_TEXT
effective function
{ANY}
Retrieve the corresponding memorized one if already loaded.
Do not launch the eiffel_parser if the class_name class is not yet loaded. (See also class_text.)
require
  • class_name /= Void
class_text_in_cluster (class_name: CLASS_NAME, cluster: CLUSTER): CLASS_TEXT
effective function
{ANY}
Retrieve the corresponding memorized one or launch the eiffel_parser if the class_name class is not yet loaded.
When the class_name.allow_missing` flag is True, no error occurs even when the class is not found. `cluster is the client cluster to start the search from. (See also class_text, loaded_class_text.)
require
  • class_name /= Void
ensure
  • Result = Void implies class_name.allow_missing
generating_type_used: BOOLEAN
writable attribute
{ANY}
When ANY generating_type is used.
generator_used: BOOLEAN
writable attribute
{ANY}
When ANY generator is used.
deep_features_used: BOOLEAN
writable attribute
{ANY}
When deep_twin or is_deep_equal support is necessary.
thread_used: BOOLEAN
writable attribute
{ANY}
When threading support is necessary (i.e. threads are actually started using THREAD_CONTEXT.run).
accumulating_type: TYPE
effective function
{ANY}
Service provided for debugging purpose only
ensure
  • debugging_only: Result /= Void
unknown_feature_fatal_error (target_expression: EXPRESSION, target_type: TYPE, fn: FEATURE_NAME)
effective procedure
{ANY}
(This feature is placed here to standardize all error messages of this kind.)
require
  • target_expression /= Void
  • target_type /= Void
  • fn /= Void
analyze_class (cn: CLASS_NAME, c: CLUSTER): CLASS_TEXT
effective function
free_inline_memo: FAST_ARRAY[INLINE_MEMO]
once function
{}
get_inline_memo: INLINE_MEMO
effective function
{ANY}
ensure
  • Result.cleared
dispose_inline_memo (im: INLINE_MEMO)
effective procedure
{ANY}
require
  • im /= Void
vffd7_fatal_error (sp: POSITION)
effective procedure
root_procedure: RUN_FEATURE_3
writable attribute
The root procedure of the system to compile.
class_text_for_pretty (file_path: STRING, class_name: CLASS_NAME): CLASS_TEXT
effective function
require
  • (create {FILE_TOOLS}).is_readable(file_path)
  • class_name /= Void
remove_loaded_class (ct: CLASS_TEXT)
effective procedure
Removed the already loaded ct in order to allow pretty to parse again the generated file to check that the newly created file is syntactically correct.
require
  • ct /= Void
find_paths_for (class_name: HASHED_STRING): FAST_ARRAY[CLASS_TEXT]
effective function
Finds the path to any class having the given class_name
require
  • class_name /= Void
ensure
  • Result /= Void
effective procedure
Hard-coded ordered list of parent tuples
set_short_or_class_check_flag
effective procedure
set_pretty_flag
effective procedure
set_no_id
effective procedure
{}
class_text_count: INTEGER_32
effective function
{ANY}
Total number of class text actually loaded.
compile (back_end: CODE_PRINTER)
effective procedure
Produce some code for all know pairs of root_class_name, root_procedure_name.
run_front_end
effective procedure
{}
Code parsing
require
run_collect
effective procedure
{}
Code collect
require ensure
run_adapt
effective procedure
{}
Code simplification and adaptation
require
run_back_end (back_end: CODE_PRINTER)
effective procedure
{}
Code simplification and generation
require
customize_runtime
effective procedure
run_features: FAST_ARRAY[RUN_FEATURE]
writable attribute
All the known features just prior the generation itself
class_invariants: FAST_ARRAY[LIVE_TYPE]
writable attribute
All the known types having an invariant during the generation
agent_creations: FAST_ARRAY[AGENT_CREATION]
writable attribute
All the known agent creations during the generation
agent_switches: FAST_ARRAY[TYPE]
writable attribute
All the known agent switches during the generation
type_dictionary: DICTIONARY[TYPE, HASHED_STRING]
once function
When looking for a TYPE using it's name (ie. FOO[BAR] is stored at key with name "FOO[BAR]").
generic_type_dictionary: DICTIONARY[HASHED_STRING, HASHED_STRING]
once function
Helper dictionary for generic types shrinking
magic_count: INTEGER_32
writable attribute
{ANY}
Grow each time a new run class is added, each time a new class loaded, each time a new feature is checked, each time another expression is optimized, etc.
... Thus when magic_count stops growing, we are really ready :-).
magic_count_increment
effective procedure
{ANY}
simplify_done: BOOLEAN
writable attribute
After optimizations, some code may be turned into invalid eiffel code.
Has to be very uncommon.
live_type_map: TRAVERSABLE[LIVE_TYPE]
effective function
{ANY}
The Result is not Void when fs is actually a function (see ensure).
require
  • fs.has_anonymous_feature_for(type)
ensure
  • fs.anonymous_feature(type).result_type /= Void implies Result = fs.anonymous_feature(type).result_type.resolve_in(type)
collect_local_expanded (type: TYPE)
effective procedure
Make live the given type.
require
  • type.is_expanded
ensure
  • type.live_type /= Void
collect_constant (type: TYPE)
effective procedure
Make live the given type (of a constant)
require
  • type /= Void
ensure
  • type.live_type /= Void
collect_external (type: TYPE)
effective procedure
Make live the given type (of an external function)
require
  • type /= Void
ensure
  • type.live_type /= Void
collect_assertion (type: TYPE)
effective procedure
Make live the given type (of an assertion)
require
  • type.is_boolean
ensure
  • type.live_type /= Void
collect_create (type: TYPE)
effective procedure
require
  • type /= Void
ensure
  • type.live_type.at_run_time
collect_generic (type: TYPE)
effective procedure
require
  • type /= Void
ensure
  • type.live_type /= Void
collect_se_atexit (type: TYPE)
effective procedure
require ensure
se_atexit_stamp: FEATURE_STAMP
writable attribute
se_atexit_id: INTEGER_32
writable attribute
collected_external_functions: FAST_ARRAY[NON_VOID_NO_DISPATCH]
once function
{}
collect_external_function (non_void_no_dispatch: NON_VOID_NO_DISPATCH, fs: FEATURE_STAMP, type: TYPE)
effective procedure
require
  • non_void_no_dispatch /= Void
  • type /= Void
  • fs /= Void
collect_precomputable (type: TYPE, fs: FEATURE_STAMP)
effective procedure
require
  • type /= Void
  • fs /= Void
long_type_name (type_name: HASHED_STRING, type_cluster: CLUSTER): HASHED_STRING
effective function
require
  • type_name /= Void
  • type_cluster /= Void
ensure
  • Result /= Void
Make live the given type.
require
  • type /= Void
ensure
  • definition: Result = type.live_type
  • is_alive: type.live_type /= Void
    hence: Result /= Void

require
context_feature_stack: STACK[ANONYMOUS_FEATURE]
once function
{}
We really need a stack.
As an example, it is necessary to follow the calling graph during collect.
is_tagged (lt: LIVE_TYPE): BOOLEAN
effective function
require
weak_reference_used: BOOLEAN
effective function
Is the WEAK_REFERENCE class used?
This function is conservative: when it returns False, you are guaranteed that no WEAK_REFERENCE is used. There is no guarantee when it returns True.
require

specializing_feature_local_var_list: LOCAL_VAR_LIST
writable attribute
specializing_closure_local_var_lists: FAST_ARRAY[LOCAL_VAR_LIST]
writable attribute
specializing_feature_arguments_list: FORMAL_ARG_LIST
writable attribute
specializing_closure_arguments_lists: FAST_ARRAY[FORMAL_ARG_LIST]
writable attribute
set_specializing_feature_variables (lvl: LOCAL_VAR_LIST, clvl: FAST_ARRAY[LOCAL_VAR_LIST])
effective procedure
set_specializing_feature_arguments (fal: FORMAL_ARG_LIST, cfal: FAST_ARRAY[FORMAL_ARG_LIST])
effective procedure
type_to_be_created: HASHED_STRING
writable attribute
{}
create_type (static_type: TYPE_MARK, allow_raw_class_name: BOOLEAN): TYPE
effective function
{}
Create a type.
Type creation is locked until register_type has been called.
require ensure
lock_type_creation (t: HASHED_STRING): BOOLEAN
effective function
{}
ensure
  • Result
type_any_memory: TYPE
writable attribute
{}
type_boolean_memory: TYPE
writable attribute
{}
type_character_memory: TYPE
writable attribute
{}
type_string_memory: TYPE
writable attribute
{}
type_native_array_character_memory: TYPE
writable attribute
{}
type_unicode_string_memory: TYPE
writable attribute
{}
type_pointer_memory: TYPE
writable attribute
{}
type_integer_8_memory: TYPE
writable attribute
{}
type_integer_16_memory: TYPE
writable attribute
{}
type_integer_32_memory: TYPE
writable attribute
{}
type_integer_64_memory: TYPE
writable attribute
{}
type_natural_8_memory: TYPE
writable attribute
{}
type_natural_16_memory: TYPE
writable attribute
{}
type_natural_32_memory: TYPE
writable attribute
{}
type_natural_64_memory: TYPE
writable attribute
{}
type_real_32_memory: TYPE
writable attribute
{}
type_real_64_memory: TYPE
writable attribute
{}
type_real_extended_memory: TYPE
writable attribute
{}
type_any: TYPE
effective function
{ANY}
ensure
type_boolean: TYPE
effective function
{ANY}
ensure
type_character: TYPE
effective function
{ANY}
ensure
type_string: TYPE
effective function
{ANY}
ensure
type_native_array_character: TYPE
effective function
{ANY}
ensure
type_unicode_string: TYPE
effective function
{ANY}
require ensure
type_pointer: TYPE
effective function
{ANY}
ensure
type_integer_8: TYPE
effective function
{ANY}
ensure
type_integer_16: TYPE
effective function
{ANY}
ensure
type_integer_32: TYPE
effective function
{ANY}
ensure
type_integer_64: TYPE
effective function
{ANY}
ensure
type_natural_8: TYPE
effective function
{ANY}
ensure
type_natural_16: TYPE
effective function
{ANY}
ensure
type_natural_32: TYPE
effective function
{ANY}
ensure
type_natural_64: TYPE
effective function
{ANY}
ensure
type_internals_handler_if_exists: TYPE
effective function
{ANY}
type_real_32: TYPE
effective function
{ANY}
ensure
type_real_64: TYPE
effective function
{ANY}
ensure
type_real_extended: TYPE
effective function
{ANY}
ensure
unlock_type_creation (t: HASHED_STRING): BOOLEAN
effective function
{ANY}
ensure
  • Result
has_type (static_type: TYPE_MARK): BOOLEAN
effective function
{ANY}
require
  • static_type.is_static
get_type (static_type: TYPE_MARK, allow_raw_class_name: BOOLEAN): TYPE
effective function
{ANY}
require
  • static_type.is_static
ensure
tuple_class_not_found_fatal_error (class_name: CLASS_NAME)
effective procedure
{ANY}
Because there is a special trick for TUPLE related classes.
require
  • class_name.is_tuple_related
get_type_for_non_generic (non_generic_static_type: TYPE_MARK, allow_raw_class_name: BOOLEAN): TYPE
effective function
Just an optimized version of get_type.
require
  • non_generic_static_type.is_static
  • not non_generic_static_type.is_generic
ensure
  • Result = get_type(non_generic_static_type, allow_raw_class_name)
feature_stamp_of (class_name: STRING, feature_name: STRING): FEATURE_STAMP
effective function
{}
require ensure
  • Result /= Void
feature_stamp (type: TYPE, feature_name: STRING): FEATURE_STAMP
effective function
require ensure
  • Result /= Void
memory_dispose_stamp: FEATURE_STAMP
once function
Feature stamp of {DISPOSABLE}.dispose
require ensure
  • Result /= Void
manifest_creation_name: FEATURE_NAME
once function
Feature name of {ANY}.manifest_creation
ensure
  • Result /= Void
register_type (t: TYPE)
effective procedure
require
get_constraint_ancestor (generic_type: TYPE, rank: INTEGER_32): TYPE
effective function
{}
require
very_last_information
effective procedure
id_extra_information (tfw: TEXT_FILE_WRITE, name: HASHED_STRING, cluster: CLUSTER)
effective procedure
require
  • cluster /= Void
covariance_check (call_site: POSITION, up_rf: RUN_FEATURE, run_time_set: RUN_TIME_SET)
effective procedure
require
  • not call_site.is_unknown
  • up_rf.arguments.count >= 1
  • not run_time_set.is_empty
register_old (e_old: E_OLD)
effective procedure
require
  • e_old /= Void
old_list_stack: FAST_ARRAY[FAST_ARRAY[E_OLD]]
once function
{}
Non Void when some E_OLD have been gathered.
old_list_stack_push
effective procedure
old_list_stack_pop: FAST_ARRAY[E_OLD]
effective function
collected_plug_in: SET[NATIVE_PLUG_IN]
once function
{}
register_plug_in (native_plug_in: NATIVE_PLUG_IN)
effective procedure
require
  • native_plug_in /= Void
set_deep_features_used
effective procedure
set_thread_used
effective procedure
set_generating_type_used
effective procedure
set_generator_used
effective procedure
parse_include (include_name: STRING)
effective procedure
require
  • include_name /= Void
register_run_feature (rf: RUN_FEATURE)
effective procedure
require ensure
registered (rf: RUN_FEATURE): BOOLEAN
effective function
initialize_any_tuple
once procedure
Some tools have to call this initialize_any_tuple once routine.
Actually, initialize_any_tuple forces the creation of ANY and TUPLE first. Note, this is not in the creation of smart_eiffel itself because, not all tools are supposed to load Eiffel classes.
register_class_invariant (t: LIVE_TYPE)
effective procedure
register_agent_creation (ac: AGENT_CREATION)
effective procedure
register_agent_switch (t: TYPE)
effective procedure
simplify_integer_infix_power (call_site: POSITION, target: EXPRESSION, exponent: EXPRESSION): INTEGER_CONSTANT
effective function
Static simplification of {INTEGER_GENERAL}.infix "^" is here to be shared for static_simplify and simplify.
is_at_run_time (a_class_name: STRING): BOOLEAN
effective function
query to know if the type a_class_name is used at runtime The class name must be the one of a basic type because the cluster information is not appended
require
agent_creation_error_trap: STACK[AGENT_CREATION]
once function
{}
set_agent_creation_error_trap (agent_creation: AGENT_CREATION)
effective procedure
require
  • agent_creation /= Void
clear_agent_creation_error_trap (agent_creation: AGENT_CREATION)
effective procedure
require
  • agent_creation /= Void
try_agent_creation_error_trap (function_call: FUNCTION_CALL): BOOLEAN
effective function
code_accumulator: CODE_ACCUMULATOR
frozen
once function
{}
root_class_text (root_class_name: STRING): CLASS_TEXT
effective function
{ACE}
cwd_cluster: CLUSTER
once function
{}
echo_magic_count (msg: STRING)
effective procedure
{}
require
  • msg /= Void
do_front_end (root_class_name: STRING, root_procedure_name: STRING)
effective procedure
{}
Get started to compile using creation procedure root_procedure_name of class text root_class_name.
require
  • not root_class_name.is_empty
  • not root_procedure_name.is_empty
ensure
do_collect (root_class_name: STRING, root_procedure_name: STRING)
effective procedure
{}
require
do_adapt (root_class_name: STRING, root_procedure_name: STRING)
effective procedure
{}
require
do_back_end (back_end: CODE_PRINTER, root_class_name: STRING, root_procedure_name: STRING)
effective procedure
{}
require
collect_from_root (root_type: TYPE, root_feature: FEATURE_STAMP)
effective procedure
{}
do_one_collect_cycle
effective procedure
{}
collect_deep_features
effective procedure
{}
safety_check
effective procedure
{}
Start final whole system analysis to decide whether this system is safe or not.
require ensure
  • status.is_safety_checking
  • ace.safety_check implies status.safety_check_done
monomorphic_procedure_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
monomorphic_function_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
expanded_target_procedure_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
expanded_target_function_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
polymorphic_procedure_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
polymorphic_function_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
void_target_procedure_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
void_target_function_call_count: INTEGER_32
writable attribute
{}
Updated during inline_dynamic_dispatch.
polymorphic_distribution: ARRAY[INTEGER_32]
writable attribute
{}
About the "inspect" statements used to implement dynamic dispatch.
The index of the ARRAY is used to indicate the number of branches of the inspect. The corresponding content in the ARRAY indicate the number of call sites. As an example polymorphic_distribution.item(50) = 4 indicates that we have 4 polymorphic call sites implemented with a 50 branches inspect.
inspect_when_merge_counter: INTEGER_32
writable attribute
{}
Total number of merged when clauses in "inspect" statements.
inline_dynamic_dispatch (root_type: TYPE, root_fn: FEATURE_NAME)
effective procedure
{}
require ensure
  • status.inlining_dynamic_dispatch_done
simplify_and_optimize (root_type: TYPE, root_feature: FEATURE_STAMP)
effective procedure
{}
require
set_simplify_done
effective procedure
{}
ensure
simplify
effective procedure
{}
require
contextual_simplify
effective procedure
{}
require
inspect_when_merge_counter_increment
effective procedure
echo_polymorphic_inspect_distribution (step_tag: STRING)
effective procedure
register_live_type (live_type: LIVE_TYPE)
effective procedure
require
  • live_type /= Void
monomorphic_procedure_call_count_increment
effective procedure
expanded_target_procedure_call_count_increment
effective procedure
polymorphic_procedure_call_count_increment (nb_branches: INTEGER_32)
effective procedure
require
  • nb_branches >= 2
void_target_procedure_call_count_increment
effective procedure
monomorphic_function_call_count_increment
effective procedure
expanded_target_function_call_count_increment
effective procedure
polymorphic_function_call_count_increment (nb_branches: INTEGER_32)
effective procedure
require
  • nb_branches >= 2
void_target_function_call_count_increment
effective procedure
update_polymorphic_distribution (nb_branches: INTEGER_32)
effective procedure
require
  • nb_branches >= 2
sort_live_type_map
effective procedure
ensure
show_live_types
effective procedure
live_type_map_: FAST_ARRAY[LIVE_TYPE]
writable attribute
{}
live_type_sorter: COLLECTION_SORTER[LIVE_TYPE]
writable attribute
{}
_inline_agent1 (cn: CLASS_NAME): BOOLEAN
frozen
effective function
{}
_inline_agent2 (ct: CLASS_TEXT, tuple_index: INTEGER_32, pl: FAST_ARRAY[TYPE])
frozen
effective procedure
{}
require
  • ct.name.is_tuple_related
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}
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
{}
is_equal (other: SMART_EIFFEL): BOOLEAN
effective function
{ANY}
Is other attached to an object considered equal to current object?
require
  • other /= Void
ensure
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
is_real_singleton: BOOLEAN
effective function
{}
ensure
  • assertion_check_only: Result
singleton_memory_pool: HASHED_DICTIONARY[POINTER, STRING]
once function
{}
This pool is unique in the whole system.
A memory is kept for each singleton type (type, not class) in the system.
current_is_not_an_expanded_type: BOOLEAN
effective function
{}
Check that the dynamic type of the SINGLETON is not an expanded type.
liberty_release: STRING
is "2022.dev (preparing Glenn Curtiss)"
constant attribute
{ANY}
short_copyright: ABSTRACT_STRING
once function
{ANY}
print_version
effective procedure
{ANY}
argument_count: INTEGER_32
effective function
{ANY}
Number of arguments given to command that started system execution (command name does not count).
ensure
  • Result >= 0
argument (i: INTEGER_32): STRING
effective function
{ANY}
i th argument of command that started system execution Gives the command name if i is 0.
require ensure
  • Result /= Void
command_name: STRING
effective function
{ANY}
command_arguments: FAST_ARRAY[STRING]
frozen
once function
{}
Give access to arguments command line including the command name at index 0.
This is a once function, so you can modify command-line arguments! (NOTE: just be sure not to remove the first argument, although you may change it)
ensure
  • not Result.is_empty
se_argc: INTEGER_32
{}
To implement command_arguments
se_argv (i: INTEGER_32): STRING
{}
To implement command_arguments