![]() |
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.
source text = class specification, {Semicolon_SY, class specification} ; |
class specification = | [library signifier], |
(abstract class definition | class) ; |
library signifier = | Library_SY, identifier ; |
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 ; |
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] ; |
abstract signature = abstract routine signature | abstract iter signature ; |
identifier list = identifier, {Comma_SY, identifier} ; |
return signature = Colon_SY, type specifier ; |
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)] ; |
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)] ; |
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] ; |
class element = | constant definition |
| shared definition | |
| attribute definition | |
| routine definition | |
| iter definition | |
| include clause | |
| stub ; |
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 ; |
shared definition = | [Private_SY | Readonly_SY], Shared_SY, |
(simple value | declaration) ; |
attribute definition = | [Private_SY | Readonly_SY], Attr_SY, |
declaration ; |
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 ; |
iter definition = | [Private_SY], iter name, [iter parameter pack], |
[return signature], | |
[pre-condition], | |
[post-condition], | |
[method body] ; |
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)] ; |
stub = Stub_SY, abstract signature ; |
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 ; |
assign statement = | (expression | (identifier, Colon_SY, [type specifier])), |
initialise ; |
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 ; |
return statement = Return_SY, [expression] ; |
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 ; |
typecase statement = | Typecase_SY, identifier, |
type guard, guarded clause, | |
[{type guard, guarded clause}], | |
[default clause], End_SY ; |
loop statement = Loop_SY, statement list, End_SY ; |
yield statement = Yield_SY, [expression] ; |
quit statement = Quit_SY ; |
protect statement = | Protect_SY, statement list, |
[type guard, guarded clause], | |
[{type guard, guarded clause}], | |
[default clause], End_SY |
raise statement = Raise_SY, expression ; |
assert statement = Assert_SY, expression ; |
while statement = While_SY, Iter_SY, parenthesised expression ; |
until statement = Until_SY, Iter_SY, parenthesised expression ; |
break statement = Break_SY, Iter_SY ; |
parallel statement = Parallel_SY, statement list, End_SY ; |
fork statement = | Fork_SY, [At_SY, expression, Semicolon_SY], |
statement list, End_SY ; |
parallel loop statement = | Parloop_SY, statement list, Do_SY, |
[At_SY, expression, Semicolon_SY], | |
statement list, End_SY ; |
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 ; |
lock statement = | Lock_SY, expression, |
guarded clause, | |
[default clause], End_SY ; |
unlock statement = Unlock_SY, expression ; |
attach statement = expression, Do_Attach_SY, expression ; |
synchronise statement = Synchronise_SY ; |
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 ; |
qualified ident = | (expression, Fullstop_SY) |
| (type specifier, Colon_SY, Colon_SY) ; |
parenthesised expression = | Left_Parenthesis_SY, |
expression, | |
Right_Parenthesis_SY ; |
self expression = Self_SY ; |
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 ; |
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 ; |
void test expression = Is_Void_SY, parenthesised expression ; |
initial expression = Initial_SY, parenthesised expression ; |
result expression = Result_SY ; |
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 ; |
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 ; |
new expression = New_SY, [parenthesised expression] ; |
array expression = Bar_SY, expression list, Bar_SY ; |
expression list = expression, {Comma_SY, expression} ; |
infix expression = unary expression | binary expression ; |
unary expression = unary operator, expression ; |
binary expression = | (expression, binary operator, expression) |
| (expression, binary logical operator, expression) ; |
exception expression = Exception_SY ; |
at expression = expression, At_SY, expression ; |
![]() |
Specification Index | ![]() |
Language Index |
Comments
or enquiries should be made to Keith Hopper. Page last modified: Wednesday, 17 May 2000. |
![]() |