Eiffeldoc: UNIVERSE

add_entry (a_distance: INTEGER_32, system_path: STRING, path: STRING, name: STRING, discard_silently: BOOLEAN)

effective procedure

{ACE}

require

a_distance > 0
name /= Void
string_aliaser.registered_one(name)
path /= Void
is_classes_path(path)
string_aliaser.registered_one(path)
system_path /= Void implies is_system_path(system_path)

has_physical_cluster (system_path: STRING): BOOLEAN

effective function

{CLASSES_TREE_FACTORY}

make

effective procedure

{}

show_name

effective procedure

{}

find_physical_cluster (system_path: STRING): CLUSTER

effective function

{CLUSTERS}

add_classes (a_classes: CLASSES)

effective procedure

{}

Object sin: knowing your heirs -- here, LOADPATH and UNIVERSE

require

a_classes.parent = Void

ensure

a_classes.parent = Current
classeses.fast_has(a_classes)

cluster_named (cluster_name: STRING): CLUSTER

effective function

require

not cluster_name.is_empty
string_aliaser.registered_one(cluster_name)

ensure

Result /= Void implies Result.name.is_equal(cluster_name)

clusters_of (class_name: CLASS_NAME, skip: CLASSES, clusters: FAST_ARRAY[CLUSTER], distances: FAST_ARRAY[INTEGER_32], current_distance: INTEGER_32)

effective procedure

require

coherent: clusters.count = distances.count
obviously: skip /= Current

ensure

grow_only: clusters.count >= old clusters.count
still_coherent: clusters.count = distances.count
all_kept: old clusters.twin.for_all(clusters.fast_has())

cluster_by_directory_path (path: STRING): CLUSTER

effective function

require

not path.is_empty

class_text_count: INTEGER_32

effective function

loaded_class_count: INTEGER_32

effective function

cluster_count: INTEGER_32

effective function

has_class (class_name: HASHED_STRING): BOOLEAN

effective function

has_cluster (c: CLUSTER): BOOLEAN

effective function

require

c /= Void

for_all (action: PROCEDURE[TUPLE 1[CLASS_TEXT]])

effective procedure

for_all_filtered (name_guard: FUNCTION[TUPLE 1[CLASS_NAME], BOOLEAN], action: PROCEDURE[TUPLE 1[CLASS_TEXT]])

effective procedure

for_all_clusters (action: PROCEDURE[TUPLE 1[CLUSTER]])

effective procedure

cluster_at (index: INTEGER_32): CLUSTER

effective function

require

index.in_range(1, cluster_count)

parse_include

effective procedure

Look for some class(es) to be loaded first because of some "include" option.

require

using_ace_file: ace.file_path /= Void

pretty_in (txt: STRING)

effective procedure

When pretty-printing the ACE file

require

txt /= Void

view_in (msg: STRING)

effective procedure

Append in msg a viewable version of the Current as well as some other informations to help the user to fix the problem.

require

msg /= Void

get_started (level: INTEGER_32)

effective procedure

show (tab: INTEGER_32)

effective procedure

Tree display in verbose mode

classeses: FAST_ARRAY[CLASSES]

writable attribute

{}

Sorted by growing distance.

Pretty name ain't it :-)

parent: CLUSTERS

writable attribute

{ANY}

Void only for Universe

distance: INTEGER_32

writable attribute

{ANY}

Distance to the parent

classes_notation: UNIX_DIRECTORY_NOTATION

once function

{ANY}

Cluster paths are UNIX-like

set_parent (a_parent: CLUSTERS)

effective procedure

{CLUSTERS}

ensure

parent = a_parent

is_classes_path (path: STRING): BOOLEAN

effective function

{ACE}

is_system_path (path: STRING): BOOLEAN

effective function

{ACE}

system_notation: DIRECTORY_NOTATION

once function

{ACE}

ensure

Result /= Void

classes_path_to_system_path (classes_path: STRING): STRING

effective function

{ACE}

require

not classes_path.is_empty
is_classes_path(classes_path)

ensure

not Result.is_empty
is_system_path(Result)
classes_notation.is_absolute_path(classes_path) implies system_notation.is_absolute_path(Result)

system_path_to_classes_path (system_path: STRING): STRING

effective function

{ACE}

require

not system_path.is_empty
is_system_path(system_path)

ensure

not Result.is_empty
is_classes_path(Result)
system_notation.is_absolute_path(system_path) implies classes_notation.is_absolute_path(Result)

show_tabs (tabs: INTEGER_32)

effective procedure

{}

basic_directory: BASIC_DIRECTORY

writable attribute

{}

smart_eiffel: SMART_EIFFEL

frozen

once function

{ANY}

eiffel_parser: EIFFEL_PARSER

frozen

once function

{ANY}

ace: ACE

frozen

once function

{ANY}

ini_parser: INI_PARSER

frozen

once function

{ANY}

plugin_config: INI_PARSER

frozen

once function

{ANY}

error_handler: ERROR_HANDLER

frozen

once function

{ANY}

string_aliaser: STRING_ALIASER

frozen

once function

{ANY}

cpp: C_PRETTY_PRINTER

frozen

once function

{ANY}

pretty_printer: PRETTY_PRINTER

frozen

once function

{ANY}

mini_buffer: MINI_BUFFER

frozen

once function

{ANY}

nb_errors: INTEGER_32

effective function

{ANY}

ensure

Result >= 0

system_tools: SYSTEM_TOOLS

frozen

once function

{ANY}

introspection_handler: INTROSPECTION_HANDLER

frozen

once function

{ANY}

assignment_test_pool: ASSIGNMENT_TEST_POOL

frozen

once function

{ANY}

precomputable_routine_detector: PRECOMPUTABLE_ROUTINE_DETECTOR

frozen

once function

{ANY}

feature_accumulator: FEATURE_ACCUMULATOR

frozen

once function

{ANY}

live_type_extra_collectors: FAST_ARRAY[LIVE_TYPE_EXTRA_COLLECTOR]

frozen

once function

{ANY}

is_launcher: BOOLEAN

effective function

{ACE}

If True, the clusters list will not be retrieved (it means that the tool is only used to start other tools; it does not load classes itself)

set_launcher

effective procedure

{SE, COMPILE}

ensure

is_launcher

is_launcher_memory: REFERENCE[BOOLEAN]

once function

{}

parser_buffer: PARSER_BUFFER

frozen

once function

{SMART_EIFFEL, SYSTEM_TOOLS, VISITOR}

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

cecil_pool /= Void

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

is_install

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}

strings: STRING_RECYCLING_POOL

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: UNIVERSE): BOOLEAN

effective function

{ANY}

Is other attached to an object considered equal to current object?

require

other /= Void

ensure

commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)

is_real_singleton: BOOLEAN

effective function

{}

ensure

assertion_check_only: Result

singleton_memory_pool: HASHED_DICTIONARY[POINTER, STRING]

once function

{}

This pool is unique in the whole system.

A memory is kept for each singleton type (type, not class) in the system.

current_is_not_an_expanded_type: BOOLEAN

effective function

{}