Eiffel programming language syntax

The syntax specification shown here is a less complete and less formal version of that which is in the Eiffel ISO/ECMA standard document. The format is BNF-E. The Language Specification section of the standard document includes an overview of BNF-E.

There are a few parts of the syntax that are either non-production or non-representable in BNF-E. Some of these have been omitted from the following specification. These omitted parts of the syntax definition add to the precision of the specification, but knowledge of them is not always vital for developers.

In the BNF-E representation, generally non-terminals which are defined in the same group of productions in which they are used are not linked. However when a non-terminal is defined outside a group in which it is used, it is linked to the group in which it is defined.

Contents 1 Eiffel non-production elements 1.1 Identifiers 1.2 Characters 1.3 Reals 1.4 Strings 1.5 Simple strings 1.6 Special characters 1.7 Line wrapping parts 2 Eiffel BNF-E Syntax 2.1 Class names 2.2 Class declarations 2.3 Notes 2.4 Class headers 2.5 Obsolete marks 2.6 Feature parts 2.7 Feature declarations 2.8 New feature lists 2.9 Feature bodies 2.10 Feature names 2.11 Operators 2.12 Assigner marks 2.13 Inheritance parts 2.14 Rename clauses 2.15 Clients 2.16 Export adaptation 2.17 Formal argument and entity declarations 2.18 Routine bodies 2.19 Local variable declarations 2.20 Instructions 2.21 Assertions 2.22 “Old” postcondition expressions 2.23 “Only” postcondition clauses 2.24 Check instructions 2.25 Variants 2.26 Precursor 2.27 Redefinition 2.28 Undefine clauses 2.29 Types 2.30 Actual generic parameters 2.31 Formal generic parameters 2.32 Generic constraints 2.33 Tuple types 2.34 Manifest tuples 2.35 Converter clauses 2.36 Select clauses 2.37 Conditionals 2.38 Multi-branch instructions 2.39 Loops 2.40 Debug instructions 2.41 Attribute bodies 2.42 Entities and variables 2.43 Creators parts 2.44 Creation instructions 2.45 Creation expressions 2.46 Equality expressions 2.47 Assignments 2.48 Assigner calls 2.49 Feature calls 2.50 Actual arguments 2.51 Object test 2.52 Rescue clauses 2.53 Agents 2.54 Call agent bodies 2.55 Expressions 2.56 Operator expressions 2.57 Bracket expressions 2.58 Constants 2.59 Manifest constants 2.60 Manifest strings 2.61 External routines 2.62 Registered languages 2.63 External signatures 2.64 External file use 2.65 C externals 2.66 C++ externals 2.67 DLL externals 2.68 Comments 2.69 Integers

The following section contains those non-production elements of the specification that are used later in the BNF-E specification.

Eiffel non-production elements

Identifiers

An identifier is a sequence of one or more alphanumeric characters of which the first is a letter.

The definition is augmented by the rule that Identifiers are not valid if they are the same as one of the language's reserved words.

Characters

Characters are either:

• All 32-bit, corresponding to Unicode and to the Eiffel type CHARACTER_32.
• All 8-bit, corresponding to 8-bit extended ASCII and to the Eiffel type CHARACTER_8

Reals

A real -- specimen of Real -- is made of the following elements, in the order given:

• An optional decimal Integer, giving the integral part.
• A required "." (dot).
• An optional decimal Integer, giving the fractional part.
• An optional exponent, which is the letter e or E followed by an optional Sign and a decimal Integer.

No intervening character (blank or otherwise) is permitted between these elements. The integral and fractional parts may not both be absent.

Strings

A string -- specimen of construct String -- is a sequence of zero or more manifest characters.

Simple strings

A simple string -- specimen of Simple_string -- is a String consisting of at most one line (that is to say, containing no embedded new-line manifest character), possibly containing codes for special characters.

Special characters

Special Characters and Their Codes

Character	Code	Mnemonic name
@	%A	At-sign
BS	%B	Backspace
^	%C	Circumflex
$	%D	Dollar
FF	%F	Form feed
\	%H	Backslash
~	%L	Tilde
NL (LF)	%N	Newline
`	%Q	Backquote
CR	%R	Carriage return
#	%S	Sharp
HT	%T	Horizontal tab
NUL	%U	Null
|	%V	Vertical bar
%	%%	Percent
'	%'	Single quote
"	%"	Double quote
[	%(	Opening bracket
]	%)	Closing bracket
{	%<	Opening brace
}	%>	Closing brace

Line wrapping parts

A sequence of characters consisting of the following, in order:

•  % (percent character)
• Zero or more blanks or tabs
• New line (Line feed)
• Zero or more blanks or tabs
•  % (percent character)

Line wrapping parts are used as separators between one Simple_string and the next in a Basic_manifest_string so that the string can be split across lines.

Eiffel BNF-E Syntax

Class names

Class_name ::= Identifier

Class declarations

Class_declaration ::= [Notes]
Class_header
[Formal_generics]
[Obsolete]
[Inheritance]
[Creators]
[Converters]
[Features]
[Invariant]
[Notes]
end

Notes

Notes ::= note Note_list
Note_list ::= {Note_entry ";" …}*
Note_entry ::= Note_name Note_values
Note_name ::= Identifier ":"
Note_values ::= {Note_item ","…}+
Note_item ::= Identifier | Manifest_constant

Class headers

Class_header ::= [Header_mark] class Class_name
Header_mark ::= deferred | expanded | frozen

Obsolete marks

Obsolete ::= obsolete Message
Message ::= Manifest_string

Feature parts

Features ::= Feature_clause+
Feature_clause ::= feature [Clients] [Header_comment] Feature_declaration_list
Feature_declaration_list ::= {Feature_declaration ";" …}*
Header_comment ::= Comment

Feature declarations

Feature_declaration ::= New_feature_list Declaration_body
Declaration_body ::= [Formal_arguments] [Query_mark] [Feature_value]
Query_mark ::= Type_mark [Assigner_mark]
Type_mark ::= ":" Type
Feature_value ::= [Explicit_value]
[Obsolete]
[Header_comment]
[Attribute_or_routine]
Explicit_value ::= "=" Manifest_constant

New feature lists

New_feature_list ::= {New_feature "," …}+
New_feature ::= [frozen] Extended_feature_name

Feature bodies

Attribute_or_routine ::= [Precondition]
[Local_declarations]
Feature_body
[Postcondition]
[Rescue]
end
Feature_body ::= Deferred | Effective_routine | Attribute

Feature names

Extended_feature_name ::= Feature_name [Alias]
Feature_name ::= Identifier
Alias ::= alias '"' Alias_name '"' [convert]
Alias_name ::= Operator | Bracket
Bracket ::= "[ ]"

Operators

Operator ::= Unary | Binary
Unary ::= not | "+" | "–" | Free_unary
Binary ::= "+" | "–" | "*" | "/" | "//" | "\\" | "^" | ".." |
"<" | ">" | "<=" | ">=" |
and | or | xor | and then | or else | implies |
Free_binary

Note: Free_unary and Free_binary are free operators that are distinct from (respectively) the standard unary and binary operators (one- or two-character symbols) explicitly listed in the Unary and Binary productions. See Definition: Free operator in the standard for more precision.

Assigner marks

Assigner_mark ::= assign Feature_name

Inheritance parts

Inheritance ::= Inherit_clause+
Inherit_clause ::= inherit [Non_conformance] Parent_list
Non_conformance ::= "{" NONE "}"
Parent_list ::= {Parent ";" …}+
Parent ::= Class_type [Feature_adaptation]
Feature_adaptation ::= [Undefine]
[Redefine]
[Rename]
[New_exports]
[Select]
end

Rename clauses

Rename ::= rename Rename_list
Rename_list ::= {Rename_pair "," …}+
Rename_pair ::= Feature_name as Extended_feature_name

Clients

Clients ::= "{" Class_list "}"
Class_list ::= {Class_name "," …}+

Export adaptation

New_exports ::= export New_export_list
New_export_list ::= {New_export_item ";" …}+
New_export_item ::= Clients [Header_comment] Feature_set
Feature_set ::= Feature_list | all
Feature_list ::= {Feature_name "," …}+

Formal argument and entity declarations

Formal_arguments ::= "(" Entity_declaration_list ")"
Entity_declaration_list ::= {Entity_declaration_group ";" …}+
Entity_declaration_group ::= Identifier_list Type_mark
Identifier_list ::= {Identifier "," …}+

Routine bodies

Deferred ::= deferred
Effective_routine ::= Internal | External
Internal ::= Routine_mark Compound
Routine_mark ::= do | Once
Once ::= once [ "("Key_list ")" ]
Key_list ::= {Manifest_string "," …}+

Local variable declarations

Local_declarations ::= local [Entity_declaration_list]

Instructions

Compound ::= {Instruction ";" …}*
Instruction ::= Creation_instruction | Call | Assignment | Assigner_call | Conditional | Multi_branch
| Loop | Debug | Precursor | Check | Retry

Assertions

Precondition ::= require [else] Assertion
Postcondition ::= ensure [then] Assertion [Only]
Invariant ::= invariant Assertion
Assertion ::= {Assertion_clause ";" …}*
Assertion_clause ::= [Tag_mark] Unlabeled_assertion_clause
Unlabeled_assertion_clause ::= Boolean_expression | Comment
Tag_mark ::= Tag ":"
Tag ::= Identifier

“Old” postcondition expressions

Old ::= old Expression

“Only” postcondition clauses

Only ::= only [Feature_list]

Check instructions

Check ::= check Assertion [Notes] end

Variants

Variant ::= variant [Tag_mark] Expression

Precursor

Precursor ::= Precursor [Parent_qualification] [Actuals]
Parent_qualification ::= "{" Class_name "}"

Redefinition

Redefine ::= redefine Feature_list

Undefine clauses

Undefine ::= undefine Feature_list

Types

Type ::= Class_or_tuple_type | Formal_generic_name | Anchored
Class_or_tuple_type ::= Class_type | Tuple_type
Class_type ::= [Attachment_mark] Class_name [Actual_generics]
Attachment_mark ::= "?" | "!"
Anchored ::= [Attachment_mark] like Anchor
Anchor ::= Feature_name | Current

Actual generic parameters

Actual_generics ::= "[" Type_list "]"
Type_list ::= {Type "," …}+

Formal generic parameters

Formal_generics ::= "[" Formal_generic_list "]"
Formal_generic_list ::= {Formal_generic ","…}+
Formal_generic ::= [frozen] Formal_generic_name [Constraint]
Formal_generic_name ::= [?] Identifier

Generic constraints

Constraint ::= "–>" Constraining_types [Constraint_creators]
Constraining_types ::= Single_constraint | Multiple_constraint
Single_constraint ::= Type [Renaming]
Renaming ::= Rename end
Multiple_constraint ::= "{" Constraint_list "}"
Constraint_list ::= {Single_constraint "," …}+
Constraint_creators ::= create Feature_list end

Tuple types

Tuple_type ::= TUPLE [Tuple_parameter_list]
Tuple_parameter_list ::= "[" Tuple_parameters "]"
Tuple_parameters ::= Type_list | Entity_declaration_list

Manifest tuples

Manifest_tuple ::= "[" Expression_list "]"
Expression_list ::= {Expression "," …}*

Converter clauses

Converters ::= convert Converter_list
Converter_list ::= {Converter ","…}+
Converter ::= Conversion_procedure | Conversion_query
Conversion_procedure ::= Feature_name "(" "{" Type_list "}" ")"
Conversion_query ::= Feature_name ":" "{" Type_list "}"

Select clauses

Select ::= select Feature_list

Conditionals

Conditional ::= if Then_part_list [Else_part] end
Then_part_list ::= {Then_part elseif …}+
Then_part ::= Boolean_expression then Compound
Else_part ::= else Compound

Multi-branch instructions

Multi_branch ::= inspect Expression [When_part_list] [Else_part] end
When_part_list ::= When_part+
When_part ::= when Choices then Compound
Choices ::= {Choice "," …}+
Choice ::= Constant | Manifest_type | Constant_interval | Type_interval
Constant_interval ::= Constant ".." Constant
Type_interval ::= Manifest_type ".." Manifest_type

Loops

Loop ::= Initialization
[Invariant]
Exit_condition
Loop_body
[Variant]
end
Initialization ::= from Compound
Exit_condition ::= until Boolean_expression
Loop_body ::= loop Compound

Debug instructions

Debug ::= debug [ "("Key_list ")" ] Compound end

Attribute bodies

Attribute ::= attribute Compound

Entities and variables

Entity ::= Variable | Read_only
Variable ::= Variable_attribute | Local
Variable_attribute ::= Feature_name
Local ::= Identifier | Result
Read_only ::= Formal | Constant_attribute | Current
Formal ::= Identifier
Constant_attribute ::= Feature_name

Creators parts

Creators ::= Creation_clause+
Creation_clause ::= create [Clients] [Header_comment] Creation_procedure_list
Creation_procedure_list ::= {Creation_procedure ","…}+
Creation_procedure ::= Feature_name

Creation instructions

Creation_instruction ::= create [Explicit_creation_type] Creation_call
Explicit_creation_type ::= "{" Type "}"
Creation_call ::= Variable [Explicit_creation_call]
Explicit_creation_call ::= "." Unqualified_call

Creation expressions

Creation_expression ::= create Explicit_creation_type [Explicit_creation_call]

Equality expressions

Equality ::= Expression Comparison Expression
Comparison ::= "=" | "/=" | "~" | "/~"

Assignments

Assignment ::= Variable ":=" Expression

Assigner calls

Assigner_call ::= Expression ":=" Expression

Feature calls

Call ::= Object_call | Non_object_call
Object_call ::= [Target "."] Unqualified_call
Unqualified_call ::= Feature_name [Actuals]
Target ::= Local | Read_only | Call | Parenthesized_target
Parenthesized_target ::= "( |" Expression "| )"
Non_object_call ::= "{" Type "}" "." Unqualified_call

Actual arguments

Actuals ::= "(" Actual_list ")"
Actual_list ::= {Expression "," …}+

Object test

Object_test ::= "{" Identifier ":" Type "}" Expression

Rescue clauses

Rescue ::= rescue Compound
Retry ::= retry

Agents

Agent ::= Call_agent | Inline_agent
Call_agent ::= agent Call_agent_body
Inline_agent ::= agent [Formal_arguments] [Type_mark] [Attribute_or_routine] [Agent_actuals]

Call agent bodies

Call_agent_body ::= Agent_qualified | Agent_unqualified
Agent_qualified ::= Agent_target ". " Agent_unqualified
Agent_unqualified ::= Feature_name [Agent_actuals]
Agent_target ::= Entity | Parenthesized | Manifest_type
Agent_actuals ::= "(" Agent_actual_list ")"
Agent_actual_list ::= {Agent_actual "," …}+
Agent_actual ::= Expression | Placeholder
Placeholder ::= [Manifest_type] "?"

Expressions

Expression ::= Basic_expression | Special_expression
Basic_expression ::= Read_only | Local | Call | Precursor | Equality | Parenthesized | Old |
Operator_expression | Bracket_expression | Creation_expression
Special_expression ::= Manifest_constant | Manifest_tuple | Agent | Object_test | Once_string |
Address
Parenthesized ::= "(" Expression ")"
Address ::= "$" Variable
Once_string ::= once Manifest_string
Boolean_expression ::= Basic_expression | Boolean_constant | Object_test

Operator expressions

Operator_expression ::= Unary_expression | Binary_expression
Unary_expression ::= Unary Expression
Binary_expression ::= Expression Binary Expression

Bracket expressions

Bracket_expression ::= Bracket_target "[" Actuals "]"
Bracket_target ::= Target | Once_string | Manifest_constant | Manifest_tuple

Constants

Constant ::= Manifest_constant | Constant_attribute
Constant_attribute ::= Feature_name

Manifest constants

Manifest_constant ::= [Manifest_type] Manifest_value
Manifest_type ::= "{" Type "}"
Manifest_value ::= Boolean_constant |
Character_constant |
Integer_constant |
Real_constant |
Manifest_string |
Manifest_type
Sign ::= "+" | "–"
Integer_constant ::= [Sign] Integer
Character_constant ::= " ' " Character " ' "
Boolean_constant ::= True | False
Real_constant ::= [Sign] Real

Manifest strings

Manifest_string ::= Basic_manifest_string | Verbatim_string
Basic_manifest_string ::= ' " ' String_content ' " '
String_content ::= {Simple_string Line_wrapping_part …}+
Verbatim_string ::= Verbatim_string_opener Line_sequence Verbatim_string_closer
Verbatim_string_opener ::= ' " ' [Simple_string] Open_bracket
Verbatim_string_closer ::= Close_bracket [Simple_string] ' " '
Open_bracket ::= "[" | "{"
Close_bracket ::= "]" | "}"Verbatim_string ::= Verbatim_string_opener Line_sequence Verbatim_string_closer
Verbatim_string_opener ::= ' " ' [Simple_string] Open_bracket
Verbatim_string_closer ::= Close_bracket [Simple_string] ' " '
Open_bracket ::= "[" | "{"
Close_bracket ::= "]" | "}"

External routines

External ::= external External_language [External_name]
External_language ::= Unregistered_language | Registered_language
Unregistered_language ::= Manifest_string
External_name ::= alias Manifest_string

Registered languages

Registered_language ::= C_external | C++_external | DLL_external

External signatures

External_signature ::= signature [External_argument_types] [: External_type]
External_argument_types ::= "(" External_type_list ")"
External_type_list ::= {External_type "," …}*
External_type ::= Simple_string

External file use

External_file_use ::= use External_file_list
External_file_list ::= {External_file "," …}+
External_file ::= External_user_file | External_system_file
External_user_file ::= ' " ' Simple_string ' " '
External_system_file ::= "<"Simple_string ">"

C externals

C_external ::= ’' " ' C
’[inline]
[External_signature] [External_file_use]
' " '

C++ externals

C++_external ::= ' " ' C++
inline
[External_signature]
[External_file_use]
' " '

DLL externals

DLL_external ::= ' " ' dll
[windows]
DLL_identifier
[DLL_index]
[External_signature]
[External_file_use]
' " '
DLL_identifier ::= Simple_string
DLL_index ::= Integer

Comments

Comment ::= "– –" {Simple_string Comment_break …}*
Comment_break ::= New_line [Blanks_or_tabs] "– –"

Integers

Integer ::= [Integer_base] Digit_sequence
Integer_base ::= "0" Integer_base_letter
Integer_base_letter ::= "b" | "c" | "x" | "B" | "C" | "X"
Digit_sequence ::= Digit+
Digit ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" |
"a" | "b" | "c" | "d" | "e" | "f" |
"A" | "B" | "C" | "D" | "E" | "F" | "_"