class ANONYMOUS_FEATURE_MIXER
Summary
Object used to store all informations for a single feature inheritance, because FEATURE_ACCUMULATOR is not able to specialize ANONYMOUS_FEATUREs (because not all FEATURE_STAMPs are ready).
The first step is to collect all informations for each anonymous feature of one type. Then the signatures may be resolved and the possible incompatibilities detected. The last step is to specialize assertions and body.
Those objects are recycled for the next type.
Direct parents
Insert list: GLOBALS
Class invariant
Overview
Creation features
{FEATURE_ACCUMULATOR}
Features
{FEATURE_ACCUMULATOR}
{}
{PRECURSOR_CALL}
{}
{FEATURE_ACCUMULATOR, RESULT, ARGUMENT_NAME_REF, LOCAL_NAME_REF}
{ARGUMENT_NAME_REF}
{FEATURE_ACCUMULATOR, RESULT}
{FEATURE_ACCUMULATOR}
{FEATURE_ACCUMULATOR, PRECURSOR_CALL}
{}
{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 (a_fn: FEATURE_NAME)
effective procedure
require
  • a_fn /= Void
ensure
add_inherited_definition (t: TYPE, parent_edge: PARENT_EDGE, an_af: ANONYMOUS_FEATURE)
effective procedure
require
  • t /= Void
  • an_af /= Void
  • an_af.permissions /= Void
ensure
set_body (an_af: ANONYMOUS_FEATURE, parent_type: TYPE, parent_edge: PARENT_EDGE)
effective procedure
require
  • parent_type /= Void

  • an_af.has_been_specialized
  • ensure
    remove_body
    effective procedure
    add_local_definition (an_af: ANONYMOUS_FEATURE)
    effective procedure
    require ensure
    specialize_signature (context_type: TYPE)
    effective procedure
    At this stage, all the feature_stamps for context_type are created and linked with it.
    The anonymous_features are not yet connected to the feature_stamps.
    This feature prepares a specialized version of the anonymous feature signature for the context_type.
    If there is no local definition, we must have a look at *all* the inherited signatures (which must have been themselves specialized for context_type) and verify that they are all the same. This common signature becomes the one for the feature.
    If there is a local definition, its signature must be interpreted for context_type. We must verify that this signature is a valid (covariant) redefinition of all the inherited signatures, for the context_type.
    There are two major pitfalls:
    1. context_type *is* being built. Hence there is no associated anonymous_feature per se (yet). We have to ask the feature_accumlator a TYPE_MARK (the result of a feature of context_type). On the other hand, the "like featurename" types can be easily adapted since they exist.
    2. The feature_accumulator, to be able to answer, does not have to ask another anonymous_feature_mixer to specialize_feature (because the specialization uses feature_stamps).
    Remark: we always have to begin with the result type resolution. The arguments come afterwards, because they can be anchored to Result; we must be able to resolve that without it being a recursivity case.
    require ensure

    specialize_feature (context_type: TYPE)
    effective procedure
    Prepare a specialized version of the feature: collect and specialize assertions, then specialize the body too.
    Specializing means modifying the CALLs and PROC_CALLs having "Current" as target (be it explicit or not). Those calls are known by their feature_name; we must connect the feature_stamp to the new type.
    Finding the good feature_stamp is important to be able afterwards to ignore all previous renamings.
    Principle: if the feature is a local feature_name (meaning source code locally written), the context_type allows to find the associated feature_stamp.
    If it's an inherited feature_name (meaning written in a parent class), it is already connected to a feature_stamp; we use get_feature_name in the original type, then we apply the renamings (in *this* inheritance branch) to access the local feature_name, and then find the good feature_stamp (back to the first case).
    require
    export_status_for (original: ANONYMOUS_FEATURE, context_type: TYPE): CLIENT_LIST
    effective function
    {}
    ensure
    • Result /= Void
    • Result.has_been_specialized
    build_precursor (pc: PRECURSOR_CALL, new_type: TYPE): ANONYMOUS_FEATURE
    effective function
    require
    • pc /= Void
    • new_type /= Void
    specialize_precursor (af: ANONYMOUS_FEATURE, parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): ANONYMOUS_FEATURE
    effective function
    require
    • af.has_been_specialized
    • af.start_position.class_text /= new_type.class_text
    • new_type.direct_thru_step(parent_type, parent_edge)
    error_handler_add_export_positions (client_list: CLIENT_LIST)
    effective procedure
    {}
    error_handler_show_resulting_client_list (client_list: CLIENT_LIST)
    effective procedure
    {}
    Show the computed client list, and emit a warning
    formal_arg_list: FORMAL_ARG_LIST
    effective function
    require
    closure_formal_arg_list (closure_rank: INTEGER_32): FORMAL_ARG_LIST
    effective function
    require
    result_type (context_type: TYPE): TYPE_MARK
    effective function
    require
    computing_result_type: INTEGER_8
    writable attribute
    Cycle detection status.
    0 = ready. 1 = computing. 2 = cycle detected -> message printing. 3 = error message ready.
    feature_name: FEATURE_NAME
    writable attribute
    The final name in the unique type in the unique accumulator.
    Actually related to Current (one element or zero with single inheritance).
    parents_type: FAST_ARRAY[TYPE]
    writable attribute
    Corresponding to parents_af at the same index.
    parents_edges: FAST_ARRAY[PARENT_EDGE]
    writable attribute
    Corresponding to parents_af at the same index.
    build_definition: ANONYMOUS_FEATURE
    writable attribute
    The one we are currently building.
    body_feature: ANONYMOUS_FEATURE
    writable attribute
    The one which gives the body.
    body_type: TYPE
    writable attribute
    When body_feature is inherited, the corresponding one of body_feature.
    body_inherit: PARENT_EDGE
    writable attribute
    When body_type is not Void.
    signature_ready: BOOLEAN
    writable attribute
    The build_definition signature is ready.
    local_definition: BOOLEAN
    writable attribute
        • Is there a proper definition in the context type.
    implicit_any: PARENT_EDGE
    once function
    {}
    ensure
    • Result /= Void
    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
    {}