# Annex B:
Collected Concrete Syntax

This Annex contains all of the concrete syntax of the Sather language as given in the various sections of the language specification.

The reference form of the xxx_SY tokens for the purposes of program example text is given in Annex D.

### B.1 Program Components

source text = class specification, {Semicolon_SY, class specification} ;

### B.2 Class Definitions

class specification = | [library signifier],
| (abstract class definition | class) ;

library signifier = | Library_SY, identifier ;

### B.2.1 Abstract Class Definition

abstract class definition = | Abstract_SY, Class_SY, abstract type name,
| [generic arguments],
| [subtyping clause],
| [supertyping clause], Is_SY,
| [abstract signature], {Semicolon_SY, [abstract signature]}, End_SY ;

### B.2.2 Implementation Class Definitions

class = | [class type], Class_SY, concrete type name, [generic arguments],
| [subtyping clause], Is_SY,
| [class element], {Semicolon_SY, [class element]}, End_SY ;

class type = Immutable_SY | Partial_SY | (External_SY, [identifier]) ;

generic arguments = | Left_Brace_SY, parameter declaration,
| {Comma_SY, parameter declaration}, Right_Brace_SY ;

subtyping clause = Left_Angle_Bracket_SY, type specifier list ;

supertyping clause = Right_Angle_Bracket_SY, type specifier list ;

parameter declaration = | type name, [Left_Angle_Bracket_SY, type specifier] ;

### B.3 Method Signatures

abstract signature = abstract routine signature | abstract iter signature ;

identifier list = identifier, {Comma_SY, identifier} ;

return signature = Colon_SY, type specifier ;

### 3.3.1 Routine Signatures

abstract routine signature = | identifier, [routine parameter pack], [return signature] ;

routine parameter pack = | Left_Parenthesis_SY,
| routine argument list, Right_Parenthesis_SY ;

routine argument list = routine argument, {Comma_Sy, routine argument} ;

routine argument = routine mode, identifier list, return signature ;

routine mode = [(Out_SY | Inout_SY)] ;

### B.3.2 Iter Signatures

abstract iter signature = | iter name, [iter parameter pack], [return signature] ;

iter parameter pack = | Left_Parenthesis_SY,
| iter argument list, Right_Parenthesis_SY ;

iter argument list = iter argument, {Comma_Sy, iter argument} ;

iter argument = iter mode, identifier list, return signature ;

iter mode = [(Out_SY | Inout_SY | Once_SY)] ;

### B.4 Type Definitions

type specifier list = type specifier, {Comma_SY, type specifier} ;

type specifier = | (type name, [{type specifier list}])
| | method closure type specifier
| | Same_Type_SY ;

method closure type specifier = | routine closure type specifier
| | iter closure type specifier ;

routine closure type specifier = | Routine_SY,
| [{routine mode, type specifier,
| {Comma_SY, routine mode, type specifier}}],
| [return signature] ;

iter closure type specifier = | Iter_SY,
| [{iter mode, type specifier,
| {Comma_SY, iter mode, type specifier}}],
| [return signature] ;

### B.5 Feature Definitions

class element = | constant definition
| | shared definition
| | attribute definition
| | routine definition
| | iter definition
| | include clause
| | stub ;

### B.5.1 Constant Definition

constant definition = | [Private_SY], Constant_SY,
| (simple value | enumerated constants) ;

simple value = identifier, return signature, initialise ;

enumerated constants = | identifier, [initialise],
| [Comma_SY,identifier list] ;

initialise = assign op, expression ;

### B.5.2 Shared Definition

shared definition = | [Private_SY | Readonly_SY], Shared_SY,
| (simple value | declaration) ;

### B.5.3 Attribute Definition

attribute definition = | [Private_SY | Readonly_SY], Attr_SY,
| declaration ;

### B.5.4 Routine Definition

routine definition = | [Private_SY], identifier, [routine parameter pack],
| [return signature],
| [pre-condition],
| [post-condition],
| [method body] ;

pre-condition = Pre_SY, expression ;

post-condition = Post_SY, expression ;

method body = Is_SY, statement list, End_SY ;

### B.5.5 Iter Definition

iter definition = | [Private_SY], iter name, [iter parameter pack],
| [return signature],
| [pre-condition],
| [post-condition],
| [method body] ;

### B.5.6 Include Clause

include clause = | [Private_SY], Include_SY,
| (library include | class include),
| [feature modifier list] ;

library include = Library_SY, identifier ;

class include = type specifier ;

feature modifier list = | feature modifier,
| {Comma_SY, feature modifier} ;

feature modifier = | (identifier | iter name), Rename_SY,
| [Private_SY | Readonly_SY],
| [(identifier | iter name)] ;

### B.5.7 Stub Definition

stub = Stub_SY, abstract signature ;

### B.6 Statements

statement list = [statement], {Semicolon_SY, [statement]} ;

statement = | declaration statement
| | assign statement
| | if statement
| | return statement
| | case statement
| | typecase statement
| | expression statement
| | loop statement
| | yield statement
| | quit statement
| | protect statement
| | raise statement
| | assert statement
-- Iters
| | while statement
| | until statement
| | break statement
-- Concurrent programming
| | parallel statement
| | fork statement
| | parallel loop statement
| | select statement
| | lock statement
| | unlock statement
| | attach statement
| | synchronise statement
| | with near statement ;

### B.6.1 Declaration Statement

declaration statement = declaration ;

declaration = identifier list, return signature ;

### B.6.2 Assign Statement

assign statement = | (expression | (identifier, Colon_SY, [type specifier])),
| initialise ;

### B.6.3 If Statement

if statement = | If_SY, expression, guarded clause,
| [Elsif_SY, expression, guarded clause},
| [default clause], End_SY ;

guarded clause = Then_SY, statement list ;

default clause = Else_SY, statement list ;

### B.6.4 Return Statement

return statement = Return_SY, [expression] ;

### B.6.5 Case Statement

case statement = | Case_SY, expression,
| value guard, guarded clause,
| [{value guard, guarded clause}],
| [default clause], End_SY ;

guard = value guard | type guard ;

value guard = When_SY, expression, {Comma_SY, expression} ;

type guard = When_SY, type specifier ;

### B.6.6 Typecase Statement

typecase statement = | Typecase_SY, identifier,
| type guard, guarded clause,
| [{type guard, guarded clause}],
| [default clause], End_SY ;

### B.6.7 Expression Statement

expression statement = expression ;

### B.6.8 Loop Statement

loop statement = Loop_SY, statement list, End_SY ;

### B.6.9 Yield Statement

yield statement = Yield_SY, [expression] ;

### B.6.10 Quit Statement

quit statement = Quit_SY ;

### B.6.11 Protect Statement

protect statement = | Protect_SY, statement list,
| [type guard, guarded clause],
| [{type guard, guarded clause}],
| [default clause], End_SY

### B.6.12 Raise Statement

raise statement = Raise_SY, expression ;

### B.6.13 Assert Statement

assert statement = Assert_SY, expression ;

### B.6.14 While Statement

while statement = While_SY, Iter_SY, parenthesised expression ;

### B.6.15 Until Statement

until statement = Until_SY, Iter_SY, parenthesised expression ;

### B.6.16 Break Statement

break statement = Break_SY, Iter_SY ;

### B.6.17 Parallel Statement

parallel statement = Parallel_SY, statement list, End_SY ;

### B.6.18 Fork Statement

fork statement = | Fork_SY, [At_SY, expression, Semicolon_SY],
| statement list, End_SY ;

### B.6.19 Parallel Loop Statement

parallel loop statement = | Parloop_SY, statement list, Do_SY,
| [At_SY, expression, Semicolon_SY],
| statement list, End_SY ;

### B.6.20 Select Statement

select statement = | Lock_SY,
| select guard, {select guard},
| [default clause], End_SY ;

select guard = lock guard, guarded clause ;

lock guard = [Guard_SY, expression], value guard ;

### B.6.21 Lock Statement

lock statement = | Lock_SY, expression,
| guarded clause,
| [default clause], End_SY ;

### B.6.22 Unlock Statement

unlock statement = Unlock_SY, expression ;

### B.6.23 Attach Statement

attach statement = expression, Do_Attach_SY, expression ;

### B.6.24 Synchronise Statement

synchronise statement = Synchronise_SY ;

### B.6.25 With Near Statement

with near statement = | With_SY, local feature list,
| Near_SY, statement list,
| [default clause], End_SY ;

local feature list = local feature, {Comma_SY, local feature} ;

local feature = identifier | self expression ;

### B.7 Expressions

expression = | literal expression
| | parenthesised expression
| | self expression
| | local expression
| | call expression
| | void test expression
| | post-condition expression
| | method closure expression
| | creation expression
| | array expression
| | logical expression
| | infix expression
| | exception expression
| | at expression ;

qualified ident = | (expression, Fullstop_SY)
| | (type specifier, Colon_SY, Colon_SY) ;

### B.7.1 Literal Expressions

literal expression = literal ;

### B.7.2 Parenthesised Expressions

parenthesised expression = | Left_Parenthesis_SY,
| expression,
| Right_Parenthesis_SY ;

### B.7.3 Self Expression

self expression = Self_SY ;

### B.7.4 Local Expression

local expression = identifier ;

### B.7.5 Call Expression

call expression = routine call | iter call ;

### B.7.5.1 Routine Call Expression

routine call = qualified ident, identifier, [routine call args] ;

routine call args = | Left_Parenthesis_SY,
| routine call arg list, Right_Parenthesis_SY ;

routine call arg list = | routine call argument,
| {Comma_Sy, routine call argument} ;

routine call argument = routine mode, expression ;

### B.7.5.2 Iter Call Expression

iter call = qualified ident, iter name, [iter call args] ;

iter call args = | Left_Parenthesis_SY,
| iter call arg list, Right_Parenthesis_SY ;

iter call arg list = | iter call argument,
| {Comma_Sy, iter call argument} ;

iter call argument = iter mode, expression ;

### B.7.6 Void Test Expression

void test expression = Is_Void_SY, parenthesised expression ;

### B.7.7 Post-condition Expression

postcondition expression = | initial expression
| | result expression ;

### B.7.7.1 Initial Expression

initial expression = Initial_SY, parenthesised expression ;

### B.7.7.2 Result Expression

result expression = Result_SY ;

### B.7.8 Method Closure Expression

method closure expression = | routine closure expression
| | iter closure expression ;

### B.7.8.1 Routine Closure Expression

routine closure expression = | Bind_SY, Left_Parenthesis_SY,
| routine bind expression, Right_Parenthesis_SY ;

routine bind expression = | [qualified ident], identifier,
| [routine closure argument expression] ;

routine closure argument expression = | Left_Parenthesis_SY,
| routine closure argument list, Right_Parenthsis_SY ;

routine closure argument list = | routine closure argument,
| {Comma_SY, routine closure argument} ;

routine closure argument = routine mode, closure argument ;

closure argument = expression | low line ;

### B.7.8.2 Iter Closure Expression

iter closure expression = | Bind_SY, Left_Parenthesis_SY,
| iter bind expression, Right_Parenthesis_SY ;

iter bind expression = | [qualified ident], iter name,
| [iter closure argument expression] ;

iter closure argument expression = | Left_Parenthesis_SY,
| iter closure argument list, Right_Parenthesis_SY ;

iter closure argument list = | iter closure argument,
| {Comma_SY, iter closure argument} ;

iter closure argument = iter mode, closure argument ;

### B.7.9 Creation Expressions

creation expression = create expression | new expression ;

### B.7.9.1 Create Expression

create expression = create op, [type_specifier], routine call args ;

### B.7.9.2 New Expression

new expression = New_SY, [parenthesised expression] ;

### B.7.10 Array Expression

array expression = Bar_SY, expression list, Bar_SY ;

expression list = expression, {Comma_SY, expression} ;

### B.7.11 Logical Expression

logical expression = expression, binary logical op, expression ;

### B.7.12 Infix Expressions

infix expression = unary expression | binary expression ;

unary expression = unary operator, expression ;

binary expression = | (expression, binary operator, expression)
| | (expression, binary logical operator, expression) ;

### B.7.13 Exception Expression

exception expression = Exception_SY ;

### B.7.14 At Expression

at expression = expression, At_SY, expression ;

| Specification Index |  | Language Index

Comments or enquiries should be made to Keith Hopper. Page last modified: Monday, 12 February 2001. |