Eiffeldoc: AGENT_CREATION

+

Point of view

All features

class AGENT_CREATION

Summary

An Eiffel agent is a delayed call. Such an Eiffel object include a feature call with closed or open arguments (or closed or open target as well). An AGENT_CREATION object is the notation to create the agent (i.e. the feature is not launched yet, see also AGENT_EXPRESSION).

Examples of AGENT_CREATION:

         agent my_array.add_last(?)         -- The target is closed and the argument is open.
         agent {ARRAY[INTEGER]}.add_last(1) -- The target is open and the argument is closed.
         agent {ARRAY[INTEGER]}.add_last(?) -- Both the target and the argument are open.
         agent {ARRAY[INTEGER]}.add_last    -- A short-hand for the previous notation.
         agent my_array.put(?, 3)           -- Only the second argument is open.
         agent my_array.put(3, ?)           -- Only the first argument is open.
         agent {ARRAY[INTEGER]}.put         -- Target and all arguments are open.

See also directly related classes: OPEN_OPERAND and CLOSED_OPERAND.

Direct parents: Inherit list: EXPRESSION

Class invariant

not start_position.is_unknown
inline_feature /= Void implies inline_feature.is_inline_agent
not start_position.is_unknown

Overview

Creation features

{EIFFEL_PARSER}

make (sp: POSITION, function_call: FUNCTION_CALL, a_inline_feature: FEATURE_TEXT)

Features

start_position: POSITION

Of the first letter of the mandatory "agent" keyword (obviously provided by the eiffel_parser).
original_function_call: FUNCTION_CALL

The one provided by the eiffel_parser (the syntactical information).
code: CODE

Initialized with original_function_call, the code will be more and more specialized as the compilation process is going on.
open_operand_list: FAST_ARRAY[OPEN_OPERAND]

If any, the ordered list of OPEN_OPERAND objects.
closed_operand_list: FAST_ARRAY[CLOSED_OPERAND]

If any, the ordered list of CLOSED_ARGUMENT objects which are also immutable objects (never twinned as OPEN_OPERAND objects are).
resolved_memory: HASHED_DICTIONARY[TYPE, TYPE]

Because computing of resolve_in requires allocating many objects and because it is very difficult (if not impossible) to compute after inlining of dynamic dispatch, values of resolve_in are cached into resolved_memory.
context_features: HASHED_DICTIONARY[ANONYMOUS_FEATURE, TYPE]

The containing feature for each type
is_current: BOOLEAN

Is it a Current like expression (really written Current or some implicit not-written Current)?
is_implicit_current: BOOLEAN

Is it an implicit Current (i.e., not explicitly written)?
inline_feature: FEATURE_TEXT

non-Void if the agent is an inline agent (useful for pretty, also for closure parts)
extra_bracket_flag: BOOLEAN

True when we do have to add an extra pair of brackets if the Current expression is the target of a call.
declaration_type: TYPE

The static type one can deduce from the declaration written in source text.
written_declaration_type_mark: TYPE_MARK

This variant of declaration_type is used to check the left-hand side of "?:=", "::=" or "?=" and the generic creation constraints.
feature_stamp: FEATURE_STAMP

useful for the interpreter
has_omitted_open_arguments: BOOLEAN
specialize_in (type: TYPE): AGENT_CREATION

Specialize Current knowing that the corresponding source code was written in type.
specialize_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): AGENT_CREATION

Assuming that Current is already specialized in parent_type, now specialize Current for the new_type knowing that this source code is inherited thru parent_edge.
specialize_and_check (type: TYPE): AGENT_CREATION

This specialize_and_check step is applied after specialize_in / specialize_thru.
has_been_specialized: BOOLEAN

Used both for specialize_in and specialize_thru to indicate that we have all FEATURE_STAMPs ready for use and that FEATURE_NAMEs are no longer used (except for calls on non-current target who are available after specialize_and_check -- step).
resolve_in (type: TYPE): TYPE

This method may be called to solve the Current expression type knowing that the Current expression has_been_specialized for the type given as an argument.
collect (type: TYPE): TYPE

Collect Current to become actually true live code in type knowing that Current already specialized in type.
adapt_for (type: TYPE): AGENT_CREATION

This function is called only once at the end of the compilation process (i.e. after collect inline_dynamic_dispatch and simplify).
non_void_no_dispatch_type (type: TYPE): TYPE

A non Void Result indicates that Current cannot be Void and that Current drives exactly to a single possible dynamic TYPE.
simplify (type: TYPE): AGENT_CREATION

May return Current, Void or a simplified version of Current.
accept (visitor: AGENT_CREATION_VISITOR)

Accept to be visited by the visitor.
is_void: BOOLEAN

Is it the built-in Void?
is_writable: BOOLEAN

Is is something that one can find on the left-hand-side of the := operator ?
is_manifest_string: BOOLEAN

Is it a manifest string (i.e. a basic manifest string or some verbatim manifest string)?
is_static: BOOLEAN

True if the expression has always the same static value regardless the context of the code.
is_result: BOOLEAN

Is it the pseudo local variable Result ?
side_effect_free (type: TYPE): BOOLEAN

True when the evaluation of Current has no side effect at all (i.e. no memory allocated, no modification in the _heap_ memory, no external code with possible side effect).
safety_check (type: TYPE)
use_current (type: TYPE): BOOLEAN

Is Current used?
bracketed_pretty (indent_level: INTEGER_32)

For pretty.
pretty (indent_level: INTEGER_32)
pretty_target (indent_level: INTEGER_32)

For pretty.
short (type: TYPE)

Produce the short command output in the given context type.
short_target (type: TYPE)

Produce the short command output in the given context type.
precedence: INTEGER_32

Handling of precedence (priority of expressions).

{}

specialize_and_check_function (type: TYPE): AGENT_CREATION
specialize_and_check_procedure (type: TYPE): AGENT_CREATION

mold_id_in (type: TYPE, buffer: STRING)

Identify the corresponding AGENT_CREATION function.
same_mold_id_as (other: AGENT_CREATION): BOOLEAN

{AGENT_CREATION}

set_code (c: CODE)
set_feature_stamp (fs: FEATURE_STAMP)
set_open_operand_list (l: FAST_ARRAY[OPEN_OPERAND])

{}

make (sp: POSITION, function_call: FUNCTION_CALL, a_inline_feature: FEATURE_TEXT)

{CODE, EFFECTIVE_ARG_LIST}

inline_dynamic_dispatch_ (code_accumulator: CODE_ACCUMULATOR, type: TYPE)

{}

warn_omitted_open_arguments

{AGENT_CREATION}

omitted_open_arguments_update (omitted_arguments: EFFECTIVE_ARG_LIST)

stored_closed_operand (type: TYPE, closed_operand: CLOSED_OPERAND): BOOLEAN

Is the closed_operand stored inside the agent memory.
is_equal_used_in (agent_type: TYPE): BOOLEAN

Because it is quite uncommon to use is_equal between two agents, this feature make it easy to skip the corresponding runtime support.

{C_LIVE_TYPE_COMPILER}

set_inside_agent_launcher_flag (flag_value: BOOLEAN)

is_default_value: BOOLEAN

True if Current represents Void, False , 0, or whatever is a default value.
is_stored_in_some_local_variable: BOOLEAN

True if Current is stored in some local variable of the _target_ language.
static_simplify: EXPRESSION

This one is working completely out of context and is called directly by the parser only for some typical expressions.
base_class_written: CLASS_TEXT

The base class where this expression is written.
written_in: CLASS_NAME

The name of the base class where this expression is written.
is_an_acceptable_replacement (type: TYPE, other: EXPRESSION): BOOLEAN

Well, it is just for debug (see ensure).
inline_dynamic_dispatch (code_accumulator: CODE_ACCUMULATOR, type: TYPE): EXPRESSION

For pretty and short:

bracketed_short (type: TYPE)

specialize_without_checks (type: TYPE): CODE

Perform specialize_and_check without checking the validity (export violations, ...)
to_expression: EXPRESSION

Safe down-casting.
to_instruction: INSTRUCTION

Safe down-casting.
is_not_a_compound: BOOLEAN

Mostly for assertion checks.

{}

inline_dynamic_dispatch_of (code_accumulator: CODE_ACCUMULATOR, type: TYPE, l: FAST_ARRAY[EXPRESSION]): FAST_ARRAY[EXPRESSION]

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)

set_launcher

{}

is_launcher_memory: REFERENCE[BOOLEAN]

{SMART_EIFFEL, SYSTEM_TOOLS, VISITOR}

parser_buffer: PARSER_BUFFER

id_provider: ID_PROVIDER
manifest_string_pool: MANIFEST_STRING_POOL
manifest_generic_pool: MANIFEST_GENERIC_POOL
once_routine_pool: ONCE_ROUTINE_POOL
agent_pool: AGENT_POOL
cecil_pool: CECIL_POOL
cecil_pool_memory: REFERENCE[CECIL_POOL]
set_cecil_pool
short_printer: SHORT_PRINTER
echo: ECHO
assignment_handler: ASSIGNMENT_HANDLER
thread_pool: THREAD_POOL
exceptions: EXCEPTIONS
exceptions_handler: EXCEPTIONS_HANDLER
nb_warnings: INTEGER_32
tmp_path: STRING
tmp_file_read: TEXT_FILE_READ
class_any: CLASS_TEXT
omitted_client_list: CLIENT_LIST

(To avoid multiple creation(s).)
any_default_create_fs: FEATURE_STAMP
any_default_rescue_fs: FEATURE_STAMP
any_copy_fs: FEATURE_STAMP
any_is_equal_fs: FEATURE_STAMP
any_deep_twin_fs: FEATURE_STAMP
any_is_deep_equal_fs: FEATURE_STAMP
boolean_and_then_fs: FEATURE_STAMP
manifest_make_name: HASHED_STRING
manifest_put_name: HASHED_STRING
manifest_semicolon_check_name: HASHED_STRING
manifest_initialize_name: HASHED_STRING
calloc_name: HASHED_STRING
put_name: HASHED_STRING
item_name: HASHED_STRING
is_empty_name: HASHED_STRING
make_name: HASHED_STRING
from_external_sized_copy_name: HASHED_STRING
count_name: HASHED_STRING
storage_name: HASHED_STRING
capacity_name: HASHED_STRING
storage_lower_name: HASHED_STRING
mark_item_name: HASHED_STRING
mark_native_arrays_name: HASHED_STRING
and_then_name: HASHED_STRING
or_else_name: HASHED_STRING
twin_name: HASHED_STRING
copy_name: HASHED_STRING
is_equal_name: HASHED_STRING
deep_twin_name: HASHED_STRING
deep_twin_from_name: HASHED_STRING
is_deep_equal_name: HASHED_STRING
deep_memcmp_name: HASHED_STRING
se_atexit_name: HASHED_STRING
default_rescue_name: HASHED_STRING
default_create_name: HASHED_STRING
flush_name: HASHED_STRING
clear_all_name: HASHED_STRING
from_pointer_name: HASHED_STRING
no_errors: BOOLEAN
character_coding (c: CHARACTER, str: STRING)

Append in str the Eiffel coding of the character (Table in chapter 25 of ETL, page 423).%%%%%%%%
eiffel_suffix: STRING

Eiffel Source file suffix.
c_suffix: STRING

C files suffix.
h_suffix: STRING

Heading C files suffix.
c_plus_plus_suffix: STRING

C++ files suffix.
backup_suffix: STRING

Backup suffix for command pretty.
class_suffix: STRING
dot_precedence: INTEGER_32

The highest precedence value according to ETL.
atomic_precedence: INTEGER_32

Used for atomic elements.
append_u1 (str: STRING, u1: INTEGER_32)
append_u2 (str: STRING, u2: INTEGER_32)
append_u4 (str: STRING, u4: INTEGER_32)
is_install: BOOLEAN
set_install
install_memory: REFERENCE[BOOLEAN]
unrelated_code: INTEGER_8
inserts_code: INTEGER_8
inherits_code: INTEGER_8
strings: STRING_RECYCLING_POOL

an option to minimize generic types

{}

shrink_generic_types: BOOLEAN
shrink_generic_types_memory: REFERENCE[BOOLEAN]

Set the item to True if you want less generic type duplication

Hard-coded class names:

{}

Hard coded feature names:

{}

Operator/Infix/Prefix/Alias list:

{}

Other names:

{}

as_arguments: STRING
as_current: STRING
as_native_array_character: STRING
as_last_result: STRING
as_like_current: STRING
as_method: STRING
as_open_arguments: STRING
as_open_argument_indices: STRING
as_open_argument_index: STRING
as_open_argument_count: STRING
as_precursor: STRING
as_result: STRING
as_target: STRING
as_void: STRING

The keywords section:

{}

Most of them are message parts:

{}

fz_cad: STRING
fz_dtideena: STRING
fz_error_stars: STRING
fz_vuar4: STRING

Some other names:

{}

fz_bin: STRING
fz_c_shift_left: STRING
fz_c_shift_right: STRING
fz_install: STRING
fz_jobs: STRING
fz_no_check: STRING
fz_none: STRING
fz_libertyeiffel: STRING
fz_seconf: STRING

The environment name pointing to the config file.

The known keys of the INI file:

{}

fz_conf_general: STRING
fz_conf_loadpath: STRING
fz_conf_environment: STRING

since version 2
fz_conf_se_tools: STRING

since version 3
fz_conf_bin: STRING
fz_conf_lib: STRING
fz_conf_sys: STRING
fz_conf_short: STRING
fz_conf_tools: STRING
fz_conf_os: STRING
fz_conf_flavor: STRING
fz_conf_jobs: STRING
fz_conf_boost: STRING
fz_conf_no_check: STRING
fz_conf_require_check: STRING
fz_conf_ensure_check: STRING
fz_conf_invariant_check: STRING
fz_conf_loop_check: STRING
fz_conf_all_check: STRING
fz_conf_debug_check: STRING
fz_conf_flat_check: STRING
fz_conf_smarteiffel_options: STRING
fz_conf_undefined: STRING
fz_conf_tag: STRING
fz_conf_compiler_type: STRING
fz_conf_compiler_path: STRING
fz_conf_linker_path: STRING
fz_conf_strip_path: STRING
fz_conf_compiler_options: STRING
fz_conf_linker_options: STRING
fz_conf_cpp_compiler_type: STRING
fz_conf_cpp_compiler_path: STRING
fz_conf_cpp_compiler_options: STRING
fz_conf_cpp_linker_path: STRING
fz_conf_cpp_strip_path: STRING
fz_conf_cpp_linker_options: STRING

start_position: POSITION

writable attribute

Of the first letter of the mandatory "agent" keyword (obviously provided by the eiffel_parser).

ensure

not Result.is_unknown

original_function_call: FUNCTION_CALL

writable attribute

The one provided by the eiffel_parser (the syntactical information).

Indeed, the parser cannot know about the result type of the delayed call, thus, the parser is always creating a FUNCTION_CALL. This original_function_call attribute is always kept unchanged in order to allow pretty at any step (or any mode) of the compilation process.

code: CODE

writable attribute

Initialized with original_function_call, the code will be more and more specialized as the compilation process is going on.

Syntactically, it is always a FUNCTION_CALL. Then, it can be transformed into a PROCEDURE_CALL, as soon as the target is resolved. Finally, after inlining of dynamic dispatch (after inline_dynamic_dispatch_) this can be transformed accordingly, may be with a COMPOUND or a COMPOUND_EXPRESSION or anything else produced by inlining or simplify.

open_operand_list: FAST_ARRAY[OPEN_OPERAND]

writable attribute

If any, the ordered list of OPEN_OPERAND objects.

As OPEN_OPERAND objects are never twinned, open_operand_list is always up-to-date.

closed_operand_list: FAST_ARRAY[CLOSED_OPERAND]

writable attribute

If any, the ordered list of CLOSED_ARGUMENT objects which are also immutable objects (never twinned as OPEN_OPERAND objects are).

resolved_memory: HASHED_DICTIONARY[TYPE, TYPE]

writable attribute

Because computing of resolve_in requires allocating many objects and because it is very difficult (if not impossible) to compute after inlining of dynamic dispatch, values of resolve_in are cached into resolved_memory.

context_features: HASHED_DICTIONARY[ANONYMOUS_FEATURE, TYPE]

writable attribute

The containing feature for each type

is_current: BOOLEAN

is False

constant attribute

Is it a Current like expression (really written Current or some implicit not-written Current)?

is_implicit_current: BOOLEAN

is False

constant attribute

Is it an implicit Current (i.e., not explicitly written)?

ensure

Result implies is_current

inline_feature: FEATURE_TEXT

writable attribute

non-Void if the agent is an inline agent (useful for pretty, also for closure parts)

extra_bracket_flag: BOOLEAN

is False

constant attribute

True when we do have to add an extra pair of brackets if the Current expression is the target of a call.

As an example, this is True for infix calls. (This feature is used for pretty as well as for short). As another example, it is also true (-1).foo because of the usual low priority of prefix minus.

declaration_type: TYPE

effective function

The static type one can deduce from the declaration written in source text.

As inheritance and redefinitions are ignored, it's the type to use for a lookup (for a method with this expression as target).

require

has_been_specialized
not smart_eiffel.status.is_specializing
no_type_for_void: not is_void

ensure

Result /= Void

written_declaration_type_mark: TYPE_MARK

effective function

This variant of declaration_type is used to check the left-hand side of "?:=", "::=" or "?=" and the generic creation constraints.

Note: this is the written one i.e. not always a static one.

require

assignment_test_family_only: is_writable
has_been_specialized
not smart_eiffel.status.is_specializing

ensure

Result /= Void

feature_stamp: FEATURE_STAMP

writable attribute

useful for the interpreter

has_omitted_open_arguments: BOOLEAN

writable attribute

specialize_in (type: TYPE): AGENT_CREATION

effective function

Specialize Current knowing that the corresponding source code was written in type.

The Result still contains all the original source code information in order to be able to specialize_in again the Result in another type. (See also specialize_thru and has_been_specialized as well.)

require

start_position.class_text = type.class_text

ensure

Result.has_been_specialized
All the original source code information is kept in the Result:
Result.generating_type = generating_type

specialize_thru (parent_type: TYPE, parent_edge: PARENT_EDGE, new_type: TYPE): AGENT_CREATION

effective function

Assuming that Current is already specialized in parent_type, now specialize Current for the new_type knowing that this source code is inherited thru parent_edge.

(See also specialize_in and has_been_specialized as well.)

require

has_been_specialized
start_position.class_text /= new_type.class_text
new_type.direct_thru_step(parent_type, parent_edge)

ensure

has_been_specialized
Result.has_been_specialized
All the original source code information is kept in the Result:
Result.generating_type = generating_type

specialize_and_check (type: TYPE): AGENT_CREATION

effective function

This specialize_and_check step is applied after specialize_in / specialize_thru.

The specialize_and_check step has been added to continue specialization which can't be made at specialize_in / specialize_thru time (because the expression TYPE computation may involve TYPEs who don't yet exist). At specialize_and_check step, all TYPEs used by Current expression are ready, so TYPE may be known for all sub-members (target, arguments) using resolve_in, if we take care to call specialize_and_check on them before calling resolve_in. So we can continue the specialization process and perform some validation checks knowing the TYPE of other components.

After this specialize_and_check has been called on Current, resolve_in can be used to know the Current expression result TYPE.

require

has_been_specialized
not smart_eiffel.status.is_specializing
may_report_an_error: error_handler.is_empty

ensure

has_been_specialized
Result.has_been_specialized
may_report_an_error: error_handler.is_empty

has_been_specialized: BOOLEAN

effective function

Used both for specialize_in and specialize_thru to indicate that we have all FEATURE_STAMPs ready for use and that FEATURE_NAMEs are no longer used (except for calls on non-current target who are available after specialize_and_check -- step).

Finally, also note that the purpose of this feature is mostly to write contracts (see also the strange ensure assertion).

ensure

assertion_check_only: Result

resolve_in (type: TYPE): TYPE

effective function

This method may be called to solve the Current expression type knowing that the Current expression has_been_specialized for the type given as an argument.

It is important to keep in mind that the resolve_in function must not be called from some specialize_in or specialize_thru function (those functions are used when *one* TYPE is created and current expression may refer to TYPEs not yet created). Hence, resolve_in calls are likely to occurs during the specialize_and_check process or later if it is necessary, but specialize_and_check *must* have been called on Current expression before resolve_in is called. One may also know that resolve_in function may be called one or more times or may not be called at all. (Note that the require assertion is checking that we are not currently doing some specialize_in or specialize_thru.)

require

has_been_specialized
not smart_eiffel.status.is_specializing
no_type_for_void: not is_void

ensure

Result /= Void

collect (type: TYPE): TYPE

effective function

Collect Current to become actually true live code in type knowing that Current already specialized in type.

The Result is used for EXPRESSION only to indicates its TYPE in the type context. Feature collect may be call more than once on the same target until for example the magic_count to be stabilized. Also note that, when not Void, the Result must be the one given by a similar resolve_in call.

- - AS THE NEW collect NOW ACCEPT VOID AS A TARGET, IT
  - CAN BE COOL TO TRACK is_void CALL PROTECTIONS.
  - (Dom April 6th 2008)

require

has_been_specialized
type.feature_collection_done
smart_eiffel.status.is_collecting
not smart_eiffel.status.is_specializing

ensure

Result /= Void implies Result = resolve_in(type)

adapt_for (type: TYPE): AGENT_CREATION

effective function

This function is called only once at the end of the compilation process (i.e. after collect inline_dynamic_dispatch and simplify).

During this last step RUN_FEATUREs are prepared too.

require

type /= Void
not smart_eiffel.short_or_class_check_flag

ensure

Result /= Void

non_void_no_dispatch_type (type: TYPE): TYPE

effective function

A non Void Result indicates that Current cannot be Void and that Current drives exactly to a single possible dynamic TYPE.

require

type /= Void
smart_eiffel.status.collecting_done

ensure

Result /= Void implies Result.live_type /= Void

simplify (type: TYPE): AGENT_CREATION

effective function

May return Current, Void or a simplified version of Current.

require

type /= Void
not smart_eiffel.pretty_flag
not smart_eiffel.short_or_class_check_flag
smart_eiffel.status.collecting_done

ensure

Result.is_an_acceptable_replacement(type, Current)
Result /= Current or Result = Void implies smart_eiffel.magic_count > old smart_eiffel.magic_count
Result = Current implies smart_eiffel.magic_count = old smart_eiffel.magic_count

accept (visitor: AGENT_CREATION_VISITOR)

effective procedure

Accept to be visited by the visitor.

require

visitor /= Void

is_void: BOOLEAN

is False

constant attribute

Is it the built-in Void?

is_writable: BOOLEAN

is False

constant attribute

Is is something that one can find on the left-hand-side of the := operator ?

is_manifest_string: BOOLEAN

is False

constant attribute

Is it a manifest string (i.e. a basic manifest string or some verbatim manifest string)?

is_static: BOOLEAN

is False

constant attribute

True if the expression has always the same static value regardless the context of the code.

For example, this is True for True, False, Void, 2, "foo", 2.5, etc.

is_result: BOOLEAN

is False

constant attribute

Is it the pseudo local variable Result ?

side_effect_free (type: TYPE): BOOLEAN

effective function

True when the evaluation of Current has no side effect at all (i.e. no memory allocated, no modification in the _heap_ memory, no external code with possible side effect).

Actually, when side_effect_free is True, Current can be evaluated more than once or not evaluated at all.

require

smart_eiffel.status.collecting_done
type /= Void

safety_check (type: TYPE)

effective procedure

require

smart_eiffel.status.is_safety_checking
type.live_type /= Void

use_current (type: TYPE): BOOLEAN

effective function

Is Current used?

require

smart_eiffel.status.collecting_done
type /= Void

bracketed_pretty (indent_level: INTEGER_32)

effective procedure

For pretty.

Add a bracket pair around Current only when it is necessary.

pretty (indent_level: INTEGER_32)

effective procedure

require

smart_eiffel.pretty_flag implies indent_level >= 1

pretty_target (indent_level: INTEGER_32)

effective procedure

For pretty.

Print the expression viewed as a target plus the corresponding dot when it necessary.

short (type: TYPE)

effective procedure

Produce the short command output in the given context type.

require

type /= Void

short_target (type: TYPE)

effective procedure

Produce the short command output in the given context type.

Same as short, but here, the Current expression is itself the target of some call, hence this call may add a dot (".") only when it is needed.

require

type /= Void

precedence: INTEGER_32

effective function

Handling of precedence (priority of expressions).

ensure

1 <= Result and Result <= atomic_precedence

specialize_and_check_function (type: TYPE): AGENT_CREATION

effective function

{}

require

code

specialize_and_check_procedure (type: TYPE): AGENT_CREATION

effective function

{}

require

code

mold_id_in (type: TYPE, buffer: STRING)

effective procedure

Identify the corresponding AGENT_CREATION function.

same_mold_id_as (other: AGENT_CREATION): BOOLEAN

effective function

set_code (c: CODE)

effective procedure

{AGENT_CREATION}

require

c /= Void

ensure

code = c

set_feature_stamp (fs: FEATURE_STAMP)

effective procedure

{AGENT_CREATION}

require

fs /= Void

ensure

feature_stamp = fs

set_open_operand_list (l: FAST_ARRAY[OPEN_OPERAND])

effective procedure

{AGENT_CREATION}

require

l.count = open_operand_list.count

make (sp: POSITION, function_call: FUNCTION_CALL, a_inline_feature: FEATURE_TEXT)

effective procedure

{}

require

not sp.is_unknown
function_call /= Void
a_inline_feature /= Void implies a_inline_feature.is_inline_agent

ensure

start_position.is_equal(sp)
code = function_call
inline_feature = a_inline_feature

inline_dynamic_dispatch_ (code_accumulator: CODE_ACCUMULATOR, type: TYPE)

effective procedure

{CODE, EFFECTIVE_ARG_LIST}

require

code_accumulator /= Void
type /= Void

ensure

code_accumulator.context_level = old code_accumulator.context_level

warn_omitted_open_arguments

effective procedure

{}

require

has_omitted_open_arguments

ensure

print_only_once: not has_omitted_open_arguments

omitted_open_arguments_update (omitted_arguments: EFFECTIVE_ARG_LIST)

effective procedure

{AGENT_CREATION}

require

omitted_arguments.count >= 1

ensure

has_omitted_open_arguments

stored_closed_operand (type: TYPE, closed_operand: CLOSED_OPERAND): BOOLEAN

effective function

Is the closed_operand stored inside the agent memory.

require

closed_operand /= Void

is_equal_used_in (agent_type: TYPE): BOOLEAN

effective function

Because it is quite uncommon to use is_equal between two agents, this feature make it easy to skip the corresponding runtime support.

require

agent_type.is_agent

set_inside_agent_launcher_flag (flag_value: BOOLEAN)

effective procedure

{C_LIVE_TYPE_COMPILER}

is_default_value: BOOLEAN

frozen

effective function

True if Current represents Void, False , 0, or whatever is a default value.

Also note that some default values like NULL_POINTER, cannot be written in pure Eiffel. (Thanks to the new ?:= operator, this is_default_value frozen definition is pretty fine.)

is_stored_in_some_local_variable: BOOLEAN

frozen

effective function

True if Current is stored in some local variable of the _target_ language.

It does not mean that Current is writable! The goal here is to avoid creating an extra local storage in the _target_ language.

static_simplify: EXPRESSION

effective function

This one is working completely out of context and is called directly by the parser only for some typical expressions.

require

not smart_eiffel.pretty_flag
not smart_eiffel.short_or_class_check_flag

ensure

Result /= Void

base_class_written: CLASS_TEXT

frozen

effective function

The base class where this expression is written.

require

not start_position.is_unknown

written_in: CLASS_NAME

frozen

effective function

The name of the base class where this expression is written.

require

not start_position.is_unknown

is_an_acceptable_replacement (type: TYPE, other: EXPRESSION): BOOLEAN

frozen

effective function

Well, it is just for debug (see ensure).

ensure

assertion_check_only: Result

inline_dynamic_dispatch (code_accumulator: CODE_ACCUMULATOR, type: TYPE): EXPRESSION

frozen

effective function

require

code_accumulator /= Void
type /= Void

ensure

code_accumulator.context_level = old code_accumulator.context_level
Result /= Void

bracketed_short (type: TYPE)

frozen

effective procedure

require

type /= Void

specialize_without_checks (type: TYPE): CODE

effective function

Perform specialize_and_check without checking the validity (export violations, ...)

Useful for generated code

require

has_been_specialized
not smart_eiffel.status.is_specializing

ensure

has_been_specialized
Result.has_been_specialized

to_expression: EXPRESSION

effective function

Safe down-casting.

require

Current

to_instruction: INSTRUCTION

effective function

Safe down-casting.

require

Current

is_not_a_compound: BOOLEAN

frozen

effective function

Mostly for assertion checks.

ensure

Result = not Current

inline_dynamic_dispatch_of (code_accumulator: CODE_ACCUMULATOR, type: TYPE, l: FAST_ARRAY[EXPRESSION]): FAST_ARRAY[EXPRESSION]

effective function

{}

require

not l.is_empty

ensure

Result.count = l.count

smart_eiffel: SMART_EIFFEL

frozen

once function

eiffel_parser: EIFFEL_PARSER

frozen

once function

ace: ACE

frozen

once function

ini_parser: INI_PARSER

frozen

once function

plugin_config: INI_PARSER

frozen

once function

error_handler: ERROR_HANDLER

frozen

once function

string_aliaser: STRING_ALIASER

frozen

once function

cpp: C_PRETTY_PRINTER

frozen

once function

pretty_printer: PRETTY_PRINTER

frozen

once function

mini_buffer: MINI_BUFFER

frozen

once function

nb_errors: INTEGER_32

effective function

ensure

Result >= 0

system_tools: SYSTEM_TOOLS

frozen

once function

introspection_handler: INTROSPECTION_HANDLER

frozen

once function

assignment_test_pool: ASSIGNMENT_TEST_POOL

frozen

once function

precomputable_routine_detector: PRECOMPUTABLE_ROUTINE_DETECTOR

frozen

once function

feature_accumulator: FEATURE_ACCUMULATOR

frozen

once function

live_type_extra_collectors: FAST_ARRAY[LIVE_TYPE_EXTRA_COLLECTOR]

frozen

once function

is_launcher: BOOLEAN

effective function

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

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

manifest_string_pool: MANIFEST_STRING_POOL

frozen

once function

manifest_generic_pool: MANIFEST_GENERIC_POOL

frozen

once function

once_routine_pool: ONCE_ROUTINE_POOL

frozen

once function

agent_pool: AGENT_POOL

frozen

once function

cecil_pool: CECIL_POOL

frozen

effective function

cecil_pool_memory: REFERENCE[CECIL_POOL]

frozen

once function

set_cecil_pool

frozen

once procedure

ensure

cecil_pool /= Void

short_printer: SHORT_PRINTER

frozen

once function

echo: ECHO

frozen

once function

assignment_handler: ASSIGNMENT_HANDLER

frozen

once function

thread_pool: THREAD_POOL

frozen

once function

exceptions: EXCEPTIONS

frozen

writable attribute

exceptions_handler: EXCEPTIONS_HANDLER

frozen

once function

nb_warnings: INTEGER_32

effective function

ensure

Result >= 0

tmp_path: STRING

once function

tmp_file_read: TEXT_FILE_READ

once function

class_any: CLASS_TEXT

once function

omitted_client_list: CLIENT_LIST

frozen

once function

(To avoid multiple creation(s).)

any_default_create_fs: FEATURE_STAMP

once function

any_default_rescue_fs: FEATURE_STAMP

once function

any_copy_fs: FEATURE_STAMP

once function

any_is_equal_fs: FEATURE_STAMP

once function

any_deep_twin_fs: FEATURE_STAMP

once function

any_is_deep_equal_fs: FEATURE_STAMP

once function

boolean_and_then_fs: FEATURE_STAMP

once function

manifest_make_name: HASHED_STRING

once function

manifest_put_name: HASHED_STRING

once function

manifest_semicolon_check_name: HASHED_STRING

once function

manifest_initialize_name: HASHED_STRING

once function

calloc_name: HASHED_STRING

once function

put_name: HASHED_STRING

once function

item_name: HASHED_STRING

once function

is_empty_name: HASHED_STRING

once function

make_name: HASHED_STRING

once function

from_external_sized_copy_name: HASHED_STRING

once function

count_name: HASHED_STRING

once function

storage_name: HASHED_STRING

once function

capacity_name: HASHED_STRING

once function

storage_lower_name: HASHED_STRING

once function

mark_item_name: HASHED_STRING

once function

mark_native_arrays_name: HASHED_STRING

once function

and_then_name: HASHED_STRING

once function

or_else_name: HASHED_STRING

once function

twin_name: HASHED_STRING

once function

copy_name: HASHED_STRING

once function

is_equal_name: HASHED_STRING

once function

deep_twin_name: HASHED_STRING

once function

deep_twin_from_name: HASHED_STRING

once function

is_deep_equal_name: HASHED_STRING

once function

deep_memcmp_name: HASHED_STRING

once function

se_atexit_name: HASHED_STRING

once function

default_rescue_name: HASHED_STRING

once function

default_create_name: HASHED_STRING

once function

flush_name: HASHED_STRING

once function

clear_all_name: HASHED_STRING

once function

from_pointer_name: HASHED_STRING

once function

no_errors: BOOLEAN

effective function

character_coding (c: CHARACTER, str: STRING)

effective procedure

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

Eiffel Source file suffix.

c_suffix: STRING

is ".c"

constant attribute

C files suffix.

h_suffix: STRING

is ".h"

constant attribute

Heading C files suffix.

c_plus_plus_suffix: STRING

is ".cpp"

constant attribute

C++ files suffix.

backup_suffix: STRING

is ".bak"

constant attribute

Backup suffix for command pretty.

class_suffix: STRING

is ".class"

constant attribute

dot_precedence: INTEGER_32

is 12

constant attribute

The highest precedence value according to ETL.

atomic_precedence: INTEGER_32

is 13

constant attribute

Used for atomic elements.

append_u1 (str: STRING, u1: INTEGER_32)

effective procedure

append_u2 (str: STRING, u2: INTEGER_32)

effective procedure

append_u4 (str: STRING, u4: INTEGER_32)

effective procedure

is_install: BOOLEAN

effective function

set_install

effective procedure

ensure

is_install

install_memory: REFERENCE[BOOLEAN]

once function

unrelated_code: INTEGER_8

is 0

constant attribute

inserts_code: INTEGER_8

is 1

constant attribute

inherits_code: INTEGER_8

is 2

constant attribute

strings: STRING_RECYCLING_POOL

once function

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

{}