aBelle – a small language you can follow down to the machine code

Two first programs

On the left a program for Windows: it takes WriteFile from kernel32.dll and writes to the console. On the right one for the ESP32 board: the registers of the chip are arrays at their address, and the LED blinks.

extern "kernel32.dll":
    def GetStdHandle(n: i32) u32
    def WriteFile(h: u32, buf: pchar, n: u32,
                  written: pchar, ov: u32) i32

written: char[4]

def strlen(s: pchar) i32:
    n = 0
    while s[n] != 0: n += 1
    return n

def print(s: pchar):
    WriteFile(GetStdHandle(-11), s, u32(strlen(s)), written, 0)

def main() i32:
    print("Hello, world!\n")
    return 0

target "esp32"

gpio:  u32[0x140] at 0x3FF44000    # the GPIO registers
iomux: u32[64]    at 0x3FF49000    # the function of each pin

LED = 2

def wait():
    for i in 0..500000: pass     # about half a second

def main():
    iomux[0x40 / 4] = 0x2800            # GPIO 2 is a GPIO
    gpio[(0x530 + 4 * LED) / 4] = 0x100
    gpio[0x24 / 4] = 1 << LED          # an output
    while True:
        gpio[0x08 / 4] = 1 << LED      # on
        wait()
        gpio[0x0C / 4] = 1 << LED      # off
        wait()

The files are called .abel. A block follows a line with : and is indented four spaces further, as in Python. A program for a board says so in its first line with target; without it, it is one for Windows.

The language at a glance

aBelle is small on purpose: just what a compiler needs to translate itself, and the registers of a board. All of it in detail is in the language description (provisional version).

Three targets

The same language, three compilers, each from the same source but for the part that writes the code and the file.

On the ESP32 an aBelle program can also stay on the board as a file: Debug > ESP32 Board Files uploads it to the console of examples/esp32/console.asm, which starts it, after every reset if you like.

Libraries for the ESP32: UART and WiFi

The examples for the ESP32 include files from examples\abelle\esp32\inc. They are written in aBelle themselves: you can read them, change them and follow them in the debugger.

The WiFi itself runs on the second core of the ESP32, the aBelle program on the first. When the debugger holds the program at a breakpoint, the connection stays up, and what comes in waits in a buffer. So you go line by line through a DHCP exchange or a TCP connection. Once per board this needs Install WiFi; more on the ESP32 page.

Debugging in the source

Next to the program the compiler writes a map file: which code belongs to which line and where the variables are. With it Asmonite debugs right in the .abel file.

• Breakpoints on lines, F8 goes one line on, F7 also into a function
• Variables under the mouse and in the window Watch, by their type: a pchar with its text, arrays as a list, growing arrays with their length
• Registers, stack and memory beside it: you see what the processor makes of your line
• F1 explains the words and operators of the line
• On the ESP32 the same over the USB cable, with Pause and Stop also in an endless loop

A compiler that translates itself

aBelle came about the way languages used to: in stages, until the language carries itself.

1. Stage 0, written in Delphi, translates aBelle into assembler for Asmonite.
2. The compiler in aBelle, translated by stage 0, writes the machine code and the program file itself.
3. It translates itself into the same file, byte for byte, in about 25 milliseconds. From here on aBelle grows in aBelle.

The compiler works in one pass: read, split into tokens and write code at once, without a syntax tree. Over 350 tests and a fuzzer with random programs check that all compilers do the same.

Examples

The examples for Windows are in examples\abelle, those for the ESP32 in examples\abelle\esp32. All ESP32 examples with a description →

What is not (yet) there

• Structures, floating point, modules (include only puts in text), numbers of 64 bits.
• Local arrays, arrays as parameters, several return values, freeing memory.
• Checks at run time: an index outside an array is not checked – as in the hardware.
• An index behind a call (f(i)[0]) and the expression x and a or b as a choice do not work; a helper variable does.
• A parameter or a local variable of an included file must not have the name of a global variable of the program. The files in inc put a prefix in front of their names for that (wl_, u_, md_).
• Boards: only the original ESP32 so far, not yet the ESP32-S3, the ESP32-C3 and the Picos.