Syntax

Packed binary literal

A packed binary literal defines a word as a sequence of bits overlayed with named fields. Each field is a range of unset bits into which a value with the same name as the field will be packed. The name of each field can only be one character long.

A packed binary literal is a # character followed by one or more underscores, letters, or the characters 0 and 1. Each letter and 0 character represents an unset bit, and each 1 character represents a set bit. Underscores are ignored, and are only used for readability.

The following example is a packed binary literal with a three-bit field named b and a seven-bit field named f.

#01_01bb_bfff_ffff

Hexadecimal literal

A hexadecimal literal defines a fixed integer value.

A hexadecimal literal is a 0x character pair followed by one or more characters in the ranges 0-9, a-z, and A-Z.

0x0
0x1ffc
0x3FFFFFF

Decimal literal

A decimal literal defines a fixed integer value.

A decimal literal is a sequence of one or more characters in the range 0-9.

0
1009
100000000000

Pinned address

A pinned address defines the initial address of a segment of assembled bytecode.

When a pinned address is reached during assembly and the current bytecode address is less than the value of the pinned address, a number of zero words will be assembled until the current address is equal to the pinned address. An error will be displayed if the current bytecode address is greater than the pinned address.

A pinned address is a | character followed by either a decimal or hexadecimal literal.

|0
|256
|0x8000

Label definition

A label is a named address. An invocation of a label will resolve to the address of that label as an integer.

A main label definition is a @ character followed by a name. A sublabel definition is a & character followed by a name.

Outside of a macro definition, the full name of a sublabel is the name of the most recent non-sublabel label definition, followed by a / character, followed by the name of the sublabel.

Inside of a macro definition, non-sublabel label definitions cannot be used. Sublabels must be used instead, and cannot be referenced outside the macro definition.

@main
  &loop

@draw
  &loop

Macro definition

A macro definition is a template for a fragment of code. An invocation of a macro will resolve to the body of that macro, with passed arguments inserted into the body.

A macro definition is a @ character followed by a name, followed by zero or more argument definitions, followed by the macro body, followed by a ; character. An argument definition is a : character followed by an argument name, with the argument name optionally wrapped with the { and } characters. A macro body is a sequence of zero or more tokens.

Arguments are typed. An argument name wrapped with the { and } characters represents a block argument, and a plain argument name represents an integer argument.

Argument names will shadow previous definitions with the same name.

%VERSION  3;

%DOUBLE:v  [v v +];

%FOR:count:{block}
  WRITE:i:count
  &loop
    block
    NEXT:~loop;

Invocation

An invocation is the use of a label or a macro, resolving to either an integer or block value.

An invocation prefixed with a ~ character is a local invocation. A local invocation inside a macro definition will resolve to a sublabel with that name defined in the body of that macro. A local invocation outside a macro body will resolve to a sublabel with that name defined since the most recent main label definition.

An invocation is an optional ~ character, followed by a name, followed by zero or more invocation arguments. An invocation argument is a : character followed by either a block or an integer. An integer is either a constant expression, a decimal or hexadecimal literal, a string, or a no-argument invocation that resolves to an integer value. A block is either a block literal or a no-argument invocation that resolves to a block value. A block literal is a sequence of zero or more tokens wrapped with the { and } characters.

@main
  &loop
    FOR:8:{ PULSE:DATA-PIN }
    DELAY:1000
    GOTO:~loop

Constant expression

A constant expression is an expression written in a stack-based language that will evaluate to an integer.

Constant expressions are evaluated left-to-right. Integer literals and invocations will push the value of that literal or invocation to the stack. Operators consume values from the top of the stack and then push a result value to the stack. The stack must contain only a single value once evaluation has completed.

A constant expression is a sequence of tokens starting with a [ character and ending with a ] character. Each token in a constant expression can be a decimal literal, a hexadecimal literal, an invocation with no arguments, or an operator.

The following table lists the available operators. b denotes the value at the top of the stack, and a denotes the next value down. When evaluating an operator, all values used by the operator are popped from the stack, and then the result value is pushed to the stack.

%TEST:a:b   [a b =];
%PAGE:addr  [addr 8 >> 0xff &];

Comment

Comments are ignored by the assembler.

A comment is a sequence of characters starting with a ( character and ending with a ) character.

( Increment the value of a register. )
%INC:r  #1011_0010 #rrrr_rrrr ;

String

A string is a sequence of characters. Strings are treated as a special case of an integer. Each character in a string is represented by an integer with the value of the Unicode value of that character.

When a string is passed into a field of a packed binary literal, the packed binary literal is invoked once for every character in the string, with each invocation receiving the value of a character.

A string is a " character, followed by zero or more other characters, followed by a " character.

%BYTE:b  #bbbb_bbbb ;

BYTE:"String"