Overview of HAL Language

• HAL is an "Object Oriented Language Environment" that tries to take the complexity out of programming useful applications.
• HAL is organized as 1 large Windows file.
• You specify how large the disk file will be at creation time. (Can be hundreds of gigabytes in size.)
• You specify how much memory this application will take at execution time. (Up to a current maximum of 4 gigabytes)
• The disk space is allocated internally so that only Classes and Objects are programmed, while the disk and memory space are managed by the program itself.
• There is no need to retrieve data from or save data to the disk. These functions and memory management are handled automatically.
• All program code is stored in Methods of a Class.
• Data is defined as Properties of a Class.
• All program data is stored as belonging to an Object which is defined by it’s Class.
• You can think of creating Classes as a compile time construct and Objects as an execution time construct.
• All Objects have a Class that describes the data contained by that Object and the methods that are available to that Object.
• All data that is stored to disk will be in an object of some kind or referred to by an object.
• Program code in a method can access data from it's own object and from any other object as well without regard to whether it is in memory or used by another process.
• A Class could have only data, only methods, both or none. (A Class with no data or methods could exist and could be used as a container class but would have no useful purpose in itself.)
• Any change to a Class is automatically implemented to all Objects of that Class. If the changed Class is inherited from another Class then all Objects of that Class are changed and this is recursed until all are changed.

e.g. This code creates a Class named "myclass". This Class has 2 properties called NAME and CUSTN respectively. This Class has only 1 method called add_name() which takes 1 parameter called mname. This method returns a logical value of true. The "return logical" defines what callers of this method should expect as a return variable but this could have been eliminated because the default return type is logical. After this Class is created and the method is automatically compiled. An Object called demo would be created of length 36 bytes. The “add_name” function could be called by any other Object by referring to it by “demo.add_name(mvariable)”. Class, Object and variable names are not case sensitive so the capitals on NAME and CUSTN are for readability and "name" and "custn" would be treated the same.

class myclass {
	char NAME(30)
	char CUSTN(6)

	add_name(char mname) return logical{
		return _TRUE
	}
} demo
  

The following is a list of the data types.

Type	Length in Bytes	Example
Misc Atoms:
Logical	1	logical mflag
Bit	1/8	bit bitstring[100,100]
Numeric types: All 6 numeric data types are automatically converted. Any overflow problems are up to the programmer to catch.
Byte	1	byte i
Integer	2	int i
Long	4	long i
Float	4	float i
Double	8	double i
Number	12	number i(10,2) // length 10 with 2 decimal places
Date/Time types:
Date	8	date mdate
Time	4	time mtime
Character types:
Char	fixed size	char mstring(20) // variable length but fixed maximum size
Varchar	4	char mstring // variable length and auto sizing
Blob	4	blob mjpeg // stores data of variable length in binary format
Special Objects:
Class	4	class mclass(name) - # of properties or methods is not limited
Object	4	object mobj(mclass) - size limit is available memory
Index	4	index mindex(mclass, nkeys) - size limit is disk space
Table	4	table mtable(mclass, cluster) - size limit is disk space
List	4	list mlist(myclass) - list can be auto sorted
Tree	4	tree mlist(myclass) - tree uses parent field to create tree
Stack	4	stack mystack(myclass) - list is last in - first out
Queue	4	queue myqueue(myclass) - list is first in - first out
Misc Referenced:
Vector	4	size is memory limited - all of vector/matrix must be in memory
Other classes:
Port	4	encapsulates serial port operations
Socket	4	encapsulates socket operations
Event	4	encapsulates data for spawning and communicating with other events

The above list is the smallest list I thought would still be useful. Any other kind of object can be made with the object data type.
Notes:

• The syntax "name.name2" or "name.name2()" is used to access the properties or methods of an object. The syntax "name:name2" is used to refer to members of the Object or Class hierarchy. This Class hierarchy has nothing to do with a class “inheriting” the Properties and Methods of another Class. Classes can be defined in one Class and inherit it’s Properties and Methods from any other Class.
• All names of Objects, Classes, Properties, Methods, Variables etc are limited to no more than 15 characters. The first character must be a letter and only letters, numbers, and the “_” character are permitted. A leading “_” character is used for certain inherited and system variables. All Class and Object names are relative to the Class or Object that contains them. Therefore, the small limit on the name size should never be a problem as names can be reused extensively. All names are case insensitive.
  • Mst:var1.add() and Mst:var2.add()
    
    • both of these add() functions could be totally different if the Classes of var1 and var2 are different.
  • Mst:var1:xyz and Mst:var2:xyz
    
    • both of the xyz Classes are totally separate because they were defined in different Classes.
• Methods are referred to as if they were a Property but have a "(" immediately after the Method name.
• NOTE: The colon ":" naming convention is used for the Object hierarchy and the Class hierarchy. This shouldn't cause any problems because the name of a Class wouldn't appear in a location in the code where you would find an Object name. The dot "." naming convention is exclusively used for Properties of an Object and where the name is followed by a "(", a Method name.

HAL Environment Structure

• HAL is contained in a single Windows file. It can grow if needed over time.
• Central to HAL are the managers:
• Disk - Manages the disk space within the HAL database.
• Memory - Allocates and garbage collects memory for all HAL functions.
• Blob - Blobs consist of memory and disk space (normally) that are read and written automatically by this manager.
• Memo - Variable length data is managed by this manager in Tables, Lists, Matrixes, and in Blobs if occuring in an Object.
• Class - Class info including inheritance, Properties, and Methods are managed here.
• Object - Uses Blobs to manage named Objects that are defined as belonging to a specific Class.
• Event - The event manager is responsible for loading and executing many programs at the same time.
• Although Indexes, Table data and Varchars are stored directly by the Disk manager, Blobs are the main mechanism to store and save info in HAL.
• The Memory and Disk managers automatically allocate, garbage collect and save changes to Objects without the programmer bothering with such details.