class EIFFEL_PARSER
Summary
Singleton object in charge of Eiffel parsing. This singleton is shared via the GLOBALS.eiffel_parser once function.
Direct parents
Inherit list: PARSER
Insert list: SINGLETON
Class invariant
Overview
Creation features
{ANY}
Features
{ANY}
{ANY}
{SMART_EIFFEL}
{ACE, COMMAND_LINE_TOOLS}
{CECIL_FILE}
{}
{SMART_EIFFEL}
{}
{COMPILE_TO_C, RUN}
To add extra contextual information:
{}
{}
{EXTERNAL_PROCEDURE, FEATURE_CALL}
{}
{TOKEN_BUFFER}
{}
{}
{}
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}
  • is_equal (other: EIFFEL_PARSER): BOOLEAN
    Is other attached to an object considered equal to current object?
{}
no_rescue: BOOLEAN
writable attribute
{ANY}
is_running: BOOLEAN
writable attribute
{ANY}
True when the parser is running (i.e. parsing of the current class is not finished).
total_time: INTEGER_64
writable attribute
{ANY}
predefined_type_mark (tm: STRING, sp: POSITION): TYPE_MARK
effective function
{ANY}
analyse_class (class_name: CLASS_NAME, a_cluster: CLUSTER): CLASS_TEXT
effective function
analyse_buffer: CLASS_TEXT
effective function
Scan the header of the parser_buffer in order to find the name of the class in order to launch analyse_class with the appropriate argument.
set_no_rescue
effective procedure
connect_to_cecil (a_path: STRING): STRING
effective function
Return the cecil file user's include path (first information).
end_of_input: BOOLEAN
effective function
parse_c_name: STRING
effective function
parse_type_mark: TYPE_MARK
effective function
parse_feature_name: FEATURE_NAME
effective function
parse_cecil_is_creation: BOOLEAN
effective function
disconnect
effective procedure
a_creation_keyword: BOOLEAN
effective function
{}
echo_information
effective procedure
show_total_time
effective procedure
{}
show_nb_warnings
effective procedure
{}
show_nb_errors
effective procedure
{}
set_drop_comments
effective procedure
Expression_syntax_flag: INTEGER_8
is 0
constant attribute
{}
Any possible complex expression.
Instruction_syntax_flag: INTEGER_8
is 1
constant attribute
{}
Any possible complex instruction.
Atomic_syntax_flag: INTEGER_8
is 2
constant attribute
{}
Simple value with no dot.
When_inspect_syntax_flag: INTEGER_8
is 3
constant attribute
{}
Expression in "when" part of "inspect".
current_id: INTEGER_16
writable attribute
{}
This is the id of the last_class_text or the id of the ACE file or of some cecil file path.
cluster: CLUSTER
writable attribute
{}
The current cluster of the class being analyzed
last_class_text: CLASS_TEXT
writable attribute
{}
The one being parsed.
inside_function_flag: BOOLEAN
writable attribute
{}
True when a function (an ordinary one as well as a once function) is being parsed.
inside_ensure_flag: BOOLEAN
writable attribute
{}
True during the parsing of a ensure clause.
inside_rescue_flag: BOOLEAN
writable attribute
{}
True during the parsing of a rescue clause.
inside_class_invariant_flag: BOOLEAN
writable attribute
{}
True during the parsing of a class invariant.
tuple_flag: BOOLEAN
writable attribute
{}
True when we are parsing the special tuple.e file.
formal_generic_list: FORMAL_GENERIC_LIST
writable attribute
{}
Void or not empty list of formal generic arguments.
arguments: FORMAL_ARG_LIST
writable attribute
{}
Void or actual formal arguments list.
local_vars: LOCAL_VAR_LIST
writable attribute
{}
Void or actual local variables list.
closure_arguments: RING_ARRAY[FORMAL_ARG_LIST]
writable attribute
{}
closure_local_vars: RING_ARRAY[LOCAL_VAR_LIST]
writable attribute
{}
ok: BOOLEAN
writable attribute
{}
Dummy variable to call functions.
last_expression: EXPRESSION
writable attribute
{}
last_type_mark: TYPE_MARK
writable attribute
{}
last_class_name: CLASS_NAME
writable attribute
{}
last_feature_declaration: FEATURE_TEXT
writable attribute
{}
last_feature_name: FEATURE_NAME
writable attribute
{}
last_feature_name_list: FEATURE_NAME_LIST
writable attribute
{}
last_formal_generic_type_mark: FORMAL_GENERIC_TYPE_MARK
writable attribute
{}
last_instruction: INSTRUCTION
writable attribute
{}
last_parent_edge: PARENT_EDGE
writable attribute
{}
last_tag_mark: TAG_NAME
writable attribute
{}
S_just_started_manifest_number_or_generic_manifest: INTEGER_32
is 0
constant attribute
{}
S_after_sign_of_some_number: INTEGER_32
is 1
constant attribute
{}
S_after_open_curly_brace: INTEGER_32
is 2
constant attribute
{}
S_inside_some_number: INTEGER_32
is 3
constant attribute
{}
S_inside_a_real_just_after_the_dot: INTEGER_32
is 4
constant attribute
{}
S_after_real_waiting_the_closing_curly: INTEGER_32
is 5
constant attribute
{}
S_after_integer_waiting_the_closing_curly: INTEGER_32
is 6
constant attribute
{}
S_first_hexadecimal_digit: INTEGER_32
is 7
constant attribute
{}
S_inside_hexadecimal: INTEGER_32
is 8
constant attribute
{}
S_after_hexadecimal_waiting_the_closing_curly: INTEGER_32
is 9
constant attribute
{}
S_after_type_mark: INTEGER_32
is 10
constant attribute
{}
S_inside_fractional_part_of_a_real: INTEGER_32
is 11
constant attribute
{}
S_just_after_the_e_of_exponent_part_of_a_real: INTEGER_32
is 12
constant attribute
{}
S_inside_exponent_part_of_a_real: INTEGER_32
is 13
constant attribute
{}
S_inside_manifest_generic: INTEGER_32
is 14
constant attribute
{}
S_finished_with_no_error_and_true: INTEGER_32
is 20
constant attribute
{}
S_finished_with_no_error_and_false: INTEGER_32
is 21
constant attribute
{}
a_manifest_or_type_test (syntax_flag: INTEGER_8): BOOLEAN
effective function
{}
 ++ manifest_or_type_test_expression -> manifest_or_type_test [ "." after_a_dot ]
 ++ manifest_or_type_test -> integer |
 ++                      real |
 ++                      "{" type_mark integer "}" |
 ++                      "{" type_mark real "}" |
 ++                      open_argument |
 ++                      "{" type_mark "} ?:= expression |
  ++                      "{" type_mark [ { expression "," ... } ] "<<" { expression "," ...} ">>" "}"
  ++ open_argument -> "{" type_mark "}"

 When True, the result is made available in `last_expression'.

u
integer_overflow_error (l: INTEGER_32, c: INTEGER_32, normal_integer_view: STRING)
effective procedure
{}
a_argument_ (args: FORMAL_ARG_LIST, closure_rank: INTEGER_32): BOOLEAN
effective function
{}
a_argument: BOOLEAN
effective function
{}
check_name_rank (name: LOCAL_ARGUMENT_DEF, dl: DECLARATION_LIST, err: STRING): BOOLEAN
effective function
{}
check_name_rank_and_closure (name: LOCAL_ARGUMENT_DEF)
effective procedure
{}
a_formal_arg_list: BOOLEAN
effective function
{}
 ++ formal_arg_list -> ["(" {declaration_group ";" ...} ")"]
 ++ declaration_group -> {identifier "," ...}+ ":" type_mark
error_handler_append_info_about_feature_name
effective procedure
{}
a_local_name_def: BOOLEAN
effective function
{}
Used inside a_local_var_list in order to detect a LOCAL_NAME_DEF name.
S_waiting_for_the_first_name_of_a_group: INTEGER_32
is 0
constant attribute
{}
S_waiting_for_colon_or_semicolon: INTEGER_32
is 1
constant attribute
{}
S_waiting_for_a_second_local_name: INTEGER_32
is 2
constant attribute
{}
S_waiting_for_a_type_mark: INTEGER_32
is 3
constant attribute
{}
S_waiting_for_optional_colon: INTEGER_32
is 4
constant attribute
{}
check_local_var_rank_and_closure (name: LOCAL_NAME_DEF)
effective procedure
{}
a_local_var_list
effective procedure
{}
 ++ local_var_list -> [{declaration_group ";" ...}]
a_local_name_ref_ (vars: LOCAL_VAR_LIST, closure_rank: INTEGER_32): BOOLEAN
effective function
{}
Used to detect the usage of some local variable.
a_local_name_ref: BOOLEAN
effective function
{}
get_comment: COMMENT
effective function
{}
skip2 (c1: CHARACTER, c2: CHARACTER): BOOLEAN
effective function
{}
skip3 (c1: CHARACTER, c2: CHARACTER, c3: CHARACTER): BOOLEAN
effective function
{}
skip1unless2 (c1: CHARACTER, c2: CHARACTER): BOOLEAN
effective function
{}
a_character_constant (syntax_flag: INTEGER_8): BOOLEAN
effective function
{}
an_allowed_expression_in_when_of_inspect: BOOLEAN
effective function
{}
Only True for static values allowed in "when of inspect".
a_class_name: BOOLEAN
effective function
{}
The class name found is left in the token_buffer.
a_base_class_name: BOOLEAN
effective function
{}
a_base_class_name_def
effective procedure
{}
Read the current class text name which is just after the "class" keyword.
a_formal_generic_type_mark: BOOLEAN
effective function
{}
freeop_prefix: INTEGER_8
is 1
constant attribute
{}
freeop_infix: INTEGER_8
is 2
constant attribute
{}
freeop_alias: INTEGER_8
is 3
constant attribute
{}
a_free_operator_definition (freeop: INTEGER_8, sp: POSITION): BOOLEAN
effective function
{}
A free operator name definition (the one which comes after the "infix" keyword or the "prefix" keyword at the definition place).
a_free_operator_usage (freeop: INTEGER_8): BOOLEAN
effective function
{}
Syntactically, a free operator must start and finish with one of the following set of characters: +-*/\=<>@#|&~ Because of priority, traditional operators are not handled here.
a_retry: BOOLEAN
effective function
{}
a_address_of: BOOLEAN
effective function
{}
 ++ address_of -> "$" identifier
a_actuals: EFFECTIVE_ARG_LIST
effective function
{}
 ++ actuals -> "(" {actual "," ...} ")"
 ++
a_actuals_until (close: CHARACTER, allow_empty: BOOLEAN): EFFECTIVE_ARG_LIST
effective function
{}
 ++ actuals -> "(" {actual "," ...} ")"
 ++                ^
 ++
just_after_a_dot (do_instruction: BOOLEAN, target: EXPRESSION): BOOLEAN
effective function
{}
 ++ after_a_dot -> identifier [actuals] ["." after_a_dot]
 ++
a_alias_parentheses (do_instruction: BOOLEAN, target: EXPRESSION): BOOLEAN
effective function
{}
 ++ alias_parentheses -> "(" {actual "," ...} ")"
 ++                      ^
a_alias_brackets (do_instruction: BOOLEAN, target: EXPRESSION): BOOLEAN
effective function
{}
 ++ alias_brackets -> "[" {actual "," ...} "]"
 ++                   ^
a_assignment_or_procedure_call: BOOLEAN
effective function
{}
 ++ assignment_or_procedure_call -> "(" expression ")" r10 |
 ++                       "Precursor" ["{" type_mark "}"] [actuals] r10 |
 ++                       "Current" r10 |
 ++                       "Result" r10 |
 ++                       local_variable r10 |
 ++                       formal_argument r10 |
 ++                       writable ":=" expression |
 ++                       writable "?=" expression |
 ++                       writable "::=" expression |
 ++                       identifier procedure_call
 ++
a_assignment_call_assigner (do_expression: BOOLEAN): BOOLEAN
effective function
{}
a_assertion_buffer: FAST_ARRAY[ASSERTION]
once function
{}
Used only inside a_assertion.
a_assertion: FAST_ARRAY[ASSERTION]
effective function
{}
 ++ assertion -> {assertion_clause ";" ...}
brackets_name: HASHED_STRING
once function
parentheses_name: HASHED_STRING
once function
slash_slash_name: HASHED_STRING
once function
backslash_backslash_name: HASHED_STRING
once function
muls_name: HASHED_STRING
once function
slash_name: HASHED_STRING
once function
pow_name: HASHED_STRING
once function
xor_name: HASHED_STRING
once function
implies_name: HASHED_STRING
once function
and_name: HASHED_STRING
once function
sharp_plus_name: HASHED_STRING
once function
sharp_minus_name: HASHED_STRING
once function
sharp_muls_name: HASHED_STRING
once function
plus_name: HASHED_STRING
once function
minus_name: HASHED_STRING
once function
not_name: HASHED_STRING
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.
a_binary (sp: POSITION): BOOLEAN
effective function
{}
 ++ binary -> "<=" | ">=" | "//" | "\\" |
 ++           "+" | "-" | "*" | "/" | "<" | ">" | "^" |
 ++           xor" | "implies" | "and then" | "and" |
  ++           "or else" | "or" | "#+" | "#-" | "#*"
  ++
t
a_boolean_constant: BOOLEAN
effective function
{}
 ++ boolean_constant -> "True" | "False"
 ++
a_check: BOOLEAN
effective function
{}
 ++ check -> "check" assertion [indexing] "end"
 ++
a_class_declaration
effective procedure
{}
 ++ class_declaration -> [indexing]
 ++                      ["expanded" | "deferred" | "separate"]
 ++                      "class" class_text_name
 ++                      ["[" formal_generic_list "]"]
 ++                      [comment]
 ++                      ["obsolete" manifest_string]
 ++                      ["inherit" inherit_text]
 ++                      ["insert" inherit_text]
 ++                      {{"creation"|"create"} creation_clause ...}
 ++                      ["convert" convert_clause]
 ++                      {"feature" feature_clause ...}
 ++                      ["invariant" assertion]
 ++                      [indexing]
 ++                      "end"
 ++
a_static_type_mark (for_client_list: BOOLEAN): BOOLEAN
effective function
{}
 ++ base_type_mark -> "ANY" | ARRAY "[" type_mark "]" | "BOOLEAN" |
 ++         "CHARACTER" | "DOUBLE" | "INTEGER" |
 ++         "POINTER" | "REAL" | "STRING" | "TUPLE" |
 ++         "ROUTINE" | "PROCEDURE" | "FUNCTION" | "PREDICATE"
 ++
 ++ static_type_mark -> base_type_mark |
 ++               class_text_name ["[" {type_mark "," ...} "]"]
 ++
a_type_mark_inside_client_list: BOOLEAN
effective function
{}
a_conversion_list
effective procedure
{}
 ++ conversion_list -> type_mark_list
 ++
a_clients: CLIENT_LIST
effective function
{}
 ++ clients -> type_mark_list
 ++
a_type_mark_list: TYPE_MARK_LIST
effective function
{}
 ++ type_mark_list -> "{" { class_text_name "," ... } "}"
 ++
a_compound1: INSTRUCTION
effective function
{}
 ++ compound -> {instruction ";" ...}
a_compound2 (compound_of: STRING, terminator: STRING): INSTRUCTION
effective function
{}
Call a_compound1 and then enforce the terminator at the end.
a_exp2 (compound_of: STRING, terminator: STRING): EXPRESSION
effective function
{}
Call a_expression and then enforce the terminator at the end.
a_conditional_exp: BOOLEAN
effective function
{}
 ++ conditional_exp -> "if" expression "then" expression
 ++                    [ {"elseif" expression "then" expression ...}+ ]
 ++                    [ "else" expression ]
 ++                    "end"
 ++
a_conditional: BOOLEAN
effective function
{}
 ++ conditional -> "if" expression "then" compound
 ++                [ {"elseif" expression "then" compound ...}+ ]
 ++                [ "else" compound ]
 ++                "end"
 ++
no_void_after_elseif_check (expression: EXPRESSION)
effective procedure
{}
a_then_compound: INSTRUCTION
effective function
{}
 ++ then_compound -> "then" compound
a_then_exp: EXPRESSION
effective function
{}
 ++ then_exp -> "then" expression
a_old_creation: BOOLEAN
effective function
{}
 ++ old_creation -> "!"[type_mark]"!"
a_c_inline_c: BOOLEAN
effective function
{}
 ++ c_inline_c -> "c_inline_c" "(" manifest_string ")"
 ++
a_c_inline_h: BOOLEAN
effective function
{}
 ++ c_inline_h -> "c_inline_h" "(" manifest_string ")"
 ++
a_create_instruction: BOOLEAN
effective function
{}
 ++ create_instruction -> "create" ["{" type "}"] writable
 ++                       ["." procedure_name [actuals]]
 ++
a_create_expression: BOOLEAN
effective function
{}
 ++ create_expression -> "create" "{" type "}" ["." procedure_name [actuals]]
 ++
a_creation_clause (sp: POSITION, with_clients: BOOLEAN): CREATION_CLAUSE
effective function
{}
 ++ creation_clause -> [clients] [comment] feature_list
 ++
a_convert_clause (sp: POSITION)
effective procedure
{}
 ++ convert_clause -> {feature_name conversion_clause ...}
a_conversion_clause
effective procedure
{}
 ++ conversion_clause -> conversion_procedure |
 ++                      conversion_query
 ++
a_conversion_procedure: BOOLEAN
effective function
{}
 ++ conversion_procedure -> '(' conversion_list ')'
 ++
a_conversion_query: BOOLEAN
effective function
{}
 ++ conversion_query -> ':' conversion_list
 ++
a_debug: BOOLEAN
effective function
{}
 ++ debug -> "debug" "(" {manifest_string "," ...} ")"
 ++                  compound "end"
 ++
a_expression: BOOLEAN
effective function
{}
 ++ expression -> "<<" { expression "," ... } ">>" |
 ++               e1 r1
 ++
a_e1: BOOLEAN
effective function
{}
 ++ e1 -> e2 r2
 ++
a_e2: BOOLEAN
effective function
{}
 ++ e2 -> e3 r3
 ++
a_e3: BOOLEAN
effective function
{}
 ++ e3 -> e4 r4
 ++
a_e4: BOOLEAN
effective function
{}
 ++ e4 -> e5 r5
 ++
a_e5: BOOLEAN
effective function
{}
 ++ e5 -> e6 r6
 ++
a_e6: BOOLEAN
effective function
{}
 ++ e6 -> e7 r7
 ++
a_e7: BOOLEAN
effective function
{}
 ++ e7 -> e8 r8
 ++
a_e8: BOOLEAN
effective function
{}
 ++ e8 -> "not" e8 |
 ++       "+" e8 |
 ++       "-" e8 |
 ++       free_operator e8 !
 ++       e9
 ++
a_e9: BOOLEAN
effective function
{}
 ++ e9 -> e10 |
 ++       "old" e10
 ++
a_e10: BOOLEAN
effective function
{}
 ++ e10 -> "(" expression ")" r10 |
 ++       "[" {Expression "," ...} "]" |
 ++       "True" | "False" |
 ++       "?" |
 ++       character_constant |
 ++       manifest_string |
 ++       manifest_or_type_test |
 ++       "Precursor" ["{" type_mark "}"] [actuals] r10 |
 ++       "agent" expression |
 ++       "Result" r10 |
 ++       "Current" r10 |
 ++       "Void" r10 |
 ++       local_variable r10 |
 ++       argument r10 |
 ++       identifier ?:= expression
 ++       function_call r10 |
++        a_condition_exp r10
 ++
inline_agent_counter: INTEGER_32
writable attribute
{}
inline_agents: FAST_ARRAY[FEATURE_TEXT]
once function
{}
a_is: BOOLEAN
effective function
{}
a_inline_agent: FEATURE_TEXT
effective function
{}
 ++ inline_agent -> formal_arg_list
 ++                 [":" type]
 ++                 "is" routine
 ++
inline_agent_no_name: FEATURE_NAME
once function
{}
a_external: FEATURE_TEXT
effective function
{}
 ++ external -> "<external-specification>" external_name
 ++ external_name -> ["alias" manifest_string]
 ++
a_external_specification: NATIVE
effective function
{}
a_external_name: MANIFEST_STRING
effective function
{}
a_feature_name_list: BOOLEAN
effective function
{}
 ++ feature_name_list -> {feature_name "," ...}
a_feature_name: BOOLEAN
effective function
{}
 ++ feature_name -> prefix |
 ++                 infix |
 ++                 simple_feature_name
 ++
a_feature_clause
effective procedure
{}
 ++ feature_clause -> [clients] [comment] feature_declaration_list
 ++
a_possibly_frozen_feature_name: BOOLEAN
effective function
{}
a_feature_declaration: BOOLEAN
effective function
{}
 ++ feature_declaration -> {["frozen"] feature_name "," ...}+
 ++                        formal_arg_list
 ++                        [":" type]
 ++                        ["is" "unique" |
 ++                         "is" manifest_constant |
 ++                         "is" routine]
 ++
check_alias
effective procedure
{}
a_formal_generic_list
effective procedure
{}
 ++ formal_generic_list -> ["[" {formal_generic "," ...} "]"]
 ++ formal_generic -> class_text_name ["->" static_type_mark]
 ++
a_function_call: BOOLEAN
effective function
{}
 ++ function_call -> [actuals] r10 |
 ++                   ^
 ++
a_index_clause (a_indexingable: INDEXINGABLE, a_spec: STRING): BOOLEAN
effective function
{}
 ++ index_clause -> [identifier ":"] {index_value "," ...}+
 ++
a_index_value: BOOLEAN
effective function
{}
 ++ index_value -> identifier | manifest_constant
 ++
a_indexing (a_indexingable: INDEXINGABLE, a_spec: STRING)
effective procedure
{}
 ++ indexing -> "indexing" {index_clause ";" ...}
a_infix: BOOLEAN
effective function
{}
 ++ infix -> "infix" """ binary """
 ++          "infix" """ free_operator """
 ++
a_inspect: BOOLEAN
effective function
{}
 ++ inspect -> "inspect" expression
 ++            {when_part ...}
a_instruction: BOOLEAN
effective function
{}
 ++ instruction -> check | debug | conditional | retry |
 ++                inspect | loop | old_creation |
 ++                c_inline_c | c_inline_h |
 ++                create_instruction |
 ++                assignment_or_procedure_call [":=" expression ]
 ++                expression [":=" expression ]
 ++
eiffel_parser_stamp: INTEGER_32
writable attribute
{}
a_loop: BOOLEAN
effective function
{}
 ++ loop -> "from" compound
 ++         ["invariant"] assertion
 ++         ["variant" [identifier ":"] expression]
 ++         "until" expression
 ++         "loop" compound
 ++         "end"
 ++
a_new_export_list
effective procedure
{}
 ++ new_export_list -> ["export" {new_export_item ";" ...}]
a_parent_list
effective procedure
{}
 ++ inherit_text -> ["external" ***]
 ++                 ["inherit" {parent ";" ...}]
a_parent_edge (is_insert_flag: BOOLEAN): BOOLEAN
effective function
{}
 ++ parent -> static_type_mark
 ++           ["rename" rename_list]
 ++           new_export_list
 ++           ["undefine" feature_name_list]
 ++           ["redefine" feature_name_list]
 ++           ["end"]
 ++
a_alias (fn: FEATURE_NAME): BOOLEAN
effective function
{}
 ++ alias -> "alias" """ unary """
 ++          "alias" """ free_operator """
 ++
a_prefix: BOOLEAN
effective function
{}
 ++ prefix -> "prefix" """ unary """
 ++           "prefix" """ free_operator """
 ++
a_procedure_call: BOOLEAN
effective function
{}
 ++ procedure_call -> [actuals] r10 |
 ++                   ^
 ++
a_rename_list
effective procedure
{}
 ++ rename_list -> {rename_pair "," ...}
a_rename_pair: BOOLEAN
effective function
{}
 ++ rename_pair -> identifier "as" identifier
 ++
a_routine (expect_routine: BOOLEAN): FEATURE_TEXT
effective function
{}
 ++ routine -> [indexing]
 ++            ["obsolete" manifest_string]
 ++            ["require" ["else"] assertion]
 ++            ["local" entity_declaration_list]
 ++            routine_body
 ++            ["ensure" ["then"] assertion]
 ++            ["rescue" compound]
 ++            "end"
 ++
a_routine_body (expected: BOOLEAN): FEATURE_TEXT
effective function
{}
 ++ routine_body -> "deferred" |
 ++                 "external" external |
 ++                 "do" compound ( "then" expression )?
a_r1 (left_part: EXPRESSION)
effective procedure
{}
 ++ r1 -> "implies" e1 r1 |
 ++       ^
 ++
a_r2 (left_part: EXPRESSION)
effective procedure
{}
 ++ r2 -> "or else" e2 r2 |
 ++       "or" e2 r2 |
 ++       "xor" e2 r2 |
 ++       ^
 ++
a_r3 (left_part: EXPRESSION)
effective procedure
{}
 ++ r3 -> "and then" e3 r3 |
 ++       "and" e3 r3 |
 ++       ^
 ++
a_r4 (left_part: EXPRESSION)
effective procedure
{}
 ++ r4 -> "=" e4 r4 |
 ++       "/=" e4 r4 |
 ++       "<=" e4 r4 |
 ++       "<" e4 r4 |
 ++       ">=" e4 r4 |
 ++       ">" e4 r4 |
 ++       ^
 ++
a_r5 (left_part: EXPRESSION)
effective procedure
{}
 ++ r5 -> "+" e5 r5 |
 ++       "-" e5 r5 |
 ++       ^
 ++
a_r6 (left_part: EXPRESSION)
effective procedure
{}
 ++ r6 -> "*" e6 r6 |
 ++       "//" e6 r6 |
 ++       "\\" e6 r6 |
 ++       "/" e6 r6 |
 ++       ^
 ++
a_r7 (left_part: EXPRESSION)
effective procedure
{}
 ++ r7 -> "^" e7 r7 |
 ++       ^
 ++
a_r8 (left_part: EXPRESSION)
effective procedure
{}
 ++ r8 -> free_operator e8 r8 |
 ++       ^
 ++
a_r10 (do_instruction: BOOLEAN, t: EXPRESSION, fn: FEATURE_NAME, eal: EFFECTIVE_ARG_LIST): BOOLEAN
effective function
{}
 ++ r10 -> "."
a_tag_mark: BOOLEAN
effective function
{}
 ++ tag_mark -> identifier ":"
 ++
a_type_mark (for_client_list: BOOLEAN): BOOLEAN
effective function
{}
 ++ type_mark -> static_type_mark |
 ++              formal_generic_type_mark |
 ++              "like" "Current" |
 ++              "like" feature_name |
 ++              "like" argument |
 ++              "separate" static_type_mark
 ++
effective function
Initialize a new one at line l and column c.
valid_parent_edge_type_check (type_mark: TYPE_MARK)
effective procedure
{}
Check that no anchored type are used.
inside_function_precursor_check (exp: EXPRESSION)
effective procedure
{}
a_unary (sp: POSITION): BOOLEAN
effective function
{}
 ++ unary -> "not" | "+" | "-"
 ++
a_when_part (manifest_string_flag: INTEGER_32, when_clause: WHEN_CLAUSE): INTEGER_32
effective function
{}
 ++ when_part -> "when" {when_part_item "," ...}
a_writable: BOOLEAN
effective function
{}
Which is Result, some local variable or some writable attribute name.
mandatory_writable: EXPRESSION
effective function
{}
Skip and return the writable which is mandatory here.
effective function
{}
effective function
{}
a_ordinary_feature_name_or_local_name: BOOLEAN
effective function
{}
Is there some name here which looks like an ordinary feature name or which looks like an ordinary local variable name (Result is not an ordinary local name).
a_non_allowed_very_strange_identifier: BOOLEAN
effective function
{}
Is there some name here which looks like a very strange identifier (not a_ordinary_feature_name_or_local_name and not a_class_name and not a keyword).
show_nb (nb: INTEGER_32, tail: STRING)
effective procedure
{}
tmp_feature: TMP_FEATURE
writable attribute
{}
once function
{}
err_exp (sp: POSITION, prefix_flag: BOOLEAN, operator: STRING)
effective procedure
{}
When an error occurs in the right hand side of some operator.
expression_with_comment (e: EXPRESSION): EXPRESSION
effective function
{}
There is some following comment, e may be wrapped inside some EXPRESSION_WITH_COMMENT object.
unknown_external_language (external_tag: MANIFEST_STRING)
effective procedure
{}
unused_once_warning_check
effective procedure
{}
create_infix_prefix (freeop: INTEGER_8, l: INTEGER_32, c: INTEGER_32)
effective procedure
{}
anchored_creation_check (type: TYPE_MARK)
effective procedure
{}
void_current_comparison_check (e1: EXPRESSION, e2: EXPRESSION)
effective procedure
{}
void_current_comparison_check_ (e1: EXPRESSION, e2: EXPRESSION)
effective procedure
{}
a_precursor_type_mark (sp: POSITION): TYPE_MARK
effective function
{}
To continue the work after the first '{'.
a_keyword_precursor: BOOLEAN
effective function
{}
no_static_simplify: BOOLEAN
once function
{}
static_simplify (expression: EXPRESSION): EXPRESSION
effective function
{}
manifest_just_after_a_dot (sign_flag: CHARACTER, do_instruction: BOOLEAN, target: EXPRESSION): BOOLEAN
effective function
{}
a_keyword_void: BOOLEAN
effective function
{}
a_keyword_result: BOOLEAN
effective function
{}
a_keyword_current: BOOLEAN
effective function
{}
a_keyword_true: BOOLEAN
effective function
{}
a_keyword_false: BOOLEAN
effective function
{}
no_void_check (expression: EXPRESSION, msg: STRING)
effective procedure
{}
make
effective procedure
{}
unused_tmp_features: STACK[TMP_FEATURE]
once function
{}
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.
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.
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.
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.
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.
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
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.
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
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}
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
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}
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}
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).%%%%%%%%
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}
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: