Language specification

Variables

"var" {VarItems}
VarItems = Identifier ":" TypeDecleration ["=" ConstValue]

The var block specifies all the fields in a structured type.  Variables are always accessible by the outside world.  When generating the memory locations, the order of decleration is observed.  For all the decleration possiblities, see Type declerations

var x: int
    y: int = 10

Properties

"prop" {identifier ":" TypeDecl 
          ["read" [ExpDecleration | identifier |"var" MemLoc]]
          ["write" [ExpDecleration | identifier |"var" MemLoc]]
       }

The property block identifies a list of fields that are accessible to the outside world.  However, with properties you can control access to the value through the definition of a reader and writer.  These can be an expression or a variable.  If the variable is declared inside the property, it is local to the object and the outside world can not access the value.  You can also use a previously declared variable to specify the read or write value.

If  you use an expression, the result type of the read part needs to be the same type as that of the property and it should not have any parameters.  The writer needs 1 parameter of the same type as the property and no result value.

When generating the memory locations, the order of declarition is observed.  This means that a property with 1 or 2 internal memory declerations will store these variables in the order that the property appeared with the memloc that was declared first, at the first possition.

struct x =
 var a: int
 prop b: int read var c: int
 var d: int
;

will be converted to

struct x =
 var a: int
     c: int
     d: int
;

some examples:

struct x =
 prop a: int read exp GetVal: int write var b: int
;

exp x.GetVal = 
   return(b)
;

struct x =
 var b: int
 prop a: int write b
;

Expression declerations

"exp" { ExpDefinition} 
ExpDefinition = Identifier ["("[ MemLoc {","MemLoc} ")" ] [":" TypeDecleration] 
                   ["in" identifier[":" identifier] {", " identifier[":" identifier]} ] 
                   ["out" identifier[":" identifier] {", " identifier[":"identifier]} ] 
                   ["inline"] ["static"] ["extern" [identifier] ] ["abstract" | "override"|
                    "virtual"] ["default"] 
                   [ExpImplementation] 
ExpImplemention = "=" {Statement} ";"

An expression is the equivalent of a function.  It is called expression cause unlike functions, expressions can contain a form of regular expressions (inteface statements).  For more on this, see Message statements

Just as functions in most other languages, an expression can have parameters and/or a result type.  For parameters by value of complex types, a local copy will be made using the assign operator if it is defined, otherwise by simply making a copy of the data.

The special keywords "in" and "out" allow you to specify to/from which message handlers the expression can send and or receive data.  This needs to be specified if you want to use message statements in the code.  A message handler can be specified as a normal var decleration (identifier: typedecleration) or by specifying the name of the global variable (identifier).

The keyword 'Inline' specifies that whenever a call is made to the expression, the body should be copied inside the caller instead of making a call.

The static keyword defines that the expression can be called from the type.  Static expressions can't access field data.

Extern expressions are only allowed in libraries and processes.  Extern expressions can be called from outside the library, they are exported.  Possibly, an extra name can be specified in case the name of the function in the library is different than that of expression.  This allows you to use different names in the object than the actual names found in the library and it also allows you to link to case sensitive libraries such as the ones produced by C compilers.

Abstract, override and virtual are only allowed in complex types (spaces and stores).  Abstract expressions don't have code associated with them but need to be implemented by a descending object.  If you want to allow an exprssion to be reimplemented by a descendent, you use the virtual keyword.  Expressions that are reimplemented need to use the override keyword.  Virtual and abstract expressions will make certain that the correct implementation of the expression is used for the caller.  If you reimplement an expression without initially declaring it abstract or virtual in the base type, you will always use the expression that is located in the type of the variable, not in the data's real type.

The default keyword can only be used with constructors and destructors.  For more info on this, see constructors or destructors.

After an expression decleration, you can always give the implementation of it.

Overloaded operators

OperatorOverlaoder = {"'"Operator"'" ExpDefinition}
Operator =[ "*" | "/" | "%" |"&"
           |"+" | "-" | "|" | "~"
           |"=="| "<" |"<=" | ">" | ">=" | "<>"
           |"=" | "+="|"-=" | "*="| "/=" |"%=" | "<<" | ">>" | "<<-" | "->>" ]

• An operator overloader needs 1 parameter.  This represents the second variable of the operator.
  
• To invert the precence rules of an operator, specify the operator overloader as static and give as second parameter a ref to the object type itself
• The assign operator is always used for passing parameter by value of structured objects.  If this is missing, a normal copy is used.
• Note that the operator you want to overload nees to be put between single quote signs.
  

//create an operator overloader so we can assign a char to the object
operator '=' DoAssign(aVal: char)
//a multiply operator for a vector type that is reversed so we can
//write aint * avector
operator '*' DoMul(aVal: int, aVector: sVector) static

Constructors

Constructor = "constructor" {ExpDefinition}

• You don't have to create constructors that have parameters to define default values for the fields.  These can be supplied through the
constructor call.

constructor create = ; default

Destructors

Detructor  = "destructor" {ExpDefinition}

A destructor is defined just as a normal expression. If an object has no desstructors, it can not be destroyed.  A desstructor can be defined as default, which indicates that this is the desstructor that should be used for destroying the object in situations were the object is being destroyed without a destructor (such as a parameter by value or a field of a structured type).  There can only be 1 default destructor per type and it can not have any parameters.  Other destructors can have as many parameters as you want.

destructor destroy = ; default

Send to Message handler

"message" { identifier ["read"ExpDefinition] ["write" ExpDefinition] ["is" ExpDefinition]}

For more info on message principles, see messages.

With message receive definitions you can define which objects can be sent to the defining object.  You need to specify the object type that we can send to, the read, write and verify function.

The read function will get a value from the defining object.  The write function will write the value.  The verify function will check if the requested type is available

For this to work, each function needs to have a set number of parameters and a specific return value.

• For the read expression:
• parameters:  a ref to the message handler
• return value:  the object itself
  
• has to be static
  
• For the Write expression:
• parameters: a ref to the message handler
• return value: nothing
• can't be static
  
• For the Is expression:
• parameters: a ref to the message handler
• return value :bool
• needs to be static

space sContainer =
 entity pointer     //stores refs to anything
 store stLinkedList //store the data as a list
 var CurPos: int = 0  //stores at which position we are currently
 Next DoNext = CurPos += 1;
;
space sElement =
 var Val1: string     
 message string read ReadFromContainer(aContainer: sContainer&): sElement static
                  write WriteToContainer(aContainer: sContainer&) inline       
                  is IssElement(aContainer: sContainer&): bool static inline

exp sElement.ReadFromContainer(aContainer: sContainer) 
=
   return(sElement^(aContainer@CurPos.entity)^)
   //note: don't advance, this is done by the GetNext of the container object
;

exp sElement.WriteToContainer(aContainer: sContainer) 
=
   //add ourselves to the list
   aContainer << pointer(self)
;

exp sElement.IsElement(aContainer: sContainer): bool 
=
   //check if the object at the current position is of our type
   [<-aContainer@CurPos is sElement-> return(true)
    <--> return(false)
   ]
;

Union

"union" identifier "=" { Var | ExpDeclerations } ";" 

A union allows you to define variables that occupy the same memory location.  In additionn, you can define expressions that are local to the object.  The compiler will allocate enough memory to accomodate the largest variable in the union.  Since memory is shared between the variables, writing a value to one variable also changes the other variables.

To select a variable within the union, use the "." selector.

union uIntAndFloat =
  anInt: int
  aFloat: float
;

aVal: uIntAndFloat
aVal.anInt = 5
aVal.aFloat = 5.5     //value of anInt is
overwritten

Complex types

Complex types are types that contain run time type information.  There are 2 variations: spaces and stores.  Since complex types have run time information, they can contain static fields and virtual expressions.  Complex types can also inherit from one or more parents (multiple inheritence).  All parents must be of the same type as the current type.  Or in other words, a space can only inherit from other spaces and a store only from other stores.

You can also check if a complex object is of a specific type or if the type is in the inheritence tree of the object by using the '=' and 'is' operators.

Spaces

"space" Identifier ["(" [ Identifier {, Identifier} ] ")"] "="
{SimpleVar
|PropDef
|ExpDeclerations
|OperatorDefs
|constructorDefs
|DestructorDefs
|MessageSendDefs 
|MessageReceiveDefs 
|"entity" TypeDecleration
|"storage" Identifier
|"Next" ExpDefinition
|"space" Designator
}";"

A space is a complex type that expands the struct type (a struct type with run time type information).  A space can also receive objects that are send to it through the messageing system.  Furthermore, a space can operate as a container for other object of a specific type.

The following capabilities can be defined in a space:

• Variables
  
• Properties which can have readers and writers in the form of expressions or variables.  See Properties for more info.
  
• If and how it can dynamically be constructed and created.  See Constructors and Destructors for more info.
• which expressions can be performed on it.  See Expression declerations
  
• which types can be send to the structure through the Messaging system.  See Send to messages for more info.
  
• to which Message handlers it can be sent.  See Receive from messages for more info.
  
• Operators that can be applied to them. See overloaded operators for more info.
• If it needs to act as a container or not, which data type to store and how.
• An expression that will be called whenever the next token (or data) needs to be processed or prepared for reading data through the interface system.  This allows you to build a look ahead system.  The expression should not take any parameters or return a value.
  

To define a space as a container, you use the "entity" and "storage" sections.  Under "entity" you  specify a type decleration of the object that you want the store.  The "storage" keyword is used to let the system know how it should manage this data.  This has to be the name of a store.  A space doesn't have to be a container.  If the entity and storage keyword are not suppplied, it is impossible to store data in the space.  

If the first parent space defines the sections, descendants will inherit these settings.  They can not be overwritten. All secundary parents can retain their container definitions.  This means that a space can actually have multiple containers, one of it's own and one for ech of the secundary parents which can only be reached by casting to the parent type.

Normally, an entity always keeps a reference to the space that it owns, but if the entity is a structured type that already contains a reference to it's owner, you don't need to store this information  2 times, therefor, you can use the keyword 'space' to indicate which field of the entity has the ref to the owner.

There are special operators provided to add and remove data from a space.  There is also a general way to loop through the data.

When data is added or removed to/from a space, this is done through the store that it defined.  Sometimes you need to call some extra code, specific for this space during these operations.  This can be done be implementing an operator overloader (for the add and remove operators) with as parameter, a reference to the space entity.  In the case of an add, this expression will be called after the actual operation, for the remove, it will be called before the data is removed from the space.

//a simple string type
space sSimpleString =
 entity char
 storage stArray  //this is a store defined somewhere else and represents an array
;

//an example using space

space sOwner;  //forward declare
struct sChild =
 var Owner: sOwner^  //a ref to the owning object
;
space sOwner =
 entity sChild		//the object type we store
 store stLinkedList	//how we store it
 space Owner		//where can we find the owner in the object type we store
;

//an example with an operator overloader for the add and remove in the space
space sOwner =
 entity sChild
 store stLinkedlist
 operator '<<' AddElement(aValue: sOwner.entity) = aValue.Owner = self;
 operator '>>' RemoveElement(aValue: sOnwer.entity) = aValue.Owner = nil;
;

Message receiving

"type" {identifier ["read" ExpDefinition] ["write" ExpDefinition] ["is" ExpDefinition]}

For more info on messaging principles, see Messages.

With message receiving definitions you can define which objects the can be sent to the defining object.  You need to specify the object type that we can handle, the read, write and verify function.

The read function will return a value of the type this message is suppose to handle.  The write function will write the value from the defining object to the message object.  The verify function will check if the message handler can read the value(s) as the specfied type.

For this to work, each function needs to have a set number of parameters and a specific return value.

• For the read expression:
• parameters:  nothing
  
• return value:  the object that receives the data
  
• can't be static
  
• For the Write expression:
• parameters: a ref to the object that needs to be written
  
• return value: nothing
• can't be static
  
• For the Is expression:
• parameters: nothing
• return value :bool
• can't be static

Next

space sIntListString(string) =
 var CurStart: int = 0
     CurEnd: int = -1  //so that we have a proper first init
 type int read ReadFromString: int
          write WriteToString(aVal: int^) inline 
          is IsInt: bool inline
 Next DoNext
 constructor create default = DoNext;
;

exp sIntListString.ReadFromString: int
=
   //get the substring out into a temp string, convert that into an integer
   iTemp: string
   iTemp = self.SubString(CurStart, CurEnd) 
   return(Convert.StrToInt(iTemp))
;

exp sIntListString.WriteToString(aVal: int^) 
=
   //convert the int to a string, add it to us
   iTemp: string
   iTemp = convert.IntToStr(aVal^)
   self += iTemp + " "
;

exp sIntListString.IsElement(aString: string): bool 
=
   //There is an integer waiting if the start is different from the end
   return((CurEnd - CurStart)> 0)
;

exp sIntListString.DoNext 
=
   //find next space, check if we found  an alpha numeric value, if so, 
   //set start and end to end, otherwise, it was a number so leave start  
   iNeedEqual: bool 
   [<-(CurEnd + 1) < Self.NrRecords->
      iNeedEqual = false
      iChar: char
      CurEnd += 1
      iChar = Self@CurEnd
      {<-CurEnd >= Self.NrRecords->
       >-iChar == " "-> break
       <-->
         [<-iChar < "0"|| iChar > "9" -> iNeedEqual = true]
         CurEnd += 1
         iChar = Self.@CurEnd
      }
    <--> iNeedEqual = true
   ]
   [<-iNeedEqual-> CurStart = CurEnd ]
;

Stores

"store" Identifier ["(" [Identifier {, Identifier} ] ")"] "="
{ SimpleVar
| PropDef
| ExpDeclerations
| OperatorDefs
| constructorDefs
| DestructorDefs
| InterfaceSendDefs 
| "Loop" ExpDefinition 
| "space" {MemLoc}
| "entity" {MemLoc}
| "first" ["read" ExpDefinition] ["write" ExpDefinition] 
| "last" ["read" ExpDefinition] ["write" ExpDefinition] 
| "next" ["read" ExpDefinition] ["write" ExpDefinition] 
| "prev" ["read" ExpDefinition] ["write" ExpDefinition] 
| "NrRecords" ["read" ExpDefinition] ["write" ExpDefinition]
| "pos" ["read" ExpDefinition] ["@" ExpDefinition] ["write" ExpDefinition] 
}
";"

A store is a complex type that is used to define data storage systems. It has the same capabilities as a structure with the added benifit of inheritence.  A store is used by a space to define how its data can be accessed, what the possibilities are and what is needed for this type of storage mecanisme.  A store defines the fields needed in the space and in each record, how the space should loop through the data, how to get to and/or set the first, last, next and previous record, how to get and/or set the total number of records in the space and how to get, set and retrieve a record at a specific position within the space.

Besides these special properties, a store can also define how it is supposed to add and/or remove a record from it's internal data by implementing the '<<' and '>>' operators.

The loop expression can not be static or virtual.  It expects 1 parameter: an integer which is the total size of 1 record.  It has no return value.  The 'inherited' keyword is overloaded in the loop expression.  It expects 1 parameter: a pointer type that should ref to the current entity to be processed in the loop.  The 'inherited' keyword in the loop expression indicates where execution needs to be handed over to the system to perform the inner loop code.

The get first and last expressions expect an int as parameter, representing the size of a record and return a pointer, which is the record.  The set first and last expect an int and pointer as parameters in that order, meaning the size of a record an the record which contains as it's first fields, the fields defined in the entity section.  No return value is expected.

The get next and prev expressions expect an int and pointer as parameters in that order and return a pointer. The first parameter indicates the size of a record, the second, gives the previous record.  The set next and prev add 1 more parameter as pointer, the new record.

The Get NrRecords expression has 1 parameter: the size of a record.  It returns an int representing the number of records in the store.  The Set NrRecords expressions has 2 parameters: an int representing the size of a record and an int representing the new number of records.  There should be no return value.  The manner on how a decrease in the record count is handled is not defined and is therefor left over to be defined by the store

The get at Pos expression expects an int representing the position and an int representing the record size in that order.  It returns a pointer representing the record found at the specified position.  The GetPos (read) expression expects a pointer representing the record we want to know the position of and an integer representing the size of a record.  It returns an integer, representing the position of the record.  The write position expression gets an integer represinting the old pos, an int represinting the size and an int represting the new position in that order.  It does not return a value.

All the first, last, next, prev, nrRecords and pos expressions can be static or virtual but don't have to be.

You shouldn't normally have to write store objects unless you are designing core libraries.  Gene contains a set of predefined store objects that you can use.  These are located in the 'BaseStores' unit.  You can use stores like linked list, stack, queue, array,... which behave just like normally.  For more information on the specific stores that are available, check the library documentation (at time of writing not ready yet).

Type declerations

Type decleration = [ [Identifier | designator "." "entity"]   [ [ "$" | "&" {"^"}]  
                                                              | "." Constructor 
                                                              | "@" Integer
                                                              ]
                   | Struct 
                   | Union                   
                   | Space 
                   | Store 
                   | ExpDecleration 
                   ]

• One of the base types
• A structured type
• A renamed type
• A designator pointing to a space and ending with 'Entity'
• The definition of a structured type or expression
  

• Structured types can have a
constructor in case you don't wan to use the default constructor of the object.

• To declare arrays, you can use the '@' operator.  The integer value defines the number of elements in the array and is always 0 based.  Currently, only single arrays are supported.
  
• If there is no constructor or array definition, you can give a default value.  This has to be of the same type as the object.  This does not work for structured objects.  To give default values for these objects,  you need to use a constructor.
• Type definitions can be nested.
• To declare a pointer to an object you can use the '^', '&' or '$' operator.  The '^' operator defins normal pointers.  These pointers have to be managed by the programmer.  Pointers defined with '$' are managed by the system, that is, they are always initialised to 0 (no automatic object creation) and when they get out of scope, the object will be destroyed automatically.  This is also the case for objects declared inside a structured type: when the object is destroyed, owned pointers that are not nil will also be destroyed. The '&' operator (pointer by reference) declares an object on the heap, so it is created and destroyed automatically
  
• To declare an object as an element of a space, you can use the name of the space or a designator that selects the space, followed by '.Entity'.  If you declare the object with the name of the space type, you can assign any element from any object that is of the specified space type.  If you use a designator, the object can only contain an element from a specific space.  The second decleration style uses less memory than the general decleration but is also more restrictive.

//decleration of a variable of type int, initialized to 0
a: int = 0

//array of 5 elements of type int
a: int@5

//pointer to type int (or variable length array), initialized to nil
a: int^ = nil

//pointer to type int that will automatically be initialized to nil and
//will be destroyed once it gets out of scope
a: int$

//nested definition of a space (structured object)
a: space x =
     entity int
     storage stLinkedList
    ;

//definition of a struct object and variable that initializes the fields
struct x =
  a: int
  b: int = 0
  constructor create = ; default
  destructor destroy = ; default
;
a: x.Create(\ a = 2, b = 3)

Rename

"rename" identifier "=" [TypeDecleration | ExpDecleration ] ";"

Use the rename keyword to assign a symbol name to a type decleration.  This can be used to create shorter names for typedeclerations, to make the code more readable or more typesafe and to declare pointer types to expressions.  Gene treads a renamed type as the same type, so it not type safe except for messages where a renamed type is seen as a new one.  This can also be used in the messaging system to identify types that have a different logical meaning but have a similar physical representation.  In this case, one is usually a subset of the other.  For instance you can have a string type to handle normal strings and rIntAsString which is a rename of the string type to handle strings that can be converted to integer values such as '123'.

rename rWidth = int;
rename rIntAsString = string;
rename rStringInitToJan = String.Create('Jan');
rename rSimpleExp = exp (aValue: int) virtual; 

aWidth: rWidth
aInt: int = 1
aWidth = aInt  //will work
aWidth = rWidth(aInt)  //using a cast will also work but is not needed

Global variables and constants

Constant = "const" {Identifier "=" ConstValue }";"
ConstValue = ["nil" | integer | extended | String | Bool | Char]
Variable = "var" { Identifier ":" TypeDecleration } ";"

Globals can be accessed anywhere in the code of a unit that includes the unit containing the definition of the global.  Globals can be constant or variable.  Constant globals must be assigned a value during decleration and can't have a type specifier.  They can only be of a base type, so integers, boolean, extended, characters, constant strings or the nil value.  Their value can't be changed during the execution of the application.  Variables must have a type definition.  This can be any type that is known at the location where the variable is defined.  They can have an initial value assigned and it can change during the live of the application.

A global variable of a complex type is created properly with either the default constructor, the one specified at the decleration or none if there is no default constructor and the default fieldvalues are assigned before any code is executed.

const 
 gInt = 1
 gFloat = 1.1
 gString = 'This is a test'
 gBool = false
 gEmpty = nil
 gChar = "t"
;
var 
 gString: string.create('initValue')
 gInt: int = 0
 gFloat: float
 gPerson: sPerson.Create(\ Name = 'Jan Bogaerts', Sex = Sex_Male)
;

Processes and Libraries

"process" identifier ["(" Identifier ")"] 
          { "OS" ["linux" | "win32" | "win32consolse"] 
          | ["platform" "x86"]          
          } "="
  { "entry" ExpDefinition 
  | SimpleVar
  | ExpDeclerations}
  }
";"

"lib" identifier ["(" Identifier ")"] 
          {"OS" ["linux" | "win32" | "win32consolse"] 
          | ["platform" "x86"]             
          } "="
  { "entry" ExpDefinition 
  | "return" ExpDefinition
  | ExpDeclerations 
  |constructorDefs
  |DestructorDefs}
  }
";"

A process object identifies an application that needs to be generated.  A library object identifies an object file that is used by an application at run time and that is not contained by that application (in other words dll's or os files).

A Gene project can have multiple processes and or libraries as output.  An output is generated for each process and or library that is contained in the project unit.  Processes defined in other units are only accessible through inheritence.  Libraries declared in other units can be used, but no output will be generated for them.  This allows you to define common run time libraries in seperate units and include those units to use these libraries.

Unlike libraries, processes can inherite from other processes.  Descending processes can access the variables and expressions of the parent process.  Variables are always static and expressions can not be abstract or virtual.

The entry point is used to define the start of the appliction or library.  A process must always have one but a library doesn't.  A library can also define an exit point if it wants to.  The definition of the entry/exit point is fixed and determined by the Os.  Current valid definitions are:

A process can have variables and expressions.  These variables and expressions are only available inside the process.  A library can't have variables, only expressions.

Each library and process needs to be assigned to an Os and and possibly platform.  Currently, only linux and windows (normal and console) are supported as Os and for the platform, only x86 is available.  This may be expanded in the future.  This information can be used to write platform specific code through the use of the interpreter.

Example:

#[CurrentProcess.Os
  #<-Linux-> Kernel32.CloseHandle(fHandle)
  #<-Win32-> CloseFile(fFile)
  #<--> #errors << StrErrorLine.Create(f: Unit = Name, Line = CurLineNr, Col = CurColNr, 
                                          Text = 'Platform not supported')
#]

Libraries can also have constructors and destructores.  They are used to dynamically load/unload a dll at run time.  The constructor call of a library  has 2 extra parts besides the parameter list: the name of the library, which always has to be string and a list of assignments for binding function names to expressions that have a different name than the expressions themselves.

Note: The code declared in a constructor, destructor of a library is situated in the calling process while the code for the entry/exit points is in the library itself.

process foo Os linux =
 entry main(Argc: int, Argv: char^^): int
 var IntValue: int
;
lib foolib Os linux platform x86 =
 exp dox
     doa(aValue: int) extern
     dob extern '__dob'
 constructor create
 destructor destroy
;
var StaticLib: fooLib
    RunTimeLoaded: fooLib^
;
RunTimeLoaded.Create(\ Doa = '__doa')

AutomationName ["(" identifier ")" ] { "\" AutomationName ["(" identifier ")" ] } identifier [ typespecific ]
 {ChapterName Value}
";"

//original definition
struct x =
 var y: int
;
//with observer
struct x =
 varObserver y: int ObserveBefore true;    //we only supply the ObserveBefore, we leave the ObserveAfter as its default, so false
;

//original definition
struct x =
 var y: int
;
//with observer
SingletonStruct Observedstruct x =
 var y: int
;

Identifier ":" TypeDecleration

Condition ["=" | "+=" | "-=" | "/=" | "*=" | "%=" ] Condition

a: int
b: int
a = b
c: char
a = c  //error
a = int(c)   //ok
aString: string
aString = 'test'  //operator overloader will be used
aString += ' '    //operator overloader will be used, ' ' will be added at end of the string

Condition ["<<" | ">>" ] Condition

a: int
a << 5  //will shift the bits in a 5 positions to the left

Condition ["<<" | "<<-" | "->>" | ">>" ] Condition

//suppose we have the following space definitions:
space sStringList =
 storage stLinkedList
 entity string
;
space sIntList =
 storage stLinkedList
 entity int
;

var iStrings1: sStringList
    iStrings2: sStringList
    iStrEnt: sStringList.Entity   //entity of space sSTringList
    iInts: sIntList
    iStrVal: string
    iIntVal: int
;

//add element with a constructor
iStrings1 << string.Create('an initial value')
//add element through the entity constructor, after the operation,
//iStrEnt will point to the element that was added
iStrings1 << iStrEnt.Create
//copy the values from list 1 to list 2
iStrings2 << iStrings1
//empty list 1
iStrings >> nil
//add integer to list
5 >> iIntEnt 
iIntVal = 1
iIntVal >> iIntEnt

condition

space x =
 var StrVal: string
 exp DoSomething
     dox in aString: string           //read from a string
     doy(aVal: string) out screen     //write to THE screen (screen is a global parameter)
     doz out aString: string, screen  //write to a string and a screen
;

exp x.DoSomething =
   iStr: string
   dox@iStr   //we have to provide an interface object, cause it is defined as a variable
   //a temp var will be created and the assign operator will be called 
   //to copy the data of the string
   doy(iStr)        //don't have to provide interface, the compiler knows you mean the screen
   //when the call is completed, the temp var is destroyed.
;
exp x.dox =
   doz      //we don't have to provide an interface, the compiler will automatically use 
            //the interface of dox doz will put 'test' in the interface string   'test'  
//we want to read test out of the interface
;
exp x.doz =
   'test'   //put test in the interface
;
exp x.doy(aVal: string) =
   //write the value that was passed as a parameter
   aVal    //ask doz to write 'test' to the screen, we don't have to provide an interface, 
           //the compiler will use the screen 
   doz
;

condition

//suppose we have a definition of:
space a =
 var b: int
 exp dox in string out file
;
exp a.dox =
   aVal:string = 'my age is'
   b = 1
   aVal ' ' b ', but could also be '  b+2
;

"return" ["(" Condition ")"]

return
return(false)

"[" CodeItems {CodeItems} "]"

//simple if else if structure
[<-a == 1-> b = 2 
 <-c == 2-> d = 3
]
//case statement
[a 
 <-1-> dox 
 <-2-> doy
]
//another case statement
[aString 
 <-'test'-> dox 
 <-'tester'-> doy
]
//an if statement with a fall through
[<-a == 1-> dox //if a == 1 then dox and doy will be executed
 >-a == 2-> doy //if a == 2 only doy will be executed
]

[ ">-" | "<-" ] Condition ["\" Condition ["\" Condition]] ["->" | "-<" ]

aval: string
//if there is a string in the input, store it in aVal, 
//don't advance and call 'DoSomething'
[<-aVal-<
doSomething(aVal)]  
//if there is a string in the input, store it in aVal, 
//goto next in interface and call 'DoSomething'
[<-aVal-> doSomething(aVal)]
//if 'test' is in the interface, goto next in interface, call 'DoSomething'
[<-'test'-> doSomething]
//if there is an int in the interface and it is bigger than 2, 
//goto next in interface and call 'DoSomething'
[<- >2 -> DoSomething]
//an interface statement through an expression, the option will be executed 
//if the interface currnently contains
//'x', 'y' or 'z'.  Before DoSomething is called, dox will be called
[<-dox-> DoSomething]

exp dox =
   a: int = 0
   {<-'x'-> doa
    <-'y'-> dob
    <-'z'-> doc
   }
   dod
;

"{" CodeItems {CodeItems} "}"
 

//a case loop: perform for as long as aVal is 'something', 'test' or 'something else'.  
//If it is test, perform the code: doy doz aval= 'something'
aVal: string
aVal = 'test'
{aVal
 <-'something'-> 
   dox
   aVal = ''
 <-'test'-> doy
 >-'something else'-> 
   doz
   aVal = 'something'
}
//a mormal loop with multiple blocks and the last block as empty: do eternal loop
{<-aVal == 5 && aVal2 > 2-> dox
 <-aVal== 5-> doy
 >-aVal==6-> 
   doz
   break  //exits the loop
 <--> doz
}
//a mormal loop with interface calls as conditionblocks: perform for as long
//as one of the values in the conditionblock can be retrieved from the interface
{<-aval-> dox
 <-1-> doy
 <-3-> doz
}
//a repeat loop: do for as long as aval > 0
{ dox
  doy
  aVal -= 1
 <-aVal > 0->
}
//a space loop: loop through all the characters of a string
aStr: string
aEl: aStr.Entity
{<-aStr\ iEl-> dow(iEl.Entity)} //iEl.Entity returns the content of the space entity, 
//in this case the char a for loop with increment 1 and a declare in the conditionblock:  
//loop for as long as i <> 10
{<-1; i:int; 10-> dow(i)}
//a for loop with our own increment
{<-i: int =0\i < 10\i+=1->dow(i)}

"break" 
"continue"

"inherited" ["(" [Condition {"," condition} ] ")"]

[designator [ "(" [calculation {"," calculation}] ["\" [assignment {"," assignment} ] ] ")" ]   
 | typedecl 
]

//a space definition:
space x =
 var a: int = 0
 constructor create =;
            
CreateWithPar(aval: int)
 destructor destroy = ;
;
space y(x) =
 var b: int = 1  
//constructor is inherited from x
;

exp z.dosomething =
  ax: x^
  //a simple constructor
  ax.create
  //a constructor with initial values
  ax.create(\ a = 2)
  ax.destroy
  //a constructor with parameters
  ax.CreatewithPar(1)
  ax.destroy
  //a constructor with parameters and initial values
  ax.CreateWithPar(1\ a = 2)
  //constructing an object with type that of a parent of the actual object being created
  ax = y.create
  ax.destroy
  //and with initial values
  ax = y.create(\ b = 2)
  ax.destroy
;

Designator

aStr: string^
aStr.Create  //create the string
aStr.Delete  //destroy the string

"raise "(" Statement ")"

raise(Exception.Create('internal error'))

"try"
   {statement}
 "except" [memloc] 
   statement 
{"except" [memloc] 
   statement 
}

try
  a: float = 5.0
  a /= 0  //oeps, division by zero
except aErr: EDivByZero  
  screen.WriteChar('oeps, devision by 0')
except 
  screen.WriteChar('unexpected error')

"try"
   {statement}
 "finally"  
   statement 

a: string^
a.Create
try
  b: float = 5.0
  b /= 0   //oeps
finally
  a.destroy  //make certain that the string is always freed.
;

[identifier | SpaceSelector | "Self" ] 
 { "." [identifier | SpaceSelector | SpaceEntitySelector] 
 |"(" [Condition {"," Condition}] ")" ["@" Factor]
 |"@" Factor
 |"^" 
 }
SpaceSelector =  ["first" | "last | "NrRecords" | "store" ]
SpaceEntitySelector = ["Next" | "Prev" | "Pos" | "entity" ]

screen //select the screen object which is a global var
aStr: string
astrEnt: string.entity
astrEnt = aStr@1 //select the char at the second pos in the string (string is 0 based)
aPChar: char^
aPChar = aStr.Store.Data //select the internal data of the string through the store
aChar: char
aChar = aPChar@1 //select the second char in the string pointer (pointer array is 0 based)
aChar = aPChar^ //select the first char through a pointer deref

"(" [Condition] ")"

aStr: string
aStr = 'aabbaabccaa'
//cange all 'a' to d
aStr(entity == "a") = "d"
//count all the 'b'
aChar: aStr.Entity
Counter: int = 0
{<-aStr(entity == "b")-> Counter += 1}
//set all the people's house number who are male to 1, this supposes 
//we have a space 'peoply' with as subrecord, address
People(Gender == "m").Address.Nr = 1
//delete all the people who are not male or female
People(Gender <> "m" && Gender <> "f") ->> nil
//print all the people address (send to interface)
People().Address
//get the first female
aTemp: People.Entity
aTemp = People(Gender == "f")
//add the house nr of the first female to the counter
counter += People(Gender == "f").Address.Nr

["+"|"-"] term
term ["+"|"-"] term
factor ["*"|"/"|"%"] factor

Condition ["="|"+="|"-="|"*="|"/="|"%="|"<<"|">>"|"<<-"|"->>"] Condition

term ["|"|"~"] term
factor "&" factor
`factor
condition ["shl"|"shr"] condition

!Factor
OrCondition "||" OrCondition
BoolCalculation "&&" BoolCalculation

designator "@" factor

"@" Factor
designator "^"

Calculation ["=="|"<"|"<="|">"|">="|"<>"] Calculation

"sizeof" "(" Designator ")"
condition "==" condition
condition "is" condition

space x =
 var a: int
 constructor create = ; default
 destructor destroy = ; default
;
space y(x) = 
 var b: int
;

a: x^
a = y.create
[<-a is x->  //this will return true
 <-a is y->  //this will return true
 <-a == x->  //this will return false
 <-a == y->  //this will return true
]

"asm"  "[" {AssemblerStatement} "]"
AssemblerStatement = Opcode {operands}

asm[
 move EAX @Screen     //move a ref to the global screen object in the eax register
]

'This is a test |nthat needs to be put on a new line'
"|""  //a double quote char