ALEF Language Reference Manual

Phil Winterbottom philw@research.att.com

Introduction

Much of the terminology used in this manual is borrowed from the C language reference manual and the Plan 9 manual. The manual expects familiarity with both.

1. Lexical

1.1. Tokens

1.2. Reserved Words

	adt		aggr		alloc	
	alt		become		break	
	byte		case		chan	
	check		continue	default	
	do		else		enum	
	extern		float		for	
	goto		if		int	
	intern		lint		nil	
	par		proc		raise
	rescue		return		sint	
	sizeof		switch		task	
	tuple		typedef		uint	
	ulint		unalloc		union	
	usint		void		while

	+	-	/	=	
	>	<	|	%	
	&	|	?	.	
	"	'	{	}	
	[	]	(	)	
	*	 ;

	+=	-=	/=	*= 
	%=	&=	|=	^= 
	<<=	>>=	==	!= 
	--	<-	->	++

1.3. Comments

1.4. Identifiers

1.5. Constants

constant:
	 integer-const 
         character-const 
         floating-const 
         string-const 
         rune-string-const

none	decimal		0-9		
0x  	hexadecimal	0-9 a-f A-F	
0   	octal		0-7		

A floating point constant consists of an integer part, a period, a fractional part, the letter e and an exponent part. The integer, fraction and exponent parts must consist of decimal digits. Either the integer or fractional parts may be omitted. Either the decimal point or the letter e and the exponent may be omitted. The integer part or period and the exponent part may be preceded by the unary + or - operators. Floating point constants have the type float.

A string constant is a sequence of characters between the double quote marks ". A string has the type 'static array of byte'. The NUL character is automatically appended to the string by the compiler. The effect of modifying a string constant is implementation dependent. The sizeof operator applied to a string constant yields the number of bytes including the appended NUL.

A rune string constant is a sequence of unicode characters introduced by $" and terminated by ". A rune string has the type 'static array of usint'. A zero rune character is automatically appended to the string by the compiler. The sizeof operator applied to a rune string constant yields the number of runes including the appended zero.

1.6. Programs

1.7. Processes and Tasks

A group of tasks executing within the context of a process are defined to be in the same address space. Tasks are scheduled during communication and synchronisation operations. The term thread is used wherever the distinction between a process and task is unimportant.

2. Definitions and Declarations

2.1. Scope

• A local identifier is declared at the start of a block. A local has scope starting from its declaration to the end of the block in which it was declared.
• Exception identifiers and labels have the scope of a function. These identifiers can be referenced from the start of a function to its end, regardless of position of the declaration.
• A member of a complex type is in scope only when the dereference operators . and -> are applied to the type. Hidden type members have special scope and may only be referenced by function members of the type.
• All definitions outside of a function body have the scope of file. Unqualified declarations at the file scope have static storage class.

2.2. Storage classes

3. Types

3.1. Basic types

3.2. Derived types

*	create a pointer to
&	yield the address of 
()	a function returning 
[]	an array of

int *ptr;	/* A pointer to an integer */ 
char c[10];	/* A vector of 10 characters */ 
float *pow();	/* A function returning a pointer to a float */

The declaration of complex types introduces typenames into the language. After declaration a type-name can be used wherever a basic type is permitted. Derived types and basic types may be renamed using the typedef statement.

The integral types are int, uint, sint, suint, byte, lint and ulint. The arithmetic types are the integral types and the type float. The pointer type is a type derived from the & (address of) operator or derived from a pointer declaration.

3.3. Conversions and Promotions

4. Declarations

program: 
	declaration-list

declaration-list: 
	declaration 
	declaration-list declaration

declaration: 
	simple-declarations 
	type-declaration 
	type-definition 
	function-declaration

4.1. Simple declarations

simple-declarations: 
	type-specifier simple-decl-list ;

simple-decl-list: 
	simple-declaration 
	simple-decl-list , simple-declaration

simple-declaration: 
	pointeropt identifier array-specopt 
	pointeropt identifier array-specopt = initialiser-list

pointer: 
	* 
	pointer *

array-spec: 
	[ constant-expression ]
	[ constant-expression ] array-spec

4.2. Array Specifiers

4.3. Type Specifiers

type-specifier:
	storage-classopt type

type:
	byte
	int
	uint
	sint
	usint
	lint
	ulint
	void
	float
	typename 
	channel-specifier

storage-class: 
	intern
	extern

channel-specifier: 
	chan ( chan-type ) buffer-specopt

buffer-spec: 
	[ constant-expression ]

Typename is an identifier defined by a complex type declaration or a typedef statement.

4.3.1. Channel Type Specification

chan-type: 
	basic 
	basic , chan-type

basic: 
	type pointeropt

Values of chan-type are passed between threads using the channel for communication. If chan-type is a comma separated list of types the channel supplies a .variantprotocol A variant protocol allows messages to be demultiplexed by type during a receive operation. A form of the alt statement allows the control flow to be modified based on the type of a value received from a channel supplying a variant protocol.

4.4. Initialisers

initialiser-list: 
	constant-expression 
	[ constant-expression ] constant-expression 
	{ initialiser-list } 
	initialiser-list , initialiser-list

char a[256] = { 
		['a']	'A',	/* Set element 97 to 65 */ 
		['a'+1]	'B',	/* Set element 98 to 66 */ 
		'C'		/* Set element 99 to 67 */ 
};

4.5. Type Declarations

type-declaration: 
	complex typename { memberlist } ; 
	complex { memberlist } decl-tag ; 
	complex typename { memberlist } decl-tag ; 
	enumeration-type tupletype

complex: 
	adt
	aggr
	union

decl-tag: 
	identifier

tupletype: 
	tupleopt ( typelist )

typelist: 
	typelist , type-declaration

memberlist: 
	member 
	memberlist member

member: 
	tname pointeropt decl-tag array-specopt ; 
	tname decl-tag ( arglist ) ;

(int, byte*) 
func() 
{ 
	return (10, "hello"); 
}

void
main() 
{ 
	int  a; 
	byte  *str;

	(a, str) = func(); 
}

aggr T 
{ 
	int a; 
	byte b; 
	float c; 
};

void 
main() 
{ 
	(a, b, c) = func(); 
}

4.6. Abstract Data Types

adt Point 
{ 
		int  x;			/* Access by member functions only */ 
	extern  int  y;			/* Access by everybody */


		Point set(Point*);	/* Access by everybody */ 
	intern  Point tst(Point);	/* Access only from Point.set */ 
};

Point 
Point.set(Point *a) 
{ 
	a->x = 0;		/* Set the value of the point to zero */ 
	a->y = 0;

	return *a; 
}

adt Point 
{ 
		int  x; 
	extern  int  y;

		Point set(*Point);	/* Pass &Point as first argument */ 
	intern  Point tst(Point); 
};

void 
func() 
{ 
	Point p;

	p.set();		/* Set receives &p as first argument */
}

void 
Point.set(Point *p) 
{ 
	... 
};

4.7. Enumeration Types

enumeration-type: 
	enum typename { enum-list } ;

enum-list: 
	identifier 
	identifier = constant-expression 
	enum-list , enum-list

4.8. Type Definition

type-definition: 
	typedef tname identifier;

typedef aggr A;

aggr B 
{ 
	A  *aptr; 
	B  *bptr; 
}

aggr A 
{ 
	A  *aptr; 
	B  *bptr; 
}

4.9. Function Declarations

function-declaration: 
	type-specifier identifier ( arglist ) block 
	type-specifier function-id ( arglist ) ; 
	type-specifier ( function-id ) ( arglist ) ;

function-id: 
	pointeropt identifier array-specopt 
	adt-function

adt-function: 
	typename . decl-tag

arglist: 
	arg 
	pointer type 
	arglist , arg
arg: 
	type 
	type pointer 
	type ( pointer ) ( arglist ) 
	type simple-declaration 
	...

5. Expressions

The behaviour of exceptional conditions such as divide by zero, arithmetic overflow and floating point exceptions is not defined.

5.1. Pointer Generation

5.2. Primary Expressions

primary-expression: 
	identifier 
	constant
	...
	nil
	( expression )
	tuple

6. Tuples

tuple:
	 ( tlist )

tlist: 
	tlist , expression

void 
f() 
{ 
	int a; 
	tuple (int, byte, Rectangle) b;
	int c; 
}

6.1. Postfix Expressions

postfix-expression: 
	primary-expression 
	postfix-expression [ expression ]
	postfix-expression ( argument-list ) 
	postfix-expression . tag 
	postfix-expression -> tag 
	postfix-expression ++ 
	postfix-expression -- 
	postfix-expression ?

tag: 
	typename 
	identifier

argument-list: 
	expression 
	argument-list , expression

6.1.1. Array Reference

6.1.2. Function Calls

aggr Test 
{ 
	int  t; 
	Lock;			/* Unnamed substructure */ 
};

Test yuk;			/* Definition of complex Test */ 
void lock(Lock*);		/* Prototype for function lock */

void 
main() 
{ 
	lock(&yuk);		/* address of Lock in Test is passed */ 
}

6.1.3. Complex Type References

6.1.4. Postfix Increment and Decrement

6.2. Unary Operators

unary-expression: 
	postfix-expression 
	++ unary-expression 
	-- unary-expression 
	unary-operator cast-expression 
	sizeof cast-expression

unary-operator: one of 
	<-  ?  * 
	+  -  ~  !

6.3. Prefix Increment and Decrement

6.4. Receive and Can Receive

6.5. Can send

The prefix or postfix blocking test operator ? is only reliable when used on a channel shared between tasks in a single process. A process may block after a successful ? because the interleaving of the processes using the channel is undefined.

6.6. Indirection

6.7. Unary Plus and Minus

6.8. Bitwise Negate

6.9. Logical Negate

6.10. Sizeof Operator

6.11. Casts

cast-expression: 
	unary-expression 
	( type-cast ) cast-expression

cast-type: 
	type pointer

6.12. Multiply, Divide and Modulus

multiplicative-expression: 
	cast-expression 
	multiplicative-expression * multiplicative-expression 
	multiplicative-expression / multiplicative-expression 
	multiplicative-expression % multiplicative-expression

6.13. Add and Subtract

additive-expression: 
	multiplicative-expression 
	additive-expression + multiplicative-expression 
	additive-expression - multiplicative-expression

6.14. Shift Operators

shift-expression: 
	additive-expression 
	shift-expression << additive-expression
	shift-expression >> additive-expression

6.15. Relational Operators

relational-expression: 
	relational-expression < shift-expression 
	relational-expression > shift-expression 
	relational-expression <= shift-expression 
	relational-expression >= shift-expression

6.16. Equality operators

equality-expression: 
	relational-expression 
	relational-expression == equality-expression 
	relational-expression != equality-expression

6.17. Bitwise Logic Operators

AND-expression: 
	equality-expression 
	AND-expression & equality-expression

XOR-expression: 
	AND-expression 
	XOR-expression ^ AND-expression

OR-expression: 
	XOR-expression 
	OR-expression | XOR-expression

6.18. Logical Operators

logical-AND-expression: 
	OR-expression 
	logical-AND-expression && OR-expression

logical-OR-expression: 
	logical-AND-expression 
	logical-OR-expression || logical-AND-expression

6.19. Constant expressions

constant-expression: 
	logical-OR-expression

6.20. Assignment

assignment-expression: 
	logical-OR-expression 
	unary-expression <-= assignment-expression 
	unary-expression assignment-operator assignment-expression 
	unary-expression = ( type-cast ) tuple

assignment-operator: one of 
	= += *= /= %= &amp;= |= ^= >>= <<=

aggr Readmesg			/* Read message to file system */ 
{ 
	int  fd; 
	void  *data; 
	int  len; 
};

chan (Readmsg) filesys;

int 
read(int fd, void *data, int len) 
{	
	/* Pack message parameters and send to file system */ 
	filesys <-= (Readmesg)(fd, data, len); 
}

(int, int, int) func();

void main() 
{
	int a, c;

	(a, nil, c) = func(); 
}

6.20.1. Promotion

6.21. Binding and Precedence

binding		operator
l to r		()  []  ->  .
r to l		!  ~  ++  --  <-  ? +  -  *  &amp;  (cast) sizeof
l to r		*  /  %
l to r		+  -
l to r		<<  >>
l to r		<  <=  >  >=
l to r		==  !=
l to r		&amp;
l to r		^
l to r		|
 to r		&amp;&amp;
l to r		||
l to r		<-=  =  +=  -=  *=  /=  %=  =  ^=  |=  <<=  >>=

7. Statements

statement: 
	label-statement : 
	expression-statement ; 
	block-statement 
	selection-statement ; 
	loop-statement 
	jump-statement 
	exception-statement 
	process-statement ; 
	allocation-statement ;

7.1. Label Statements

7.2. Expression Statements

7.3. Block Statements

block: 
	{ autolist slist } 
	!{ autolist slist }

autolist: 
	declaration 
	autolist declaration

slist: 
	statement 
	slist statement

The value of identifiers declared in autolist is undefined at block entry and should be assigned to a known value after declaration but before use.

The symbol !{ introduces a guarded block. Only one thread may be executing the statements contained in the guarded block at any instant.

7.4. Selection Statements

selection-statement: 
	if ( expression ) statement else statement 
	if ( expression ) statement 
	switch ( expression ) cbody 
	alt cbody

cbody: 
	{ caselist } 
	!{ caselist }

caselist: 
	case-item 
	alt-item 
	caselist case-item

case-item: 
	case constant-expression : statement 
	default : statement

alt-item: 
	case expression : statement

The switch statement selects one of several statements. The expression is evaluated and converted into an integer. The integer is compared with the value specified in each case. If the integers compare the statement part of the case is executed. The case expression must yield an integer constant. For a single switch statement each case expression must yield a unique value. If no case is matched, the default clause is executed. If the default is omitted then none of the case statements are executed.

The alt statement allows threads to perform communication on several channels simultaneously without polling. The expression in each case of an alt must contain either a send or receive operation. The alt statement provides a fair select between ready channels. A thread will remain blocked in alt until one of the case expressions can be evaluated without blocking. The case expression may be evaluated more than once, therefore care should be taken when using expressions which have side effects. If several of the case expressions are ready for evaluation one is chosen at random. A break statement terminates each case of the alt. If the break statement is omitted execution will proceed to execute the communication of the next case regardless of its readiness to communicate. For example:

chan(Mesg) keyboard, mouse; 
Mesg m;

alt { 
case m = <-keyboard: 
	/* Process keyboard event */ 
	break; 
case m = <-mouse: 
	/* Process mouse event */
	break; 
}

Aggr1 a; 
Aggr2 b; 
Aggr3 c;

chan (Aggr1, Aggr2, Aggr3) c;

alt { 
case a = <-c: 
	print("received Aggr1"); 
	break; 
case b = <-c: 
	print("received Aggr2"); 
	break; 
case c = <-c:
	print("received Aggr3"); 
	break; 
}

The symbol !{ introduces a guarded caselist. Only one thread may be executing the statements contained in the guarded caselist at any instant.

7.5. Loop Statements

loop-statement: 
	while ( expression ) statement 
	do statement while ( expression ) ; 
	for ( expression ; expression ; expression ) statement

In the for loop the first expression is evaluated once before loop entry. The expression is usually used to initialise the loop variable. The second expression is evaluated at the beginning of each loop iteration, including the first. The expression must yield either a pointer or arithmetic type. The statement is executed while the evaluation of the second expression does not compare to 0. The third expression is evaluated after the statement on each loop iteration. The first and third expressions have no type restrictions. All of the expressions are optional. If the second expression is omitted an expression returning a non-zero value is implied.

7.6. Jump Statements

jump-statement: 
	goto identifier ;
	continue countopt ; 
	break countopt ; 
	raise identifieropt ; 
	return expressionopt ; 
	become expression ;

count: 
	integer-constant

7.6.1. Continue Statements

while(1) { 
	while(1) { 
		continue 2;	/* Same as goto contin; */ 
	} 
contin:				/* Continue comes here */ 
}

7.6.2. Break Statements

7.6.3. Raise Statement

	alloc p;			alloc p; 
	rescue {			goto notrescue; 
		unalloc p;			dorescue: 
		raise;					unalloc p; 
	}						goto nextrescue; 
						notrescue: 
	if(error)			if(error) 
		raise;				goto dorescue;

7.6.4. Return Statement

7.6.5. Become Statement

7.7. Exception Statements

exception-statement: 
	rescue identifieropt block 
	check expression ;

7.7.1. Rescue Statement

alloc a, b; 
rescue { 
	unalloc a, b; 
	return 0; 
}

alloc c; 
rescue { 
	unalloc c; 
	raise; 
}

dostuff();

if(error) 
	raise;

7.7.2. Check Statement

alloc ptr; 
check ptr != nil;	/* Program aborts if allocation fails */

7.8. Process Control Statements

process-statement: 
	proc function-call ; 
	task function-call ; 
	par block

The par statement implements fork/process/join. A new process is created for each statement in the block. The par statement completes when all processes have completed execution of their statements. A par with a single statement is the same as a block. The process that entered the par is guaranteed to be the same process that exits.

All tasks within a process will block until a system call completes.

7.9. Allocation Statements

allocation-statement: 
	alloc alloclist ; 
	unalloc alloclist ;

alloclist: 
	expr alloclist , expr

7.9.1. Alloc Statement

If the pointer has chan type, the runtime system will also initialise the new channel. If the channel is asynchronous then the specified number of buffers will be allocated.

7.9.2. Unalloc Statement

8. Runtime Support

	#include <alef.h>

8.1. Lock

Lock ADTs have no runtime state and may be dynamically allocated. The thread which claimed the lock need not be the thread which unlocks it.

8.2. Qlock

The thread which claimed the lock need not be the thread which unlocks it.

QLock ADTs have runtime state and may be dynamically allocated provided they are unallocated when unlocked. The thread which claimed the lock need not be the thread which unlocks it.

9. Yacc Style Grammar

prog		:  decllist

decllist	:	
		| decllist decl

decl		: tname vardecllist ';' 
		| tname vardecl '(' arglist ')' block 
		| tname adtfunc '(' arglist ')' block 
		| tname vardecl '(' arglist ')' ';' 
		| typespec ';' 
		| TYPEDEF ztname vardecl zargs ';'

zargs		: 
		| '(' arglist ')'

ztname		: tname 
		| AGGR 
		| ADT 
		| UNION

adtfunc		: TYPENAME '.' name 
		| indsp TYPENAME '.' name

typespec	: AGGR ztag '{' memberlist '}' ztag 
		| UNION ztag '{' memberlist  '}' ztag 
		| ADT ztag '{' memberlist '}' ztag 
		| ENUM ztag '{' setlist '}'

ztag		: 
		| name 
		| TYPENAME

setlist		: sname 
		| setlist ',' setlist

sname		: 
		| name 
		| name '=' expr

name		: ID

memberlist	: decl 
		| memberlist decl

vardecllist	: 
		| ivardecl 
		| vardecllist ',' ivardecl

ivardecl	: vardecl zinit

zinit		: 
		| '=' zelist

zelist		: zexpr 
		| '[' expr ']' expr 
		| '{' zelist '}' 
		| '[' expr ']' '{' zelist '}' 
		| zelist ',' zelist

vardecl		: ID arrayspec 
		| indsp ID arrayspec 
		| '(' indsp ID arrayspec ')' '(' arglist ')' 
		| indsp '(' indsp ID arrayspec ')' '(' arglist ')'

arrayspec	: 
		| arrayspec '[' zexpr ']'

indsp		: '*' 
		| indsp '*'

arglist		: 
		| arg 
		| '*' xtname 
		| arglist ',' arg

arg		: xtname 
		| xtname indsp arrayspec 
		| xtname '(' indsp ')' '(' arglist ')' 
		| TUPLE tname '(' indsp ')' '(' arglist ')' 
		| TUPLE tname vardecl 
		| xtname vardecl 
		| '.' '.' '.'

autolist	: 
		| autolist autodecl

autodecl	: xtname vardecllist ';' 
		| TUPLE tname vardecllist ';'

block		: '{' autolist slist '}' 
		| '!{' autolist  slist '}'

slist		: 
		| slist stmnt

cbody		: '{' clist '}' 
		| '!{' clist '}'

clist		: 
		| clist case

case		: CASE expr ':' slist 
		| DEFAULT ':' slist

rbody		: stmnt 
		| ID block

zlab		: 
		| ID

stmnt		: nlstmnt 
		| ID ':' stmnt

nlstmnt		: error ';' 
		| zexpr ';' 
		| block 
		| CHECK expr ';'
		| ALLOC elist ';' 
		| UNALLOC elist ';' 
		| RESCUE rbody 
		| RAISE zlab ';' 
		| GOTO ID ';' 
		| PROC expr ';' 
		| TASK expr ';' 
		| BECOME expr ';' 
		| ALT cbody 
		| RETURN zexpr ';' 
		| FOR '(' zexpr ';' zexpr ';' zexpr ')' stmnt 
		| WHILE '(' expr ')' stmnt 
		| DO stmnt WHILE '(' expr ')' 
		| IF '(' expr ')' stmnt 
		| IF '(' expr ')' stmnt ELSE stmnt 
		| PAR block 
		| SWITCH '(' expr ')' cbody 
		| CONTINUE zconst ';' 
		| BREAK zconst ';'

zconst		: 
		| CONST

zexpr		: 
		| expr

expr		: castexpr 
		| expr '*' expr 
		| expr '/' expr 
		| expr '%' expr 
		| expr '+' expr 
		| expr '-' expr 
		| expr '>>' expr 
		| expr '<<' expr 
		| expr '<' expr 
		| expr '>' expr 
		| expr '<=' expr 
		| expr '>=' expr 
		| expr '!=' expr 
		| expr '==' expr 
		| expr '&amp;' expr 
		| expr '^' expr 
		| expr '|' expr 
		| expr '&amp;&amp;' expr 
		| expr '||' expr 
		| expr '=' expr 
		| expr '<-' '=' expr 
		| expr '+=' expr 
		| expr '-=' expr 
		| expr '*=' expr 
		| expr '/=' expr 
		| expr '%=' expr 
		| expr '>>=' expr 
		| expr '<<=' expr 
		| expr '&amp;=' expr 
		| expr '|='  expr 
		| expr '^=' expr

castexpr	: monexpr


		| '[' typecast ']' castexpr 
		| '(' typecast ')' castexpr

typecast	: xtname 
		| xtname indsp 
		| xtname '(' indsp ')' '(' arglist ')' 
		| TUPLE tname

monexpr		: term 
		| '*' castexpr 
		| '&' castexpr 
		| '+' castexpr 
		| '-' castexpr 
		| Tdec castexpr 
		| Tinc castexpr 
		| '!' castexpr 
		| '~' castexpr 
		| SIZEOF monexpr 
		| '<-' castexpr 
		| '?' castexpr

term		: '(' elist ')' 
		| SIZEOF '(' typecast ')' 
		| term '(' zarlist ')' 
		| term '[' expr ']' 
		| term '.' stag 
		| '.' TYPENAME '.' stag 
		| term '->' stag 
		| term '--' 
		| term '++' 
		| term '?' 
		| name 
		| '.' '.' '.' 
		| CONST 
		| NIL 
		| ENUM_MEMBER 
		| FCONST 
		| STRING 
		| '$' STRING

stag		: ID 
		| TYPENAME

zarlist		: 
		| elist

elist		: expr 
		| elist ',' expr

tlist		: typecast 
		| typecast ',' tlist

tname		: sclass xtname 
		| sclass '(' tlist ')'

xtname		: TYPENAME 
		| INT 
		| UINT 
		| SINT 
		| SUINT 
		| BYTE 
		| FLOAT 
		| VOID 
		| CHAN '(' typecast ')' bufdim

bufdim		: 
		| '[' expr ']'

sclass		: 
		| EXTERN 
		| INTERN 
		| PRIVATE