tests.txt

@ Minimal working program
void reset()
{
    STOP = 0;
}

@ Output
@out 1 2 3
void reset()
{
    OUT = 1;
    OUT = 2;
    OUT = 3;
    STOP = 0;
}

@ Integer parsing
@out 0
void reset()
{
    OUT = 0;
    STOP = 0;
}

@error
void reset()
{
    OUT = 0x;
    STOP = 0;
}

@error
void reset()
{
    OUT = 0x0x0x33;
    STOP = 0;
}

@out 0
void reset()
{
    OUT = 0x00000000;
    STOP = 0;
}

@out 0
void reset()
{
    OUT = $00;
    STOP = 0;
}

@out 1
void reset()
{
    OUT = 1;
    STOP = 0;
}

@out 2
void reset()
{
    OUT = 0x02;
    STOP = 0;
}

@out 3
void reset()
{
    OUT = $3;
    STOP = 0;
}

@out 20
void reset()
{
    OUT = 20;
    STOP = 0;
}

@out 32
void reset()
{
    OUT = 0x20;
    STOP = 0;
}

@out 42
void reset()
{
    OUT = 42;
    STOP = 0;
}

@out 43
void reset()
{
    OUT = 0x2B;
    STOP = 0;
}

@out 255
void reset()
{
    OUT = 255;
    STOP = 0;
}

@out 255
void reset()
{
    OUT = 0xFF;
    STOP = 0;
}

@out 255
void reset()
{
    OUT = $FF;
    STOP = 0;
}

@out 65535
void reset()
{
    OUT = 65535;
    STOP = 0;
}

@out 65535
void reset()
{
    OUT = $FFFF;
    STOP = 0;
}

@ Binary operators
@out 0x5100 0x1125
void reset()
{
    OUT = 0x20FF + 0x3001;
    OUT = 0x1234 - 0x010F;
    STOP = 0;
}

@ Parentheses
@out 1 9
void reset()
{
    OUTB = 10 - 5 - 4;
    OUTB = 10 - (5 - 4);
    STOP = 0;
}

@ Nested assignment
@out 0x1234 0x1234 0x1234
void reset()
{
    OUT = (OUT = (OUT = 0x1234));
    STOP = 0;
}

@ Locals
@out 0x1122
void reset()
{
    uint16_t a = 0x1122;
    OUT = a;
    STOP = 0;
}

@ Locals
@out 0x3344 0x1122 0x3344
void reset()
{
    uint16_t b;
    uint16_t a = 0x1122;
    b = 0x3344;
    OUT = b;
    OUT = a;
    OUT = b;
    STOP = 0;
}

@ scope of local names
@out 20 10

void reset()
{
    OUTB = f(0);
    OUTB = f(1);
    STOP = 0;
}

u8 f(u8 x)
{
    // This one gets shadowed:
    u8 tmp = 99;

    if (x)
    {
        u8 tmp = 10;
        return tmp;
    }
    else
    {
        // Same name, different scope.
        u8 tmp = 20;
        return tmp;
    }
}

@ If statement
@out 1 2 4
void reset()
{
    uint16_t a;
    a = 4;
    if (a) OUT = 1;
    a = 0x1200;
    if (a) OUT = 2;
    a = 0;
    if (a) OUT = 3;
    a = 6;
    if (a) OUT = 4;
    STOP = 0;
}

@ Short type names
@out 5 0x607 8
void reset()
{
    u8 a = 0x05;
    u16 b = 0x0607;
    u8 c = 0x08;
    OUTB = a;
    OUTB = c;
    OUT = b;
    STOP = 0;
}

@ If statement
@out 1 1 9 2
void reset()
{
    uint16_t a = 1;
    uint16_t b = 0;
    uint16_t c = 1;

    uint16_t x = 0;
    if (a) x = x + 1;
    OUT = x;
    if (b) { x = x + 1; }
    OUT = x;
    if (c)
    {
        OUT = 9;
        x = x + 1;
    }
    OUT = x;
    STOP = 0;
}

@ If / else statements
@out 1 2 0xFFFF 4 0xBBBB 0xFFFF 7 8 0xFFFF 0xBBBB 11 0xFFFF 13 14 0xFFBB 16 17 0xFFFF 19 0xBBBB
void test(uint16_t i)
{
    if (i % 3 == 0)
    {
        if (i % 5 == 0) OUT = 0xFFBB;
        else OUT = 0xFFFF;
    }
    else if (i % 5 == 0) OUT = 0xBBBB;
    else
    {
        OUT = i;
    }
}
void reset()
{
    for (uint16_t i = 1; i <= 20; i++) test(i);
    STOP = 0;
}

@ Invalid else statement
@error
void reset()
{
    uint8_t i = 5;
    if (i == 0) OUTB = 0;
    else if (i == 1) OUTB = 1;
    else if (i == 2) OUTB = 2;
    else OUTB = 3;
    else OUTB = 4;
    STOP = 0;
}

@ Single line comments
@out 1 4 5
void reset()
{
    OUT = 1;
    //OUT = 2;
//    OUT = 3;
    OUT = 4;
    //
    OUT = 5;
    STOP = 0;
}

@ Functions
@out 1 2 1 3 1 4
void f(uint16_t x)
{
    OUT = 1;
    OUT = x;
}

void reset()
{
    f(2);
    f(3);
    f(4);
    STOP = 0;
}

@ Function arguments
@out 1 7 2 8 3 9

void f(uint16_t red, uint16_t blue)
{
    OUT = blue;
    OUT = red;
}

void reset()
{
    f(7, 1);
    f(8, 2);
    f(9, 3);
    STOP = 0;
}

@ Function argument count
@error

void g(u8 a, u8 b)
{
    OUTB = a + b;
}

void reset()
{
    STOP = g(2);
}

@ Function return values
@out 3 5 7

uint16_t f(uint16_t arg)
{
    arg = arg + arg;
    return arg + 1;
}

void reset()
{
    OUT = f(1);
    OUT = f(2);
    OUT = f(3);
    STOP = 0;
}

@ Function return type checking
@error

void act()
{
    OUTB = 33;
}

void reset()
{
    // This is a type error:
    STOP = act();
}

@ Forward reference of functions
@out 5

void reset()
{
    OUTB = f(3);
    STOP = 0;
}

u8 f(u8 arg)
{
    return arg + 2;
}

@ Forward reference to missing function.
@error

void reset()
{
    OUTB = h(3);
    STOP = 0;
}

// 'h' is not defined.

@ Forward reference of structs (global)
@out 30

struct Point p;

void reset()
{
    p.x = 10;
    p.y = 20;
    OUTB = p.x + p.y;
    STOP = 0;
}

struct Point
{
    u8 x, y;
};

@ Forward reference of structs (local)
@out 30

void reset()
{
    struct Point p;
    p.x = 10;
    p.y = 20;
    OUTB = p.x + p.y;
    STOP = 0;
}

struct Point
{
    u8 x, y;
};

@ Forward reference of variables
@out 50

void reset()
{
    width = 100;
    height = 150;
    OUTB = height - width;
    STOP = 0;
}

u8 width;
u8 height;

@ Multiple functions
@out 3 4 7

uint16_t f(uint16_t arg)
{
    return arg + arg + 1;
}

uint16_t g(uint16_t arg)
{
    return arg + arg;
}

void reset()
{
    OUT = f(1);
    OUT = g(2);
    OUT = f(3);
    STOP = 0;
}

@ Entry points
@out 0x9988

void nmi()
{
    OUT = 0x7766;
    STOP = 0;
}

void reset()
{
    OUT = 0x9988;
    STOP = 0;
}

void brk()
{
    OUT = 0x2211;
    STOP = 0;
}

@ Preprocessor support
@out 0x4433
#pragma pack(push, 8)
#define RESPONSE 0x7788

void reset()
{
    OUT = 0x4433;
    STOP = 0;
}

@ "static"
@out

// The "static" keyword is ignored.
static uint8_t f()
{
    return 42;
}

void reset()
{
    STOP = 0;
}

@ uint8_t
@out 0x0022 0x4433

void reset()
{
    uint8_t small = 0x22;
    uint16_t large = 0x4433;
    OUTB = small;
    OUT = large;
    STOP = 0;
}

@ Choosing types of literals
@out 0x92 0x7456

static uint8_t small;
static uint16_t large;

void reset()
{
    small = 0x12;
    large = 0x3456;
    small = small + 0x80;
    large = large + 0x4000;
    OUTB = small;
    OUT = large;
    STOP = 0;
}

@ Typechecking pointers
@out 0x1122

void reset()
{
    uint16_t number = 0x1122;
    OUT = number;
    STOP = 0;
}

@ Typechecking pointers
@out
@error

void reset()
{
    uint16_t *ptr = 0x3344;
    OUT = ptr;
    STOP = 0;
}

@ Typecheck return statement
@out
@error

// Cannot return value from void function.
void v()
{
    return 56;
}

void reset()
{
    v();
    STOP = 0;
}

@out
@error

// Cannot return without value.
u8 f()
{
    return;
}

void reset()
{
    OUTB = f();
    STOP = 0;
}

@ Assigning to constant
@out
@error

void reset()
{
    uint16_t *ptr = 0x3344;
    OUT = ptr;
    STOP = 0;
}

@ Global variables
@out
@error

static uint8_t small = 2;

void reset()
{
    STOP = 0;
}

@ Global variables
@out 0x24 0x68AC

static uint8_t small;
static uint16_t large;

void reset()
{
    small = 0x12;
    large = 0x3456;
    small = small + small;
    large = large + large;
    OUTB = small;
    OUT = large;
    STOP = 0;
}

@ for loops
@out 5 4 3 2 1

void reset()
{
    for (uint8_t i = 5; i; i = i - 1)
    {
        OUTB = i;
    }
    STOP = 0;
}

@out 16
void reset()
{
    uint8_t n = 10;
    for (uint8_t i = 6; i; 0)
    {
        i = i - 1;
        if (i > 3) continue;
        n = n + i;
    }
    OUTB = n;
    STOP = 0;
}

@out 22
void reset()
{
    uint8_t n = 10;
    for (uint8_t i = 5; i; i = i - 1)
    {
        n = n + i;
        if (i < 4) break;
    }
    OUTB = n;
    STOP = 0;
}

@out 10 11 20 21
void reset()
{
    for (uint8_t i = 10; i < 12; i++)
    {
        OUTB = i;
    }

    for (uint8_t j = 20; j < 22; j++)
    {
        OUTB = j;
    }

    STOP = 0;
}

@ while loops
@out 5 4 3 2 1
void reset()
{
    uint8_t i = 5;
    while (i)
    {
        OUTB = i;
        i = i - 1;
    }
    STOP = 0;
}

@out 16
void reset()
{
    uint8_t n = 10;
    uint8_t i = 6;
    while (i)
    {
        i = i - 1;
        if (i > 3) continue;
        n = n + i;
    }
    OUTB = n;
    STOP = 0;
}

@out 22
void reset()
{
    uint8_t n = 10;
    uint8_t i = 5;
    while (i)
    {
        n = n + i;
        if (i < 4) break;
        i = i - 1;
    }
    OUTB = n;
    STOP = 0;
}

@ structs (u16)
@out 500 530

struct Triple { uint16_t x, y, z; };
struct Pair { uint16_t x; uint16_t y; };

void reset()
{
    struct Pair p;
    p.x = 500;
    OUT = p.x;
    p.y = p.x + 30;
    OUT = p.y;
    STOP = 0;
}

@ structs (u8)
@out 40 42

struct Triple { uint8_t x, y, z; };
struct Pair { uint8_t x; uint8_t y; };

void reset()
{
    struct Pair p;
    p.x = 40;
    OUTB = p.x;
    p.y = p.x + 2;
    OUTB = p.y;
    STOP = 0;
}

@ structs
@out 135

struct Pair { uint8_t a, b; };

uint8_t hadd(struct Pair *p)
{
    return p->a + p->b;
}

void reset()
{
    struct Pair p;
    p.a = 90;
    p.b = 45;
    OUTB = hadd(&p);
    STOP = 0;
}

@ structs as globals
@out 45

struct Range { uint8_t a, z; };
struct Range r;

void reset()
{
    r.a = 15;
    r.z = 60;
    OUTB = r.z - r.a;
    STOP = 0;
}

@ unions
@out 0x1234 0x34 0x12 0x5634

struct HighLow
{
    u8 Low, High;
};

union Parts
{
    u16 Word;
    struct HighLow Bytes;
};

void reset()
{
    union Parts p;
    p.Word = 0x1234;
    OUT = p.Word;
    OUTB = p.Bytes.Low;
    OUTB = p.Bytes.High;
    p.Bytes.High = 0x56;
    OUT = p.Word;
    STOP = 0;
}

@ arrays
@out 42

uint8_t factors[6];

void reset()
{
    factors[5] = 42;
    OUTB = factors[5];
    STOP = 0;
}

@ arrays
@out 342

void reset()
{
    uint16_t factors[9];
    factors[8] = 342;
    OUT = factors[8];
    STOP = 0;
}

@ arrays
@error

void reset()
{
    u8 data[4];
    u8 *p = &data[2];
    data = p;
    STOP = 0;
}

@ arrays in structs
@out 0x1234 0x34 0x12 0x7834

union Parts
{
    u16 Word;
    u8 Bytes[2];
};

void reset()
{
    union Parts p;
    p.Word = 0x1234;
    OUT = p.Word;
    OUTB = p.Bytes[0];
    OUTB = p.Bytes[1];
    p.Bytes[1] = 0x78;
    OUT = p.Word;
    STOP = 0;
}

@ comparison: equal
@out 0
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a == b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a == b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a == b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 255;
    uint8_t b = 0;
    OUTB = a == b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a == b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x4000;
    uint16_t b = 0x4001;
    OUTB = a == b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x40FF;
    uint16_t b = 0x41FF;
    OUTB = a == b;
    STOP = 0;
}

@ comparison: not equal
@out 1
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a != b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a != b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a != b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 255;
    uint8_t b = 0;
    OUTB = a != b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a != b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x4000;
    uint16_t b = 0x4001;
    OUTB = a != b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x40FF;
    uint16_t b = 0x41FF;
    OUTB = a != b;
    STOP = 0;
}

@ comparison: less than
@out 1
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 255;
    uint8_t b = 0;
    OUTB = a < b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1233;
    uint16_t b = 0x1234;
    OUTB = a < b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1135;
    uint16_t b = 0x1234;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1235;
    uint16_t b = 0x1234;
    OUTB = a < b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1333;
    uint16_t b = 0x1234;
    OUTB = a < b;
    STOP = 0;
}

@ comparison: greater than
@out 0
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a > b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a > b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a > b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 0;
    uint8_t b = 255;
    OUTB = a > b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1233;
    uint16_t b = 0x1234;
    OUTB = a > b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1135;
    uint16_t b = 0x1234;
    OUTB = a > b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a > b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1235;
    uint16_t b = 0x1234;
    OUTB = a > b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1333;
    uint16_t b = 0x1234;
    OUTB = a > b;
    STOP = 0;
}

@ comparison: less than or equal
@out 1
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a <= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a <= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a <= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 255;
    uint8_t b = 0;
    OUTB = a <= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1233;
    uint16_t b = 0x1234;
    OUTB = a <= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1135;
    uint16_t b = 0x1234;
    OUTB = a <= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a <= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1235;
    uint16_t b = 0x1234;
    OUTB = a <= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1333;
    uint16_t b = 0x1234;
    OUTB = a <= b;
    STOP = 0;
}

@ comparison: greater than or equal
@out 0
void reset()
{
    uint8_t a = 4;
    uint8_t b = 5;
    OUTB = a >= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 5;
    uint8_t b = 5;
    OUTB = a >= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint8_t a = 6;
    uint8_t b = 5;
    OUTB = a >= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint8_t a = 0;
    uint8_t b = 255;
    OUTB = a >= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1233;
    uint16_t b = 0x1234;
    OUTB = a >= b;
    STOP = 0;
}

@out 0
void reset()
{
    uint16_t a = 0x1135;
    uint16_t b = 0x1234;
    OUTB = a >= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1234;
    uint16_t b = 0x1234;
    OUTB = a >= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1235;
    uint16_t b = 0x1234;
    OUTB = a >= b;
    STOP = 0;
}

@out 1
void reset()
{
    uint16_t a = 0x1333;
    uint16_t b = 0x1234;
    OUTB = a >= b;
    STOP = 0;
}

@ bitwise operators
@out 0xA0
void reset()
{
    uint8_t a = 0xAB;
    uint8_t b = 0xF0;
    OUTB = a & b;
    STOP = 0;
}

@out 0xA0C0
void reset()
{
    uint16_t a = 0xABCD;
    uint16_t b = 0xF0F0;
    OUT = a & b;
    STOP = 0;
}

@out 0xAB
void reset()
{
    uint8_t a = 0xA0;
    uint8_t b = 0x0B;
    OUTB = a | b;
    STOP = 0;
}

@out 0xABCD
void reset()
{
    uint16_t a = 0xA0C0;
    uint16_t b = 0x0B0D;
    OUT = a | b;
    STOP = 0;
}

@out 0x5A
void reset()
{
    uint8_t a = 0xA5;
    uint8_t b = 0xFF;
    OUTB = a ^ b;
    STOP = 0;
}

@out 0xAA55
void reset()
{
    uint16_t a = 0xA5A5;
    uint16_t b = 0x0FF0;
    OUT = a ^ b;
    STOP = 0;
}

@out 0x3C
void reset()
{
    uint8_t a = 0xC3;
    OUTB = ~a;
    STOP = 0;
}

@out 0x3C5A
void reset()
{
    uint16_t a = 0xC3A5;
    OUT = ~a;
    STOP = 0;
}

@ Associativity
@out 8 4
void reset()
{
    OUTB = 9 - 3 + 2;
    OUTB = 9 - (3 + 2);
    STOP = 0;
}

@ arithmetic
@out 23 17 60 6 2
void reset()
{
    uint8_t n = 20;
    OUTB = n + 3;
    OUTB = n - 3;
    OUTB = n * 3;
    OUTB = n / 3;
    OUTB = n % 3;
    STOP = 0;
}

@ arithmetic that overflows
@out 0x40 0xD5 0xA7
void reset()
{
    uint8_t n = 197;
    OUTB = n + 123;
    OUTB = n - 240;
    OUTB = n * 123;
    STOP = 0;
}

@ arithmetic
@out 403 397 1200 133 1 1 100
void reset()
{
    uint16_t n = 400;
    OUT = n + 3;
    OUT = n - 3;
    OUT = n * 3;
    OUT = n / 3;
    OUT = n % 3;
    OUT = n / 300;
    OUT = n % 300;
    STOP = 0;
}

@ arithmetic that overflows
@out 0x1963 0xAB6A 0x93DB
void reset()
{
    uint16_t n = 40273;
    OUT = n + 31762;
    OUT = n - 61927;
    OUT = n * 58219;
    STOP = 0;
}

@ increment / decrement
@out 42 43 43 43 44 43 43 43 42
void reset()
{
    uint8_t n = 42;
    OUTB = n;
    OUTB = ++n;
    OUTB = n;
    OUTB = n++;
    OUTB = n;
    OUTB = --n;
    OUTB = n;
    OUTB = n--;
    OUTB = n;
    STOP = 0;
}

@out 0xFF 0 0 0xFF 0xFF 0xFF 0 0 0xFF
void reset()
{
    uint8_t n = 0xFF;
    OUTB = n;
    OUTB = ++n;
    OUTB = n;
    OUTB = --n;
    OUTB = n;
    OUTB = n++;
    OUTB = n;
    OUTB = n--;
    OUTB = n;
    STOP = 0;
}

@ increment / decrement
@out 42732 42733 42733 42733 42734 42733 42733 42733 42732
void reset()
{
    uint16_t n = 42732;
    OUT = n;
    OUT = ++n;
    OUT = n;
    OUT = n++;
    OUT = n;
    OUT = --n;
    OUT = n;
    OUT = n--;
    OUT = n;
    STOP = 0;
}

@out 0xFFFF 0 0 0xFFFF 0xFFFF 0xFFFF 0 0 0xFFFF
void reset()
{
    uint16_t n = 0xFFFF;
    OUT = n;
    OUT = ++n;
    OUT = n;
    OUT = --n;
    OUT = n;
    OUT = n++;
    OUT = n;
    OUT = n--;
    OUT = n;
    STOP = 0;
}

@ simulator timeout
@error
void reset()
{
    for (uint8_t i = 0; 1; i = i + 1)
    {
    }
}

@ recursion detection
@error
void a() {}
void b() { a(); }
void c() { b(); e(); }
void d() { c(); }
void e() { d(); }
void reset()
{
    e();
    STOP = 0;
}

@ binary detection
@out 42 0x1234
void reset()
{
    OUTB = 0b00101010;
    OUT = 0b1001000110100;
    STOP = 0;
}

@ shift left
@out 88 0 11
void reset()
{
    uint8_t a = 11;
    uint8_t b = 3;
    OUTB = a << b;
    b = 15;
    OUTB = a << b;
    b = 0;
    OUTB = a << b;
    STOP = 0;
}

@out 88 45056 0 0 0x1234
void reset()
{
    uint16_t a = 11;
    uint16_t b = 3;
    OUT = a << b;
    b = 12;
    OUT = a << b;
    b = 40;
    OUT = a << b;
    b = 256;
    OUT = a << b;
    a = 0x1234;
    b = 0;
    OUT = a << b;
    STOP = 0;
}

@ shift right
@out 11 0 88
void reset()
{
    uint8_t a = 88;
    uint8_t b = 3;
    OUTB = a >> b;
    b = 15;
    OUTB = a >> b;
    b = 0;
    OUTB = a >> b;
    STOP = 0;
}

@out 11 11 0 0 0x1234
void reset()
{
    uint16_t a = 88;
    uint16_t b = 3;
    OUT = a >> b;
    a = 45056;
    b = 12;
    OUT = a >> b;
    b = 40;
    OUT = a >> b;
    b = 256;
    OUT = a >> b;
    a = 0x1234;
    b = 0;
    OUT = a >> b;
    STOP = 0;
}

@ Long branch instructions
@out 1 2 0xFFFF 4 0xBBBB 0xFFFF 7 8 0xFFFF 0xBBBB 11 0xFFFF 13 14 0xFFBB 16 17 0xFFFF 19 0xBBBB
void reset()
{
    for (uint16_t i = 1; i <= 20; i++)
    {
        if (i % 3 == 0)
        {
            if (i % 5 == 0) OUT = 0xFFBB;
            else OUT = 0xFFFF;
        }
        else if (i % 5 == 0) OUT = 0xBBBB;
        else
        {
            OUT = i;
        }
    }
    STOP = 0;
}

@out 0 2 2 2 0 0 0 5 5 5 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
void reset()
{
    for (uint8_t i = 1; i <= 20; i++)
    {
        if (i == 5)
        {
            OUTB = 5;
            OUTB = 5;
            OUTB = 5;
        }
        else if (i == 2)
        {
            OUTB = 2;
            OUTB = 2;
            OUTB = 2;
        }

        OUTB = 0;
    }
    STOP = 0;
}

@ Conditional expressions
@out 2 98 2

void reset()
{
    OUTB = test(0);
    OUTB = test(51);
    OUTB = test(50);
    STOP = 0;
}

u8 test(u8 x)
{
    return x > 50 ? 98 : 2;
}

@ Conditional expressions
@out 1 2 0xFFFF 4 0xBBBB 0xFFFF 7 8 0xFFFF 0xBBBB 11 0xFFFF 13 14 0xFFBB 16 17 0xFFFF 19 0xBBBB
void reset()
{
    for (uint16_t i = 1; i <= 20; i++)
    {
        OUT = i % 3 == 0 ? (i % 5 == 0 ? 0xFFBB : 0xFFFF) : (i % 5 == 0 ? 0xBBBB : i);
    }
    STOP = 0;
}

@ Logical operators

@out 21 31 40 41

// This is a basic test of short circuiting.
void f(uint8_t a, uint8_t b, uint8_t n)
{
    if (a && b) OUTB = n;
    if (a || b) OUTB = n + 1;
}

void reset()
{
    f(0, 0, 10);
    f(0, 1, 20);
    f(1, 0, 30);
    f(1, 1, 40);
    STOP = 0;
}

@out 0 1 1 0 0 0 0 1 0 1 1 1 1 0 222

// If a function call should not be made, due to short-circuiting,
// the caller passes TRUE as the "explode" parameter.

u8 yes(u8 explode)
{
    if (explode) OUT = 8;
    return 1;
}

u8 no(u8 explode)
{
    if (explode) OUT = 8;
    return 0;
}

void reset()
{
    OUTB = no(0);
    OUTB = !no(0);
    OUTB = yes(0);
    OUTB = !yes(0);

    OUTB = no(0) && no(1);
    OUTB = no(0) && yes(1);
    OUTB = yes(0) && no(0);
    OUTB = yes(0) && yes(0);

    OUTB = no(0) || no(0);
    OUTB = no(0) || yes(0);
    OUTB = yes(0) || no(1);
    OUTB = yes(0) || yes(1);

    // Test associativity:
    OUTB = yes(0) || no(1) || no(1);
    OUTB = no(0) && yes(1) && yes(1);

    OUT = 222;
    STOP = 0;
}

@ Assignment operators
@out 5 15 30 60 60
void reset()
{
    uint8_t a = 5;
    OUTB = a;
    a += 10;
    OUTB = a;
    a += a;
    OUTB = a;
    OUTB = a += a;
    OUTB = a;
    STOP = 0;
}

@out 500 1500 3000 6000 6000
void reset()
{
    uint16_t a = 500;
    OUT = a;
    a += 1000;
    OUT = a;
    a += a;
    OUT = a;
    OUT = a += a;
    OUT = a;
    STOP = 0;
}

@out 15 10 50 6 2 16 8 15 7 36
void reset()
{
    uint8_t a = 5;
    OUTB = a += 10;
    OUTB = a -= 5;
    OUTB = a *= 5;
    OUTB = a /= 8;
    OUTB = a %= 4;
    OUTB = a <<= 3;
    OUTB = a >>= 1;
    OUTB = a |= 7;
    OUTB = a &= 55;
    OUTB = a ^= 35;
    STOP = 0;
}

@out 1500 1000 5000 625 1 4096 1024 2000 960 466
void reset()
{
    uint16_t a = 500;
    OUT = a += 1000;
    OUT = a -= 500;
    OUT = a *= 5;
    OUT = a /= 8;
    OUT = a %= 4;
    OUT = a <<= 12;
    OUT = a >>= 2;
    OUT = a |= 2000;
    OUT = a &= 999;
    OUT = a ^= 530;
    STOP = 0;
}

@ Pointers
@out 3 3 7 7
void reset()
{
    uint8_t a = 3;
    uint8_t *b = &a;
    OUTB = a;
    OUTB = *b;
    *b = 7;
    OUTB = a;
    OUTB = *b;
    STOP = 0;
}

@out 3 3 3 7 3 5 7 5 1 0 5
void reset()
{
    uint8_t a = 3;
    uint8_t b = 7;
    uint8_t *c = &a;
    uint8_t *d = &b;
    uint8_t **e = &c;
    OUTB = a;
    OUTB = *c;
    OUTB = **e;
    e = &d;
    OUTB = **e;
    *e = &a;
    OUTB = **e;
    **e = 5;
    OUTB = a;
    OUTB = b;
    OUTB = **e;
    OUTB = (&**e == &a);
    OUTB = (&**e == &b);
    OUTB = *&*&*&**&*&*&*e;
    STOP = 0;
}

@ Inline assembly

@out 40
void reset()
{
    __asm
    {
        LDA #40
        STA OUTB
        STA STOP
    }
}

@out 50
// Assembly with variables.
uint8_t global;
void reset()
{
    global = 12;
    uint8_t local = 26;
    __asm
    {
        LDA global
        ASL
        CLC
        ADC local
        STA OUTB
        STA STOP
    }
}

@out 60
// Constants with assembly.
define uint8_t RESULT = 60;
void reset()
{
    __asm
    {
        LDA #RESULT
        STA OUTB
        STA STOP
    }
}

@out 70
// Constants
define uint8_t RESULT = 70;
void reset()
{
    OUTB = RESULT;
    STOP = 0;
}

@error
// Constant value is too large.
define u8 SMALL = 0x1234;
void reset()
{
    STOP = 0;
}

@out 0xAB 0xCD
// High/low bytes
void reset()
{
    __asm
    {
        LDA #>$AB34
        STA OUTB
        LDA #<$12CD
        STA OUTB
        STA STOP
    }
}

@ Memory specifiers

@out 111
u8 arr[4];
__zeropage u8 *ptr;
void reset()
{
    __asm
    {
        LDA #<arr
        STA ptr
        LDA #>arr
        STA ptr+1

        LDA #90
        LDY #1
        STA (ptr),Y
        LDA #111
        INY
        STA (ptr),Y
        LDA #200
        INY
        STA (ptr),Y

        LDY #2
        LDA (ptr),Y
        STA OUTB

        STA STOP
    }
}

@error
// You can't use zero-page address modes with non-zero-page operands.
__ram u8 arr[4];
void reset()
{
    __asm
    {
        LDY #2
        LDA (arr),Y
        STA STOP
    }
}

@out 25
// Array initializer syntax
__prg_rom u8 minimum_commas[] = { 10, 20, 30, 40 };
__prg_rom u8 extra_comma[] = { 5, 15, 25, 35, };
void reset()
{
    OUTB = extra_comma[2];
    STOP = 0;
}

@out 10 20 30 40 50 60
__prg_rom u8 data[] = { 10, 20, 30, 40, 50, 60, 0 };
void reset()
{
    for (__zeropage u8 *p = data; *p; ++p)
    {
        OUTB = *p;
    }
    STOP = 0;
}

@out 23
// Pass arrays as pointers.
__prg_rom u8 data[] = { 21, 22, 23, 24, 25 };

u8 third(u8 *p)
{
    return p[2];
}

void reset()
{
    OUTB = third(data);
    STOP = 0;
}

@out 42
__prg_rom u8 constants[] = { 21, 42 };
void reset()
{
    // Assigning to PRG-ROM has no effect:
    constants[1] = 88;
    OUTB = constants[1];
    STOP = 0;
}

@error
void reset()
{
    // Locals can't be put in PRG-ROM.
    __prg_rom u8 local[] = { 24, 48 };
    OUTB = local[1];
    STOP = 0;
}

@ Implicit integer conversions

@out 23

// Use u8 as an index.
u8 arr[5];

void reset()
{
    u8 i = 3;
    u16 j = 3;
    arr[3] = 2;
    arr[i] += 9;
    arr[j] += 12;
    OUT = arr[i];
    STOP = 0;
}

@out 10 13 15 19 34

// Arithmetic with mixed types.
void reset()
{
    u8 b = 7;
    u16 w = 3;
    OUT = b += w; // b == 10
    OUT = w += b; // w == 13
    OUT = b += 5; // b == 15
    OUT = w += 6; // w == 19
    OUT = b + w;
    STOP = 0;
}

@ strings
@out 66 97 76 0

void reset()
{
    char *s = "Basic Label";
    OUTB = *s;
    OUTB = s[1];
    OUTB = s[6];
    OUTB = s[11];
    STOP = 0;
}

@ goto
@out 23 99 25 99

void reset()
{
    OUTB = f(3);
    OUTB = f(14);
    skip:  // a decoy label
    OUTB = f(5);
    OUTB = f(16);
    STOP = 0;
}

u8 f(u8 x)
{
    if (x > 9) goto skip;
    return x + 20;
    skip:
    return 99;
}

@ comma operator
@out 24 15

void reset()
{
    u8 x = 10;
    u8 y = 20;
    OUTB = (x + 4, y + 4);
    OUTB = ((y, x) + 5);
    STOP = 0;
}