+
Point of view
All features
class LOG_GRAMMAR
Summary
Direct parents
Insert list: EIFFEL_GRAMMAR
Class invariant
Overview
Creation features
{ANY}
Features
{}
{ANY}
{}
{ANY}
{}
{}
buffer moves
{}
{}
Maximum:
{}
Minimum:
{}
Bits:
{}
{}
  • log: LOGGER
    There is one logger per concrete type; for performance reasons it is cached in each instance.
  • log_memory__0_: LOGGER
    The cached logger.
once function
{}
end_reached: BOOLEAN
writable attribute
{ANY}
writable attribute
{}
effective function
{ANY}
display (output: OUTPUT_STREAM)
effective procedure
{ANY}
generate (o: OUTPUT_STREAM)
effective procedure
{ANY}
root_node: EIFFEL_NODE
effective function
{ANY}
reset
effective procedure
{ANY}
ensure
epsilon: FAST_ARRAY[STRING]
once function
{}
ensure
  • Result.is_empty
is_a_keyword (id: STRING): BOOLEAN
effective function
{}
is_a_free_operator (op: STRING): BOOLEAN
effective function
{}
require
  • op.count > 0
last_blanks: STRING
is ""
constant attribute
{}
comment_position: EIFFEL_POSITION
writable attribute
{}
has_comment: BOOLEAN
writable attribute
{}
skip_blank (buffer: MINI_PARSER_BUFFER, skip_semi_colons: BOOLEAN): BOOLEAN
effective function
{}
ensure
  • not Result implies buffer.current_index = old buffer.current_index
skip_blanks (buffer: MINI_PARSER_BUFFER)
effective procedure
{}
ensure
  • buffer.current_index = last_blanks.count + old buffer.current_index
  • not buffer.marked
skip_blanks_and_semi_colons (buffer: MINI_PARSER_BUFFER)
effective procedure
{}
ensure
  • buffer.current_index = last_blanks.count + old buffer.current_index
  • not buffer.marked
parse_assertion_comment (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
parse_string (buffer: MINI_PARSER_BUFFER): TYPED_EIFFEL_IMAGE[STRING]
effective function
{}
the algorithm is a bit less strict than Liberty Eiffel's
ensure
  • Result /= Void implies Result.image.count >= 2 and then Result.image.first = '"' or else Result.image.count >= 3 and then Result.image.first = 'U' and then Result.image.item(2) = '"' and then Result.image.last = '"'
is_entity_name_start (c: CHARACTER): BOOLEAN
effective function
{}
is_entity_name_part (c: CHARACTER): BOOLEAN
effective function
{}
parse_entity_name (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
is_class_name_start (c: CHARACTER): BOOLEAN
effective function
{}
is_class_name_part (c: CHARACTER): BOOLEAN
effective function
{}
parse_class_name (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
keyword_image (buffer: MINI_PARSER_BUFFER, keyword: STRING, not_successors: STRING): STRING
effective function
{}
parse_keyword (buffer: MINI_PARSER_BUFFER, keyword: STRING): UNTYPED_EIFFEL_IMAGE
effective function
{}
parse_symbol (buffer: MINI_PARSER_BUFFER, keyword: STRING, not_successors: STRING): UNTYPED_EIFFEL_IMAGE
effective function
{}
parse_semi_colons (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
in_parent_clause: BOOLEAN
writable attribute
{}
parse_parent_clause (buffer: MINI_PARSER_BUFFER, keyword: STRING): UNTYPED_EIFFEL_IMAGE
effective function
{}
ensure
parse_end_of_parent_clause (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
ensure
parse_freeop (buffer: MINI_PARSER_BUFFER): UNTYPED_EIFFEL_IMAGE
effective function
{}
parse_boolean (buffer: MINI_PARSER_BUFFER, expected: STRING): TYPED_EIFFEL_IMAGE[BOOLEAN]
effective function
{}
require
  • expected.is_boolean
ensure
  • Result /= Void implies Result.decoded = expected.to_boolean
parse_number (buffer: MINI_PARSER_BUFFER): EIFFEL_IMAGE
effective function
{}
is_hex (image: STRING): BOOLEAN
effective function
{}
hex_to_integer_64 (image: STRING): INTEGER_64
effective function
{}
require
parse_character (buffer: MINI_PARSER_BUFFER): TYPED_EIFFEL_IMAGE[CHARACTER]
effective function
{}
effective function
{}
writable attribute
{}
writable attribute
{}
show_stack
effective procedure
{}
stack_matches (node_content: TRAVERSABLE[FIXED_STRING]): BOOLEAN
effective function
{}
ensure
  • used_only_in_assertions: Result
build_root (root_name: FIXED_STRING, root_content: TRAVERSABLE[FIXED_STRING])
effective procedure
{}
build_non_terminal (node_name: FIXED_STRING, node_content: TRAVERSABLE[FIXED_STRING])
effective procedure
{}
require ensure
  • node_content.count = old node_content.count
  • stack.count = old stack.count - node_content.count + 1
  • stack.last.name.is_equal(node_name)
build_terminal (node_name: FIXED_STRING, node_image: PARSER_IMAGE)
effective procedure
{}
ensure
ensure_expression (expression: EIFFEL_NODE, expression_name: FIXED_STRING): EIFFEL_NON_TERMINAL_NODE
effective function
{}
build_expression_remainder (operator_names: FAST_ARRAY[ABSTRACT_STRING], expression_name: FIXED_STRING)
effective procedure
{}
build_expression (expression_name: FIXED_STRING)
effective procedure
{}
build_expression_epsilon (expression_name: FIXED_STRING)
effective procedure
{}
build_expression_e6
effective procedure
{}
build_expression_no_array (expression_name: FIXED_STRING, node_name: FIXED_STRING)
effective procedure
{}
left_assoc_names: FAST_ARRAY[FIXED_STRING]
once function
{}
build_empty_list (list_name: ABSTRACT_STRING)
effective procedure
{}
ensure
build_new_list (atom_name: ABSTRACT_STRING, list_name: ABSTRACT_STRING)
effective procedure
{}
require
  • not stack.is_empty
  • stack.last.name.is_equal(atom_name)
ensure
build_continue_list (atom_name: ABSTRACT_STRING, forget: INTEGER_32, list_name: ABSTRACT_STRING)
effective procedure
{}
require
  • stack.count >= forget + 2
  • stack.item(stack.upper).name.is_equal(list_name)
  • stack.item(stack.upper - 1 - forget).name.is_equal(atom_name)
ensure
next_character (buffer: MINI_PARSER_BUFFER)
effective procedure
{}
restore (buffer: MINI_PARSER_BUFFER, a_position: EIFFEL_POSITION)
effective procedure
{}
position: EIFFEL_POSITION
writable attribute
{}
make (a_factory: EIFFEL_NODE_FACTORY)
effective procedure
{}
ensure
make_default
effective procedure
{}
writable attribute
{}
Maximum_character_code: INTEGER_16
{}
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
Number of bits in a value of type POINTER.
log: LOGGER
effective function
{}
There is one logger per concrete type; for performance reasons it is cached in each instance.
ensure
  • Result /= Void
log_memory__0_: LOGGER
writable attribute
{}
The cached logger.
The ugly name is intentional. Don't use directly.