EmC Language

EmC is a statically-typed, heap-less, C-style scripting language for memory-constrained 32-bit embedded systems. Source files (.emc) compile to a compact bytecode binary (.emcbin) that runs on a stack-based virtual machine with no external dependencies and no runtime heap allocation.

The syntax is close to C. Most C code that avoids pointers, the heap, and the standard library will look familiar.

1. Program Structure

There is no main function. Top-level statements execute in source order when the script runs.

int x = 40;
int y = 2;
System::PrintInt(x + y);   // 42

System:: is the namespace for functions provided by the host application, called native functions. A host can also group natives under namespaces of its own. See Native functions.

Functions and classes may be declared at the top level. They can be referenced before their declaration appears in the file (see Forward references).

2. Comments

EmC supports C-style single line and block comments.

// Line comment.

/* Block
   comment. */

3. Types

EmC is a statically typed language. All data types are known at compile time, making execution faster and safer.

The alias column is just another way to declare the same keyword: s8 and char compile to exactly the same type, so they mix freely and error messages always report the char/byte/… name.
Aliases are provided for convenience as they are a little more descriptive than the classical type names.

// These two data types are the same and both compile as "short"
short var1 = 0; // 16 bit signed integer
s16 var2 = 0;   // 16 bit signed integer

char and byte are numeric types, not a distinct character type. Individual character literals are not supported, so an integer must be used.

char c = 'a';  // Compile error
char c = 0x61; // OK

string is a reference to a compile-time constant. String variables and string native parameters can only ever hold a literal or another string constant. For mutable text, use a byte array (see Strings).

4. Literals

int   a = 42;          // decimal
int   b = 0xFF;        // hex
int   c = 0b1010;      // binary
int   d = 0o377;       // octal
uint  e = 42U;         // unsigned (a U or u suffix, any base)
uint  f = 0xFFFFFFFFu; // unsigned literals can use the full 32-bit range
float g = 3.14;        // float (a decimal point makes it a float)
bool  h = true;
bool  i = false;

null, NULL, and nil are all accepted and evaluate to integer 0.

An integer literal without a suffix is an int. Add U to make it a uint, as in C. This matters in two places: a plain literal assigned to a uint variable warns about an implicit cast, and an expression is only compiled with unsigned arithmetic and comparisons when one of its operands is unsigned, so x > 0U and x / 2U behave correctly for a uint x above 2147483647. A literal larger than 4294967295 is a compile error. An unsuffixed literal above 2147483647 keeps its bit pattern and wraps negative as an int, with a warning unless it is being assigned to a uint (so uint mask = 0xFFFFFFFF; is fine) or negated.

String literals use double quotes. There are no escape sequences: "\n" is a backslash followed by n, not a newline.

System::PrintLine("Hello, world");

5. Variables

int count = 0;       // explicit initializer
int total;           // zero-initialized

All variables are zero-initialized if no initializer is given.

Scope

• Variables declared at the top level are globals.
• Variables declared inside a function or block are locals.
• Blocks ({ ... }) introduce a new scope. A local is visible from its declaration to the end of its enclosing block.

int g = 1;           // global

void f() {
    int local = 2;   // local to f
    {
        int inner = 3;   // local to this block only
    }
    // inner is not visible here
}

const

const marks a variable read-only after its initializer runs. Writing to it later is a compile error.

const int LIMIT = 100;
LIMIT = 200;         // compile error: Cannot write to const variable after initialisation.

A const array must be initialized where it is declared, and its elements can’t be written after that. Assignment, compound assignment and ++/-- on an element are all compile errors. This works well for lookup tables:

const byte GEAR_RATIOS[4] = {35, 21, 14, 10};
byte r = GEAR_RATIOS[gear];   // reading is fine
GEAR_RATIOS[0] = 40;          // compile error: Cannot write to an element of const array 'GEAR_RATIOS'.
const byte EMPTY[4];          // compile error: a const array must be initialized

A const array can only be passed to a const array parameter (see “Array Parameters”).

Naming Style

EmC enforces no naming convention. One common pattern is UpperCamelCase for functions and global variables and lowerCamelCase for locals and parameters, which makes a name’s scope visible at a glance and matches how the native functions are named. The compiler accepts any style, and the choice is entirely yours.

6. Operators

All basic mathematical and bitwise operations are supported.

Arithmetic

a + b       // add
a - b       // subtract
a * b       // multiply
a / b       // divide
a % b       // modulus (remainder)

Bitwise

a & b       // bitwise AND
a | b       // bitwise OR
a ^ b       // bitwise XOR
~a          // bitwise NOT (ones complement)
a << b      // shift left
a >> b      // shift right

Comparison

a == b      // equal
a != b      // not equal
a < b       // less than
a > b       // greater than
a <= b      // less than or equal
a >= b      // greater than or equal

A comparison always produces a bool.

Logical

a && b      // logical AND
a || b      // logical OR
!a          // logical NOT

Assignment

a = b       // assign
a += b      // add and assign
a -= b      // subtract and assign
a *= b      // multiply and assign
a /= b      // divide and assign
a &= b      // bitwise AND and assign
a |= b      // bitwise OR and assign
a ^= b      // bitwise XOR and assign

There is no %=, <<=, or >>=.

Increment / Decrement

Both prefix and postfix forms work on a variable, a class field or an array element:

i++;        // postfix increment
++i;        // prefix increment
i--;        // postfix decrement
--i;        // prefix decrement
car.speed++;
--this.count;
counts[b]++;
++buf[n];

A postfix ++ or -- has to be the whole expression, as in i++; or int old = counts[b]++;. Using it inside a larger expression, such as a + i++, is a compile error. The index is evaluated once, so counts[Next()]++; calls Next() once.

Narrow types wrap at their own width:

byte b = 255;
b++;                 // b is now 0
short s = 32767;
s++;                 // s is now -32768

Ternary

Behaves like a single line if/else statement.

int max = (a > b) ? a : b;

// Is equivalent to:
int max;
if (a > b)
    max = a;
else
    max = b;

Precedence

From tightest to loosest binding:

1. . [] () (member, index, call)
2. ! ~ ++ -- (unary)
3. * / %
4. + - & | ^ << >>
5. < > <= >=
6. == !=
7. &&
8. ||
9. ?: (ternary)
10. = += -= *= /= &= |= ^= (assignment)

Note that the bitwise and shift operators sit at the same level as + and -. Parenthesize when mixing them with arithmetic.

7. Type Conversions

Numeric types convert implicitly across signed, unsigned, and float categories as needed by an assignment, argument, or operator. There is no explicit cast syntax.

int   i = 10;
float f = i;         // int -> float
int   j = f / 4.0;   // float -> int on assignment

A function call’s return value converts the same way as any other value, so float f = count(); converts an int result to float and int n = 2 * ratio(); converts a float result to int.

The compiler warns when a float is converted to an integer type, because the fractional part is lost. This covers declarations, assignments, arguments, return values and array indexes. Other conversions, such as signed to unsigned, don’t warn by default.

Mixing int and float in arithmetic gives a float, as in C. The value keeps its fraction until it is stored, passed or returned, so int n = i * f * 4; only converts to int once, at the end. When the target is a float, the whole expression is worked out in float, including integer division. So float h = i / 2; with i = 1 gives 0.5, not 0.

Bitwise operators and switch need integer values, so a mixed expression like (i + f) & 3 is a compile error.

Storing a value in a char, byte, short or ushort wraps it to that type’s range, as in C. That happens at every store: a declaration, an assignment, a compound assignment, ++/--, an argument, and a return value. Arithmetic in between is done in int, so a result is only cut down when it’s stored. This makes decoding a signed 16-bit value from two bytes work as expected:

// data holds 9C FF, little-endian
short raw = (data[1] << 8) | data[0];   // -100
short big = 40000;                      // -25536
byte  low = 300;                        // 44

There is no integer overflow or wraparound detection. Arithmetic that exceeds a type’s range wraps silently.

8. Control Flow

if / else if / else

if (x > 0) {
    System::PrintInt(1);
} else if (x < 0) {
    System::PrintInt(-1);
} else {
    System::PrintInt(0);
}

while

A while loop will continue as long as the condition is true. There is no do/while.

int i = 0;
while (i < 5) {
    System::PrintInt(i);
    i++;
}

for

A for loop has an initializer, condition, and update expression. The loop will continue as long as the condition is true.

for (initializer, condition, update) { ... }

for (int i = 0; i < 10; i++) {
    System::PrintInt(i);
}

All three clauses are optional. Any of them may be left empty, and for (;;) is an infinite loop.

int i = 0;
for (; i < 10;) {        // no initializer, no post-expression
    System::PrintInt(i);
    i++;
}

for (;;) {               // infinite loop; exit with break
    if (done()) {
        break;
    }
}

break & continue

• continue will skip the rest of the loop body and continue to the next loop iteration.
• break exits the loop immediately.

break and continue work in while and for loops.

for(int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    if (i % 2 == 0) {
        continue;
    }
    // do work...
}

switch

The controlling expression is an integer (float is rejected). case labels are integer literals and must be unique. default is optional. A case without a break falls through to the next case, as in C.

switch (code) {
    case 1:
        System::PrintLine("one");
        break;
    case 2:
        System::PrintLine("two");
        break;
    default:
        System::PrintLine("other");
        break;
}

A case with no body falls straight into the next one, which is how several values share a single handler:

switch (key) {
    case 1:
    case 2:
    case 3:
        System::PrintLine("low");      // runs for key 1, 2, or 3
        break;
    case 4:
        System::PrintLine("four");
        break;
}

A case that has a body but no break runs its own body and then continues into the next case:

switch (n) {
    case 1:
        System::PrintInt(1);           // no break: falls through
    case 2:
        System::PrintInt(2);
        break;
    case 3:
        System::PrintInt(3);
        break;
}
// n == 1 prints 1 then 2
// n == 2 prints 2
// n == 3 prints 3

A switch statement has to produce a jump table entry for every value between its lowest and highest case label value. This means that for large value ranges with a low number of case labels, the compiled output will be huge compared to if/else. The number of case labels has no effect on performance. The compiler will output a warning if the number of case labels is less than half the value range.

// Very fast, small/tight binary.
// Generates ~4 jump table entries
switch(input) {
    case 1: //...
    case 2: //...
    case 3: //...
    case 4: //...
}

// Very fast, very bloated binary.
// Generates ~300 jump table entries. Compiler warning.
switch(input) {
    case 100: //...
    case 200: //...
    case 300: //...
    case 400: //...
}

// Slower (must evaluate every condition until a match is found), minimal binary size.
if (input == 100) {
    //...
} else if (input == 200) {
    //...
} else if (input == 300) {
    //...
} else if (input == 400) {
    //...
}

9. Functions

int add(int a, int b) {
    return a + b;
}

void greet() {
    System::PrintLine("hi");
}

System::PrintInt(add(3, 4));   // 7
greet();

• Scalar parameters are passed by value.
• A non-void function must return a value.
• Calling with the wrong number of arguments is a compile error.
• Recursion is supported.
• A bare return; in top-level code ends the script early. Destructors still run for every class instance declared before it. Returning a value from top-level code is a compile error.

Forward References

A top-level function or class may be used before it is declared in the file. This allows mutual recursion:

bool isEven(int n) {
    if (n == 0) { return true; }
    return isOdd(n - 1);
}

bool isOdd(int n) {
    if (n == 0) { return false; }
    return isEven(n - 1);
}

System::PrintInt(isEven(10));  // 1

Array Parameters

An array parameter is written T name[] or T *name (equivalent). The array’s size is not part of the parameter type, so pass the length as a separate argument. A variable index used inside the function is still checked at runtime against the caller’s actual array, the same as any other array (see “Bounds checking” in the Arrays section).

int sum(int values[], int count) {
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return total;
}

int data[4] = {1, 2, 3, 4};
System::PrintInt(sum(data, 4));    // 10

Passing a non-array where an array parameter is expected, or an array of the wrong element type, is a compile error. So is giving the parameter a size (int values[4]).

Inside the function the parameter is used exactly like an array: index it, or pass it on by name to another array parameter, script or native. It cannot be used as a value on its own.

void send(byte data[], int length) {
    System::SendCanMessage(0, 0x100, data, length);
}

Declare an array parameter const when the function only reads it. A const parameter can’t be written inside the function, and it accepts both const and ordinary arrays. A const array can only be passed to a const parameter, since an ordinary parameter could write to it. The same applies when a function passes its own const parameter on.

int total(const byte values[], int count) {
    int sum = 0;
    for (int i = 0; i < count; i++) {
        sum += values[i];
    }
    return sum;
}

const byte TABLE[3] = {1, 2, 3};
byte buffer[3] = {4, 5, 6};
total(TABLE, 3);    // fine
total(buffer, 3);   // fine

Class parameters

See Classes.

10. Arrays

int arr[5] = {10, 20, 30, 40, 50};
int zero[8];                 // all elements 0

• Array size is fixed at compile time.
• If an initializer list is present, its length must match the declared size exactly. int a[3] = {1, 2}; is a compile error.
• Without an initializer, every element is zero.

Indexing and assignment

System::PrintInt(arr[0]);      // 10
arr[2] = 99;
arr[2] += 1;         // 100

Packed storage

char/byte arrays pack 4 elements per 4-byte slot; short/ushort arrays pack 2 per slot. This is transparent to the script; index them normally.

byte buf[16];        // 4 slots
buf[0] = 1;
buf[15] = 200;

Bounds checking

A literal out-of-range index is a compile error, including a negative one:

byte b[8];
b[8] = 1;             // compile error: index 8 is out of bounds for 'b' (size 8)
b[-1] = 1;            // compile error

A variable or computed index is checked at runtime instead. An out-of-range access halts the VM with an “Array Index Out Of Bounds” error rather than reading or writing whatever happens to sit next to the array:

byte b[8];
int i = 8;
b[i] = 1;             // halts: Array Index Out Of Bounds

This covers array parameters too: a function indexing a T name[] parameter with a variable index is checked against the size of whatever array the caller actually passed in, even through several levels of forwarding. It also covers an array field declared inside a class, however it’s reached: directly, through a class-typed parameter, or through a composed/embedded instance. It does not cover what a native function does with an array you pass it. See Native functions.

Bare array references

An array name used without an index has no value. It cannot be assigned to a scalar, returned as a scalar, or passed as a scalar argument. Pass it only to an array parameter (with a length) or index it.

int arr[3] = {10, 20, 30};
int x = arr;         // compile error

11. Strings

String literals are immutable compile-time constants. Use them directly with the print natives:

System::Print("no newline");
System::PrintLine("with newline");

For text you need to build or modify at runtime, use a byte buffer and the string natives. Every string native takes an explicit capacity, C snprintf-style. Nothing grows a buffer for you.

byte msg[32];
System::StrCopy(msg, 32, "Value: ");
byte num[16];
System::IntToStr(num, 16, 42);
// (append num's characters via StrAppend from a string constant only;
//  buffer-to-buffer append is not supported)
System::StrAppend(msg, 32, "42");
System::PrintBuffer(msg, 32);        // Value: 42
System::PrintInt(System::StrLength(msg, 32));  // 8

Notes and limits:

• StrCopy / StrAppend take a string constant as the source, not another byte[] buffer.
• A freshly declared buffer is zero-filled, so StrLength on an untouched buffer is 0.
• Content that does not fit the capacity is truncated and null-terminated.

12. Classes

Classes are supported for advanced data structures.

class Point {
    int x;
    int y;

    Point(int px, int py) {
        this.x = px;
        this.y = py;
    }

    int sum() {
        return this.x + this.y;
    }

    void shift(int dx, int dy) {
        x += dx;         // 'this.' is optional inside a method
        y += dy;
    }
}

Point p(1, 2);
System::PrintInt(p.sum());         // 3
p.shift(10, 10);
System::PrintInt(p.sum());         // 23

Fields

Declared in the class body. Each instance gets its own copy.

Methods

• Inside a method, this.field and a bare field name both refer to the current instance’s field.
• A method can call a sibling method on the same instance with this.method().

class Calculator {
    int total;

    Calculator(int start) { this.total = start; }

    void addFive() { this.total += 5; }

    void addTen() {
        this.addFive();
        this.addFive();
    }

    int get() { return this.total; }
}

Constructors

ClassName(params) { ... }. A class has at most one constructor. It runs when an instance is declared with an argument list:

Counter c(10);       // runs Counter(int)

Fields are always zero-initialized first, before the constructor body runs. A class with no constructor is declared without parentheses:

Counter d;           // no constructor; fields are 0

Declaring an instance of a class that has a constructor without an argument list compiles, but produces a warning.

Destructors

~ClassName() { ... }. Runs automatically when the instance goes out of scope:

• A local instance is destroyed at the end of its enclosing block.
• Multiple instances in the same scope are destroyed in reverse declaration order (LIFO).
• Global instances are destroyed once, at script end, in reverse declaration order.

class Noisy {
    int id;
    Noisy(int i) { this.id = i; }
    ~Noisy() { System::PrintInt(this.id); }
}

void test() {
    Noisy n(42);
    System::PrintInt(1);
}

test();              // prints 1 then 42
System::PrintInt(2);

Passing instances

Pass an instance to a function or method by reference with ClassName *param. The callee can call methods on it and read or write its fields, including compound assignment.

void bump(Counter *c) {
    c.increment();
}

Counter a(5);
bump(a);             // a.value is now 6

Passing an instance of the wrong class, or a non-instance, is a compile error. A bare instance name (no ., no method call, not passed to a class parameter) has no value and cannot be used as one.

Class-typed fields (composition)

A field may itself be a class instance. The embedded instance is laid out inline in its owner and reached with a chain of .:

class Inner {
    int value;
    void bump() { value += 100; }
}

class Outer {
    Inner inner;
    int count;

    void run() {
        this.inner.bump();      // method call on an embedded instance
        inner.bump();           // 'this.' is optional, same as any field
    }
}

Outer o;
o.inner.value = 900;           // read / write an embedded field
o.count = 4;
o.run();
System::PrintInt(o.inner.value);         // 1100

• Nesting is unlimited: a.b.c.x resolves as long as each step names a class-typed field.
• Compound assignment works through the chain: o.inner.value += 50;.
• An embedded instance can be passed by reference like any other instance: take(o.inner); where take takes Inner *i.
• When an instance is created, each embedded field is zero-initialized and its field-default initializers run, outermost first.
• Destructors run automatically and in order: the owner’s destructor body first, then each embedded field’s destructor in reverse declaration order.

Limits:

• No member-initializer syntax. You cannot pass constructor arguments to an embedded field. Embedding a class whose constructor takes arguments is a compile error. A class with no constructor (or a parameterless one) is fine.
• No cycles. A class cannot contain itself, directly or indirectly (class A { A a; }, or A holding a B that holds an A). This is a compile error.

Not supported

• Inheritance. Every class is standalone. There is no subclassing.
• Class-typed return values. A function cannot return a class instance.

13. Namespaces

Namespaces are optional. They group top-level declarations under a name so they can be kept tidy and referred to explicitly. They have no runtime cost or effect: a namespaced global is still a plain global, and a namespaced function is still an ordinary function.

namespace Geometry {
    int gridSize = 16;

    int area(int w, int h) {
        return w * h;
    }

    class Point {
        int x;
        int y;
        int sum() { return x + y; }
    }
}

Refer to a member from outside with the :: scope operator:

Geometry::gridSize = 32;
System::PrintInt(Geometry::area(3, 4));   // 12

Geometry::Point p;
p.x = 1;
p.y = 2;
System::PrintInt(p.sum());                 // 3

• Unqualified access inside the block. Within namespace Geometry { }, other members are visible without the prefix (area() can call gridSize and Point directly). Names that don’t resolve inside the namespace fall back to the global scope.
• Reopening. The same namespace name may be opened more than once, and the contents are merged.
• Forward references work across the whole file, exactly as they do at the top level.
• No nesting. A namespace cannot be declared inside another namespace.
• Native namespaces are reserved. A script cannot declare a namespace that the host’s natives use, and System is always off limits. See Native functions.
• Math is reserved for the built-in math functions. See Math functions.

14. Preprocessor

Runs on the token stream before parsing. Two directives are supported.

#include

#include "utils.emc"

• Path is resolved relative to the including file first. If it is not found there, any include directories set up by the host are searched in order. Absolute paths are used as is.
• Each file is included at most once, so diamond includes are safe.
• A circular include is a compile error, not a hang.
• A missing file is a compile error.
• Errors inside an included file are reported against that file’s own line numbers.

#define

Object-like macros only.

#define WIDTH  10
#define HEIGHT 5
#define AREA   (WIDTH * HEIGHT)

System::PrintInt(AREA);        // 50

• A name is a macro only from its #define onward.
• A macro body may reference an earlier macro, which is re-scanned and expanded.
• Self-referential and mutually-referential macros expand once and stop.
• An empty replacement is allowed and vanishes at the use site.
• Function-like macros (#define SQ(x) ((x)*(x))) are a compile error.
• There are no conditional directives (#ifdef, #if, #endif, #undef).
• A macro defined in an including file is visible inside included files.

15. Native functions

Native functions are provided by the host application. They give a script access to the device it runs on, for example printing, timing and communications. Which natives are available depends on the host. The reference set below is a common starting point.

Calling natives

Every native must be called through its namespace:

System::Yield(10);
System::PrintInt(count);
CAN::Send(0x100, frame, 8);

A bare Yield(10) is a compile error.

Most natives are in System. A host can group others under namespaces of its own, such as CAN above.

• A namespace used by any native is reserved, so a script cannot declare one with the same name. System is always reserved.
• Only the namespace is reserved, not the names inside it. With CAN::Read available, a script is still free to declare its own Read variable or function, or a Data::Read of its own.

If the script calls a native the host doesn’t provide, it still compiles, but halts with a “Native Function Not Resolved” error when the call runs.

Array arguments

Pass an array to a native by bare name, followed by its length:

byte msg[32];
System::StrCopy(msg, 32, "hello");

The native trusts the length you give it. Its access to the array is not bounds checked, so never pass a length larger than the array.

A native that only reads an array takes it as a const parameter, and accepts both const and ordinary arrays. Passing a const array to a native that isn’t marked const is a compile error.

Callback parameters

Some natives take a script function as an argument, so the host can call back into the script later, for example when a CAN frame arrives. Pass the function’s bare name, with no parentheses:

void onFrame(uint id, byte data[], int length) {
    // data[0] .. data[length - 1] is the frame payload
}

CAN::Subscribe(0, 0x100, 0x7FF, onFrame);

A callback always returns void, and its parameters must match what the native expects. The compiler checks the parameter count, each parameter’s type, and whether it is an array, and reports a mismatch at the call site. Some natives accept any void function. A wrong parameter count is then only caught when the host calls it, which halts the script with a “Call Arg Count Error”.

An array parameter in a callback is only valid for the duration of the call. Index it or pass it on to another array parameter as usual, and copy anything you want to keep into a script array before returning.

Reference set

These natives are all in the System namespace, so Print is called as System::Print("hi").

SetError

SetError(int) records an error code without halting the VM. The host application can read it after the script finishes. The last call wins. The default is 0.

if (sensorReading < 0) {
    System::SetError(42);
}

16. Math functions

A set of math functions is built into the language under the Math namespace. They are part of the VM itself, so they are always available, whatever natives the host provides.

float hypot(float a, float b) {
    return Math::Sqrt(a * a + b * b);
}

int clamp(int v, int lo, int hi) {
    return Math::Min(Math::Max(v, lo), hi);
}

All functions take and return float. An int argument is converted to float first, the same as passing it to a float parameter.

Abs, Min and Max are the exception: when every argument is an integer type they work in integers and return int, so int m = Math::Max(3, 7); is exact with no float round trip. If any argument is a float, including a mixed expression like i + 0.5, the whole call is done in float.

A domain error such as Math::Sqrt(-1.0) or Math::Log(0.0) produces NaN or infinity, as in C. It does not halt the VM.

17. Runtime Model and Limits

• No heap. Globals, locals, and call frames all live in one buffer supplied by the host. The VM never allocates at runtime.
• No whole-script size ceiling. Function entry points are 32-bit offsets, so a compiled binary can be as large as the host is willing to load. Two 16-bit limits do apply: a single if, else, loop body, or switch cannot span more than 64 KB of bytecode (the compiler reports “Too much code to jump over”), and the VM’s data area (globals plus stack) is capped at 65,535 slots, which is 256 KB.
• Fixed stack. The host sets the stack size. Deep recursion or large local arrays can exhaust it (“Stack Overflow”).
• Bounds checking. Stack overflow/underflow and out-of-range pointer dereferences are caught and halt the VM rather than corrupting memory. The host can disable this for targets that cannot afford the checks. A local, global, or array-parameter index that runs off the end of its array is also caught (“Array Index Out Of Bounds”). See “Bounds checking” under Arrays.
• Division by zero halts the VM (“Division By Zero”) for integer and float operands.
• No overflow detection. Arithmetic wraps silently.
• No exceptions. There is no try/catch/throw. A genuine runtime error halts the VM. Use SetError for recoverable conditions.
• No string escape sequences.
• Language version. A compiled binary records the language version it was built for. A VM won’t load a binary from a newer version, for example a 0.3 script on a 0.2 VM, since it may use instructions that VM doesn’t have. Binaries from older versions still load. Recompile a script with the matching compiler, or update the VM.

Runtime errors

Every run ends with a status. “End” means the script finished normally. Anything else is an error that stopped it. The common ones are:

A binary can also be refused when it’s loaded, before any of it runs: “Unsupported Version” for a binary compiled for a newer language version, and “Invalid Script” for one that is malformed or fails its checksum.

18. Complete Example

#define TABLE_SIZE 8

int primes[TABLE_SIZE];
int primeCount = 0;

bool isPrime(int n) {
    if (n < 2) {
        return false;
    }
    for (int d = 2; d * d <= n; d++) {
        if (n % d == 0) {
            return false;
        }
    }
    return true;
}

void collectPrimes() {
    int candidate = 2;
    while (primeCount < TABLE_SIZE) {
        if (isPrime(candidate)) {
            primes[primeCount] = candidate;
            primeCount++;
        }
        candidate++;
    }
}

class Accumulator {
    int total;

    void add(int v) {
        this.total += v;
    }

    int get() {
        return this.total;
    }
}

collectPrimes();

Accumulator acc;
for (int i = 0; i < primeCount; i++) {
    System::PrintInt(primes[i]);
    acc.add(primes[i]);
}

System::PrintLine("sum:");
System::PrintInt(acc.get());

Output:

2
3
5
7
11
13
17
19
sum:
77