//this is a comment
this is not

/* this is a comment
/* so is this */
this is not */

/+ this is a comment
/+ so is this +/
/* as is this */
still a comment +/
not a comment

module a_module
{
invariant:
    //assertions belong here
public:
    //"global" functions, properties and variables
private:
    //internal functions, properties and variable
}

class A
{
public:
    int x;
    void abstractfunc();
}
//class a contains x and abstractfunc
class B
{
public:
    int y;
protected:
    inherit A;
    override void abstractfunc()
    {
    }
}
//class B contains x,y, and abstractfunc
module C
{
public:
    import class A; //illegal, class contains abstract member
    import class B; //legal, abstract member has been overriden
    B z;
    //code in this module can access z.y, but not z.x or z.abstractfunc
}

module a
{
public:
    struct b
    {
    public:
        int x;
    private:
        int y;
    }
}

enum bool{true:=1,false:=0}
enum bleh{a,b:=0,c:=3}

int x:=10;//x contains ten
real x:=1.0;//x contains one
real x:=1;//x contains one
real x:=.1;//x contains one tenth
real x:=0.1;//x contains one tenth

int x:=0b11;//x contains three
real x:=0b1.1;//x contains three halves
real x:=0x1.f;//x contains 31 sixteenths

module a(param1, char param2[param3], int param3, ...)
{
public:
    param1[param3] x;   //this declares an array of param3 elements of type param1
}
module b
{
public:
    import module inta:=a(int, "hello", 5);
    import module intb:=a(int, "hello", 5);
    //intb and inta share the same memory space, they are identical
}

type funcname(...)
{
}

a.x:=a.y:=2;

property int fakeint(int x) //writeable
{
}
property int fakeint()  //readable
{
}

module a
{
public:
    int x:=0;
}

class a
{
public:
    a()
    {
    }

    overload a(int x)
    {
    }
}

module b
{
public:
    a x;
    a y(5);
}

void sort(inout int[] list)
{
declare:

    int getsmallestvalue(int start)
    {
    declare:
        int returnVal:=start;
    body:
        loop
        {
        declare:
            int i:=start;
        doing:
            i+=1;
            until(i>=getlength(list));
        body:
            if(list[i]<list[returnVal]){returnVal:=i;}
        }
        return returnVal;
    }
    
body:

    loop
    {
    declare:
        int i:=0;
        int buffer;
        int smallVal;
    doing:
        until(i>=getlength(list));
    body:
        buffer:=list[smallVal:=getsmallestvalue(i)];
        list[smallVal]:=list[i];
        list[i]:=buffer;
    doing:
        i+=1;
    }
}

switch(var)
{
case(1):
case(2):
    //code here will be executed if var==1 or var==2
    break;
case(3):
    //code here will be executed if var==3
    break;
default:
    //code here will be executed if var
    //is not equal to one or two or three
}

label@loop
{
declare:
    int i=0;
doing:
    switch(i)
    {
    case(1):
        break;//this goes to blah
    case(2):
        break label;//this goes to foo
    }
    blah@i+=1;
}
foo@//stuff here

try
{
    try
    {
        throw 1;
    }
    //first throw 1; is caught here
    catch(int blah)
    {
        throw 2;
    }
    try
    {
        throw 3;
    }
    //throw 3; would not be caught here
    //it would be caught in the outer statement
    catch(char blah)
    {
    }
}
//second throw 2; is caught here
catch(int blah)
{
}

//as far as the casual programmer is concerned
//there is no difference between these two statements
int[5] blah;
const int* blah:=new int[5];

blah[0]:=1; //this assigns 1 to the first element of the array

//you want to declare an array of three pointers
//to a dynamic array of ints

//array of three
[3] blah;
//array of three pointers
*[3] blah;
//array of three pointers to a dynamic array
[]*[3] blah;
//array of three pointers to a dynamic array of ints
int[]*[3] blah;

int bleh()
{
}
int foo()
{
declare:
    int delegate() bar:=bleh;
body:
    return bar();
}

version
{
x86:
    asm
    {
    //x86 assembly goes here
    }
ppc:
    asm
    {
    //powerpc assembly goes here
    }
}
version
{
windows:
    //windows specific code goes here
linux:
    //linux specific code goes here
default:
    //code that works on all other platforms goes here
}