class ACE
Summary
Assembly of Classes in Eiffel.
Both an ACE file parser and a facade to the universe (i.e. all the known classes).
This singleton is shared via the GLOBALS.ace once function.
Direct parents
Inherit list: PARSER
Insert list: ASSERTION_LEVEL_NUMBERING, DEBUG_KEY_SUPPORT, FLAG_NAME_LIST, SINGLETON
Class invariant
Overview
Features
{}
{ANY}
{CLASS_TEXT}
{DEBUG_COMPOUND}
{CLASS_TEXT}
{ACE_HANDLER}
{}
{ACE_HANDLER}
{}
  • class_name_using (name: STRING): STRING
    Compute some Eiffel class name using the name information which can be some complete file path notation with some Eiffel file suffix.
{COMPILE}
  • clean: BOOLEAN
    Should the clean command be launched after compilation?
{ACE_HANDLER}
{}
Class loading
{SMART_EIFFEL}
{}
{ANY}
{SMART_EIFFEL}
{ACE_CHECK}
  • pretty_in (txt: STRING)
    Performs the ace_check and also prepare in txt a pretty version of the ACE file as it is memorized (can be also used to pretty one's ACE file).
{SYSTEM_TOOLS, CLUSTER}
  • view_in (msg: STRING)
    Append in msg a viewable version of the cluster_list as well as some other informations to help the user to fix the problem.
{ANY}
{}
{CLUSTER}
{SYSTEM_TOOLS}
{C_PRETTY_PRINTER}
{}
{C_PRETTY_PRINTER, COMPILE_TO_C, STRING_COMMAND_LINE, LIVE_TYPE, SYSTEM_TOOLS}
{ANY}
{CLUSTER}
{}
{}
Maximum:
{}
Minimum:
{}
Bits:
{}
{ANY}
{ACE}
  • is_launcher: BOOLEAN
    If True, the clusters list will not be retrieved (it means that the tool is only used to start other tools; it does not load classes itself)
{SE, COMPILE}
{}
{SMART_EIFFEL, SYSTEM_TOOLS, VISITOR}
{ANY}
an option to minimize generic types
{}
Hard-coded class names:
{}
Hard coded feature names:
{}
Operator/Infix/Prefix/Alias list:
{}
Other names:
{}
The keywords section:
{}
Most of them are message parts:
{}
Some other names:
{}
The known keys of the INI file:
{}
{ANY}
{}
Most of them are command flag names:
{}
{ANY}
  • is_equal (other: ACE): BOOLEAN
    Is other attached to an object considered equal to current object?
{}
root_class_names: FAST_ARRAY[HASHED_STRING]
once function
{}
All the class names given on the command line
root_procedure_names: FAST_ARRAY[STRING]
once function
{}
All the procedure names given on the command line
executable_names: FAST_ARRAY[STRING]
once function
{}
All the executable names given on the command line
root_index: INTEGER_32
writable attribute
{}
executable_name_memory: STRING
writable attribute
{}
file_path: STRING
writable attribute
{ANY}
Non Void when a ACE file is in use (keep in mind that one can still launch a compilation without any ACE file, passing all the information using command arguments only).
Usually, ACE files are suffixed with ".ace" or ".ACE".
executable_name: STRING
effective function
{ANY}
The name of the executable to build (after the "system" keyword in the ACE file or after the -o flag in the command line).
In command line mode, a Void value means that "a.out" is to be used for C mode while using gcc for example.
root_class_name: HASHED_STRING
effective function
{ANY}
The name of the root class using only upper case letters.
This is actually the generating type of the very first live object at runtime. This root_class_name is after the "root" keyword in the ACE file or is given as a command line argument.
require
root_procedure_name: STRING
effective function
{ANY}
The name of the procedure which is actually the main program.
This procedure is supposed to be member of the creation clause of root_class_name.
require
need_path_id: BOOLEAN
writable attribute
{ANY}
True if a path_id is mandatory because the same root class is used more than once
has_root: BOOLEAN
effective function
{ANY}
True if root_class_name` and `root_procedure_name` are valid
next_root
effective procedure
{ANY}
require
reset_roots
effective procedure
{ANY}
root_count: INTEGER_32
effective function
{ANY}
boost1: BOOLEAN
is True
constant attribute
{ANY}
boost2: BOOLEAN
is False
constant attribute
{ANY}
boost3: BOOLEAN
is False
constant attribute
{ANY}
boost: BOOLEAN
effective function
{ANY}
no_check: BOOLEAN
effective function
{ANY}
The system level value (see also {CLASS_TEXT}.no_check).
require_check: BOOLEAN
effective function
{ANY}
ensure_check: BOOLEAN
effective function
{ANY}
invariant_check: BOOLEAN
effective function
{ANY}
loop_check: BOOLEAN
effective function
{ANY}
all_check: BOOLEAN
effective function
{ANY}
flat_check: BOOLEAN
writable attribute
{ANY}
Each assertion will be executed in no_check mode
no_main: BOOLEAN
writable attribute
{ANY}
Don't include a main() in the generated executable.
safety_check: BOOLEAN
writable attribute
{ANY}
manifest_string_trace: BOOLEAN
writable attribute
{ANY}
high_memory_compiler: BOOLEAN
writable attribute
{ANY}
      • Dom feb 7th 2005 ***
profile: BOOLEAN
writable attribute
{ANY}
Is the -profile flag used?
relax: BOOLEAN
writable attribute
{ANY}
Is the -relax flag used?
precompile_header: BOOLEAN
writable attribute
{ANY}
Is the -precompile_header flag used ?
sedb: BOOLEAN
effective function
{ANY}
The -sedb flag is used or some class of the ACE file in trace mode.
(When sedb is set, files sys/runtime/sedb.[ch] are included.)
run: BOOLEAN
writable attribute
{ANY}
clean_classes: BOOLEAN
writable attribute
{ANY}
hard_clean: BOOLEAN
writable attribute
{ANY}
trace_of (a_class_text: CLASS_TEXT): BOOLEAN
effective function
Is the -sedb trace mode enabled for a_class_text.
is_debug_checked (e_debug: DEBUG_COMPOUND, type: TYPE): BOOLEAN
effective function
Is this e_debug statement is active or not?
Note: during the execution of this routine, the default_assertion_level may be switched from level_boost to level_no.
require
  • e_debug /= Void
assertion_level_of (a_class_text: CLASS_TEXT): INTEGER_32
effective function
require
  • avoid_recomputation: a_class_text.assertion_level_not_yet_computed
ensure
analyse_ace_file (fp: STRING)
effective procedure
Parse fp which is supposed to be some file containing an ACE description.
require ensure
set_default_c_mode
effective procedure
{}
set_root_class_name_using (command_line_name: STRING)
effective procedure
Compute the root_class_name name using the command_line_name as a model.
Trailing Eiffel file suffix is removed if any. Leading path is also removed if any. Finally, the feature to_upper is applied.
require
  • not command_line_name.is_empty
ensure
set_root_class_name (rcn: HASHED_STRING)
effective procedure
set_root_procedure_name (rp: STRING)
effective procedure
require ensure
class_name_using (name: STRING): STRING
effective function
{}
Compute some Eiffel class name using the name information which can be some complete file path notation with some Eiffel file suffix.
The result is written using the standard Eiffel notation for class names (upper case letters only).
require
  • not name.is_empty
clean: BOOLEAN
writable attribute
Should the clean command be launched after compilation?
set_relax
effective procedure
set_precompile_header
effective procedure
require
set_default_level
effective procedure
set_boost
effective procedure
set_no_check
effective procedure
set_require_check
effective procedure
set_ensure_check
effective procedure
set_invariant_check
effective procedure
set_loop_check
effective procedure
set_all_check
effective procedure
set_debug_check
effective procedure
set_command_line_debug
effective procedure
set_flat_check
effective procedure
command_line_parsed (command_name: STRING)
effective procedure
Should be called the end of command line argument parsing (i.e. only in command line mode) to check among other things that the root class was actually given as argument.
set_default_trace
effective procedure
ensure
set_executable_name (name: STRING)
effective procedure
ensure
set_clean (flag: BOOLEAN)
effective procedure
set_safety_check
effective procedure
set_manifest_string_trace
effective procedure
set_high_memory_compiler
effective procedure
set_profile
effective procedure
set_run
effective procedure
set_clean_classes
effective procedure
set_hard_clean
effective procedure
best_cluster_of (origin: CLASSES, class_name: CLASS_NAME, skip: CLASSES): CLUSTER
effective function
{}
clusters_: FAST_ARRAY[CLUSTER]
once function
{}
distances_: FAST_ARRAY[INTEGER_32]
once function
{}
clusters_all_: FAST_ARRAY[CLUSTER]
once function
{}
distances_all_: FAST_ARRAY[INTEGER_32]
once function
{}
cluster_named (cluster_name: STRING): CLUSTER
effective function
require
  • not cluster_name.is_empty
  • string_aliaser.registered_one(cluster_name)
ensure
  • Result /= Void implies Result.name.is_equal(cluster_name)
cluster_of (class_name: CLASS_NAME, start_cluster: CLUSTER): CLUSTER
effective function
require
  • class_name /= Void
ensure
  • Result = Void implies class_name.allow_missing
all_class_texts (class_name: CLASS_NAME): FAST_ARRAY[CLASS_TEXT]
effective function
class_text (class_name: CLASS_NAME, load: BOOLEAN, cluster: CLUSTER): CLASS_TEXT
effective function
The load flag must be True if we want to load the class if it is not already loaded.
If False, we don't load the class and the result may be Void. If cluster is not Void it overrides the information in class_name.
require
  • class_name /= Void
ensure
  • Result = Void implies class_name.allow_missing
remove (a_class_text: CLASS_TEXT)
effective procedure
class_text_count: INTEGER_32
effective function
find_class_text (class_name: CLASS_NAME, load: BOOLEAN, a_cluster: CLUSTER): CLASS_TEXT
effective function
{}
require
  • class_name /= Void
once function
{}
has (class_name: HASHED_STRING): BOOLEAN
effective function
{ANY}
parse_include
effective procedure
Look for some class(es) to be loaded first because of some "include" option.
cluster_by_directory_path (path: STRING): CLUSTER
effective function
require
  • not path.is_empty
ensure
  • Result /= Void implies Result.directory_path.is_equal(path)
pretty_in (txt: STRING)
effective procedure
Performs the ace_check and also prepare in txt a pretty version of the ACE file as it is memorized (can be also used to pretty one's ACE file).
require
view_in (msg: STRING)
effective procedure
Append in msg a viewable version of the cluster_list as well as some other informations to help the user to fix the problem.
require
  • msg /= Void
cluster_count: INTEGER_32
effective function
{ANY}
cluster_at (i: INTEGER_32): CLUSTER
effective function
{ANY}
get_started
effective procedure
{}
Should be called to set some default values at the end of command line parsing or at the end of the ACE file parsing.
highest_encountered_level: INTEGER_32
writable attribute
{}
The highest encountered one in the whole ACE file.
(Used to compute the C mode to use.)
default_trace: BOOLEAN
writable attribute
Code generated with the -sedb flag way is the default for all classes of the ACE file (see also sedb).
default_assertion_level: INTEGER_32
writable attribute
The default assertion level mangled using constants and tools from class ASSERTION_LEVEL_NUMBERING.
This value memorize the command line flag such as (-boost, -no_check, -require_check, ...). When the ACE file is used, this value memorize the information after "assertion" tag of the default section.
default_debug (e_debug: DEBUG_COMPOUND): BOOLEAN
effective function
require
  • e_debug /= Void
add_loadpath (name: STRING, path: STRING, distance: INTEGER_32, discard_silently: BOOLEAN)
effective procedure
require
splitter: C_SPLITTER
effective function
The splitter to use
ensure
  • Result /= Void
splitter_memory: C_SPLITTER
writable attribute
{}
set_no_split (flag: BOOLEAN)
effective procedure
ensure
set_split (value: STRING)
effective procedure
ensure
for_all (action: PROCEDURE[TUPLE 1[CLASS_TEXT]])
effective procedure
{ANY}
for_all_filtered (name_guard: FUNCTION[TUPLE 1[CLASS_NAME], BOOLEAN], action: PROCEDURE[TUPLE 1[CLASS_TEXT]])
effective procedure
{ANY}
for_all_clusters (action: PROCEDURE[TUPLE 1[CLUSTER]])
effective procedure
{ANY}
loaded_class_count: INTEGER_32
effective function
{ANY}
new_cluster (a_cluster: CLUSTER)
effective procedure
new_clusters: FAST_ARRAY[CLUSTER]
once function
{}
update_last_manifest_string (p: POSITION, once_flag: BOOLEAN, unicode_flag: BOOLEAN, string: STRING, source_view: STRING)
effective procedure
{}
may_expand_var
effective procedure
{}
Expand an environment variable in curly brackets into buffer, if variable expansion is active.
Else just append '$' to buffer.
a_identifier: STRING
effective function
{}
Analyse an Eiffel identifier.
ensure
a_string: STRING
effective function
{}
Analyse a notation like the one for manifest strings, returning only the content of the manifest string and expanding system environment variables (syntax: ${name})
ensure
  • Result = buffer
  • not Result.is_empty
a_cluster_mark
effective procedure
{}
a_system_level_defaults: BOOLEAN
effective function
{}
The Result is used to delay the echo.is_verbose value setting
a_collect_value
effective procedure
{}
a_cluster_clause_list: BOOLEAN
effective function
{}
++ clusters --> "cluster" { cluster_clause ";" ...}
a_cluster_clause: BOOLEAN
effective function
{}
++ cluster_clause --> [cluster_tag] ++ directory_name ++ directory_name/loadpath.se ++ cluster_properties
new_universe_entry (distance: INTEGER_32, path: STRING, name: STRING)
effective procedure
{}
require
  • distance > 0
  • path /= Void
  • string_aliaser.registered_one(path)
  • name /= Void
a_cluster_properties
effective procedure
{}
++ cluster_properties --> ++ [use] ++ [include] ++ [exclude] ++ [name_adaptation] ++ [default] ++ [options] ++ [visible]
a_option_in_cluster_properties: BOOLEAN
effective function
{}
Possible option after the keyword "option" in one cluster description.
a_class_name: BOOLEAN
effective function
{}
A single class name strictly written using only uppercase letter in order to avoid any possible ambiguities.
When the Result True, the corresponding class name is stored as usual in the token_buffer buffer.
a_external
effective procedure
{}
a_generate
effective procedure
{}
a_yes_no_all: BOOLEAN
effective function
{}
Return True for a notation like "(yes)" or for a notation like "(all)".
Return False for a notation like "(no)".
a_yes_no_all_inside: BOOLEAN
effective function
{}
Return True for a notation like "(yes)" or for a notation like "(all)".
Return False for a notation like "(no)".
a_assertion_level: INTEGER_32
effective function
{}
ensure
a_debug_key: STRING
effective function
{}
Return some acceptable notation for a debug key: "yes", "no" or some user defined key.
a_split_key: STRING
effective function
{}
Return some acceptable notation for a split key: "yes", "no" or some user defined key.
a_cecil_file: STRING
effective function
{}
Return some acceptable notation for a cecil file
effective function
{}
Initialize a new one at line l and column c.
require
  • l >= 1
  • c >= 1
universe: UNIVERSE
once function
{}
has_cluster (c: CLUSTER): BOOLEAN
effective function
{}
require
  • c /= Void
fatal_error_in (section_name: STRING)
effective procedure
{}
set_highest_encountered_level (level: INTEGER_32)
effective procedure
{}
sedb_flag: BOOLEAN
writable attribute
{}
line: INTEGER_32
writable attribute
{}
Current line number and current column number.
column: INTEGER_32
writable attribute
{}
Current line number and current column number.
current_line: STRING
writable attribute
{}
Current line string of text.
writable attribute
{}
Current character in the current_line.
end_of_text: CHARACTER
is '%/0/'
constant attribute
{}
Flag of the end of the text.
last_manifest_string: MANIFEST_STRING
writable attribute
{}
S_somewhere_inside_manifest_string: INTEGER_8
is 0
constant attribute
{}
S_just_after_a_percent_character: INTEGER_8
is 1
constant attribute
{}
S_extended_form_at_end_of_line: INTEGER_8
is 2
constant attribute
{}
S_extended_form_at_beginning_of_line: INTEGER_8
is 3
constant attribute
{}
S_inside_ascii_code_after_slash: INTEGER_8
is 4
constant attribute
{}
S_inside_ascii_code_after_slash_0x: INTEGER_8
is 5
constant attribute
{}
S_inside_unicode_after_slash_ux: INTEGER_8
is 6
constant attribute
{}
S_after_multiline_open_square: INTEGER_8
is 7
constant attribute
{}
S_after_multiline_open_curly: INTEGER_8
is 8
constant attribute
{}
S_inside_multiline_closing: INTEGER_8
is 9
constant attribute
{}
S_end_of_correct_manifest_string: INTEGER_8
is 10
constant attribute
{}
S_error_in_manifest_string: INTEGER_8
is 11
constant attribute
{}
a_manifest_string (skip_comments_flag: BOOLEAN): BOOLEAN
effective function
{}
buffer: STRING
once function
{}
unicode_string_buffer: UNICODE_STRING
once function
{}
go_back_at (l: INTEGER_32, c: INTEGER_32)
effective procedure
{}
Go back to some existing line l, and column c.
require
  • l >= 1
  • c >= 1
last_comment: COMMENT
writable attribute
{}
Void or waiting comment.
drop_comments: BOOLEAN
writable attribute
{}
When objects COMMENT are not necessary.
skipped_new_line: BOOLEAN
writable attribute
{}
True when the last skip_comments skipped a new-line
skip_comments
effective procedure
{}
Skip separators and comments if any.
Unless drop_comments, comments are stored in last_comment.
next_char
effective procedure
{}
start_line: INTEGER_32
writable attribute
{}
To store beginning position of : a_keyword, a_integer, a_real, skip1, skip2 and skip1unless2.
start_column: INTEGER_32
writable attribute
{}
To store beginning position of : a_keyword, a_integer, a_real, skip1, skip2 and skip1unless2.
a_keyword (keyword: STRING): BOOLEAN
effective function
{}
Look for a keyword beginning strictly at current position, then, skip_comment is automatically called.
A keyword is never followed by a character of this set: {'A'..'Z','a'..'z','0'..'9','_'}.
require
  • keyword.count >= 1
  • not keyword.has('%N')
skip1 (char: CHARACTER): BOOLEAN
effective function
{}
current_position: POSITION
effective function
{}
lcs: STRING
once function
{}
Last Comment String.
token_buffer: TOKEN_BUFFER
writable attribute
{}
The temporary buffer for some name.
em1: STRING
is "Underscore in fractional part must group 3 digits."
constant attribute
{}
em2: STRING
is "Right hand side expression of := assignment expected here."
constant attribute
{}
em3: STRING
is "Index value expected ("indexing ...")."
constant attribute
{}
em4: STRING
is "Error in inspect."
constant attribute
{}
em5: STRING
is "Added missing ","."
constant attribute
{}
em6: STRING
is "Added missing ";"."
constant attribute
{}
em8: STRING
is "Unexpected new line in manifest string."
constant attribute
{}
em10: STRING
is "Right hand side expression of ::= assignment expected here."
constant attribute
{}
em11: STRING
is "Bad clients list."
constant attribute
{}
em12: STRING
is "Deleted extra comma."
constant attribute
{}
em13: STRING
is "Deleted extra separator."
constant attribute
{}
em14: STRING
is "Variable `Result' is valid only inside a function."
constant attribute
{}
em16: STRING
is "Type mark expected."
constant attribute
{}
em17: STRING
is "Unexpected character."
constant attribute
{}
em18: STRING
is "Deleted useless keyword."
constant attribute
{}
em19: STRING
is "Added missing brackets to enclose the previous "once" manifest STRING."
constant attribute
{}
em20: STRING
is "Right hand side expression of ?= assignment expected here."
constant attribute
{}
em21: STRING
is "Expression expected after assignment test "?:="."
constant attribute
{}
em22: STRING
is "Bad creation/create (writable expected)."
constant attribute
{}
em23: STRING
is "Bad creation/create (procedure name expected)."
constant attribute
{}
em24: STRING
is "Deleted extra semi-colon."
constant attribute
{}
em26: STRING
is "Same identifier appears twice (local/formal)."
constant attribute
{}
em26_2: STRING
is "Same identifier appears twice (local/closure)."
constant attribute
{}
em27: STRING
is "Added missing "("."
constant attribute
{}
em28: STRING
is "Added missing ")"."
constant attribute
{}
em29: STRING
is "Added missing ":"."
constant attribute
{}
em30: STRING
is "Expected "[" (to start generic argument list)."
constant attribute
{}
em31: STRING
is "Expected "]" (to finish generic argument list)."
constant attribute
{}
em32: STRING
is "Type mark expected."
constant attribute
{}
em34: STRING
is "Bad agent (call expected)."
constant attribute
{}
em36: STRING
is "Closing "}" expected."
constant attribute
{}
em37: STRING
is "Unknown special character."
constant attribute
{}
em38: STRING
is "Unexpected character in decimal ascii code."
constant attribute
{}
em39: STRING
is "Bad (empty?) ascii code."
constant attribute
{}
em40: STRING
is "Decimal CHARACTER code out of range."
constant attribute
{}
em41: STRING
is "Error inside multi-line manifest string."
constant attribute
{}
em42: STRING
is "Extra blank or tab character removed in multi-line manifest string."
constant attribute
{}
em43: STRING
is "Invalid free operator (the last character must be a member of this +-*/\=<>@#|& character list.)."
constant attribute
{}
em44: STRING
is "Invalid free operator. (This character cannot be used.)"
constant attribute
{}
em45: STRING
is "Unexpected character in hexadecimal ascii code."
constant attribute
{}
em46: STRING
is "Unexpected character in hexadecimal unicode."
constant attribute
{}
Maximum_character_code: INTEGER_16
{}
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
Number of bits in a value of type POINTER.
smart_eiffel: SMART_EIFFEL
frozen
once function
{ANY}
eiffel_parser: EIFFEL_PARSER
frozen
once function
{ANY}
ace: ACE
frozen
once function
{ANY}
ini_parser: INI_PARSER
frozen
once function
{ANY}
plugin_config: INI_PARSER
frozen
once function
{ANY}
error_handler: ERROR_HANDLER
frozen
once function
{ANY}
string_aliaser: STRING_ALIASER
frozen
once function
{ANY}
frozen
once function
{ANY}
pretty_printer: PRETTY_PRINTER
frozen
once function
{ANY}
mini_buffer: MINI_BUFFER
frozen
once function
{ANY}
nb_errors: INTEGER_32
effective function
{ANY}
ensure
  • Result >= 0
system_tools: SYSTEM_TOOLS
frozen
once function
{ANY}
introspection_handler: INTROSPECTION_HANDLER
frozen
once function
{ANY}
assignment_test_pool: ASSIGNMENT_TEST_POOL
frozen
once function
{ANY}
precomputable_routine_detector: PRECOMPUTABLE_ROUTINE_DETECTOR
frozen
once function
{ANY}
feature_accumulator: FEATURE_ACCUMULATOR
frozen
once function
{ANY}
live_type_extra_collectors: FAST_ARRAY[LIVE_TYPE_EXTRA_COLLECTOR]
frozen
once function
{ANY}
is_launcher: BOOLEAN
effective function
{ACE}
If True, the clusters list will not be retrieved (it means that the tool is only used to start other tools; it does not load classes itself)
set_launcher
effective procedure
ensure
is_launcher_memory: REFERENCE[BOOLEAN]
once function
{}
parser_buffer: PARSER_BUFFER
frozen
once function
id_provider: ID_PROVIDER
frozen
once function
{ANY}
manifest_string_pool: MANIFEST_STRING_POOL
frozen
once function
{ANY}
manifest_generic_pool: MANIFEST_GENERIC_POOL
frozen
once function
{ANY}
once_routine_pool: ONCE_ROUTINE_POOL
frozen
once function
{ANY}
agent_pool: AGENT_POOL
frozen
once function
{ANY}
cecil_pool: CECIL_POOL
frozen
effective function
{ANY}
cecil_pool_memory: REFERENCE[CECIL_POOL]
frozen
once function
{ANY}
set_cecil_pool
frozen
once procedure
{ANY}
ensure
short_printer: SHORT_PRINTER
frozen
once function
{ANY}
echo: ECHO
frozen
once function
{ANY}
assignment_handler: ASSIGNMENT_HANDLER
frozen
once function
{ANY}
thread_pool: THREAD_POOL
frozen
once function
{ANY}
exceptions: EXCEPTIONS
frozen
writable attribute
{ANY}
exceptions_handler: EXCEPTIONS_HANDLER
frozen
once function
{ANY}
nb_warnings: INTEGER_32
effective function
{ANY}
ensure
  • Result >= 0
tmp_path: STRING
once function
{ANY}
tmp_file_read: TEXT_FILE_READ
once function
{ANY}
class_any: CLASS_TEXT
once function
{ANY}
omitted_client_list: CLIENT_LIST
frozen
once function
{ANY}
(To avoid multiple creation(s).)
any_default_create_fs: FEATURE_STAMP
once function
{ANY}
any_default_rescue_fs: FEATURE_STAMP
once function
{ANY}
any_copy_fs: FEATURE_STAMP
once function
{ANY}
any_is_equal_fs: FEATURE_STAMP
once function
{ANY}
any_deep_twin_fs: FEATURE_STAMP
once function
{ANY}
any_is_deep_equal_fs: FEATURE_STAMP
once function
{ANY}
boolean_and_then_fs: FEATURE_STAMP
once function
{ANY}
manifest_make_name: HASHED_STRING
once function
{ANY}
manifest_put_name: HASHED_STRING
once function
{ANY}
manifest_semicolon_check_name: HASHED_STRING
once function
{ANY}
manifest_initialize_name: HASHED_STRING
once function
{ANY}
calloc_name: HASHED_STRING
once function
{ANY}
put_name: HASHED_STRING
once function
{ANY}
item_name: HASHED_STRING
once function
{ANY}
is_empty_name: HASHED_STRING
once function
{ANY}
make_name: HASHED_STRING
once function
{ANY}
from_external_sized_copy_name: HASHED_STRING
once function
{ANY}
count_name: HASHED_STRING
once function
{ANY}
storage_name: HASHED_STRING
once function
{ANY}
capacity_name: HASHED_STRING
once function
{ANY}
storage_lower_name: HASHED_STRING
once function
{ANY}
mark_item_name: HASHED_STRING
once function
{ANY}
mark_native_arrays_name: HASHED_STRING
once function
{ANY}
and_then_name: HASHED_STRING
once function
{ANY}
or_else_name: HASHED_STRING
once function
{ANY}
twin_name: HASHED_STRING
once function
{ANY}
copy_name: HASHED_STRING
once function
{ANY}
is_equal_name: HASHED_STRING
once function
{ANY}
deep_twin_name: HASHED_STRING
once function
{ANY}
deep_twin_from_name: HASHED_STRING
once function
{ANY}
is_deep_equal_name: HASHED_STRING
once function
{ANY}
deep_memcmp_name: HASHED_STRING
once function
{ANY}
se_atexit_name: HASHED_STRING
once function
{ANY}
default_rescue_name: HASHED_STRING
once function
{ANY}
default_create_name: HASHED_STRING
once function
{ANY}
flush_name: HASHED_STRING
once function
{ANY}
clear_all_name: HASHED_STRING
once function
{ANY}
from_pointer_name: HASHED_STRING
once function
{ANY}
no_errors: BOOLEAN
effective function
{ANY}
character_coding (c: CHARACTER, str: STRING)
effective procedure
{ANY}
Append in str the Eiffel coding of the character (Table in chapter 25 of ETL, page 423).%%%%%%%%
When the % letter notation exists, it is returned in priority: '%N' gives "%N", '%T' gives "%T", etc. When % letter notation does not exists (not in the ETL table), numbered coding used ("%/1/", "%/2/" etc).
eiffel_suffix: STRING
is ".e"
constant attribute
{ANY}
Eiffel Source file suffix.
c_suffix: STRING
is ".c"
constant attribute
{ANY}
C files suffix.
h_suffix: STRING
is ".h"
constant attribute
{ANY}
Heading C files suffix.
c_plus_plus_suffix: STRING
is ".cpp"
constant attribute
{ANY}
C++ files suffix.
backup_suffix: STRING
is ".bak"
constant attribute
{ANY}
Backup suffix for command pretty.
class_suffix: STRING
is ".class"
constant attribute
{ANY}
dot_precedence: INTEGER_32
is 12
constant attribute
{ANY}
The highest precedence value according to ETL.
atomic_precedence: INTEGER_32
is 13
constant attribute
{ANY}
Used for atomic elements.
append_u1 (str: STRING, u1: INTEGER_32)
effective procedure
{ANY}
append_u2 (str: STRING, u2: INTEGER_32)
effective procedure
{ANY}
append_u4 (str: STRING, u4: INTEGER_32)
effective procedure
{ANY}
is_install: BOOLEAN
effective function
{ANY}
set_install
effective procedure
{ANY}
ensure
install_memory: REFERENCE[BOOLEAN]
once function
{ANY}
unrelated_code: INTEGER_8
is 0
constant attribute
{ANY}
inserts_code: INTEGER_8
is 1
constant attribute
{ANY}
inherits_code: INTEGER_8
is 2
constant attribute
{ANY}
once function
{ANY}
shrink_generic_types: BOOLEAN
effective function
{}
shrink_generic_types_memory: REFERENCE[BOOLEAN]
once function
{}
Set the item to True if you want less generic type duplication
as_any: STRING
is "ANY"
constant attribute
{}
as_array: STRING
is "ARRAY"
constant attribute
{}
as_boolean: STRING
is "BOOLEAN"
constant attribute
{}
as_character: STRING
is "CHARACTER"
constant attribute
{}
as_disposable: STRING
is "DISPOSABLE"
constant attribute
{}
as_exceptions: STRING
is "EXCEPTIONS"
constant attribute
{}
as_fixed_array: STRING
is "FAST_ARRAY"
constant attribute
{}
as_function: STRING
is "FUNCTION"
constant attribute
{}
as_integer_general: STRING
is "INTEGER_GENERAL"
constant attribute
{}
as_integer_8: STRING
is "INTEGER_8"
constant attribute
{}
as_integer_16: STRING
is "INTEGER_16"
constant attribute
{}
as_integer_32: STRING
is "INTEGER_32"
constant attribute
{}
as_integer: STRING
is "INTEGER"
constant attribute
{}
as_integer_64: STRING
is "INTEGER_64"
constant attribute
{}
as_internals: STRING
is "INTERNALS"
constant attribute
{}
as_internals_handler: STRING
is "INTERNALS_HANDLER"
constant attribute
{}
as_native_array: STRING
is "NATIVE_ARRAY"
constant attribute
{}
as_native_array_collector: STRING
is "NATIVE_ARRAY_COLLECTOR"
constant attribute
{}
as_native_array_internals: STRING
is "NATIVE_ARRAY_INTERNALS"
constant attribute
{}
as_natural: STRING
is "NATURAL"
constant attribute
{}
as_natural_8: STRING
is "NATURAL_8"
constant attribute
{}
as_natural_16: STRING
is "NATURAL_16"
constant attribute
{}
as_natural_32: STRING
is "NATURAL_32"
constant attribute
{}
as_natural_64: STRING
is "NATURAL_64"
constant attribute
{}
as_natural_general: STRING
is "NATURAL_GENERAL"
constant attribute
{}
as_platform: STRING
is "PLATFORM"
constant attribute
{}
as_pointer: STRING
is "POINTER"
constant attribute
{}
as_predicate: STRING
is "PREDICATE"
constant attribute
{}
as_procedure: STRING
is "PROCEDURE"
constant attribute
{}
as_real_general: STRING
is "REAL_GENERAL"
constant attribute
{}
as_real_32: STRING
is "REAL_32"
constant attribute
{}
as_real: STRING
is "REAL"
constant attribute
{}
as_real_64: STRING
is "REAL_64"
constant attribute
{}
as_real_80: STRING
is "REAL_80"
constant attribute
{}
as_real_128: STRING
is "REAL_128"
constant attribute
{}
as_real_extended: STRING
is "REAL_EXTENDED"
constant attribute
{}
as_routine: STRING
is "ROUTINE"
constant attribute
{}
as_set: STRING
is "SET"
constant attribute
{}
as_string: STRING
is "STRING"
constant attribute
{}
as_text_file_read: STRING
is "TEXT_FILE_READ"
constant attribute
{}
as_text_file_write: STRING
is "TEXT_FILE_WRITE"
constant attribute
{}
as_thread_context: STRING
is "THREAD_CONTEXT"
constant attribute
{}
as_thread_lock: STRING
is "THREAD_LOCK"
constant attribute
{}
as_tuple: STRING
is "TUPLE"
constant attribute
{}
as_type: STRING
is "TYPE"
constant attribute
{}
as_typed_internals: STRING
is "TYPED_INTERNALS"
constant attribute
{}
as_unicode_string: STRING
is "UNICODE_STRING"
constant attribute
{}
as_weak_reference: STRING
is "WEAK_REFERENCE"
constant attribute
{}
as_a1: STRING
is "a1"
constant attribute
{}
as_add_last: STRING
is "add_last"
constant attribute
{}
as_agent: STRING
is "agent"
constant attribute
{}
as_allocated_bytes: STRING
is "allocated_bytes"
constant attribute
{}
as_alloc_native_data: STRING
is "alloc_native_data"
constant attribute
{}
as_as_16_ne: STRING
is "as_16_ne"
constant attribute
{}
as_as_32_ne: STRING
is "as_32_ne"
constant attribute
{}
as_atan2: STRING
is "atan2"
constant attribute
{}
as_blank: STRING
is "blank"
constant attribute
{}
as_bit_clear: STRING
is "bit_clear"
constant attribute
{}
as_bit_put: STRING
is "bit_put"
constant attribute
{}
as_bit_rotate: STRING
is "bit_rotate"
constant attribute
{}
as_bit_set: STRING
is "bit_set"
constant attribute
{}
as_bit_xor: STRING
is "bit_xor"
constant attribute
{}
as_boolean_bits: STRING
is "Boolean_bits"
constant attribute
{}
as_call: STRING
is "call"
constant attribute
{}
as_calloc: STRING
is "calloc"
constant attribute
{}
as_capacity: STRING
is "capacity"
constant attribute
{}
as_ceiling: STRING
is "ceiling"
constant attribute
{}
as_character_bits: STRING
is "Character_bits"
constant attribute
{}
as_clear_all: STRING
is "clear_all"
constant attribute
{}
as_count: STRING
is "count"
constant attribute
{}
as_code: STRING
is "code"
constant attribute
{}
as_collecting: STRING
is "collecting"
constant attribute
{}
as_collection_off: STRING
is "collection_off"
constant attribute
{}
as_collection_on: STRING
is "collection_on"
constant attribute
{}
as_collector_counter: STRING
is "collector_counter"
constant attribute
{}
as_copy: STRING
is "copy"
constant attribute
{}
as_c_inline_c: STRING
is "c_inline_c"
constant attribute
{}
as_c_inline_h: STRING
is "c_inline_h"
constant attribute
{}
as_default_create: STRING
is "default_create"
constant attribute
{}
as_default_rescue: STRING
is "default_rescue"
constant attribute
{}
as_deep_memcmp: STRING
is "deep_memcmp"
constant attribute
{}
as_deep_twin: STRING
is "deep_twin"
constant attribute
{}
as_deep_twin_from: STRING
is "deep_twin_from"
constant attribute
{}
as_dispose: STRING
is "dispose"
constant attribute
{}
as_die_with_code: STRING
is "die_with_code"
constant attribute
{}
as_element_sizeof: STRING
is "element_sizeof"
constant attribute
{}
as_exception: STRING
is "exception"
constant attribute
{}
as_for_object: STRING
is "for_object"
constant attribute
{}
as_type_can_be_assigned_to_attribute: STRING
is "type_can_be_assigned_to_attribute"
constant attribute
{}
as_type_can_be_assigned_to_item: STRING
is "type_can_be_assigned_to_item"
constant attribute
{}
as_type_attribute_count: STRING
is "type_attribute_count"
constant attribute
{}
as_type_attribute_generator: STRING
is "type_attribute_generator"
constant attribute
{}
as_type_attribute_generating_type: STRING
is "type_attribute_generating_type"
constant attribute
{}
as_type_attribute_is_expanded: STRING
is "type_attribute_is_expanded"
constant attribute
{}
as_type_attribute_name: STRING
is "type_attribute_name"
constant attribute
{}
as_fifth: STRING
is "fifth"
constant attribute
{}
as_first: STRING
is "first"
constant attribute
{}
as_floor: STRING
is "floor"
constant attribute
{}
as_flush: STRING
is "flush"
constant attribute
{}
as_fourth: STRING
is "fourth"
constant attribute
{}
as_force_to_integer_16: STRING
is "force_to_integer_16"
constant attribute
{}
as_force_to_integer_32: STRING
is "force_to_integer_32"
constant attribute
{}
as_force_to_integer_64: STRING
is "force_to_integer_64"
constant attribute
{}
as_force_to_natural_16: STRING
is "force_to_natural_16"
constant attribute
{}
as_force_to_natural_32: STRING
is "force_to_natural_32"
constant attribute
{}
as_force_to_natural_64: STRING
is "force_to_natural_64"
constant attribute
{}
as_force_to_real_32: STRING
is "force_to_real_32"
constant attribute
{}
as_force_to_real_64: STRING
is "force_to_real_64"
constant attribute
{}
as_free_native_data: STRING
is "free_native_data"
constant attribute
{}
as_from_external_sized_copy: STRING
is "from_external_sized_copy"
constant attribute
{}
as_from_pointer: STRING
is "from_pointer"
constant attribute
{}
as_full_collect: STRING
is "full_collect"
constant attribute
{}
as_generating_type: STRING
is "generating_type"
constant attribute
{}
as_generator: STRING
is "generator"
constant attribute
{}
as_io: STRING
is "io"
constant attribute
{}
as_integer_bits: STRING
is "Integer_bits"
constant attribute
{}
as_internals_from_generating_type: STRING
is "internals_from_generating_type"
constant attribute
{}
as_is_basic_expanded_type: STRING
is "is_basic_expanded_type"
constant attribute
{}
as_is_deep_equal: STRING
is "is_deep_equal"
constant attribute
{}
as_is_equal: STRING
is "is_equal"
constant attribute
{}
as_do_at_exit: STRING
is "do_at_exit"
constant attribute
{}
as_is_empty: STRING
is "is_empty"
constant attribute
{}
as_is_finished: STRING
is "is_finished"
constant attribute
{}
as_is_infinity: STRING
is "is_infinity"
constant attribute
{}
as_is_locked: STRING
is "is_locked"
constant attribute
{}
as_is_normal: STRING
is "is_normal"
constant attribute
{}
as_is_not_a_number: STRING
is "is_not_a_number"
constant attribute
{}
as_is_not_null: STRING
is "is_not_null"
constant attribute
{}
as_is_started: STRING
is "is_started"
constant attribute
{}
as_is_subnormal: STRING
is "is_subnormal"
constant attribute
{}
as_item: STRING
is "item"
constant attribute
{}
as_last: STRING
is "last"
constant attribute
{}
as_lock: STRING
is "lock"
constant attribute
{}
as_lower: STRING
is "lower"
constant attribute
{}
as_low_8: STRING
is "low_8"
constant attribute
{}
as_low_16: STRING
is "low_16"
constant attribute
{}
as_low_32: STRING
is "low_32"
constant attribute
{}
as_native_array_internals_from_generating_type: STRING
is "native_array_internals_from_generating_type"
constant attribute
{}
as_make: STRING
is "make"
constant attribute
{}
as_make_blank: STRING
is "make_blank"
constant attribute
{}
as_mark_item: STRING
is "mark_item"
constant attribute
{}
as_mark_native_arrays: STRING
is "mark_native_arrays"
constant attribute
{}
as_minimum_character_code: STRING
is "Minimum_character_code"
constant attribute
{}
as_minimum_double: STRING
is "Minimum_double"
constant attribute
{}
as_minimum_real: STRING
is "Minimum_real"
constant attribute
{}
as_manifest_creation: STRING
is "manifest_creation"
constant attribute
{}
as_manifest_initialize: STRING
is "manifest_initialize"
constant attribute
{}
as_manifest_make: STRING
is "manifest_make"
constant attribute
{}
as_manifest_put: STRING
is "manifest_put"
constant attribute
{}
as_manifest_semicolon_check: STRING
is "manifest_semicolon_check"
constant attribute
{}
as_maximum_character_code: STRING
is "Maximum_character_code"
constant attribute
{}
as_maximum_double: STRING
is "Maximum_double"
constant attribute
{}
as_maximum_real: STRING
is "Maximum_real"
constant attribute
{}
as_native_data: STRING
is "native_data"
constant attribute
{}
as_notify: STRING
is "notify"
constant attribute
{}
as_notify_all: STRING
is "notify_all"
constant attribute
{}
as_object_as_pointer: STRING
is "object_as_pointer"
constant attribute
{}
as_object_attribute: STRING
is "object_attribute"
constant attribute
{}
as_object_invariant: STRING
is "object_invariant"
constant attribute
{}
as_object_memory: STRING
is "object_memory"
constant attribute
{}
as_object_size: STRING
is "object_size"
constant attribute
{}
as_pointer_bits: STRING
is "Pointer_bits"
constant attribute
{}
as_pow_postfix: STRING
is "pow"
constant attribute
{}
as_print: STRING
is "print"
constant attribute
{}
as_print_on: STRING
is "print_on"
constant attribute
{}
as_print_run_time_stack: STRING
is "print_run_time_stack"
constant attribute
{}
as_put: STRING
is "put"
constant attribute
{}
as_put_0: STRING
is "put_0"
constant attribute
{}
as_put_1: STRING
is "put_1"
constant attribute
{}
as_put_16_be: STRING
is "put_16_be"
constant attribute
{}
as_put_16_le: STRING
is "put_16_le"
constant attribute
{}
as_put_16_ne: STRING
is "put_16_ne"
constant attribute
{}
as_put_32_be: STRING
is "put_32_be"
constant attribute
{}
as_put_32_le: STRING
is "put_32_le"
constant attribute
{}
as_put_32_ne: STRING
is "put_32_ne"
constant attribute
{}
as_raise_exception: STRING
is "raise_exception"
constant attribute
{}
as_real_bits: STRING
is "Real_bits"
constant attribute
{}
as_realloc: STRING
is "realloc"
constant attribute
{}
as_rounded: STRING
is "rounded"
constant attribute
{}
as_run: STRING
is "run"
constant attribute
{}
as_same_dynamic_type: STRING
is "same_dynamic_type"
constant attribute
{}
as_second: STRING
is "second"
constant attribute
{}
as_se_argc: STRING
is "se_argc"
constant attribute
{}
as_se_argv: STRING
is "se_argv"
constant attribute
{}
as_se_atexit: STRING
is "se_atexit"
constant attribute
{}
as_se_fault: STRING
is "se_fault"
constant attribute
{}
as_sedb_breakpoint: STRING
is "sedb_breakpoint"
constant attribute
{}
as_set_item: STRING
is "set_item"
constant attribute
{}
as_set_object_attribute: STRING
is "set_object_attribute"
constant attribute
{}
as_signal_number: STRING
is "signal_number"
constant attribute
{}
as_slice_copy: STRING
is "slice_copy"
constant attribute
{}
as_standard_copy: STRING
is "standard_copy"
constant attribute
{}
as_standard_is_equal: STRING
is "standard_is_equal"
constant attribute
{}
as_standard_twin: STRING
is "standard_twin"
constant attribute
{}
as_status: STRING
is "status"
constant attribute
{}
as_std_error: STRING
is "std_error"
constant attribute
{}
as_std_input: STRING
is "std_input"
constant attribute
{}
as_std_output: STRING
is "std_output"
constant attribute
{}
as_stderr: STRING
is "stderr"
constant attribute
{}
as_stdin: STRING
is "stdin"
constant attribute
{}
as_stdout: STRING
is "stdout"
constant attribute
{}
as_storage: STRING
is "storage"
constant attribute
{}
as_storage_lower: STRING
is "storage_lower"
constant attribute
{}
as_third: STRING
is "third"
constant attribute
{}
as_timed_wait: STRING
is "timed_wait"
constant attribute
{}
as_to_character: STRING
is "to_character"
constant attribute
{}
as_to_integer_8: STRING
is "to_integer_8"
constant attribute
{}
as_to_integer_16: STRING
is "to_integer_16"
constant attribute
{}
as_to_integer_32: STRING
is "to_integer_32"
constant attribute
{}
as_to_integer_64: STRING
is "to_integer_64"
constant attribute
{}
as_to_internals: STRING
is "to_internals"
constant attribute
{}
as_to_natural_8: STRING
is "to_natural_8"
constant attribute
{}
as_to_natural_16: STRING
is "to_natural_16"
constant attribute
{}
as_to_natural_32: STRING
is "to_natural_32"
constant attribute
{}
as_to_natural_64: STRING
is "to_natural_64"
constant attribute
{}
as_to_pointer: STRING
is "to_pointer"
constant attribute
{}
as_trace_switch: STRING
is "trace_switch"
constant attribute
{}
as_twin: STRING
is "twin"
constant attribute
{}
as_type_generating_type: STRING
is "type_generating_type"
constant attribute
{}
as_type_generator: STRING
is "type_generator"
constant attribute
{}
as_type_is_expanded: STRING
is "type_is_expanded"
constant attribute
{}
as_type_item_generating_type: STRING
is "type_item_generating_type"
constant attribute
{}
as_type_item_generator: STRING
is "type_item_generator"
constant attribute
{}
as_type_item_is_expanded: STRING
is "type_item_is_expanded"
constant attribute
{}
as_unlock: STRING
is "unlock"
constant attribute
{}
as_upper: STRING
is "upper"
constant attribute
{}
as_valid_generating_type_for_internals: STRING
is "valid_generating_type_for_internals"
constant attribute
{}
as_valid_generating_type_for_native_array_internals: STRING
is "valid_generating_type_for_native_array_internals"
constant attribute
{}
as_wait: STRING
is "wait"
constant attribute
{}
as_with_capacity: STRING
is "with_capacity"
constant attribute
{}
as_and: STRING
is "and"
constant attribute
{}
as_and_then: STRING
is "and then"
constant attribute
{}
as_at: STRING
is "@"
constant attribute
{}
as_backslash_backslash: STRING
is "\\"
constant attribute
{}
as_bit_and: STRING
is "&"
constant attribute
{}
as_bit_not: STRING
is "~"
constant attribute
{}
as_bit_or: STRING
is "|"
constant attribute
{}
as_bit_rotate_left: STRING
is "#<<"
constant attribute
{}
as_bit_rotate_right: STRING
is "#>>"
constant attribute
{}
as_bit_shift_right_unsigned: STRING
is "|>>>"
constant attribute
{}
as_brackets: STRING
is "[]"
constant attribute
{}
as_eq: STRING
is "="
constant attribute
{}
as_ge: STRING
is ">="
constant attribute
{}
as_gt: STRING
is ">"
constant attribute
{}
as_implies: STRING
is "implies"
constant attribute
{}
as_le: STRING
is "<="
constant attribute
{}
as_lt: STRING
is "<"
constant attribute
{}
as_minus: STRING
is "-"
constant attribute
{}
as_muls: STRING
is "*"
constant attribute
{}
as_neq: STRING
is "/="
constant attribute
{}
as_not: STRING
is "not"
constant attribute
{}
as_or: STRING
is "or"
constant attribute
{}
as_or_else: STRING
is "or else"
constant attribute
{}
as_parentheses: STRING
is "()"
constant attribute
{}
as_plus: STRING
is "+"
constant attribute
{}
as_pow: STRING
is "^"
constant attribute
{}
as_sharp_backslash_backslash: STRING
is "#\\"
constant attribute
{}
as_sharp_minus: STRING
is "#-"
constant attribute
{}
as_sharp_muls: STRING
is "#*"
constant attribute
{}
as_sharp_plus: STRING
is "#+"
constant attribute
{}
as_sharp_slash_slash: STRING
is "#//"
constant attribute
{}
as_bit_shift_left: STRING
is "|<<"
constant attribute
{}
as_bit_shift_right: STRING
is "|>>"
constant attribute
{}
as_slash: STRING
is "/"
constant attribute
{}
as_slash_slash: STRING
is "//"
constant attribute
{}
as_xor: STRING
is "xor"
constant attribute
{}
as_arguments: STRING
is "arguments"
constant attribute
{}
as_current: STRING
is "Current"
constant attribute
{}
as_native_array_character: STRING
is "NATIVE_ARRAY[CHARACTER]"
constant attribute
{}
as_last_result: STRING
is "last_result"
constant attribute
{}
as_like_current: STRING
is "like Current"
constant attribute
{}
as_method: STRING
is "method"
constant attribute
{}
as_open_arguments: STRING
is "open_arguments"
constant attribute
{}
as_open_argument_indices: STRING
is "open_argument_indices"
constant attribute
{}
as_open_argument_index: STRING
is "open_argument_index"
constant attribute
{}
as_open_argument_count: STRING
is "open_argument_count"
constant attribute
{}
as_precursor: STRING
is "Precursor"
constant attribute
{}
as_result: STRING
is "Result"
constant attribute
{}
as_target: STRING
is "target"
constant attribute
{}
as_void: STRING
is "Void"
constant attribute
{}
fz_adapt: STRING
is "adapt"
constant attribute
{}
fz_alias: STRING
is "alias"
constant attribute
{}
fz_all: STRING
is "all"
constant attribute
{}
fz_as: STRING
is "as"
constant attribute
{}
fz_assertion: STRING
is "assertion"
constant attribute
{}
fz_assertion_flat_check: STRING
is "assertion_flat_check"
constant attribute
{}
fz_assign: STRING
is "assign"
constant attribute
{}
fz_begin_c_compile: STRING
is "# Beginning of parallelizable section"
constant attribute
{}
fz_boost: STRING
is "boost"
constant attribute
{}
fz_check: STRING
is "check"
constant attribute
{}
fz_class: STRING
is "class"
constant attribute
{}
fz_cluster: STRING
is "cluster"
constant attribute
{}
fz_convert: STRING
is "convert"
constant attribute
{}
fz_create: STRING
is "create"
constant attribute
{}
fz_creation: STRING
is "creation"
constant attribute
{}
fz_debug: STRING
is "debug"
constant attribute
{}
fz_default: STRING
is "default"
constant attribute
{}
fz_deferred: STRING
is "deferred"
constant attribute
{}
fz_do: STRING
is "do"
constant attribute
{}
fz_else: STRING
is "else"
constant attribute
{}
fz_elseif: STRING
is "elseif"
constant attribute
{}
fz_end: STRING
is "end"
constant attribute
{}
fz_end_c_compile: STRING
is "# End of parallelizable section"
constant attribute
{}
fz_ensure: STRING
is "ensure"
constant attribute
{}
fz_exclude: STRING
is "exclude"
constant attribute
{}
fz_expanded: STRING
is "expanded"
constant attribute
{}
fz_export: STRING
is "export"
constant attribute
{}
fz_external: STRING
is "external"
constant attribute
{}
fz_false: STRING
is "False"
constant attribute
{}
fz_feature: STRING
is "feature"
constant attribute
{}
fz_from: STRING
is "from"
constant attribute
{}
fz_frozen: STRING
is "frozen"
constant attribute
{}
fz_generate: STRING
is "generate"
constant attribute
{}
fz_if: STRING
is "if"
constant attribute
{}
fz_include: STRING
is "include"
constant attribute
{}
fz_indexing: STRING
is "indexing"
constant attribute
{}
fz_infix: STRING
is "infix"
constant attribute
{}
fz_inherit: STRING
is "inherit"
constant attribute
{}
fz_insert: STRING
is "insert"
constant attribute
{}
fz_inline: STRING
is "inline"
constant attribute
{}
fz_inspect: STRING
is "inspect"
constant attribute
{}
fz_invariant: STRING
is "invariant"
constant attribute
{}
fz_is: STRING
is "is"
constant attribute
{}
fz_like: STRING
is "like"
constant attribute
{}
fz_local: STRING
is "local"
constant attribute
{}
fz_loop: STRING
is "loop"
constant attribute
{}
fz_no: STRING
is "no"
constant attribute
{}
fz_note: STRING
is "note"
constant attribute
{}
fz_obsolete: STRING
is "obsolete"
constant attribute
{}
fz_old: STRING
is "old"
constant attribute
{}
fz_once: STRING
is "once"
constant attribute
{}
fz_option: STRING
is "option"
constant attribute
{}
fz_prefix: STRING
is "prefix"
constant attribute
{}
fz_redefine: STRING
is "redefine"
constant attribute
{}
fz_rename: STRING
is "rename"
constant attribute
{}
fz_require: STRING
is "require"
constant attribute
{}
fz_rescue: STRING
is "rescue"
constant attribute
{}
fz_retry: STRING
is "retry"
constant attribute
{}
fz_runtime: STRING
is "runtime"
constant attribute
{}
fz_separate: STRING
is "separate"
constant attribute
{}
fz_reference: STRING
is "reference"
constant attribute
{}
fz_then: STRING
is "then"
constant attribute
{}
fz_trace: STRING
is "trace"
constant attribute
{}
fz_true: STRING
is "True"
constant attribute
{}
fz_undefine: STRING
is "undefine"
constant attribute
{}
fz_unique: STRING
is "unique"
constant attribute
{}
fz_until: STRING
is "until"
constant attribute
{}
fz_use: STRING
is "use"
constant attribute
{}
fz_variant: STRING
is "variant"
constant attribute
{}
fz_when: STRING
is "when"
constant attribute
{}
fz_yes: STRING
is "yes"
constant attribute
{}
fz_cad: STRING
is "Cyclic anchored definition."
constant attribute
{}
fz_dtideena: STRING
is " has no compiler-defined `deep_twin' or `is_deep_equal' because the corresponding allocated size is not part of the NATIVE_ARRAY object. The client class of this NATIVE_ARRAY type is supposed to use a `capacity' attribute which contains the corresponding number of allocated items (see STRING or ARRAY for example)."
constant attribute
{}
fz_error_stars: STRING
is "****** "
constant attribute
{}
fz_vuar4: STRING
is "The $ operator must be followed by the final name of a feature which is not a constant attribute or by the name of some local variable as well."
constant attribute
{}
fz_bin: STRING
is "bin"
constant attribute
{}
fz_c_shift_left: STRING
is "<<"
constant attribute
{}
fz_c_shift_right: STRING
is ">>"
constant attribute
{}
fz_install: STRING
is "install"
constant attribute
{}
fz_jobs: STRING
is "jobs"
constant attribute
{}
fz_no_check: STRING
is "no_check"
constant attribute
{}
fz_none: STRING
is "none"
constant attribute
{}
fz_libertyeiffel: STRING
is "LibertyEiffel"
constant attribute
{}
fz_seconf: STRING
is "LIBERTY_CONF"
constant attribute
{}
The environment name pointing to the config file.
fz_conf_general: STRING
is "General"
constant attribute
{}
fz_conf_loadpath: STRING
is "Loadpath"
constant attribute
{}
fz_conf_environment: STRING
is "Environment"
constant attribute
{}
since version 2
fz_conf_se_tools: STRING
is "Tools"
constant attribute
{}
since version 3
fz_conf_bin: STRING
is "bin"
constant attribute
{}
fz_conf_lib: STRING
is "lib"
constant attribute
{}
fz_conf_sys: STRING
is "sys"
constant attribute
{}
fz_conf_short: STRING
is "short"
constant attribute
{}
fz_conf_tools: STRING
is "tools"
constant attribute
{}
fz_conf_os: STRING
is "os"
constant attribute
{}
fz_conf_flavor: STRING
is "flavor"
constant attribute
{}
fz_conf_jobs: STRING
is "jobs"
constant attribute
{}
fz_conf_boost: STRING
is "boost"
constant attribute
{}
fz_conf_no_check: STRING
is "no_check"
constant attribute
{}
fz_conf_require_check: STRING
is "require_check"
constant attribute
{}
fz_conf_ensure_check: STRING
is "ensure_check"
constant attribute
{}
fz_conf_invariant_check: STRING
is "invariant_check"
constant attribute
{}
fz_conf_loop_check: STRING
is "loop_check"
constant attribute
{}
fz_conf_all_check: STRING
is "all_check"
constant attribute
{}
fz_conf_debug_check: STRING
is "debug_check"
constant attribute
{}
fz_conf_flat_check: STRING
is "flat_check"
constant attribute
{}
fz_conf_smarteiffel_options: STRING
is "smarteiffel_options"
constant attribute
{}
fz_conf_undefined: STRING
is "undefined"
constant attribute
{}
fz_conf_tag: STRING
is "tag"
constant attribute
{}
fz_conf_compiler_type: STRING
is "c_compiler_type"
constant attribute
{}
fz_conf_compiler_path: STRING
is "c_compiler_path"
constant attribute
{}
fz_conf_linker_path: STRING
is "c_linker_path"
constant attribute
{}
fz_conf_strip_path: STRING
is "c_strip_path"
constant attribute
{}
fz_conf_compiler_options: STRING
is "c_compiler_options"
constant attribute
{}
fz_conf_linker_options: STRING
is "c_linker_options"
constant attribute
{}
fz_conf_cpp_compiler_type: STRING
is "cpp_compiler_type"
constant attribute
{}
fz_conf_cpp_compiler_path: STRING
is "cpp_compiler_path"
constant attribute
{}
fz_conf_cpp_compiler_options: STRING
is "cpp_compiler_options"
constant attribute
{}
fz_conf_cpp_linker_path: STRING
is "cpp_linker_path"
constant attribute
{}
fz_conf_cpp_strip_path: STRING
is "cpp_strip_path"
constant attribute
{}
fz_conf_cpp_linker_options: STRING
is "cpp_linker_options"
constant attribute
{}
level_name (level: INTEGER_32): STRING
effective function
{ANY}
level_not_computed: INTEGER_32
is 0
constant attribute
{ANY}
To memorize the fact that the assertion level is not yet known.
level_boost: INTEGER_32
is 1
constant attribute
{ANY}
The -boost hight speed level.
Do not check for Void target. Do not check system level validity. Optimize generated code.
level_no: INTEGER_32
is 2
constant attribute
{ANY}
No assertion checking of any kind.
level_require: INTEGER_32
is 3
constant attribute
{ANY}
Evaluate the preconditions.
level_ensure: INTEGER_32
is 4
constant attribute
{ANY}
Also evaluate postconditions.
level_invariant: INTEGER_32
is 5
constant attribute
{ANY}
Also evaluate the class invariant on entry to and return from.
level_loop: INTEGER_32
is 6
constant attribute
{ANY}
Also evaluate the loop variant and the loop invariant.
level_all: INTEGER_32
is 7
constant attribute
{ANY}
Also evaluate the check instruction.
The default value.
match_debug_keys (e_debug: DEBUG_COMPOUND, list: FAST_ARRAY[STRING]): BOOLEAN
effective function
{}
add_default_debug_key (key: STRING)
effective procedure
{}
require
  • key /= Void
ensure
default_debug_keys: FAST_ARRAY[STRING]
writable attribute
{}
The default(s) one for this cluster/ace file.
fz_case_insensitive: STRING
is "case_insensitive"
constant attribute
{}
fz_cc: STRING
is "cc"
constant attribute
{}
fz_cecil: STRING
is "cecil"
constant attribute
{}
fz_clean: STRING
is "clean"
constant attribute
{}
fz_c_mode: STRING
is "c_mode"
constant attribute
{}
fz_expect: STRING
is "expect"
constant attribute
{}
fz_flymake_mode: STRING
is "flymake_mode"
constant attribute
{}
fz_gc_info: STRING
is "gc_info"
constant attribute
{}
fz_help: STRING
is "help"
constant attribute
{}
fz_high_memory_compiler: STRING
is "high_memory_compiler"
constant attribute
{}
fz_loadpath: STRING
is "loadpath"
constant attribute
{}
fz_manifest_string_trace: STRING
is "manifest_string_trace"
constant attribute
{}
fz_mock: STRING
is "mock"
constant attribute
{}
fz_no_main: STRING
is "no_main"
constant attribute
{}
fz_no_split: STRING
is "no_split"
constant attribute
{}
fz_no_strip: STRING
is "no_strip"
constant attribute
{}
fz_style_warning: STRING
is "style_warning"
constant attribute
{}
fz_no_warning: STRING
is "no_warning"
constant attribute
{}
fz_o: STRING
is "-o"
constant attribute
{}
fz_profile: STRING
is "profile"
constant attribute
{}
fz_relax: STRING
is "relax"
constant attribute
{}
fz_safety_check: STRING
is "safety_check"
constant attribute
{}
fz_sedb: STRING
is "sedb"
constant attribute
{}
fz_split: STRING
is "split"
constant attribute
{}
fz_verbose: STRING
is "verbose"
constant attribute
{}
fz_version: STRING
is "version"
constant attribute
{}
fz_flag_run: STRING
is "run"
constant attribute
{}
fz_flag_clean_classes: STRING
is "clean_classes"
constant attribute
{}
fz_flag_hard_clean: STRING
is "hard_clean"
constant attribute
{}
is_equal (other: ACE): BOOLEAN
effective function
{ANY}
Is other attached to an object considered equal to current object?
require
  • other /= Void
ensure
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
is_real_singleton: BOOLEAN
effective function
{}
ensure
  • assertion_check_only: Result
singleton_memory_pool: HASHED_DICTIONARY[POINTER, STRING]
once function
{}
This pool is unique in the whole system.
A memory is kept for each singleton type (type, not class) in the system.
current_is_not_an_expanded_type: BOOLEAN
effective function
{}
Check that the dynamic type of the SINGLETON is not an expanded type.