class TYPE
Summary
For all kinds of TYPEs even when they are not actually created (see also LIVE_TYPE).
Direct parents
Inherit list: LOADED_HIERARCHIC_GRAPH_NODE, VISITABLE
Insert list: GLOBALS
Class invariant
Overview
Creation features
{SMART_EIFFEL}
Features
{}
{ANY}
{SMART_EIFFEL, TYPE}
  • closest_to_constraint (constraint: TYPE): TYPE
    Find some type this one conforms to, on the inheritance link up to the constraint.
{OLD_MANIFEST_ARRAY, IFTHENELSE_EXP}
{EFFECTIVE_ROUTINE}
{EFFECTIVE_ROUTINE}
{}
{FEATURE_ACCUMULATOR}
{COMMAND_LINE_TOOLS, TYPE}
{ANY}
{TYPE}
{C_PRETTY_PRINTER, LOCAL_ARGUMENT_DEF}
{ANONYMOUS_FEATURE}
some property similar to TYPE_MARK *without* start_position and some other
{ANY}
{TYPE, TYPE_VISITOR}
{INTROSPECTION_HANDLER, TYPE_VISITOR}
{}
{ANY}
{LIVE_TYPE}
{LIVE_TYPE}
{CALL_0}
{}
{FEATURE_ACCUMULATOR}
{FEATURE_ACCUMULATOR, FEATURE_STAMP}
{SMART_EIFFEL}
{FEATURE_ACCUMULATOR, FEATURE_STAMP}
{TYPE}
{}
{LIVE_TYPE}
{}
{ANY}
  • direct_thru_step (parent_type: TYPE, a_parent_edge: PARENT_EDGE): BOOLEAN
    Check that we are actually doing an atomic-valid direct step into the inheritance hierarchy (i.e. we are making a direct move move from parent_type using the a_parent_edge path to reach Current.
{ADDRESS_OF}
{}
{ANY}
{}
{ANY}
{LOADED_HIERARCHIC_GRAPH_NODE}
{ANY}
{HIERARCHIC_GRAPH_NODE}
{}
{HIERARCHIC_GRAPH_NODE}
{HIERARCHIC_GRAPH_NODE}
{ANY}
  • is_equal (other: TYPE): BOOLEAN
    Is other attached to an object considered equal to current object?
Maximum:
{}
Minimum:
{}
Bits:
{}
{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:
{}
make (ctm: TYPE_MARK, allow_raw_class_name: BOOLEAN)
effective procedure
{}
require ensure
inherits_from (other: TYPE): BOOLEAN
effective function
{ANY}
require
  • other /= Void
  • avoid_obvious_questions: other /= Current
  • not_done_to_report_errors: error_handler.is_empty
ensure
inserts (other: TYPE): BOOLEAN
effective function
{ANY}
require
  • other /= Void
  • avoid_obvious_questions: other /= Current
  • not_done_to_report_errors: error_handler.is_empty
ensure
insert_inherit_test (other: TYPE): INTEGER_8
effective function
{ANY}
Simple predicate (i.e. does not fill the error_handler).
See also xxx yyy which are supposed to be able to explain the problem.
require
  • other /= Void
  • avoid_obvious_questions: other /= Current
  • not_done_to_report_errors: error_handler.is_empty
ensure
closest_to_constraint (constraint: TYPE): TYPE
effective function
Find some type this one conforms to, on the inheritance link up to the constraint.
If there more than one possibility, the choice should not matter.
Used to implement type lookup when shrinking the generic types space.
require
  • not_obvious: constraint /= Current and then not Current.inherits_from(constraint)
ensure
has_only_one_conformant_parent: TYPE
effective function
The Result is non Void if and only if Current has only one conforming parent.
When Result is not Void Result is the unique parent of Current.
ensure
  • Result /= Void implies Result /= Current
collect_default_rescue (caller: ANONYMOUS_FEATURE)
effective procedure
require ensure
default_rescue_compound: INSTRUCTION
writable attribute
Default "rescue" compound used when a feature does not have its own rescue clause.
It contains a call to the redefined default_rescue routine. Void when the would-be called feature would be the one defined in ANY.
default_rescue_collected: BOOLEAN
writable attribute
{}
do_collect
effective procedure
specialize_and_check
effective procedure
up_to_any_in (parent_list: FAST_ARRAY[TYPE])
effective procedure
Add in parent_list, a path to the ANY class, without including the ANY class itself.
|*** Wrong comment
require
  • not parent_list.is_empty
live_type: LIVE_TYPE
writable attribute
{ANY}
The corresponding one if already created.
canonical_type_mark: TYPE_MARK
writable attribute
{ANY}
The one used to create Current.
(As the canonical_type_mark is selected nearly randomly by the compilation process, the start_position of the canonical_type_mark itself is not meaningful.)
writable attribute
{ANY}
Because canonical_type_mark is static, this is an alias for canonical_type_mark.written_name
long_name: HASHED_STRING
effective function
{ANY}
This name holds cluster info needed to make different types with the same name distinct.
Mainly used for SMART_EIFFEL.type_dictionary storage.
ensure
  • Result /= Void
class_text: CLASS_TEXT
writable attribute
{ANY}
hash_code: INTEGER_32
writable attribute
{ANY}
The hash-code value of Current.
ensure
  • good_hash_value: Result >= 0
has_local_closure: BOOLEAN
writable attribute
{ANY}
True if some object of this type may be stored in an outside local variable (i.e. visible to some closure)
add_parent (node: TYPE)
effective procedure
{ANY}
require
  • node /= Void
valid_feature_name (fn: FEATURE_NAME): BOOLEAN
effective function
{ANY}
Is fn an existing final feature name of Current?
require
  • fn /= Void
registered_name (fn: FEATURE_NAME): FEATURE_NAME
effective function
{ANY}
Useful for declaration position and frozen status.
require
effective function
{ANY}
Get the FEATURE_STAMP relative to fn.
(As expressed in the require assertion, we assume that fn is really a final name in Current.)
require ensure
  • Result /= Void
  • Result.has_type(Current)
effective function
{ANY}
To make in a single step a valid_feature_name test which may be followed by a lookup call.
(The require assertion of search is more relaxed and a Void Result indicate that fn is not a valid final name in Current.)
require ensure
get_feature_name (fs: FEATURE_STAMP): FEATURE_NAME
effective function
{ANY}
require
  • fs.has_type(Current)
ensure
has_simple_feature_name (simple_feature_name: HASHED_STRING): BOOLEAN
effective function
{ANY}
require
  • simple_feature_name.is_simple_feature_name
feature_stamp_of (simple_feature_name: HASHED_STRING): FEATURE_STAMP
effective function
{ANY}
Used to get the good one knowing that simple_feature_name is the final existing name.
require ensure
  • Result /= Void
feature_collection_done: BOOLEAN
effective function
{ANY}
class_invariant: CLASS_INVARIANT
writable attribute
{ANY}
copy_stamp: FEATURE_STAMP
effective function
{ANY}
The one of the copy feature (which is magically called inside twin).
ensure
  • Result /= Void
twin_stamp: FEATURE_STAMP
effective function
{ANY}
The one of the twin feature (which is magically called by user-expanded assignments).
ensure
  • Result /= Void
is_equal_stamp: FEATURE_STAMP
effective function
{ANY}
The one of the is_equal feature (which is magically called by user-expanded comparisons).
ensure
  • Result /= Void
do_at_exit_stamp: FEATURE_STAMP
effective function
{ANY}
The one of the do_at_exit feature (which is magically called by user-expanded comparisons).
ensure
  • Result /= Void
accept (visitor: TYPE_VISITOR)
effective procedure
{ANY}
Accept to be visited by the visitor.
require
  • visitor /= Void
effective function
{ANY}
Id of the receiver to produce C code.
private_generic_list: ARRAY[TYPE]
writable attribute
set_local_closure
effective procedure
name_from_string (s: STRING): FEATURE_NAME
effective function
require ensure
effective function
Warning: TIME CONSUMING TASK.
Try to use get_feature_name instead.
is_deferred: BOOLEAN
writable attribute
{ANY}
is_generic: BOOLEAN
effective function
{ANY}
ensure
is_expanded: BOOLEAN
effective function
{ANY}
ensure
is_reference: BOOLEAN
effective function
{ANY}
ensure
has_external_type: BOOLEAN
effective function
{ANY}
external_type: EXTERNAL_TYPE
writable attribute
{ANY}
generic_list: ARRAY[TYPE]
effective function
{ANY}
require ensure
  • Result.lower = 1
  • not Result.is_empty
is_kernel_expanded: BOOLEAN
effective function
{ANY}
True for BOOLEAN, CHARACTER, INTEGER, REAL, DOUBLE and POINTER.
is_boolean: BOOLEAN
effective function
{ANY}
ensure
is_character: BOOLEAN
effective function
{ANY}
ensure
is_integer: BOOLEAN
effective function
{ANY}
Is it some INTEGER_* type?
ensure
is_natural: BOOLEAN
effective function
{ANY}
Is it some NATURAL_* type?
ensure
is_real: BOOLEAN
effective function
{ANY}
ensure
is_pointer: BOOLEAN
effective function
{ANY}
ensure
is_string: BOOLEAN
effective function
{ANY}
is_fixed_string: BOOLEAN
effective function
{ANY}
is_unicode_string: BOOLEAN
effective function
{ANY}
is_array: BOOLEAN
effective function
{ANY}
require ensure
is_any: BOOLEAN
effective function
{ANY}
is_native_array: BOOLEAN
effective function
{ANY}
is_agent: BOOLEAN
effective function
{ANY}
is_tuple: BOOLEAN
effective function
{ANY}
is_empty_expanded: BOOLEAN
effective function
{ANY}
True when is it a user's expanded type with no attribute.
require ensure
is_user_expanded: BOOLEAN
effective function
{ANY}
Is it really a user expanded type?
is_always_void: BOOLEAN
effective function
{ANY}
Is an expression of that TYPE always Void?
require
direct_non_void_call_flag: BOOLEAN
effective function
{ANY}
require
can_be_assigned_to (other: TYPE): BOOLEAN
effective function
{ANY}
Used to know if Current can be assigned into other.
(See also valid_redefinition_of.)
require ensure
writable_attributes: ARRAY[FEATURE_STAMP]
effective function
writable_attributes_memory: ARRAY[FEATURE_STAMP]
writable attribute
{}
open_arguments: ARRAY[TYPE]
effective function
{ANY}
(The Result can be Void when open arguments is the empty TUPLE.)
require
agent_result: TYPE
effective function
{ANY}
require
forget_previous_collect
effective procedure
|*** (Dom july 14th 2004) ***
adapt_class_invariant
effective procedure
require
set_live_type (lt: LIVE_TYPE)
effective procedure
require
  • lt /= Void
  • must_be_done_once: live_type = Void
ensure
expanded_default_create_stamp: FEATURE_STAMP
effective function
Must be called when we are sure that there is only and only one creation procedure with no argument.
require ensure
  • Result /= Void
find_manifest_expression_for (fs: FEATURE_STAMP, fn: FEATURE_NAME): MANIFEST_EXPRESSION
effective function
Used to find some manifest expression in the "when" part of some "inspect" statement.
require
  • fn /= Void
ensure
  • Result /= Void
find_anonymous_feature_for (fs: FEATURE_STAMP, fn: FEATURE_NAME): ANONYMOUS_FEATURE
effective function
{}
require
  • fs /= Void
  • fn /= Void
ensure
  • Result /= Void
add_feature (fn: FEATURE_NAME, fs: FEATURE_STAMP)
effective procedure
require
add_seeds (final_fs: FEATURE_STAMP, seed_set: SET[ABSOLUTE_FEATURE_NAME], inherit_link: BOOLEAN)
effective procedure
require
  • final_fs.has_type(Current)
  • final_fs /= Void
  • seed_set /= Void
collected_feature_count: INTEGER_32
effective function
print_feature_hierarchy (final_fs: FEATURE_STAMP, seed: ABSOLUTE_FEATURE_NAME, inherit_link: BOOLEAN): BOOLEAN
effective function
Code for printing error message (do not care for speed).
All TYPEs and NAMEs for the feature are printed from seed to current type.
require
  • final_fs.has_type(Current)
  • final_fs /= Void
print_graph_cycle (first: TYPE)
effective procedure
inline_dynamic_dispatch_flag: BOOLEAN
writable attribute
{}
inline_dynamic_dispatch_must_be_done_once: BOOLEAN
frozen
effective function
{}
inline_dynamic_dispatch_for_class_invariant (code_accumulator: CODE_ACCUMULATOR)
effective procedure
temporary_simple_feature_name: FEATURE_NAME
writable attribute
{}
Used only as a temporary in feature_stamp_of and has_simple_feature_name.
inheritance_cycle_check
effective procedure
{}
collect_features
effective procedure
{}
collect_one_feature (final_fn: FEATURE_NAME, inherit_index: INTEGER_32)
effective procedure
{}
The loop is done in reverse order, so conforming types will be analyzed first.
Types after inherit_index are ignored because they have already been used and we know final_fn not to be known into.
ensure
collect_local_features
effective procedure
{}
build_actual_invariant
effective procedure
{}
Called only once per type to gather inherited class invariant and local invariant.
require
valid_feature_stamps: BOOLEAN
effective function
{}
All our feature_stamps know us.
debug_info: STRING
writable attribute
{}
debug_known_features: STRING
writable attribute
{}
direct_thru_step (parent_type: TYPE, a_parent_edge: PARENT_EDGE): BOOLEAN
effective function
{ANY}
Check that we are actually doing an atomic-valid direct step into the inheritance hierarchy (i.e. we are making a direct move move from parent_type using the a_parent_edge path to reach Current.
require
  • parent_type /= Void
  • a_parent_edge /= Void
ensure
  • assertion_check_only: Result
address_of_register (address_of: ADDRESS_OF)
effective procedure
require
  • address_of.feature_stamp /= Void
address_of_memory1: HASHED_SET[FEATURE_STAMP]
writable attribute
{}
address_of_memory2: FAST_ARRAY[ADDRESS_OF]
writable attribute
{}
do_all_address_of (action: PROCEDURE[TUPLE 1[ADDRESS_OF]])
effective procedure
{ANY}
require
  • action /= Void
insert_inherit_test_memory_cache: HASHED_DICTIONARY[INTEGER_8, TYPE]
writable attribute
{}
parent_edge_load (i: INTEGER_32): LOAD
effective function
{ANY}
require
child_edge_load (i: INTEGER_32): LOAD
effective function
{ANY}
require
add_child (node: TYPE)
effective procedure
{ANY}
require
  • node /= Void
remove_parent (node: TYPE)
effective procedure
{ANY}
require
  • has_parent(node)
remove_child (node: TYPE)
effective procedure
{ANY}
require
  • has_child(node)
parents_edge_load: FAST_ARRAY[LOAD]
writable attribute
children_edge_load: FAST_ARRAY[LOAD]
writable attribute
item: E_
writable attribute
{ANY}
max_rank: INTEGER_32
writable attribute
{ANY}
min_rank: INTEGER_32
writable attribute
{ANY}
parents: FAST_ARRAY[TYPE]
writable attribute
{ANY}
children: FAST_ARRAY[TYPE]
writable attribute
{ANY}
set_item (i: E_)
effective procedure
{ANY}
parents_count: INTEGER_32
effective function
{ANY}
children_count: INTEGER_32
effective function
{ANY}
has_parent_edge (id: INTEGER_32): BOOLEAN
effective function
{ANY}
has_child_edge (id: INTEGER_32): BOOLEAN
effective function
{ANY}
remove_parent_edge (id: INTEGER_32): TYPE
effective function
{ANY}
Return connected node.
require ensure
restore_parent_edge (id: INTEGER_32, node: TYPE)
effective procedure
{ANY}
require ensure
remove_child_edge (id: INTEGER_32): TYPE
effective function
{ANY}
Return connected node.
require ensure
restore_child_edge (id: INTEGER_32, node: TYPE)
effective procedure
{ANY}
require ensure
deep_reset_edges
effective procedure
{ANY}
Set edge identifiers with values starting from 0.
parent (i: INTEGER_32): TYPE
effective function
{ANY}
require
child (i: INTEGER_32): TYPE
effective function
{ANY}
require
has_parent (other: TYPE): BOOLEAN
effective function
{ANY}
ensure
has_child (other: TYPE): BOOLEAN
effective function
{ANY}
ensure
parent_edge (i: INTEGER_32): INTEGER_32
effective function
{ANY}
require
child_edge (i: INTEGER_32): INTEGER_32
effective function
{ANY}
require
has_cycle: BOOLEAN
effective function
{ANY}
has_parent_cycle: BOOLEAN
effective function
{ANY}
has_children_cycle: BOOLEAN
effective function
{ANY}
is_toplevel: BOOLEAN
effective function
{ANY}
ensure
is_leaf: BOOLEAN
effective function
{ANY}
ensure
is_connected_to (other: TYPE): BOOLEAN
effective function
{ANY}
require
  • other /= Void
ensure
distance (other: TYPE): INTEGER_32
effective function
{ANY}
require
  • other /= Void
ensure
set_rank
effective procedure
{ANY}
require
add_connected_nodes_in (list: COLLECTION[HIERARCHIC_GRAPH_NODE[E_]])
effective procedure
{ANY}
Add in list all nodes belonging to the same graph as Current
require
  • list /= Void
fill_path_to (path: COLLECTION[INTEGER_32], destination: TYPE)
effective procedure
{ANY}
Add in path edges identifiers corresponding to a path from current node to destination node.
require
internal_has_parent_cycle: BOOLEAN
effective function
internal_has_children_cycle: BOOLEAN
effective function
internal_is_connected_to (other: TYPE): BOOLEAN
effective function
require
  • other /= Void
internal_unmark_parents
effective procedure
internal_unmark_children
effective procedure
internal_unmark_connected
effective procedure
unmark parents and children
internal_deep_reset_edges: INTEGER_32
effective function
internal_deep_init_edges (use: INTEGER_32): INTEGER_32
effective function
internal_distance (other: TYPE, pos: INTEGER_32, max: INTEGER_32): INTEGER_32
effective function
Returns Maximum_integer if inaccessibility detected Returns -1 when break needed Distance from current point otherwise Warning: max length and pos are from the search start.
require
clean_mark_score
effective procedure
internal_set_rank
effective procedure
internal_add_connected_nodes_in (list: COLLECTION[HIERARCHIC_GRAPH_NODE[E_]])
effective procedure
internal_fill_path_to (path: COLLECTION[INTEGER_32], destination: TYPE, position: INTEGER_32): BOOLEAN
effective function
invariant_checking_mode: REFERENCE[BOOLEAN]
once function
{}
valid_parents: BOOLEAN
effective function
{}
valid_children: BOOLEAN
effective function
{}
valid_parents_and_children: BOOLEAN
effective function
{}
ensure
  • assertion_only: Result
set_invariant_checking_mode (new_mode: BOOLEAN)
effective procedure
{}
require
deconnect_current
effective procedure
{}
parents_edge: FAST_ARRAY[INTEGER_32]
writable attribute
children_edge: FAST_ARRAY[INTEGER_32]
writable attribute
mark: BOOLEAN
writable attribute
unmark
effective procedure
set_mark
effective procedure
deep_unmark_connected
effective procedure
deep unmark parents and children (paths stops at unmarked nodes)
mark_score: INTEGER_32
writable attribute
is_equal (other: TYPE): 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)
Maximum_character_code: INTEGER_16
{}
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
Number of bits in a value of type POINTER.
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
{}