class SYSTEM_TOOLS
Summary
Singleton object to handle system dependent information. This singleton is shared via the GLOBALS.system_tools once function.
Only this object is supposed to handle contents of the Liberty system environment variable.
You may also want to customize this class in order to support a new operating system (please let us know).
Direct parents
Insert list: ACE_HANDLER, DIRECTORY_NOTATION_HANDLER, GLOBALS, SINGLETON, SYSTEM_TOOLS_CONSTANTS
Class invariant
Overview
Creation features
{ANY}
Features
{SERC_FACTORY}
{C_PLUGIN, C_SPLITTER}
{ECHO}
{}
{BDW_GC}
{C_PRETTY_PRINTER}
{}
{}
{}
{SE}
{ANY}
{}
{}
{}
{SE, COMPILE}
{COMPILE}
{SHORT_PRINTER}
{ANY}
{CLUSTER, ACE}
{COMMAND_LINE_TOOLS}
{ANY}
{C_PRETTY_PRINTER, C_COMPILATION_MIXIN}
{}
{COMPILE, COMPILE_TO_C}
{C_PLUGIN}
{ANY}
{SE, ACE, COMMAND_LINE_TOOLS}
  • bad_use_exit (command_name: STRING, command_line_help_summary: STRING)
    Print the traditional command_line_help_summary as well as some extra information to find more help.
  • set_c_compiler (cc_arg: STRING)
    If cc_arg is not Void, this cc_arg is used as the C compiler.
{}
{ACE, COMPILE_TO_C, STRING_COMMAND_LINE}
{ACE, C_PRETTY_PRINTER}
{}
{C_PRETTY_PRINTER}
{C_PRETTY_PRINTER, COMPILE}
{NATIVE_PLUG_IN}
{}
{C_PRETTY_PRINTER}
{PLUGIN}
{ANY}
{C_PRETTY_PRINTER, C_SPLITTER}
{ACE}
{ECHO}
{}
{}
{ID_PROVIDER}
{}
  • check_c_plus_plus
    Check if we must use the C++ compiler; in that case, we switch to it if it is available
{}
{COMMAND_LINE_TOOLS}
{ACE, COMMAND_LINE_TOOLS}
{C_PLUGIN}
{}
{ACE}
{}
{PLUGIN}
{}
Strings:
{}
{}
Buffers:
{}
{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}
  • is_equal (other: SYSTEM_TOOLS): BOOLEAN
    Is other attached to an object considered equal to current object?
{}
Currently handled system list:
{SERC_FACTORY, C_SPLITTER}
Currently handled C/C++ compiler list:
{}
system_list: FAST_ARRAY[STRING]
once function
compiler_list: FAST_ARRAY[STRING]
once function
c_plus_plus_compiler_list: FAST_ARRAY[STRING]
once function
Compilers (among compiler_list) which can handle C++
set_system_name (name: STRING)
effective procedure
require
set_system_flavor (name: STRING)
effective procedure
add_x_suffix (cmd: STRING)
effective procedure
make
effective procedure
system_name: STRING
writable attribute
system_flavor: STRING
writable attribute
environment (var: STRING): STRING
effective function
set_automatic_system_name
effective procedure
{}
Sets a "not very smart" default system_name value
require ensure
add_bdwgc_lib
effective procedure
add_pthread_lib
effective procedure
add_lib_math_do_it_again
effective procedure
{}
verify_system_name
effective procedure
{}
seconf: STRING
writable attribute
{}
Path to the configuration file.
Non Void if the new environment variable is used; in that case, the informations for accessing data are retrieved from the ini_file.
load_tools_in (tools: DICTIONARY[STRING, STRING])
effective procedure
{SE}
require
  • tools.is_empty
config: SE_CONFIG
writable attribute
{ANY}
set_config
once procedure
{}
include_config_loadpaths
once procedure
{}
sys_directory: STRING
writable attribute
{}
The SmartEiffel/sys directory computed with the value of the environment variable SmartEiffel.
For example, under UNIX: "/usr/lib/SmartEiffel/sys/"
bin_directory: STRING
writable attribute
{}
For example, under UNIX: "/usr/lib/SmartEiffel/bin/"
short_directory: STRING
writable attribute
{}
For example, under UNIX: "/usr/lib/SmartEiffel/short/"
set_sys_directory (sysdir: STRING)
effective procedure
set_bin_directory (bindir: STRING)
effective procedure
set_short_directory (shortdir: STRING)
effective procedure
append_command_path_to (command: STRING, command_name: STRING)
effective procedure
Append in command the correct path for command_name.
remove_other_extra_files (name: STRING)
effective procedure
Remove some other extra file which may be created while compiling name root class in split mode.
remove_make_script_and_other_extra_files
effective procedure
Remove the *.make file script and some other extra files.
connect_make_file (make_file: TEXT_FILE_READ, make_script_name: STRING)
effective procedure
Because of a bug in cygnus on windows 95/NT.
format_directory (format: STRING): STRING
effective function
require
  • format /= Void
is_c_plus_plus_file_path (path: STRING): BOOLEAN
effective function
{ANY}
True when there path has one of the following suffix: ".cpp", ".cc", or ".C".
file_path (parent_path: STRING, file_name: STRING)
effective procedure
Use the system_name knowledge to call feature compute_file_path_with of BASIC_DIRECTORY.
The parent_path is modified accordingly.
set_plugin_factory (factory: PLUGIN_FACTORY)
effective procedure
make_suffix: STRING
once function
{ANY}
Suffix for make file produced by compile_to_c.
x_suffix: STRING
once function
{ANY}
Executable files suffix.
ensure
  • Result /= Void
object_suffix: STRING
once function
{ANY}
Of object File produced by the C Compiler.
precompiled_header_suffix: STRING
once function
{ANY}
Suffix for precompiled header.
Void if none.
add_lib_math
once procedure
root_class_wait_for_procedure: BOOLEAN
writable attribute
{}
extra_arg (arg: STRING, argi: INTEGER_32, next_arg: STRING): INTEGER_32
effective function
require
  • arg /= Void
  • argi >= 1
ensure
  • Result > old argi
append_c_linker_option (arg: STRING)
effective procedure
require
  • arg /= Void
append_c_compiler_option (arg: STRING)
effective procedure
require
  • arg /= Void
environment_variable_substitution (path: STRING, line: STRING)
effective procedure
{ANY}
The only accepted notation is: ${...}.
The substitution is performed in line. When given the path information is used to emit an error message when the variable does not exists. If any, substitute in line some "system.se" well-known key (i.e. "sys", "bin" or "short"). If case of unknown key, uses echo.getenv instead.
require
  • line /= Void
bad_use_exit (command_name: STRING, command_line_help_summary: STRING)
effective procedure
Print the traditional command_line_help_summary as well as some extra information to find more help.
require
  • command_name /= Void
set_c_compiler (cc_arg: STRING)
effective procedure
If cc_arg is not Void, this cc_arg is used as the C compiler.
Otherwise, when cc_arg is Void, do nothing (the C compiler will be set later).
ensure
add_libraries_from_compiler_options
effective procedure
{}
Extract additional libs from c_compiler_options
set_no_strip
effective procedure
c_compiler_options: STRING
is ""
constant attribute
C compiler options including extra include path, optimization flags, etc.
c_linker_options: STRING
is ""
constant attribute
Those options are only to be passed to the linker.
c_plugin_compiler_options: STRING
is ""
constant attribute
{}
main_function_return_type_in (pending_c_function_signature: STRING)
effective procedure
main_function_exit_in (pending_c_function_body: STRING)
effective procedure
sys_runtime (name: STRING, suffix: CHARACTER)
effective procedure
Prepare tmp_file_read to access the corresponding file of the Liberty Eiffel sys/runtime directory.
The complete path is always available to the caller in tmp_path in order to emit an error message when the corresponding file is not found. (This routine does not emit errors message itself just because this may be normal. See also mandatory_sys_runtime.)
require
  • name /= Void
  • suffix = 'c' or suffix = 'h'
mandatory_sys_runtime (name: STRING, suffix: CHARACTER)
effective procedure
Same as sys_runtime, but emit an error message when the corresponding file does not exists.
ensure
strip_executable: STRING
effective function
add_c_plus_plus_file (f: STRING)
effective procedure
is_linking_mandatory: BOOLEAN
effective function
Is it mandatory to link this executable again, even when nothing has changed in the generated C code ?
add_lib_profile
once procedure
path_h: STRING
effective function
The name of the main *.h file.
ensure
path_c: STRING
effective function
The name of the main *.h file.
ensure
path_make: STRING
effective function
The name of the main *.h file.
ensure
reset_paths
effective procedure
next_path
effective procedure
plugin (location: STRING, name: STRING, position: POSITION): PLUGIN
effective function
absolute_path (a_position: POSITION, a_path: STRING): STRING
effective function
{}
auto_init_plugins
effective procedure
libraries_module: STRING
effective function
loaded_plugin (location: STRING, name: STRING): PLUGIN
effective function
precompile_header_supported: BOOLEAN
effective function
{ANY}
require
h_precompiler_command (h_file_name: STRING): STRING
effective function
require
  • ace.precompile_header
c_compiler_command (c_file_name: STRING): STRING
effective function
Where c_file_name is the name of one slice.
linker_command (c_name: STRING, objects: FAST_ARRAY[STRING]): STRING
effective function
Where c_name is only the prefix name (i.e. "compile_to_c") and objects is the list ob the objects to link
require
  • not objects.is_empty
read_loadpath_files
effective procedure
{ACE}
For command line mode only (no ACE file used).
Reads the loadpath files given on the command line, then either the loadpath.se in the current directory or the current directory itself as a cluster, and finally the configuration loadpaths.
require
  • ace.file_path = Void
system_name_in (msg: STRING)
effective procedure
{ACE}
Append in msg the current system_name.
set_external_header_path (a_paths: STRING)
effective procedure
{ACE}
Set external_header_path to a_paths, but format it according to rules for current C compiler.
set_external_lib_path (a_paths: STRING)
effective procedure
{ACE}
Set external_lib_path to a_paths, but format it according to rules for current C compiler and linker.
set_external_lib (a_libs: STRING)
effective procedure
{ACE}
Set external_lib to a_libs, but format it according to rules for current C compiler and linker.
external_object_files: STRING
is ""
constant attribute
{ACE}
External object files.
external_c_files: STRING
is ""
constant attribute
{ACE}
External C files.
external_c_plus_plus_files: STRING
is ""
constant attribute
{ACE}
External C++ files.
no_strip: BOOLEAN
writable attribute
{ACE}
parent_directory (some_path: STRING)
effective procedure
Use the system_name knowledge to call feature compute_parent_directory_of of BASIC_DIRECTORY.
The some_path is modified accordingly.
require
  • some_path.count > 0
is_absolute (path: STRING): BOOLEAN
effective function
{}
Always False on non-winlike and non-unixlike systems
require
is_relative (path: STRING): BOOLEAN
effective function
{}
Always True on non-winlike and non-unixlike systems
require
is_win_like: REFERENCE[BOOLEAN]
writable attribute
{}
is_unix_like: REFERENCE[BOOLEAN]
writable attribute
{}
set_likes
effective procedure
{}
Just speed up repeated tests on system by setting is_win_likeand is_unix_like
basic_directory: BASIC_DIRECTORY
writable attribute
{}
set_basic_directory_notation
once procedure
{}
subdirectory (parent_path: STRING, entry_name: STRING)
effective procedure
{}
Use the system_name knowledge to call feature compute_subdirectory_with of BASIC_DIRECTORY.
The parent_path is modified accordingly.
require
  • not parent_path.is_empty
  • not entry_name.is_empty
append_token (line: STRING, token: STRING)
effective procedure
{}
append_tokens (line: STRING, tokens: FAST_ARRAY[STRING])
effective procedure
{}
external_c_files_for_lcc_win32 (cmd: STRING)
effective procedure
{}
Because lcc_win32 does not accept *.c file while linking as other C compiler do :-(
id_file_path: STRING
once function
check_c_plus_plus
once procedure
{}
Check if we must use the C++ compiler; in that case, we switch to it if it is available
add_config_loadpath_file (loadpath_file: STRING, loadpath_name: STRING)
effective procedure
{}
This file will also be read by read_loadpath_files, with the cluster name prefix loadpath_name.
add_loadpath_file (loadpath_file: STRING)
effective procedure
This file will also be read by read_loadpath_files
add_smarteiffel_c_mode_options
effective procedure
Adds the Liberty Eiffel options for the chosen C mode; then add the libraries for the C compiler
is_alternate_c_mode: BOOLEAN
writable attribute
If False, then the C mode associated with the Liberty Eiffel level will be selected; otherwise, the user has explicitly used the -c_mode option; this one will be used.
set_default_c_mode (c_mode: STRING)
effective procedure
Sets the C mode to use.
If an alternate C mode has been set, this feature does nothing.
set_alternate_c_mode (c_mode: STRING)
effective procedure
Sets an alternate C mode (the user explicitly used the -c_mode flag)
c_compiler: STRING
writable attribute
c_compiler_mode: INTEGER_32
writable attribute
{}
c_compiler_none: INTEGER_32
is 27
constant attribute
{}
Value of c_compiler_none indicating that neither -cc nor -c_mode were used (yet).
c_compiler_cc: INTEGER_32
is 28
constant attribute
{}
Value of c_compiler_mode indicating that set_c_compiler was used with a non-Void value
c_compiler_cmode: INTEGER_32
is 29
constant attribute
{}
Value of c_compiler_mode indicating that set_alternate_c_mode was used.
compiler_path_of (compiler: STRING): STRING
effective function
{}
strip_path_or_default (explicit_strip_path: STRING): STRING
effective function
{}
ensure
  • explicit_strip_path /= Void implies Result = explicit_strip_path
linker_path_of (compiler: STRING): STRING
effective function
{}
set_c_mode (c_mode: STRING)
effective procedure
{}
ensure
c_compiler_path: STRING
writable attribute
{}
The path to the real C compiler
c_linker_path: STRING
writable attribute
{}
The path to the real C linker
c_strip_path: STRING
writable attribute
{}
The path to the real C strip
c_mode_compiler_options: STRING
is ""
constant attribute
{}
The compiler options set by the C mode
c_mode_linker_options: STRING
is ""
constant attribute
{}
The linker options set by the C mode
cpp_compiler: STRING
writable attribute
{}
cpp_compiler_path: STRING
writable attribute
{}
The path to the real C++ compiler
cpp_linker_path: STRING
writable attribute
{}
The path to the real C++ linker
cpp_strip_path: STRING
writable attribute
{}
The path to the real C++ strip
cpp_mode_compiler_options: STRING
is ""
constant attribute
{}
The C++ compiler options set by the C mode
cpp_mode_linker_options: STRING
is ""
constant attribute
{}
The C++ linker options set by the C mode
ace_compiler_options: STRING
writable attribute
{}
The options ACE can set
ace_linker_options: STRING
writable attribute
{}
The options ACE can set
smarteiffel_options: STRING
writable attribute
{}
The Liberty Eiffel options set by the chosen C mode
c_mode_has_explicit_linker_path_or_option: BOOLEAN
writable attribute
{}
True if either c_linker_path or c_linker_options are set for the chosen C mode.
Useful to emit warnings (e.g. when using no_split)
set_ace_compiler_options (options: STRING)
effective procedure
{ACE}
set_ace_linker_options (options: STRING)
effective procedure
{ACE}
set_ace_external_lib_path (extlibpath: STRING)
effective procedure
{ACE}
set_ace_external_lib (extlib: STRING)
effective procedure
{ACE}
external_libs: FAST_ARRAY[STRING]
once function
{ACE}
The external libs before being added to the external_lib (before the compiler is known, no such addition can take place)
external_lib_paths: FAST_ARRAY[STRING]
once function
{ACE}
The external lib paths before being added to the external_lib_path (before the compiler is known, no such addition can take place)
get_started
effective procedure
{ACE}
external_header_path: STRING
is ""
constant attribute
{}
Additional paths where .h files can be found.
external_lib_path: STRING
is ""
constant attribute
{}
External libraries path to be added at link time.
external_lib: STRING
is ""
constant attribute
{}
External libraries to be added at link time.
sys_runtime_ (name: STRING, suffix: CHARACTER)
effective procedure
{}
Common part to implement sys_runtime and mandatory_sys_runtime.
require
  • name /= Void
  • suffix = 'c' or suffix = 'h'
show_compiler_list_then_exit (list: FAST_ARRAY[STRING])
effective procedure
{}
add_executable_name (cmd: STRING)
effective procedure
{}
add_external_header_path (path: STRING)
effective procedure
Append path to external_header_path taking into account how the current linker likes it to get this path.
If path appears to be already formatted, no formatting added by this routine.
require
  • not path.is_empty
add_external_lib (lib: STRING)
effective procedure
Append lib to external_lib taking into account how the current linker likes it to get an additional library.
If lib appears to be already formatted, no formatting added by this routine.
require
  • not lib.is_empty
add_external_lib_path (path: STRING)
effective procedure
Append path to external_lib_path taking into account how the current linker likes it to get this path.
If path appears to be already formatted, no formatting added by this routine.
require
  • not path.is_empty
append_if_not_already (command_buffer: STRING, token: STRING)
effective procedure
{}
Append the token to the command_buffer if it is not already in the buffer.
| Patch proposed by Tim Wilson-Brown <twilsonb@mac.com>, enhanced by
exe_suffix: STRING
is ".exe"
constant attribute
{}
o_suffix: STRING
is ".o"
constant attribute
{}
obj_suffix: STRING
is ".obj"
constant attribute
{}
c_flag: STRING
is "-c"
constant attribute
{}
o_flag: STRING
is "-o"
constant attribute
{}
e_flag: STRING
is "-e"
constant attribute
{}
s_flag: STRING
is "-s"
constant attribute
{}
lcc: STRING
is "lcc"
constant attribute
{}
vc: STRING
is "vc"
constant attribute
{}
dcc: STRING
is "dcc"
constant attribute
{}
lcclnk: STRING
is "lcclnk"
constant attribute
{}
lnk_suffix: STRING
is ".lnk"
constant attribute
{}
libm: STRING
is "m"
constant attribute
{}
l_flag: STRING
is "-L"
constant attribute
{}
o2: STRING
is "-O2"
constant attribute
{}
libcpml: STRING
is "cpml"
constant attribute
{}
extra_loadpath_files: FAST_ARRAY[STRING]
writable attribute
{}
config_loadpath_files: FAST_ARRAY[STRING]
writable attribute
{}
config_loadpath_names: FAST_ARRAY[STRING]
writable attribute
{}
writable attribute
{}
plugin_factory: PLUGIN_FACTORY
writable attribute
{}
path_id_memory: STRING
is ""
constant attribute
{}
path_h_memory: STRING
is ""
constant attribute
{}
path_c_memory: STRING
is ""
constant attribute
{}
path_make_memory: STRING
is ""
constant attribute
{}
path_id: INTEGER_32
writable attribute
{}
fill_path (path: STRING, suffix: STRING)
effective procedure
{}
require
  • path.is_empty
  • suffix /= Void
ensure
  • path.has_suffix(suffix)
token_buffer: STRING
once function
{}
c_mode_memory: STRING
once function
{}
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
{}
is_equal (other: SYSTEM_TOOLS): 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.
unix_system: STRING
is "UNIX"
constant attribute
windows_system: STRING
is "Windows"
constant attribute
cygwin_system: STRING
is "Cygwin"
constant attribute
dos_system: STRING
is "DOS"
constant attribute
gcc: STRING
is "gcc"
constant attribute
{}
gpp: STRING
is "g++"
constant attribute
{}
distcc: STRING
is "distcc"
constant attribute
{}
lcc_win32: STRING
is "lcc-win32"
constant attribute
{}
cc: STRING
is "cc"
constant attribute
{}
cc_pp: STRING
is "CC"
constant attribute
{}
bcc32: STRING
is "bcc32"
constant attribute
{}
cl: STRING
is "cl"
constant attribute
{}
ccc: STRING
is "ccc"
constant attribute
{}
tcc: STRING
is "tcc"
constant attribute
{}