Zinc Reference Manual

Single line comments starts with two slashes.

// this is a comment

Multiple line comments start with a /* and finish with */. Nested comments are not permited.

/* 
  This is another comment
  on several lines 
*/

An identifier is defined as follow:

List of reserved keywords:

def
equ
func
struct
union
enum
typedef
sizeof
public
private
const
import
if
elsif
while
switch
case
else
end
return
repeat

true 1  // a valid identifier
nil (-> void) // a valid function

Operators

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

Pointer to a type:

-> type

Pointers preserves inheritance: if t2 inherits from t1, -> t2 intherits from -> t1.

[n] type

n is a positive integer.

Examples:

[10] int	// an array of 10 integers
[10] [20] int	// a two dimension array of integer
[] char		// a pointer to an array of character 

[n2] t2 inherits from [n1] t1 if and only if n1=n2 and t2 inherits from t1.

{type1, type2, ...} return-type

This type is a pointer, but the -> is implicit.

Examples:

{int, int} int
{int} void

// A function without argument:
{} int

Anonymous structures (and unions) are defined in the same way as named structures but wihout the name:

def origin: 
  struct
    x: int
    y: int
  end

Attributes of anonymous structures are always private.

Anonymous enums are defined in the same way as regular enums but wihout the name:

def category: 
  enum 
    rock
    pop
    folk
    classic
  end

Values of anonymous enums are always private.

A named type is an identifier that can be

Functions, equates and iterators without arguments:

f

Functions, equates and iterators with arguments:

f (arg1, arg2, ...)

Iterator with block without parameters:

f (arg1, arg2, ...) ?
  instr1
  instr2
  ...
end

Iterator with block with parameters:

f (arg1, arg2, ...) ? x1, x2, ...
  instr1
  instr2
  ...
end

is nil (p)

Returns true if p is nil. p is a pointer.

not nil (p)

Returns true if p is not nil. p is a pointer.

if cond1
  ...
elsif cond2
  ...
elsif ...
  ...
else
  ...
end

Where:

while cond
  ...
end

Repeat the block as long as the boolean expression cond evaluates to true. The break statement can interrupt the loop.

repeat
  ...
end

A synonym for while true, and endless loop can that only be interrupted by a break.

switch e
case c1
  ...
case c2
  ...
case ...
  ...
else
  ...
end

e is an integer or character expression. c1 and c2 are constant integers or characters. The else statement is optional.

Variables are locals or globals. A variable is a value that can be stored in a machine register.

def name : type

def name = e1

def name := fn (e1, e2, ...)

def name := "a string"
def name := const type (...)

def name1 = "a string"
def name2 := "a string"

Define a function:

func name (arg1: t1, arg2: t2, ...) [: return-type]
  ...
end

The return type is optional. In fact it is required only when there is a circular reference with the function. This can happen when

Types of arguments cannot be structures or array, they must be pointers or basic types, i.e. values that can be stored in registers.

To return a value or simply return from the function, just use

return [expr]

There is an alternative syntax to define functions:

func name (arg1: t1, arg2: t2, ...) -> (return-arg: return-type)
  ...
end

It must be a void function, the return-arg behaves like other arguments except that its type must be a pointer to a structure or an array. This kind of function differs by its calling method:

Equates are for macro expansion. There is two kind of equates:

equ name (arg1: t1, arg2: t2, ...) = expr

equ name (arg1: t1, arg2: t2, ...)
  ...
end

Define a structure:

struct name [:parent name]
  attr1: t1
  attr2: t2
  public
    attr3: t3
    attr4: t4
  end
  private attr5: t5
  public attr6: t6
end

This creates a structure named local name and an alias named name that is a pointer to this structure.

For each attribute attr of the structure name, a declaration is created to read and modifiy it:

attr (t: name)

When the exposition of an attribute is not specified, it inherits the exposition of the structure.

Define an enumeration

enum name
  item1 [= value1]
  item2 [= value2]
  ...
end

An enumeration is an integer.

Each item can have a value assigned to it. If the value is not specified, it gets the value of its predecessor plus one or zero for the first item.

Define a type alias

typedef name = type

To import public declarations of another module:

import "module-name"

The name of the module is the path relative to the include path plus the filename without the extension (.zc).

Circular imports is not permitted: modules cannot be inter-dependents.