deferred class ONCE_ROUTINE
Summary
Direct parents
Inherit list: EFFECTIVE_ROUTINE, HASHABLE
Known children
Inherit list: ONCE_FUNCTION, ONCE_PROCEDURE
Class invariant
Overview
Features
{ANY}
{}
{ANY}
{FEATURE_ACCUMULATOR}
{ANONYMOUS_FEATURE_MIXER}
{FEATURE_STAMP, PRECURSOR_CALL}
{FEATURE_STAMP, LIVE_TYPE, PRECURSOR_CALL}
  • simplify (type: TYPE): ONCE_ROUTINE
    May return Current or a simplified version of Current.
{EFFECTIVE_ROUTINE}
{}
{}
{ANONYMOUS_FEATURE}
{}
{}
{ANY}
{EIFFEL_PARSER}
{ANONYMOUS_FEATURE_MIXER}
{E_ROUTINE}
{}
{ANY}
{CALL_0}
{CALL_1}
{FUNCTION_CALL_N}
{PROCEDURE_CALL_0}
{PROCEDURE_CALL_1}
{PROCEDURE_CALL_N}
{LIVE_TYPE, PRECURSOR_CALL}
{}
{FEATURE_STAMP, LIVE_TYPE, PRECURSOR_CALL}
{FEATURE_STAMP, LIVE_TYPE}
{}
{ANONYMOUS_FEATURE, ANONYMOUS_FEATURE_MIXER, ANONYMOUS_FEATURE_VISITOR, FEATURE_CALL, FEATURE_NAME_LIST, HIDDEN_EXPRESSION_DETECTOR, RUN_FEATURE}
  • permissions: CLIENT_LIST
    Authorized clients list computed from the corresponding feature clause in the base definition class and export items in inherit clauses . This list is semantic.
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE}
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE_MIXER}
{ANONYMOUS_FEATURE}
{LIVE_TYPE, TYPE, PRECURSOR_CALL}
{}
{ANONYMOUS_FEATURE, FEATURE_TEXT}
{FEATURE_ACCUMULATOR}
{FEATURE_TEXT}
{ANY}
{FEATURE_TEXT}
{}
{RUN_FEATURE}
{}
{}
{}
{ANY}
{ANY}
{}
{EIFFEL_PARSER}
{INDEXINGABLE}
{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: ONCE_ROUTINE): BOOLEAN
    Is other attached to an object considered equal to current object?
hash_code: INTEGER_32
effective function
{ANY}
The hash-code value of Current.
ensure
  • good_hash_value: Result >= 0
pretty_print_once_or_do (indent_level: INTEGER_32)
effective procedure
{}
is_deferred: BOOLEAN
is False
constant attribute
{ANY}
Is it a deferred feature ?
rescue_compound_in (type: TYPE): INSTRUCTION
frozen
effective function
{ANY}
rescue_compound: INSTRUCTION
writable attribute
{ANY}
Not Void if any.
set_rescue_compound (rc: INSTRUCTION)
effective procedure
{ANY}
require
  • not eiffel_parser.no_rescue
ensure
  • rescue_compound = rc
has_been_specialized: BOOLEAN
effective function
{ANY}
ensure
  • Result
use_current (type: TYPE): BOOLEAN
effective function
{ANY}
require
  • smart_eiffel.status.collecting_done
  • type /= Void
same_body_as (other: ANONYMOUS_FEATURE): BOOLEAN
frozen
effective function
specialize_body_in (new_type: TYPE, can_twin: BOOLEAN): ONCE_ROUTINE
effective function
require
  • new_type /= Void
ensure
  • not can_twin implies Result = Current
  • Result.has_been_specialized
specialize_body_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE, can_twin: BOOLEAN): ONCE_ROUTINE
effective function
require
  • parent_type /= Void
  • parent_edge /= Void
  • new_type /= Void
  • has_been_specialized
ensure
  • not can_twin implies Result = Current
  • has_been_specialized
  • Result.has_been_specialized
specialize_and_check (type: TYPE): ONCE_ROUTINE
effective function
require
  • has_been_specialized
  • not smart_eiffel.status.is_specializing
ensure
  • has_been_specialized
  • Result.has_been_specialized
simplify (type: TYPE): ONCE_ROUTINE
effective function
May return Current or a simplified version of Current.
require
  • type /= Void
  • not smart_eiffel.pretty_flag
  • not smart_eiffel.short_or_class_check_flag
  • smart_eiffel.status.collecting_done
  • ace.boost1 or ace.boost2
ensure
  • Result /= Void
  • Result /= Current = smart_eiffel.magic_count > old smart_eiffel.magic_count
collect_body (type: TYPE)
effective procedure
{}
require
  • type /= Void
effective procedure
{}
Note: the add_into_shared is the most common behavior.
require
  • feature_text = ft
use_current_state: INTEGER_32
writable attribute
{}
computed_true: INTEGER_32
is 12
constant attribute
{}
computed_false: INTEGER_32
is 13
constant attribute
{}
not_computed: INTEGER_32
is 14
constant attribute
{}
in_computation: INTEGER_32
is 15
constant attribute
{}
pretty_print_routine_body (indent_level: INTEGER_32)
effective procedure
{}
pretty_print_rescue (indent_level: INTEGER_32)
effective procedure
{}
make_effective_routine (fa: FORMAL_ARG_LIST, om: MANIFEST_STRING, hc: COMMENT, ra: REQUIRE_ASSERTION, lv: LOCAL_VAR_LIST, rb: INSTRUCTION, rt: EXPRESSION, c: BOOLEAN)
effective procedure
{}
ensure
left_most_current_direct_call_0_sequence (type: TYPE, e: EXPRESSION): CALL_0
effective function
{}
Is e a direct inlinable sequence of CALL_0 with a left-most Current?
Examples: Current.foo
          Current.foo.bar
          Current.foo.bar.zoo
This function also check that each call is a direct non-void call as well as some
special situation when there is a user's expanded type in the way.
ensure
  • Result = Void or else Result = e
left_most_current_direct_call_0_sequence_inline (type: TYPE, call_0: CALL_0, target_type: TYPE, target: EXPRESSION): CALL_0
effective function
{}
require ensure
  • Result /= Void
no_rescue_no_local_expanded_in (type: TYPE): BOOLEAN
effective function
remove_first_redundant_initialisation (type: TYPE, rb: INSTRUCTION): INSTRUCTION
effective function
{}
The goal is to remove the first assignment of rb when this assignment (re)set the default value to some local (or Result).
require
inline_dynamic_dispatch_ (code_accumulator: CODE_ACCUMULATOR, type: TYPE)
effective procedure
{}
arguments: FORMAL_ARG_LIST
writable attribute
{ANY}
Arguments if any.
obsolete_mark: MANIFEST_STRING
writable attribute
{ANY}
The obsolete mark if any.
end_comment: COMMENT
writable attribute
{ANY}
is_attribute: BOOLEAN
is False
constant attribute
{ANY}
is_external: BOOLEAN
effective function
{ANY}
local_vars: LOCAL_VAR_LIST
writable attribute
{ANY}
routine_body: INSTRUCTION
writable attribute
{ANY}
routine_then: EXPRESSION
writable attribute
{ANY}
has_closures: BOOLEAN
writable attribute
{ANY}
pretty (indent_level: INTEGER_32, is_inline_agent: BOOLEAN)
effective procedure
{ANY}
set_end_comment (ec: COMMENT)
effective procedure
require( ) or else (
    • False
) ensure
specialize_signature_in (new_type: TYPE): ONCE_ROUTINE
effective function
require
  • new_type /= Void
ensure
  • Result /= Void
specialize_signature_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): ONCE_ROUTINE
effective function
require
  • parent_type /= Void
  • parent_edge /= Void
  • new_type /= Void
ensure
  • Result /= Void
set_arguments (args: FORMAL_ARG_LIST, cfal: FAST_ARRAY[FORMAL_ARG_LIST])
effective procedure
make_routine (fa: FORMAL_ARG_LIST, om: MANIFEST_STRING, hc: COMMENT, ra: REQUIRE_ASSERTION, c: BOOLEAN)
effective procedure
{}
feature_text: FEATURE_TEXT
writable attribute
{ANY}
Back-link to the corresponding written one.
class_text: CLASS_TEXT
effective function
{ANY}
The class where the feature is really written.
ensure
  • Result /= Void
clients: CLIENT_LIST
effective function
{ANY}
Authorized clients list of the corresponding feature clause in the base definition class.
This list is purely syntactic. Also see permissions.
effective function
{ANY}
All the names of the feature.
ensure
  • Result /= Void
result_type: TYPE_MARK
deferred function
{ANY}
Result type if any.
header_comment: COMMENT
writable attribute
{ANY}
Header comment for a routine or following comment for an attribute.
require_assertion: REQUIRE_ASSERTION
writable attribute
{ANY}
Not Void if any.
ensure_assertion: ENSURE_ASSERTION
writable attribute
{ANY}
Not Void if any.
sedb_trace_before_exit: POSITION
frozen
effective function
{ANY}
class_text_name: CLASS_NAME
frozen
effective function
{ANY}
Name of the class where the feature is really written.
first_name: FEATURE_NAME
frozen
effective function
{ANY}
ensure
  • Result /= Void
start_position: POSITION
frozen
effective function
{ANY}
assigner: FEATURE_NAME
writable attribute
{ANY}
If this feature can be assigned to, the assigner feature name.
obsolete_warning_check (type: TYPE, caller: POSITION)
frozen
effective procedure
{ANY}
set_header_comment (hc: COMMENT)
frozen
effective procedure
{ANY}
ensure
is_once_function: BOOLEAN
frozen
effective function
{ANY}
(Just to be able to write assertions.)
side_effect_free (target_type: TYPE): BOOLEAN
deferred function
{ANY}
Assuming that it is a final call (See comment in code.)
require
  • target_type.direct_non_void_call_flag
empty_body_side_effect_free_effective_routine (type: TYPE): BOOLEAN
frozen
effective function
{ANY}
Assuming that it is a final call (See comment in code.)
inline_expression_0 (type: TYPE, feature_stamp: FEATURE_STAMP, call_site: POSITION, target_type: TYPE, target: EXPRESSION, return_type: TYPE): INLINE_MEMO
effective function
require
  • ace.boost
  • type /= Void
  • Current = feature_stamp.anonymous_feature(target_type)
  • target /= Void
  • return_type = result_type.resolve_in(target_type)
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_expression_holder
inline_expression_1 (type: TYPE, feature_stamp: FEATURE_STAMP, call_site: POSITION, target_type: TYPE, target: EXPRESSION, arg: EXPRESSION, return_type: TYPE): INLINE_MEMO
effective function
require
  • ace.boost
  • type /= Void
  • Current = feature_stamp.anonymous_feature(target_type)
  • target /= Void
  • arg /= Void
  • return_type = result_type.resolve_in(target_type)
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_expression_holder
inline_expression_n (type: TYPE, feature_stamp: FEATURE_STAMP, target_type: TYPE, target: EXPRESSION, args: EFFECTIVE_ARG_LIST, return_type: TYPE): INLINE_MEMO
effective function
require
  • ace.boost
  • type /= Void
  • Current = feature_stamp.anonymous_feature(target_type)
  • target /= Void
  • args.count >= 2
  • return_type = result_type.resolve_in(target_type)
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_expression_holder
inline_instruction_0 (type: TYPE, target_type: TYPE, target: EXPRESSION): INLINE_MEMO
effective function
require
  • ace.boost
  • type /= Void
  • target /= Void
  • target_type /= Void
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_instruction_holder
inline_instruction_1 (type: TYPE, target_type: TYPE, target: EXPRESSION, arg: EXPRESSION): INLINE_MEMO
effective function
require
  • ace.boost
  • type /= Void
  • target /= Void
  • target_type /= Void
  • arg /= Void
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_instruction_holder
inline_instruction_n (type: TYPE, target_type: TYPE, target: EXPRESSION, args: EFFECTIVE_ARG_LIST): INLINE_MEMO
effective function
Attempt to inline the corresponding procedure call (see exportation).
If it is possible to inline, the Result is not Void and the Result holds the corresponding CODE . (In order to recycle INLINE_MEMO objects, see also get_inline_memo and dispose_inline_memo of smart_eiffel.)
require
  • ace.boost
  • type /= Void
  • target /= Void
  • args.count >= 2
  • target_type /= Void
ensure
  • Result /= Void = smart_eiffel.magic_count > old smart_eiffel.magic_count
  • Result /= Void implies Result.is_instruction_holder
inline_dynamic_dispatch (code_accumulator: CODE_ACCUMULATOR, type: TYPE)
frozen
effective procedure
This should not be done twice.
Assume the twin is made by the caller.
require
inline_dynamic_dispatch_flag: BOOLEAN
writable attribute
{}
inline_dynamic_dispatch_must_be_done_once: BOOLEAN
frozen
effective function
{}
contextual_simplify (type: TYPE): ANONYMOUS_FEATURE
effective function
May return Current or a simplified version of Current.
|*** Future optimization mode. To be implemented
require ensure
brand_new_run_feature_for (t: TYPE, fn: FEATURE_NAME, is_precursor: BOOLEAN): RUN_FEATURE
frozen
effective function
TODO: translate comment
require
  • t /= Void
ensure
  • not is_precursor implies name_check(Result.name, t.name_of(Current))
  • is_precursor implies t.name_of(Current) = Void
new_run_feature_for (t: TYPE, fn: FEATURE_NAME): RUN_FEATURE
deferred function
{}
require
  • t /= Void
name_check (n1: FEATURE_NAME, n2: FEATURE_NAME): BOOLEAN
effective function
{}
Authorized clients list computed from the corresponding feature clause in the base definition class and export items in inherit clauses . This list is semantic.
 Also see clients.
specialize_permissions_in (new_type: TYPE): ONCE_ROUTINE
effective function
require
  • new_type /= Void
specialize_permissions_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): ONCE_ROUTINE
effective function
require
  • parent_type /= Void
  • parent_edge /= Void
  • new_type /= Void
ensure
  • Result /= Void
merge_signature_thru (other: ANONYMOUS_FEATURE, parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE, can_twin: BOOLEAN): ANONYMOUS_FEATURE
frozen
effective function
Merge the Current signature using the given insert/inherit path.
Signature has to be identical with the one given in other and the result has signature from Current or other based on inserted path.
require
  • other /= Void
  • parent_type /= Void
  • parent_edge /= Void
  • new_type /= Void
  • error_handler.is_empty
valid_redefinition (other: ANONYMOUS_FEATURE, parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): BOOLEAN
frozen
effective function
Test if Current is a valid redefinition of other through the specified inherit way.
require
  • other /= Void
  • parent_type /= Void
  • new_type /= Void
  • Current /= other
  • error_handler.is_empty
same_signature (other: ANONYMOUS_FEATURE, into: TYPE): BOOLEAN
frozen
effective function
True when Current and other have the same signature when both are interpreted in type into.
This property is required by the join rule.
require ensure
specialize_require_in (type: TYPE): ONCE_ROUTINE
effective function
ensure
specialize_require_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): ONCE_ROUTINE
effective function
require ensure
change_require (req: REQUIRE_ASSERTION, can_twin: BOOLEAN): ONCE_ROUTINE
frozen
effective function
require
  • req /= Void
ensure
  • not can_twin implies Result = Current
specialized_require_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): REQUIRE_ASSERTION
effective function
ensure
  • Result /= Void implies Result.has_been_specialized
specialize_ensure_in (type: TYPE, can_twin: BOOLEAN): ONCE_ROUTINE
effective function
ensure
specialize_ensure_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, type: TYPE, can_twin: BOOLEAN): ONCE_ROUTINE
effective function
require ensure
change_ensure (ens: ENSURE_ASSERTION, can_twin: BOOLEAN): ONCE_ROUTINE
frozen
effective function
require
  • ens /= Void
ensure
  • not can_twin implies Result = Current
specialized_ensure_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, type: TYPE): ENSURE_ASSERTION
effective function
ensure
  • Result /= Void implies Result.has_been_specialized
specialize_permissions (export_clause: CLIENT_LIST, can_twin: BOOLEAN): ONCE_ROUTINE
effective function
require
  • export_clause /= Void
ensure
  • Result /= Void
  • not can_twin implies Result = Current
set_permissions (perm: CLIENT_LIST)
effective procedure
collect (t: TYPE)
effective procedure
require
valid_redefinition_error (parent_type_mark: TYPE_MARK, parent_type: TYPE, redefinition_type_mark: TYPE_MARK, new_type: TYPE)
frozen
effective procedure
{}
Trying to explain the error the best as we can.
require ensure
set_require_assertion (ra: REQUIRE_ASSERTION)
effective procedure
set_ensure_assertion (ea: ENSURE_ASSERTION)
effective procedure
try_to_undefine (fn: FEATURE_NAME, bc: CLASS_TEXT): DEFERRED_ROUTINE
frozen
effective function
Compute the corresponding deferred feature for Current.
This occurs for example when bc has an undefine clause for fn which refer to Current. The Result is never Void because fatal_error may be called.
require ensure
  • Result /= Void
set_assigner (a_assigner: FEATURE_NAME)
effective procedure
ensure
frozen
effective procedure
require
  • ft /= Void
ensure
closure_arguments: FAST_ARRAY[FORMAL_ARG_LIST]
writable attribute
{ANY}
Arguments of enclosing features
closure_local_vars: FAST_ARRAY[LOCAL_VAR_LIST]
writable attribute
{ANY}
Local vars of enclosing features
effective procedure
specialize_closure_arguments_lists_in (new_type: TYPE): FAST_ARRAY[FORMAL_ARG_LIST]
effective function
{}
specialize_closure_arguments_lists_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): FAST_ARRAY[FORMAL_ARG_LIST]
effective function
{}
specialize_closure_local_var_lists_in (new_type: TYPE): FAST_ARRAY[LOCAL_VAR_LIST]
effective function
{}
specialize_closure_local_var_lists_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): FAST_ARRAY[LOCAL_VAR_LIST]
effective function
{}
hook_for (lt: LIVE_TYPE)
effective procedure
A hook called at adapt time by RUN_FEATURE
hook_collect (t: TYPE)
effective procedure
{}
A hook called at collect time
require
  • t /= Void
pretty_print_names
frozen
effective procedure
{}
Print only the names of the feature.
try_to_undefine_aux (fn: FEATURE_NAME, bc: CLASS_TEXT): DEFERRED_ROUTINE
deferred function
{}
require
  • fn /= Void
  • bc /= Void
em_chtfi: STRING
is "Cannot inherit these features in "
constant attribute
{}
em_ohrbnto: STRING
is "Incompatible signatures. (One has a result type and not the other.)"
constant attribute
{}
em_ohabnto: STRING
is "Incompatible signatures. (One has argument(s) but not the other.)"
constant attribute
{}
em_ina: STRING
is "Incompatible number of arguments."
constant attribute
{}
effective procedure
{}
It's not shared anymore.
require ensure
  • fd.count = old fd.count + ft.names.count
obsolete_warning_check_memory: AVL_SET[POSITION]
once function
{}
To avoid same warning repetition.
export_to_any: CLIENT_LIST
once function
{}
accept (visitor: VISITOR)
deferred procedure
{ANY}
Accept to be visited by the visitor.
require
  • visitor /= Void
index_list: INDEX_LIST
writable attribute
{ANY}
For the indexing of the class.
pretty_index (indent_level: INTEGER_32, a_spec: STRING)
effective procedure
{}
ensure
add_index_clause (index_clause: INDEX_CLAUSE)
effective procedure
require
  • index_clause /= Void
set_index_list (a_index_list: INDEX_LIST)
effective procedure
require
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: ONCE_ROUTINE): BOOLEAN
deferred function
{ANY}
Is other attached to an object considered equal to current object?
require
  • other /= Void
ensure
  • Result implies hash_code = other.hash_code
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)