Notes
The following operators exist
| Operator | Description | Example |
|---|---|---|
* | Last Match Pointer | A pointer to the buffer of where the last found match is stored |
% | Stack Operator | A pointer to the memory location of the stack. Will output the last element on the stack when used as an output. |
#name | Named Counters | Variables (int32) that can store any value, when used in an output context the value will get printed as a signed number. |
*name | String Buffers | Variables (String) that can store any set of characters. Will get printed as a string when used in an output context. |
%<...> | Stack Offset | Will access the string pointer at memory location stack + len(stack) - ... (Reverse Stack lookup without popping) |
%<...,> | Reverse Substack | Will return all elements before stack - len(stack) - ... as a String*[] (Array of string pointers) |
%<,...> | Substack | Will return all elements after stack - len(stack) - ... as a String*[] (Array of string pointers) |
%<-...> | Negative stack offset | Will return stack + ... as a String* |
%<#named-counter> | Named Counter Stack Offset | All offset variants also work using named counters. |
& | Symbol Table Operator | META uses integrated, high performance, symbol tables. These can be referenced using the symbol table operator. |
&<..., ...> | Symbol Table Set | Inserts the combination of key (argument 1) and value (argument 2) into the current symbol table. |
&*<...> | Symbol Table Get into Last Match | Retrieves the value that corresponds to key (argument 1) and writes it into * (last match operator) |
&<...> -<...> | Symbol Table Get | Retrieves the value that corresponds to key (argument 1). This value will have to be captured by a immediate modifier that follows the expression or used inside an output method. |
&^<...> | Symbol Table Walking | Since some variables may have to be stored in a higher scope than the one currently in, the Symbol Table walk operator may be used to walk up ... steps in the symbol table tree. |
&^^ | Global Symbol Table Operator | Since writing &^<#global-symbol-scope> is quite cumbersome, the global symbol table can always be accessed by doing &^^ |
-<...> | Immediate Capture | Captures the last expression result into a variable specified in ... |
-f<...> | Immediate Modifier | Calls the function f with the specified arguments and the last expression result. The last expression result will ALWAYS be in position 0 of the argument list |
Declaring Variables
[define [i32 name] 0]
[defunc [fn [i32 arg1] [i32 arg2]] -> i32
[+ arg1 arg2]]Overrides
[override [fn [u32 arg1] [u32 arg2]] -> u32
[+ arg1 arg2]]Enum
[enum MyEnumName
[first 1]
[second 1]]
[define [MyEnumName variable] MyEnumName::first]Structs
[struct MyStruct<T>
[T prop1]
[u32 prop2]
[char[2,] name]]
[define [MyStruct<i32> prop1]]Arrays
Arrays can be created by doing: '[1 2 3 4]
Array elements are separated by a space
Types
The types of all variables have to be explicitly declared so the compiler can
optimize for them. You have several options when creating an array. By default
there are no mixed arrays meaning you cannot write char and i32 into the
same array.
i32[] Will create a dynamically sized array of i32s
i32[5] Will create an i32 array of size 5
i32[5,] Will create an i32 array with initial length 5 that can be
dynamically resized but may not be resized to less than 5 entries.
i32[,5] Will create an i32 array with no initial length that can be resized
up to an entry count of 5
i32[5,10] Will create an i32 array with initial length 5 that may be
extended up to a size of 10
Char
'a
Datatypes
| Name | Description |
|---|---|
| u8 | 8 bit unsigned integer |
| u16 | 16 bit unsigned integer |
| u32 | 32 bit unsigned integer |
| u64 | 64 bit unsigned integer |
| i8 | 8 bit signed integer |
| i16 | 16 bit signed integer |
| i32 | 32 bit signed integer |
| i64 | 64 bit signed integer |
| char | 8 bit character |
| wchar | 16 bit wide character |
i32[] | Array of i32s - refer to arrays for more information |