Landin for C programmers

#include "paths.h"

import core/text (host_over, host_string)

--- Where the tool reads its settings.
public config_path: () -> (path: host_string) =
    path = host_over("/etc/tool.conf")
end config_path

#define BUFFER_SIZE 4096

--- The size of every read buffer.
buffer_size: usize = 4096

#ifdef __APPLE__
#define LIBRARY_SUFFIX ".dylib"
#else
#define LIBRARY_SUFFIX ".so"
#endif

-- The suffix this system gives a shared library.
fixed if compiler.os == darwin then
    library_suffix: utf8 = ".dylib"
else
    library_suffix: utf8 = ".so"
end if

--- Whether the tool says what it does: `--option=verbose=true`.
option verbose: bool = false

fixed if verbose then
    log_capacity: usize = 256
else
    log_capacity: usize = 0
end if

_Static_assert(sizeof(size_t) == 8, "64-bit only");

-- This module is written for a 64-bit target.
compiler.assert(sizeof usize == 8)

struct header { uint8_t kind; uint16_t length; uint32_t id; };

--- A record C reads and writes, field for field.
header: type = layout(c) struct
    kind: u8
    length: u16
    id: u32
end header

header_size: usize = sizeof header -- 8: one byte of padding after kind

struct __attribute__((packed)) wire { uint8_t kind; uint32_t id; };

size_t at = offsetof(struct linux_dirent64, d_name);

--- The fixed part of Linux's `struct linux_dirent64`; the name follows it.
directory_record: type = layout(c) struct
    inode: u64
    offset: i64
    length: u16
    kind: u8
end directory_record

--- Where the name begins: the byte after `kind`, measured.
name_offset: () -> (bytes: usize) =
    record: directory_record = zeroed
    bytes = usize(addr record.kind) + sizeof u8 - usize(addr record)
end name_offset

struct linux_dirent64 { ino64_t d_ino; off64_t d_off;
                        unsigned short d_reclen; unsigned char d_type;
                        char d_name[]; };

import core/mem

--- The name in the record at `at` of what `getdents64` read: the bytes after
--- the fixed part, up to the NUL that ends them. Every hosted target is
--- little-endian, so the length's low byte comes first.
record_name: (buffer: []u8, at: usize) -> (name: []u8 from buffer) =
    length: u16 = u16(buffer[at + 16]) | u16(buffer[at + 17]) << 8
    rest := buffer[at + name_offset()..<at + usize(length)]
    name = rest[0..<mem.find(rest, 0)]
end record_name

struct token { uint32_t offset; enum { NUMBER, WORD, END } tag;
               union { int64_t value; uint32_t letters; } as; };

--- A token and what it holds; the variant part is the tag and the union.
token: type = struct
    offset: u32
    kind: variant
        number: (value: i64) |
        word: (letters: u32) |
        end_of_input
    end kind
end token

token_width: (t: token) -> (width: u32) =
    match t.kind
        number(value): width = if value < 0 then 2 else 1 end if
        word(letters): width = letters
        end_of_input: width = 0
    end match
end token_width

--- The bits of a float, which C reads through a union or `memcpy`.
float_bits: (value: f32) -> (bits: u32) =
    view: ptr u32 = ptr(usize(addr value))
    bits = view.val
end float_bits

uint32_t *first_entry(uint32_t *table, size_t n);  /* NULL when n is 0 */

no_entry: atom

--- A pointer that may be absent.
maybe_entry: type = no_entry | ptr mut u32

first_entry: (table: []mut u32) -> (found: maybe_entry from table) =
    found = no_entry
    if lenof table > 0 then found = addr table[0] end if
end first_entry

bump_first: (table: []mut u32) -> none =
    match first_entry(table)
        no_entry: return
        ptr (entry): entry.val += 1
    end match
end bump_first

void *largest(void *items, size_t n, size_t size,
              int (*less)(const void *, const void *));

import core/cmp

--- The largest of the items, for any type with an ordering.
largest: (t: type is cmp.ordered, items: []t) -> (best: t) =
    best = items[0]
    for item in items do
        if t.less(best, item) then best = item end if
    end for
end largest

highest_reading: (readings: []u32) -> (high: u32) =
    high = largest(readings)
end highest_reading

uint32_t value = table[index];  /* table came from C */

--- The entry at `index` of a table C handed over as a bare pointer.
entry_at: (table: ptr u32, index: usize) -> (value: u32) =
    entry: ptr u32 = ptr(usize(table) + index * sizeof u32)
    value = entry.val
end entry_at

uint8_t low = (uint8_t)measured;
double ratio = (double)total / 1000.0;
uintptr_t address = (uintptr_t)cell;

narrowing: (measured: u32, total: i64) -> (low: u8, ratio: f64) =
    low = u8(measured & 0xFF) -- the low byte, which the mask says is wanted
    ratio = f64(total) / 1000.0
end narrowing

checked: (measured: u32) -> (small: u8) =
    small = u8(measured) -- traps when measured is above 255
end checked

as_address: (cell: ptr mut u32) -> (address: usize) =
    address = usize(cell) -- the integer has no origin from here on
end as_address

const char *greeting = "héllo";

greeting: utf8 = "héllo"
greeting_bytes: []u8 = "héllo" -- six bytes; the NUL is not counted

spaces_in: (line: utf8) -> (count: u32) =
    count = 0
    for character in line do
        if character == ' ' then inc count end if
    end for
end spaces_in

*(volatile uint32_t *)0x40021018 |= 1;

--- Turn on a port's clock: one read and one write of the device register.
enable_port_clock: () -> none =
    enable: ptr mut u32 = ptr(0x4002_1018)
    value: u32 = compiler.volatile_load(enable)
    compiler.volatile_store(enable, value | 1)
end enable_port_clock

struct point *cell = malloc(sizeof *cell);
if (cell == NULL) return -1;
free(cell);

import core/arena
import core/mem
import hosted/heap

point: type = struct
    x: i32
    y: i32
end point

--- Allocate a point, move it and free it, through the caller's allocator.
moved_point: (provider: type is mem.allocator, memory: provider, start: point)
             -> (x: i32) ! mem.out_of_memory =
    cell := try mem.new(memory, start)
    defer mem.delete(memory, cell)
    cell.val.x += 1
    x = cell.val.x
end moved_point

from_heap_or_arena: () -> (sum: i32) ! mem.out_of_memory =
    origin: point = (x: 0, y: 0)
    sum = try moved_point(heap.new(), origin)
    mut backing: [64]u8 = zeroed
    mut state: arena.space = zeroed
    scratch := arena.over_unchecked(state, addr backing[0], 64)
    sum += try moved_point(scratch, origin)
end from_heap_or_arena

while (i < n && line[i] != ' ') i++;
h = h * 31 + c;

--- Where the word that starts at `start` ends.
word_end: (line: []u8, start: usize) -> (i: usize) =
    i = start
    while i < lenof line and line[i] <> u8(' ') do
        inc i
    end while
end word_end

--- A hash that wraps on purpose, which the operators say.
hash_bytes: (bytes: []u8) -> (h: u32) =
    h = 0
    for byte in bytes do
        h = h *% 31 +% u32(byte)
    end for
end hash_bytes

switch (light) { case RED: return 30; case AMBER: return 3; default: return 0; }

red, amber, green: atom

signal: type = red | amber | green

wait_seconds: (light: signal) -> (seconds: u32) =
    match light
        red: seconds = 30
        amber: seconds = 3
        green: seconds = 0
    end match
end wait_seconds

digit_name: (digit: u32) -> (name: utf8) =
    if digit == 0 then
        name = "zero"
    elsif digit == 1 then
        name = "one"
    else
        name = "many"
    end if
end digit_name

    if ((in = open(src, O_RDONLY)) < 0) goto out;
    if ((to = creat(dst, 0644)) < 0) goto close_in;
    ...
    close(to);
close_in:
    close(in);
out:
    return result;

import core/io
import core/text
import hosted/system

--- Copy the first block of one file into another, closing both on every way
--- out.
copy_first_block: (host: system.host, source_path: text.host_string,
                   target_path: text.host_string)
                  -> none ! io.not_found | io.no_access | io.io_failed =
    source := try io.open_read(host, source_path)
    defer io.close(host, source) else none
    target := try io.open_write(host, target_path)
    defer io.close(host, target) else none
    mut block: [512]u8 = zeroed
    count := try io.read(host, source, block)
    try io.write(host, target, block[0..<count])
end copy_first_block

int fd = open("settings.conf", O_RDONLY);
if (fd < 0) { if (errno == ENOENT) return 0; return -1; }

import core/io
import core/text
import hosted/system

--- Whether the settings file is there; any other failure is the caller's.
settings_present: (host: system.host)
                  -> (present: bool) ! io.no_access | io.io_failed =
    present = false
    path := text.host_over("settings.conf")
    opened := io.open_read(host, path) else (problem)
        match problem
            io.not_found: return
            io.no_access: fail io.no_access
            io.io_failed: fail io.io_failed
        end match
    end
    io.close(host, opened) else none
    present = true
end settings_present

int main(int argc, char **argv) {
    if (argc < 2) { fputs("usage: tool FILE...\n", stderr); exit(2); }
    ...
    return 0;
}

import core/io
import hosted/system

public main: () -> (code: i32) =
    host := system.new()
    code = 2
    if io.argument_count(host) == 0 then
        io.write(host, io.err(host), "usage: tool FILE...\n") else none
        return
    end if
    print_arguments(host) else (problem)
        _ = problem
        code = 1
        return
    end
    code = 0
end main

import platform/posix

--- Stop the program from wherever it is, with status 2.
give_up: () -> noreturn =
    posix.exit(2)
end give_up

for (int i = 1; i < argc; i++) puts(argv[i]);

import core/io
import core/text
import hosted/system

--- Write each argument on a line of its own.
print_arguments: (host: system.host) -> none ! io.io_failed =
    for index in usize(0)..<io.argument_count(host) do
        argument := io.argument_at(host, index) else (problem)
            _ = problem
            return
        end
        try io.write(host, io.out(host), text.host_bytes(argument))
        try io.write(host, io.out(host), "\n")
    end for
end print_arguments

const char *home = getenv("HOME");
if (home == NULL) home = "/";

import core/io
import core/text
import hosted/system

--- The home directory, or `/` when the environment names none.
home_directory: (host: system.host) -> (home: text.host_string from host) =
    home = io.variable_named(host, text.host_over("HOME")) else (problem)
        _ = problem
        text.host_over("/")
    end
end home_directory

printf("%s: %5u items\n", name, count);

import core/io
import core/text
import hosted/system

--- Write a name and a count, the count right-aligned in five columns.
report: (host: system.host, name: utf8, count: u32)
        -> none ! io.io_failed | text.no_space | text.invalid_format =
    mut storage: [128]u8 = zeroed
    mut line := text.over(storage)
    try text.format(line, "{}: ", [any(addr name)])
    start := text.length(line)
    try text.append_u32(line, count)
    try text.align_right(line, start, 5, u8(' '))
    try text.append(line, " items\n")
    try io.write(host, io.out(host), text.used(line))
end report

int port = atoi("8080");

import platform/c

--- C's `atoi`, from the C library.
extern(c) atoi: (s: cstring) -> (value: c.c_int)

default_port: () -> (port: i32) =
    port = atoi("8080") -- the literal carries its NUL
end default_port