class-decl ::= class identifier [ "<" generics_list ">"] is
class-definition
class-definition ::= Enumeration enum-class-decl
| [ class_type ] general-class-decl
enum-class-decl ::= class-comment
manifest ident-list
end class
general-class-decl ::= class-comment
uses [ ident-list ]
[ internal
[ const const-decls ]
[ var var-decls ]
[ routines routine-decls ]
interface
[ creation [ "(" parameter-list ")" ] is
routine-impl ]
[ routines routine-decls ]
[ invariant condition ]
end class
generics-list ::= generics-decl { "," generics-decl }
generics-decl ::= formal-generic-param [ is class-type ]
formal-generic-param ::= identifier
const-decls ::= const-decl { const-decl }
const-decl ::= ident-list ":" type initialisation
var-decls ::= var-decl { var-decl }
var-decl ::= ident-list ":" type [ initilisation ]
ident-list ::= identifier {"," identifier }
initilisation ::= ":=" expression
type ::= class-type
| formal-generic-param
class-type ::= identifier [ "<" actual-generics-list ">" ]
actual-generics-list ::= type { "," type }
routine-decls ::= routine-decl { routine-decl }
routine-decl ::= identifier [ "(" parameter-list ")" ]
[ "->" "(" parameter-list ")"] is
routine-impl
parameter-list ::= param-decl {"," param-decl }
param-decl ::= identifier ":" type
routine-impl ::= deferred routine-spec
| builtin routine-spec
| [ redefined ] routine-body
routine-body ::= routine-comment
[ pre condition ]
[ const const-decls ]
[ var var-decls ]
do
statement-list
[ post condition ]
end identifier
routine-spec ::= routine-comment
[ pre condition ]
[ post condition ]
end identifier
statement ::= assignment
| assignment-attempt
| procedure-call
| return
| assertion
| conditional
| selection
| loop
assignment ::= indexed-ident-list ":=" expression-list
assignment-attempt ::= indexed-ident-list "?=" expression-list
indexed-ident-list ::= indexed-ident {"," indexed-ident }
expression-list ::= expression {"," expression }
procedure-call ::= call-chain
return ::= return
assertion ::= assert "(" condition ")"
conditional ::= if condition then
statement-list
{ elseif expression then
statement-list }
[ else
statement-list ]
end if
condition ::= boolean-expression
statement-list ::= { statement }
selection ::= case expression of
{ set_expr ":" statement-list }
[ else statement-list ]
end case
loop ::= loop
statement-list
exit on condition
statement-list
{ exit on condition
statement-list }
end loop
boolean-expression ::= expression
expression ::= function-call
| operator-expression
| reference-equality
| type-equality
| in
| create
| old
| this
function-call ::= call-chain
call-chain ::= [ super "!" ] unqualified-call { "." unqualified-call }
unqualified-call ::= identifier [ "(" expression-list ")" ]
operator-expression ::= ...
| expression "=>" expression
| entity
reference-equality ::= expression comparison expression
comparison ::= "=" | "<>"
type-equality ::= expression is type
in ::= expression in set_expr
set_expr ::= "{" [ set_elem { "," set_elem } ] "}"
set_elem ::= expression | subrange
subrange ::= expression ".." expression
create ::= general-create | array-create
general-create ::= create class-ident [ "(" expression-list ")" ]
array-create ::= "[" expression { "," expression } "]"
old ::= old expression
entity ::= indexed-ident
| manifest-constant
indexed-ident ::= identifier { "[" expression "]" }
manifest-constant ::= integer-constant
| real-constant
| boolean-constant
| string-constant
| enum-constant
enum-constant ::= identifier
| qualified-ident
qualified-ident ::= class-ident "!" identifier