Initial commit

Makefile

@@ -0,0 +1,43 @@
+CC=gcc
+PREFIX=/usr/local
+VERSION=0.12.1
+CCONFIG=-std=c11 -Werror -D_XOPEN_SOURCE=700 -D_POSIX_C_SOURCE=200809L -fPIC -ftrapv -fvisibility=hidden -flto -fno-fat-lto-objects -Wl,-flto
+LDFLAGS=-Wl,-rpath '-Wl,$$ORIGIN'
+# MAKEFLAGS := --jobs=$(shell nproc) --output-sync=target
+CWARN=-Wall -Wextra -Wno-format
+  # -Wpedantic -Wsign-conversion -Wtype-limits -Wunused-result -Wnull-dereference \
+	# -Waggregate-return -Walloc-zero -Walloca -Warith-conversion -Wcast-align -Wcast-align=strict \
+	# -Wdangling-else -Wdate-time -Wdisabled-optimization -Wdouble-promotion -Wduplicated-branches \
+	# -Wduplicated-cond -Wexpansion-to-defined -Wfloat-conversion -Wfloat-equal -Wformat-nonliteral \
+	# -Wformat-security -Wformat-signedness -Wframe-address -Winline -Winvalid-pch -Wjump-misses-init \
+	# -Wlogical-op -Wlong-long -Wmissing-format-attribute -Wmissing-include-dirs -Wmissing-noreturn \
+	# -Wnull-dereference -Woverlength-strings -Wpacked -Wpacked-not-aligned -Wpointer-arith \
+	# -Wredundant-decls -Wshadow -Wshadow=compatible-local -Wshadow=global -Wshadow=local \
+	# -Wsign-conversion -Wstack-protector -Wsuggest-attribute=const -Wswitch-default -Wswitch-enum \
+	# -Wsync-nand -Wtrampolines -Wundef -Wunsuffixed-float-constants -Wunused -Wunused-but-set-variable \
+	# -Wunused-const-variable -Wunused-local-typedefs -Wunused-macros -Wvariadic-macros -Wvector-operation-performance \
+	# -Wvla -Wwrite-strings
+OSFLAGS != case $$(uname -s) in *BSD|Darwin) echo '-D_BSD_SOURCE';; Linux) echo '-D_GNU_SOURCE';; *) echo '-D_DEFAULT_SOURCE';; esac
+EXTRA=
+G=-ggdb
+O=-Og
+CFLAGS=$(CCONFIG) $(EXTRA) $(CWARN) $(G) $(O) $(OSFLAGS)
+LDLIBS=-lgc -lgccjit -lcord -lm -lunistring
+
+all: nextlang
+
+nextlang: nextlang.c parse.o files.o util.o ast.o compile.o
+
+SipHash/halfsiphash.c:
+	git submodule update --init --recursive
+
+tags:
+	ctags **/*.[ch]
+
+clean:
+	rm -f nextlang *.o
+
+%.1: %.1.md
+	pandoc --lua-filter=.pandoc/bold-code.lua -s $< -t man -o $@
+
+.PHONY: all clean install uninstall test

ast.c

@@ -0,0 +1,179 @@
+// Some basic operations defined on AST nodes, mainly converting to
+// strings for debugging.
+#include <gc/cord.h>
+#include <stdarg.h>
+#include <printf.h>
+
+#include "ast.h"
+
+static const char *OP_NAMES[] = {
+    [BINOP_UNKNOWN]="unknown",
+    [UNOP_NOT]="not", [UNOP_NEGATIVE]="negative",
+    [BINOP_POWER]="^", [BINOP_MULT]="*", [BINOP_DIVIDE]="/",
+    [BINOP_MOD]="mod", [BINOP_MOD1]="mod1", [BINOP_PLUS]="+", [BINOP_MINUS]="minus",
+    [BINOP_CONCAT]="++", [BINOP_LSHIFT]="<<", [BINOP_RSHIFT]=">>", [BINOP_MIN]="min",
+    [BINOP_MAX]="max", [BINOP_EQ]="==", [BINOP_NE]="!=", [BINOP_LT]="<",
+    [BINOP_LE]="<=", [BINOP_GT]=">", [BINOP_GE]=">=", [BINOP_AND]="and", [BINOP_OR]="or", [BINOP_XOR]="xor",
+};
+
+static CORD ast_to_cord(ast_t *ast);
+static CORD ast_list_to_cord(ast_list_t *asts);
+static CORD type_ast_to_cord(type_ast_t *t);
+static CORD arg_list_to_cord(arg_list_t *args);
+static CORD tags_to_cord(tag_t *tags);
+
+#define TO_CORD(x) _Generic(x, \
+                            ast_t*: ast_to_cord(x), \
+                            ast_list_t*: ast_list_to_cord(x), \
+                            type_ast_t*: type_ast_to_cord(x), \
+                            arg_list_t*: arg_list_to_cord(x), \
+                            tag_t*: tags_to_cord(x), \
+                            const char *: x, \
+                            int64_t: CORD_asprintf("%ld", x), \
+                            unsigned short int: CORD_asprintf("%d", x), \
+                            double: CORD_asprintf("%g", x), \
+                            bool: CORD_asprintf("%s", x ? "yes" : "no"), \
+                            unsigned char: CORD_asprintf("%s", x ? "yes" : "no"))
+
+CORD ast_list_to_cord(ast_list_t *asts)
+{
+    if (!asts)
+        return "\x1b[35mNULL\x1b[m";
+
+    CORD c = "[";
+    for (; asts; asts = asts->next) {
+        c = CORD_cat(c, ast_to_cord(asts->ast));
+        if (asts->next) c = CORD_cat(c, ", ");
+    }
+    c = CORD_cat(c, "]");
+    return c;
+}
+
+CORD arg_list_to_cord(arg_list_t *args) {
+    CORD c = "Args(";
+    for (; args; args = args->next) {
+        if (args->var && args->var->name)
+            c = CORD_cat(c, args->var->name);
+        if (args->type)
+            CORD_sprintf(&c, "%r:%s", c, type_ast_to_cord(args->type));
+        if (args->default_val)
+            CORD_sprintf(&c, "%r=%s", c, ast_to_cord(args->default_val));
+        if (args->next) c = CORD_cat(c, ", ");
+    }
+    c = CORD_cat(c, ")");
+    return c;
+}
+
+CORD tags_to_cord(tag_t *tags) {
+    CORD c = "Tags(";
+    for (; tags; tags = tags->next) {
+        if (tags->name)
+            c = CORD_cat(c, tags->name);
+        CORD_sprintf(&c, "%r:%s=%ld", c, type_ast_to_cord(tags->type), tags->value);
+        if (tags->next) c = CORD_cat(c, ", ");
+    }
+    c = CORD_cat(c, ")");
+    return c;
+}
+
+CORD ast_to_cord(ast_t *ast)
+{
+    if (!ast) return "\x1b[35mNULL\x1b[m";
+
+    switch (ast->tag) {
+#define T(type, ...) case type: { auto data = ast->__data.type; (void)data; return CORD_asprintf("\x1b[34;1m" #type "\x1b[m" __VA_ARGS__); }
+    T(Unknown,  "Unknown")
+    T(Nil, "(%r)", type_ast_to_cord(data.type))
+    T(Bool, "(\x1b[35m%s\x1b[m)", data.b ? "yes" : "no")
+    T(Var, "(\x1b[36;1m%s\x1b[m)", data.var.name)
+    T(Int, "(\x1b[35m%ld\x1b[m, precision=%ld)", data.i, data.precision)
+    T(Num, "(\x1b[35m%ld\x1b[m, precision=%ld)", data.n, data.precision)
+    T(Char, "(\x1b[35m'%c'\x1b[m)", data.c)
+    T(StringLiteral, "\x1b[35m\"%s\"\x1b[m", data.str)
+    T(StringJoin, "(%r)", ast_list_to_cord(data.children))
+    T(Interp, "(%r)", ast_to_cord(data.value))
+    T(Declare, "(var=%s, value=%s)", ast_to_cord(data.var), ast_to_cord(data.value))
+    T(Assign, "(targets=%r, values=%r)", ast_list_to_cord(data.targets), ast_list_to_cord(data.values))
+    T(BinaryOp, "(%r, %s, %r)", ast_to_cord(data.lhs), OP_NAMES[data.op], ast_to_cord(data.rhs))
+    T(UpdateAssign, "(%r, %s, %r)", ast_to_cord(data.lhs), OP_NAMES[data.op], ast_to_cord(data.rhs))
+    T(UnaryOp, "(%s, %r)", OP_NAMES[data.op], ast_to_cord(data.value))
+    T(Min, "(%r, %r, key=%r)", ast_to_cord(data.lhs), ast_to_cord(data.rhs), ast_to_cord(data.key))
+    T(Max, "(%r, %r, key=%r)", ast_to_cord(data.lhs), ast_to_cord(data.rhs), ast_to_cord(data.key))
+    T(Array, "(%r, type=%r)", ast_list_to_cord(data.items), type_ast_to_cord(data.type))
+    T(Table, "(key_type=%r, value_type=%r, fallback=%r, default_value=%r, entries=%r)",
+      type_ast_to_cord(data.key_type), type_ast_to_cord(data.value_type),
+      ast_to_cord(data.fallback), ast_to_cord(data.default_value),
+      ast_list_to_cord(data.entries))
+    T(TableEntry, "(%r => %r)", ast_to_cord(data.key), ast_to_cord(data.value))
+    T(FunctionDef, "(name=%r, args=%r, ret=%r, body=%r)", ast_to_cord(data.name),
+      arg_list_to_cord(data.args), type_ast_to_cord(data.ret_type), ast_to_cord(data.body))
+    T(Lambda, "(args=%r, body=%r)", arg_list_to_cord(data.args), ast_to_cord(data.body))
+    T(FunctionCall, "(fn=%r, args=%r)", ast_to_cord(data.fn), ast_list_to_cord(data.args))
+    T(KeywordArg, "(%s=%r)", ast_to_cord(data.arg))
+    T(Block, "(%r)", ast_list_to_cord(data.statements))
+    T(For, "(index=%r, value=%r, iter=%r, body=%r)", ast_to_cord(data.index), ast_to_cord(data.value),
+      ast_to_cord(data.iter), ast_to_cord(data.body))
+    T(While, "(condition=%r, body=%r)", ast_to_cord(data.condition), ast_to_cord(data.body))
+    T(If, "(condition=%r, body=%r, else=%r)", ast_to_cord(data.condition), ast_to_cord(data.body), ast_to_cord(data.else_body))
+    T(Reduction, "(iter=%r, combination=%r, fallback=%r)", ast_to_cord(data.iter), ast_to_cord(data.combination), ast_to_cord(data.fallback))
+    T(Skip, "(%s)", data.target)
+    T(Stop, "(%s)", data.target)
+    T(Pass, "")
+    T(Return, "(%r)", ast_to_cord(data.value))
+    T(Extern, "(name=%s, type=%r)", data.name, type_ast_to_cord(data.type))
+    T(TypeDef, "(%s, type=%r, namespace=%r)", data.var.name, type_ast_to_cord(data.type), ast_to_cord(data.namespace))
+    T(Index, "(indexed=%r, index=%r)", ast_to_cord(data.indexed), ast_to_cord(data.index))
+    T(FieldAccess, "(fielded=%r, field=%s)", ast_to_cord(data.fielded), data.field)
+    T(DocTest, "(expr=%r, output=%s)", ast_to_cord(data.expr), data.output)
+    T(Use, "(%s)", data.path)
+    T(LinkerDirective, "(%s)", data.directive)
+#undef T
+    }
+    return NULL;
+}
+
+CORD type_ast_to_cord(type_ast_t *t)
+{
+    if (!t) return "\x1b[35mNULL\x1b[m";
+
+    switch (t->tag) {
+#define T(type, ...) case type: { auto data = t->__data.type; (void)data; return CORD_asprintf("\x1b[32;1m" #type "\x1b[m" __VA_ARGS__); }
+    T(TypeUnknown, "")
+    T(TypeVar, "(\x1b[36;1m%s\x1b[m)", data.var.name)
+    T(TypePointer, "(%r, is_optional=%d, is_stack=%d, is_readonly=%d)",
+      type_ast_to_cord(data.pointed), data.is_optional,
+      data.is_stack, data.is_readonly)
+    T(TypeStruct, "(%r)", arg_list_to_cord(data.fields))
+    T(TypeTaggedUnion, "(%r)", tags_to_cord(data.tags))
+    T(TypeArray, "(%r)", type_ast_to_cord(data.item))
+    T(TypeTable, "(%r => %r)", type_ast_to_cord(data.key), type_ast_to_cord(data.value))
+    T(TypeFunction, "(args=%r, ret=%r)", arg_list_to_cord(data.args), type_ast_to_cord(data.ret))
+#undef T
+    }
+    return NULL;
+}
+
+const char *ast_to_str(ast_t *ast) {
+    CORD c = ast_to_cord(ast);
+    return CORD_to_char_star(c);
+}
+
+const char *type_ast_to_str(type_ast_t *t) {
+    CORD c = type_ast_to_cord(t);
+    return CORD_to_char_star(c);
+}
+
+int printf_ast(FILE *stream, const struct printf_info *info, const void *const args[])
+{
+    ast_t *ast = *(ast_t**)(args[0]);
+    if (ast) {
+        if (info->alt)
+            return fprintf(stream, "%.*s", (int)(ast->end - ast->start), ast->start);
+        else
+            return fprintf(stream, "%s", ast_to_str(ast));
+    } else {
+        return fputs("(null)", stream);
+    }
+}
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

ast.h

@@ -0,0 +1,290 @@
+#pragma once
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <printf.h>
+
+#include "files.h"
+#include "util.h"
+
+#define NewAST(_file, _start, _end, ast_tag, ...) (new(ast_t, .file=_file, .start=_start, .end=_end,\
+                                                     .tag=ast_tag, .__data.ast_tag={__VA_ARGS__}))
+#define NewTypeAST(_file, _start, _end, ast_tag, ...) (new(type_ast_t, .file=_file, .start=_start, .end=_end,\
+                                                     .tag=ast_tag, .__data.ast_tag={__VA_ARGS__}))
+#define FakeAST(ast_tag, ...) (new(ast_t, .tag=ast_tag, .__data.ast_tag={__VA_ARGS__}))
+#define WrapAST(ast, ast_tag, ...) (new(ast_t, .file=(ast)->file, .start=(ast)->start, .end=(ast)->end, .tag=ast_tag, .__data.ast_tag={__VA_ARGS__}))
+#define StringAST(ast, _str) WrapAST(ast, StringLiteral, .str=heap_str(_str))
+
+struct binding_s;
+typedef struct type_ast_s type_ast_t;
+typedef struct ast_s ast_t;
+
+typedef struct {
+    const char *name;
+    struct binding_s *binding;
+} var_t;
+
+typedef struct ast_list_s {
+    ast_t *ast;
+    struct ast_list_s *next;
+} ast_list_t;
+
+typedef struct arg_list_s {
+    var_t *var;
+    type_ast_t *type;
+    ast_t *default_val;
+    struct arg_list_s *next;
+} arg_list_t;
+
+#define REVERSE_LIST(list) do { \
+    __typeof(list) _prev = NULL; \
+    __typeof(list) _next = NULL; \
+    auto _current = list; \
+    while (_current != NULL) { \
+        _next = _current->next; \
+        _current->next = _prev; \
+        _prev = _current; \
+        _current = _next; \
+    } \
+    list = _prev; \
+} while(0)
+
+typedef enum {
+    UNOP_UNKNOWN,
+    UNOP_NOT=1, UNOP_NEGATIVE,
+    UNOP_HEAP_ALLOCATE,
+    UNOP_STACK_REFERENCE,
+} unop_e;
+
+typedef enum {
+    BINOP_UNKNOWN,
+    BINOP_POWER=100, BINOP_MULT, BINOP_DIVIDE, BINOP_MOD, BINOP_MOD1, BINOP_PLUS,
+    BINOP_MINUS, BINOP_CONCAT, BINOP_LSHIFT, BINOP_RSHIFT, BINOP_MIN,
+    BINOP_MAX, BINOP_EQ, BINOP_NE, BINOP_LT, BINOP_LE, BINOP_GT, BINOP_GE,
+    BINOP_AND, BINOP_OR, BINOP_XOR,
+} binop_e;
+
+typedef enum {
+    TypeUnknown,
+    TypeVar,
+    TypePointer,
+    TypeStruct,
+    TypeTaggedUnion,
+    TypeArray,
+    TypeTable,
+    TypeFunction,
+} type_ast_e;
+
+typedef struct tag_s {
+    const char *name;
+    struct type_ast_s *type;
+    int64_t value;
+    struct tag_s *next;
+} tag_t;
+
+struct type_ast_s {
+    type_ast_e tag;
+    sss_file_t *file;
+    const char *start, *end;
+    union {
+        struct {} TypeUnknown;
+        struct {
+            var_t var;
+        } TypeVar;
+        struct {
+            type_ast_t *pointed;
+            bool is_optional:1, is_stack:1, is_readonly:1;
+        } TypePointer;
+        struct {
+            arg_list_t *fields;
+        } TypeStruct;
+        struct {
+            tag_t *tags;
+        } TypeTaggedUnion;
+        struct {
+            type_ast_t *item;
+        } TypeArray;
+        struct {
+            type_ast_t *key, *value;
+        } TypeTable;
+        struct {
+            arg_list_t *args;
+            type_ast_t *ret;
+        } TypeFunction;
+    } __data;
+};
+
+typedef enum {
+    Unknown = 0,
+    Nil, Bool, Var,
+    Int, Num, Char,
+    StringLiteral, StringJoin, Interp,
+    Declare, Assign,
+    BinaryOp, UnaryOp, UpdateAssign,
+    Min, Max,
+    Array, Table, TableEntry,
+    FunctionDef, Lambda,
+    FunctionCall, KeywordArg,
+    Block,
+    For, While, If,
+    Reduction,
+    Skip, Stop, Pass,
+    Return,
+    Extern,
+    TypeDef,
+    Index, FieldAccess,
+    DocTest,
+    Use,
+    LinkerDirective,
+} ast_e;
+
+struct ast_s {
+    ast_e tag;
+    sss_file_t *file;
+    const char *start, *end;
+    union {
+        struct {} Unknown;
+        struct {
+            type_ast_t *type;
+        } Nil;
+        struct {
+            bool b;
+        } Bool;
+        struct {
+            var_t var;
+        } Var;
+        struct {
+            int64_t i;
+            enum { INT_64BIT, INT_32BIT, INT_16BIT, INT_8BIT } precision;
+        } Int;
+        struct {
+            double n;
+            enum { NUM_64BIT, NUM_32BIT } precision;
+        } Num;
+        struct {
+            char c;
+        } Char;
+        struct {
+            const char *str;
+        } StringLiteral;
+        struct {
+            ast_list_t *children;
+        } StringJoin;
+        struct {
+            ast_t *value;
+            bool labelled:1, colorize:1, quote_string:1;
+        } Interp;
+        struct {
+            ast_t *var;
+            ast_t *value;
+        } Declare;
+        struct {
+            ast_list_t *targets, *values;
+        } Assign;
+        struct {
+            ast_t *lhs;
+            binop_e op;
+            ast_t *rhs;
+        } BinaryOp, UpdateAssign;
+        struct {
+            unop_e op;
+            ast_t *value;
+        } UnaryOp;
+        struct {
+            ast_t *lhs, *rhs, *key;
+        } Min, Max;
+        struct {
+            type_ast_t *type;
+            ast_list_t *items;
+        } Array;
+        struct {
+            type_ast_t *key_type, *value_type;
+            ast_t *fallback, *default_value;
+            ast_list_t *entries;
+        } Table;
+        struct {
+            ast_t *key, *value;
+        } TableEntry;
+        struct {
+            ast_t *name;
+            arg_list_t *args;
+            type_ast_t *ret_type;
+            ast_t *body;
+            ast_t *cache;
+            bool is_inline;
+        } FunctionDef;
+        struct {
+            arg_list_t *args;
+            ast_t *body;
+        } Lambda;
+        struct {
+            ast_t *fn;
+            ast_list_t *args;
+            type_ast_t *extern_return_type;
+        } FunctionCall;
+        struct {
+            const char *name;
+            ast_t *arg;
+        } KeywordArg;
+        struct {
+            ast_list_t *statements;
+        } Block;
+        struct {
+            ast_t *index, *value, *iter, *body;
+        } For;
+        struct {
+            ast_t *condition, *body;
+        } While;
+        struct {
+            ast_t *condition, *body, *else_body;
+        } If;
+        struct {
+            ast_t *iter, *combination, *fallback;
+        } Reduction;
+        struct {
+            const char *target;
+        } Skip, Stop;
+        struct {} Pass;
+        struct {
+            ast_t *value;
+        } Return;
+        struct {
+            const char *name;
+            type_ast_t *type;
+            bool address;
+        } Extern;
+        struct {
+            var_t var;
+            type_ast_t *type;
+            ast_t *namespace;
+        } TypeDef;
+        struct {
+            ast_t *indexed, *index;
+            bool unchecked;
+        } Index;
+        struct {
+            ast_t *fielded;
+            const char *field;
+        } FieldAccess;
+        struct {
+            ast_t *expr;
+            const char *output;
+            bool skip_source:1;
+        } DocTest;
+        struct {
+            const char *path;
+            sss_file_t *file;
+            bool main_program;
+        } Use;
+        struct {
+            const char *directive;
+        } LinkerDirective;
+    } __data;
+};
+
+const char *ast_to_str(ast_t *ast);
+const char *type_ast_to_str(type_ast_t *ast);
+int printf_ast(FILE *stream, const struct printf_info *info, const void *const args[]);
+ast_list_t *get_ast_children(ast_t *ast);
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

compile.c

@@ -0,0 +1,185 @@
+
+#include <ctype.h>
+#include <gc/cord.h>
+#include <gc.h>
+#include <stdio.h>
+
+#include "ast.h"
+#include "util.h"
+
+static CORD compile_type(type_ast_t *t)
+{
+    switch (t->tag) {
+    case TypeVar: return Match(t, TypeVar)->var.name;
+    default: errx(1, "Not implemented");
+    }
+}
+
+CORD compile(ast_t *ast)
+{
+    switch (ast->tag) {
+    case Nil: return "NULL";
+    case Bool: return Match(ast, Bool)->b ? "true" : "false";
+    case Var: return Match(ast, Var)->var.name;
+    case Int: return CORD_asprintf("((Int%ld_t)%ld)", Match(ast, Int)->precision, Match(ast, Int)->i);
+    case Num: return CORD_asprintf(Match(ast, Num)->precision == 64 ? "%g" : "%gf", Match(ast, Num)->n);
+    case Char: return CORD_asprintf("'\\x%02X'", (int)Match(ast, Char)->c);
+    case UnaryOp: {
+        auto unop = Match(ast, UnaryOp);
+        CORD expr = compile(unop->value);
+        switch (unop->op) {
+        case UNOP_NOT: return CORD_cat("!", expr);
+        case UNOP_NEGATIVE: return CORD_cat("-", expr);
+        case UNOP_HEAP_ALLOCATE: return CORD_asprintf("__heap(%r)", expr);
+        case UNOP_STACK_REFERENCE: return CORD_asprintf("__stack(%r)", expr);
+        default: break;
+        }
+        errx(1, "Invalid unop");
+    }
+    case BinaryOp: {
+        auto binop = Match(ast, BinaryOp);
+        CORD lhs = compile(binop->lhs);
+        CORD rhs = compile(binop->rhs);
+        switch (binop->op) {
+        case BINOP_MULT: return CORD_asprintf("(%r * %r)", lhs, rhs);
+        case BINOP_DIVIDE: return CORD_asprintf("(%r / %r)", lhs, rhs);
+        case BINOP_MOD: return CORD_asprintf("(%r %% %r)", lhs, rhs);
+        case BINOP_PLUS: return CORD_asprintf("(%r + %r)", lhs, rhs);
+        case BINOP_MINUS: return CORD_asprintf("(%r - %r)", lhs, rhs);
+        case BINOP_LSHIFT: return CORD_asprintf("(%r << %r)", lhs, rhs);
+        case BINOP_RSHIFT: return CORD_asprintf("(%r >> %r)", lhs, rhs);
+        case BINOP_EQ: return CORD_asprintf("(%r == %r)", lhs, rhs);
+        case BINOP_NE: return CORD_asprintf("(%r != %r)", lhs, rhs);
+        case BINOP_LT: return CORD_asprintf("(%r < %r)", lhs, rhs);
+        case BINOP_LE: return CORD_asprintf("(%r <= %r)", lhs, rhs);
+        case BINOP_GT: return CORD_asprintf("(%r > %r)", lhs, rhs);
+        case BINOP_GE: return CORD_asprintf("(%r >= %r)", lhs, rhs);
+        case BINOP_AND: return CORD_asprintf("(%r && %r)", lhs, rhs);
+        case BINOP_OR: return CORD_asprintf("(%r || %r)", lhs, rhs);
+        default: break;
+        }
+        errx(1, "unimplemented binop");
+    }
+    case UpdateAssign: {
+        auto update = Match(ast, UpdateAssign);
+        CORD lhs = compile(update->lhs);
+        CORD rhs = compile(update->rhs);
+        switch (update->op) {
+        case BINOP_MULT: return CORD_asprintf("%r *= %r", lhs, rhs);
+        case BINOP_DIVIDE: return CORD_asprintf("%r /= %r", lhs, rhs);
+        case BINOP_MOD: return CORD_asprintf("%r = %r %% %r", lhs, lhs, rhs);
+        case BINOP_PLUS: return CORD_asprintf("%r += %r", lhs, rhs);
+        case BINOP_MINUS: return CORD_asprintf("%r -= %r", lhs, rhs);
+        case BINOP_LSHIFT: return CORD_asprintf("%r <<= %r", lhs, rhs);
+        case BINOP_RSHIFT: return CORD_asprintf("%r >>= %r", lhs, rhs);
+        case BINOP_EQ: return CORD_asprintf("%r = (%r == %r)", lhs, lhs, rhs);
+        case BINOP_NE: return CORD_asprintf("%r = (%r != %r)", lhs, lhs, rhs);
+        case BINOP_LT: return CORD_asprintf("%r = (%r < %r)", lhs, lhs, rhs);
+        case BINOP_LE: return CORD_asprintf("%r = (%r <= %r)", lhs, lhs, rhs);
+        case BINOP_GT: return CORD_asprintf("%r = (%r > %r)", lhs, lhs, rhs);
+        case BINOP_GE: return CORD_asprintf("%r = (%r >= %r)", lhs, lhs, rhs);
+        case BINOP_AND: return CORD_asprintf("%r = (%r && %r)", lhs, lhs, rhs);
+        case BINOP_OR: return CORD_asprintf("%r = (%r || %r)", lhs, lhs, rhs);
+        default: break;
+        }
+        errx(1, "unimplemented binop");
+    }
+    case StringLiteral: {
+        const char *str = Match(ast, StringLiteral)->str; 
+        CORD c = "\"";
+        for (; *str; ++str) {
+            switch (*str) {
+            case '\\': c = CORD_cat(c, "\\\\"); break;
+            case '"': c = CORD_cat(c, "\\\""); break;
+            case '\a': c = CORD_cat(c, "\\a"); break;
+            case '\b': c = CORD_cat(c, "\\b"); break;
+            case '\n': c = CORD_cat(c, "\\n"); break;
+            case '\r': c = CORD_cat(c, "\\r"); break;
+            case '\t': c = CORD_cat(c, "\\t"); break;
+            case '\v': c = CORD_cat(c, "\\v"); break;
+            default: {
+                if (isprint(*str))
+                    c = CORD_cat_char(c, *str);
+                else
+                    CORD_sprintf(&c, "%r\\x%02X", *str);
+                break;
+            }
+            }
+        }
+        return CORD_cat_char(c, '"');
+    }
+    case StringJoin: {
+        CORD c = NULL;
+        for (ast_list_t *chunk = Match(ast, StringJoin)->children; chunk; chunk = chunk->next) {
+            if (c) CORD_sprintf(&c, "CORD_cat(%r, %r)", c, compile(chunk->ast));
+            else c = compile(chunk->ast);
+        }
+        return c;
+    }
+    case Interp: {
+        return CORD_asprintf("__cord(%r)", compile(Match(ast, Interp)->value));
+    }
+    case Block: {
+        CORD c = NULL;
+        for (ast_list_t *stmt = Match(ast, Block)->statements; stmt; stmt = stmt->next) {
+            c = CORD_cat(c, compile(stmt->ast));
+            c = CORD_cat(c, ";\n");
+        }
+        return c;
+    }
+    case Declare: {
+        auto decl = Match(ast, Declare);
+        return CORD_asprintf("auto %r = %r", decl->var, decl->value);
+    }
+    case Assign: {
+        auto assign = Match(ast, Assign);
+        CORD c = NULL;
+        for (ast_list_t *target = assign->targets, *value = assign->values; target && value; target = target->next, value = value->next) {
+            CORD_sprintf(&c, "%r = %r", compile(target->ast), compile(value->ast));
+            if (target->next) c = CORD_cat(c, ", ");
+        }
+        return c;
+    }
+    // Min, Max,
+    // Array, Table, TableEntry,
+    case FunctionDef: {
+        auto fndef = Match(ast, FunctionDef);
+        CORD c = CORD_asprintf("%r %r(", fndef->ret_type ? compile_type(fndef->ret_type) : "void", compile(fndef->name));
+        for (arg_list_t *arg = fndef->args; arg; arg = arg->next) {
+            CORD_sprintf(&c, "%r%r %s", c, compile_type(arg->type), arg->var->name);
+            if (arg->next) c = CORD_cat(c, ", ");
+        }
+        c = CORD_cat(c, ") {\n");
+        c = CORD_cat(c, compile(fndef->body));
+        c = CORD_cat(c, "}");
+        return c;
+    }
+    case FunctionCall: {
+        auto call = Match(ast, FunctionCall);
+        CORD c = CORD_cat_char(compile(call->fn), '(');
+        for (ast_list_t *arg = call->args; arg; arg = arg->next) {
+            c = CORD_cat(c, compile(arg->ast));
+            if (arg->next) c = CORD_cat(c, ", ");
+        }
+        return CORD_cat_char(c, ')');
+    }
+    // Lambda,
+    // FunctionCall, KeywordArg,
+    // Block,
+    // For, While, If,
+    // Reduction,
+    // Skip, Stop, Pass,
+    // Return,
+    // Extern,
+    // TypeDef,
+    // Index, FieldAccess,
+    // DocTest,
+    // Use,
+    // LinkerDirective,
+    case Unknown: errx(1, "Unknown AST");
+    default: break;
+    }
+    return NULL;
+}
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

compile.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include <gc/cord.h>
+#include <gc.h>
+#include <stdio.h>
+
+#include "util.h"
+
+CORD compile(ast_t *ast);
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

files.c

@@ -0,0 +1,317 @@
+//
+// files.c - Implementation of some file loading functionality.
+//
+
+#include <err.h>
+#include <fcntl.h>
+#include <gc.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+
+#include "files.h"
+#include "util.h"
+
+static const int tabstop = 4;
+
+public char *resolve_path(const char *path, const char *relative_to)
+{
+    if (!relative_to || streq(relative_to, "/dev/stdin")) relative_to = ".";
+    if (!path || strlen(path) == 0) return NULL;
+
+    // Resolve the path to an absolute path, assuming it's relative to the file
+    // it was found in:
+    char buf[PATH_MAX] = {0};
+    if (streq(path, "~") || strncmp(path, "~/", 2) == 0) {
+        char *resolved = realpath(heap_strf("%s%s", getenv("HOME"), path+1), buf);
+        if (resolved) return heap_str(resolved);
+    } else if (streq(path, ".") || strncmp(path, "./", 2) == 0) {
+        char *relative_dir = dirname(heap_str(relative_to));
+        char *resolved = realpath(heap_strf("%s/%s", relative_dir, path), buf);
+        if (resolved) return heap_str(resolved);
+    } else if (path[0] == '/') {
+        // Absolute path:
+        char *resolved = realpath(path, buf);
+        if (resolved) return heap_str(resolved);
+    } else {
+        // Relative path:
+        char *blpath = heap_str(getenv("SSSPATH"));
+        char *relative_dir = dirname(heap_str(relative_to));
+        for (char *dir; (dir = strsep(&blpath, ":")); ) {
+            if (dir[0] == '/') {
+                char *resolved = realpath(heap_strf("%s/%s", dir, path), buf);
+                if (resolved) return heap_str(resolved);
+            } else if (dir[0] == '~' && (dir[1] == '\0' || dir[1] == '/')) {
+                char *resolved = realpath(heap_strf("%s%s/%s", getenv("HOME"), dir, path), buf);
+                if (resolved) return heap_str(resolved);
+            } else if (streq(dir, ".") || strncmp(dir, "./", 2) == 0) {
+                char *resolved = realpath(heap_strf("%s/%s", relative_dir, path), buf);
+                if (resolved) return heap_str(resolved);
+            } else if (streq(dir, ".") || streq(dir, "..") || strncmp(dir, "./", 2) == 0 || strncmp(dir, "../", 3) == 0) {
+                char *resolved = realpath(heap_strf("%s/%s/%s", relative_dir, dir, path), buf);
+                if (resolved) return heap_str(resolved);
+            } else {
+                char *resolved = realpath(heap_strf("%s/%s", dir, path), buf);
+                if (resolved) return heap_str(resolved);
+            }
+        }
+    }
+    return NULL;
+}
+
+static sss_file_t *_load_file(const char* filename, FILE *file)
+{
+    if (!file) return NULL;
+
+    sss_file_t *ret = new(sss_file_t, .filename=filename);
+
+    size_t file_size = 0, line_cap = 0;
+    char *file_buf = NULL, *line_buf = NULL;
+    FILE *mem = open_memstream(&file_buf, &file_size);
+    int64_t line_len = 0;
+    while ((line_len = getline(&line_buf, &line_cap, file)) >= 0) {
+        sss_line_t line_info = {.offset=file_size, .indent=0, .is_empty=false};
+        char *p;
+        for (p = line_buf; *p == ' ' || *p == '\t'; ++p)
+            line_info.indent += *p == ' ' ? 1 : 4;
+        line_info.is_empty = *p != '\r' && *p != '\n';
+        if (ret->line_capacity <= ret->num_lines) {
+            ret->lines = GC_REALLOC(ret->lines, sizeof(sss_line_t)*(ret->line_capacity += 32));
+        }
+        ret->lines[ret->num_lines++] = line_info;
+        fwrite(line_buf, sizeof(char), line_len, mem);
+        fflush(mem);
+    }
+    fclose(file);
+
+    char *copy = GC_MALLOC_ATOMIC(file_size+1);
+    memcpy(copy, file_buf, file_size);
+    copy[file_size] = '\0';
+    ret->text = copy;
+    fclose(mem);
+
+    free(file_buf);
+    ret->relative_filename = filename;
+    if (filename && filename[0] != '<' && !streq(filename, "/dev/stdin")) {
+        filename = resolve_path(filename, ".");
+        // Convert to relative path (if applicable)
+        char buf[PATH_MAX];
+        char *cwd = getcwd(buf, sizeof(buf));
+        int64_t cwd_len = strlen(cwd);
+        if (strncmp(cwd, filename, cwd_len) == 0 && filename[cwd_len] == '/')
+            ret->relative_filename = &filename[cwd_len+1];
+    }
+    return ret;
+}
+
+//
+// Read an entire file into memory.
+//
+public sss_file_t *sss_load_file(const char* filename)
+{
+    FILE *file = filename[0] ? fopen(filename, "r") : stdin;
+    return _load_file(filename, file);
+}
+
+//
+// Create a virtual file from a string.
+//
+public sss_file_t *sss_spoof_file(const char* filename, const char *text)
+{
+    FILE *file = fmemopen((char*)text, strlen(text)+1, "r");
+    return _load_file(filename, file);
+}
+
+//
+// Given a pointer, determine which line number it points to (1-indexed)
+//
+public int64_t sss_get_line_number(sss_file_t *f, const char *p)
+{
+    // Binary search:
+    int64_t lo = 0, hi = (int64_t)f->num_lines-1;
+    if (p < f->text) return 0;
+    int64_t offset = (int64_t)(p - f->text);
+    while (lo <= hi) {
+        int64_t mid = (lo + hi) / 2;
+        sss_line_t *line = &f->lines[mid];
+        if (line->offset == offset)
+            return mid + 1;
+        else if (line->offset < offset)
+            lo = mid + 1;    
+        else if (line->offset > offset)
+            hi = mid - 1;
+    }
+    return lo; // Return the line number whose line starts closest before p
+}
+
+//
+// Given a pointer, determine which line column it points to.
+//
+public int64_t sss_get_line_column(sss_file_t *f, const char *p)
+{
+    int64_t line_no = sss_get_line_number(f, p);
+    sss_line_t *line = &f->lines[line_no-1];
+    return 1 + (int64_t)(p - (f->text + line->offset));
+}
+
+//
+// Given a pointer, get the indentation of the line it's on.
+//
+public int64_t sss_get_indent(sss_file_t *f, const char *p)
+{
+    int64_t line_no = sss_get_line_number(f, p);
+    sss_line_t *line = &f->lines[line_no-1];
+    return line->indent;
+}
+
+//
+// Return a pointer to the line with the specified line number (1-indexed)
+//
+public const char *sss_get_line(sss_file_t *f, int64_t line_number)
+{
+    if (line_number == 0 || line_number > (int64_t)f->num_lines) return NULL;
+    sss_line_t *line = &f->lines[line_number-1];
+    return f->text + line->offset;
+}
+
+//
+// Return a value like /foo:line:col
+//
+public const char *sss_get_file_pos(sss_file_t *f, const char *p)
+{
+    return heap_strf("%s:%ld:%ld", f->filename, sss_get_line_number(f, p), sss_get_line_column(f, p));
+}
+
+static int fputc_column(FILE *out, char c, char print_char, int *column)
+{
+    int printed = 0;
+    if (print_char == '\t') print_char = ' ';
+    if (c == '\t') {
+        for (int to_fill = tabstop - (*column % tabstop); to_fill > 0; --to_fill) {
+            printed += fputc(print_char, out);
+            ++*column;
+        }
+    } else {
+        printed += fputc(print_char, out);
+        ++*column;
+    }
+    return printed;
+}
+
+//
+// Print a span from a file
+//
+public int fprint_span(FILE *out, sss_file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, bool use_color)
+{
+    if (!file) return 0;
+
+    // Handle spans that come from multiple files:
+    if (start < file->text || start > file->text + file->len)
+        start = end;
+    if (end < file->text || end > file->text + file->len)
+        end = start;
+    // Just in case neither end of the span came from this file:
+    if (end < file->text || end > file->text + file->len)
+        start = end = file->text;
+
+    const char *lineno_fmt, *normal_color, *empty_marker;
+    bool print_carets = false;
+    int printed = 0;
+    if (use_color) {
+        lineno_fmt = "\x1b[0;2m%*lu\x1b(0\x78\x1b(B\x1b[m ";
+        normal_color = "\x1b[m";
+        empty_marker = "\x1b(0\x61\x1b(B";
+        printed += fprintf(out, "\x1b[33;4;1m%s\x1b[m\n", file->relative_filename);
+    } else {
+        lineno_fmt = "%*lu| ";
+        hl_color = "";
+        normal_color = "";
+        empty_marker = " ";
+        print_carets = true;
+        printed += fprintf(out, "%s\n", file->relative_filename);
+    }
+
+    if (context_lines == 0)
+        return fprintf(out, "%s%.*s%s", hl_color, (int)(end - start), start, normal_color);
+
+    int64_t start_line = sss_get_line_number(file, start),
+            end_line = sss_get_line_number(file, end);
+
+    int64_t first_line = start_line - (context_lines - 1),
+            last_line = end_line + (context_lines - 1);
+
+    if (first_line < 1) first_line = 1;
+    if (last_line > file->num_lines) last_line = file->num_lines;
+
+    int digits = 1;
+    for (int64_t i = last_line; i > 0; i /= 10) ++digits;
+
+    for (int64_t line_no = first_line; line_no <= last_line; ++line_no) {
+        if (line_no > first_line + 5 && line_no < last_line - 5) {
+            if (use_color)
+                printed += fprintf(out, "\x1b[0;2;3;4m     ... %ld lines omitted ...     \x1b[m\n", (last_line - first_line) - 11);
+            else
+                printed += fprintf(out, "     ... %ld lines omitted ...\n", (last_line - first_line) - 11);
+            line_no = last_line - 6;
+            continue;
+        }
+
+        printed += fprintf(out, lineno_fmt, digits, line_no);
+        const char *line = sss_get_line(file, line_no);
+        if (!line) break;
+
+        int column = 0;
+        const char *p = line;
+        // Before match
+        for (; *p && *p != '\r' && *p != '\n' && p < start; ++p)
+            printed += fputc_column(out, *p, *p, &column);
+
+        // Zero-width matches
+        if (p == start && start == end) {
+            printed += fprintf(out, "%s%s%s", hl_color, empty_marker, normal_color);
+            column += 1;
+        }
+
+        // Inside match
+        if (start <= p && p < end) {
+            printed += fputs(hl_color, out);
+            for (; *p && *p != '\r' && *p != '\n' && p < end; ++p)
+                printed += fputc_column(out, *p, *p, &column);
+            printed += fputs(normal_color, out);
+        }
+
+        // After match
+        for (; *p && *p != '\r' && *p != '\n'; ++p)
+            printed += fputc_column(out, *p, *p, &column);
+
+        printed += fprintf(out, "\n");
+
+        const char *eol = strchrnul(line, '\n');
+        if (print_carets && start >= line && start < eol && line <= start) {
+            for (int num = 0; num < digits; num++)
+                printed += fputc(' ', out);
+            printed += fputs(": ", out);
+            int column = 0;
+            for (const char *sp = line; *sp && *sp != '\n'; ++sp) {
+                char print_char;
+                if (sp < start)
+                    print_char = ' ';
+                else if (sp == start && sp == end)
+                    print_char = '^';
+                else if (sp >= start && sp < end)
+                    print_char = '-';
+                else
+                    print_char = ' ';
+                printed += fputc_column(out, *sp, print_char, &column);
+            }
+            printed += fputs("\n", out);
+        }
+    }
+    fflush(out);
+    return printed;
+}
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

files.h

@@ -0,0 +1,43 @@
+//
+// files.h - Definitions of an API for loading files.
+//
+#pragma once
+
+#include <stdalign.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <unistd.h>
+
+typedef struct {
+    int64_t offset;
+    int64_t indent:63;
+    bool is_empty:1;
+} sss_line_t;
+
+typedef struct {
+    const char *filename, *relative_filename;
+    const char *text;
+    int64_t len;
+    int64_t num_lines, line_capacity;
+    sss_line_t *lines;
+} sss_file_t;
+
+char *resolve_path(const char *path, const char *relative_to);
+__attribute__((nonnull))
+sss_file_t *sss_load_file(const char *filename);
+__attribute__((nonnull, returns_nonnull))
+sss_file_t *sss_spoof_file(const char *filename, const char *text);
+__attribute__((pure, nonnull))
+int64_t sss_get_line_number(sss_file_t *f, const char *p);
+__attribute__((pure, nonnull))
+int64_t sss_get_line_column(sss_file_t *f, const char *p);
+__attribute__((pure, nonnull))
+int64_t sss_get_indent(sss_file_t *f, const char *p);
+__attribute__((pure, nonnull))
+const char *sss_get_line(sss_file_t *f, int64_t line_number);
+__attribute__((pure, nonnull))
+const char *sss_get_file_pos(sss_file_t *f, const char *p);
+int fprint_span(FILE *out, sss_file_t *file, const char *start, const char *end, const char *hl_color, int64_t context_lines, bool use_color);
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

foo.c

@@ -0,0 +1,12 @@
+#include <stdio.h>
+
+int main(void) {
+    int x = 23;
+    const char *s = "Hi";
+#define say(x) _Generic(x, int: printf("%d\n", x), char *: puts(s), default: puts("???"))
+    say(x);
+    say(s);
+#define all(...) { __VA_ARGS__; }
+    all(say("one"); say(2))
+    return 0;
+}

nextlang.c

@@ -0,0 +1,23 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <gc.h>
+#include <gc/cord.h>
+
+#include "ast.h"
+#include "parse.h"
+#include "compile.h"
+
+int main(int argc, char *argv[])
+{
+    if (argc < 2) return 1;
+
+    sss_file_t *f = sss_load_file(argv[1]);
+    ast_t *ast = parse_file(f, NULL);
+    const char *s = ast_to_str(ast);
+    puts(s);
+    CORD c = compile(ast);
+    CORD_put(c, stdout);
+    return 0;
+}
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

parse.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#include <setjmp.h>
+
+#include "ast.h"
+
+type_ast_t *parse_type_str(const char *str);
+ast_t *parse_expression_str(const char *str);
+ast_t *parse_file(sss_file_t *file, jmp_buf *on_err);

util.c

@@ -0,0 +1,84 @@
+#include <ctype.h>
+#include <gc.h>
+#include <gc/cord.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "util.h"
+
+public char *heap_strn(const char *str, size_t len)
+{
+    if (!str) return NULL;
+    if (len == 0) return "";
+    char *heaped = GC_MALLOC_ATOMIC(len + 1);
+    memcpy(heaped, str, len);
+    heaped[len] = '\0';
+    return heaped;
+}
+
+public char *heap_str(const char *str)
+{
+    if (!str) return NULL;
+    return heap_strn(str, strlen(str));
+}
+
+public char *heap_strf(const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    char *tmp = NULL;
+    int len = vasprintf(&tmp, fmt, args);
+    if (len < 0) return NULL;
+    va_end(args);
+    char *ret = heap_strn(tmp, (size_t)len);
+    free(tmp);
+    return ret;
+}
+
+// Name mangling algorithm to produce valid identifiers:
+// Escape individual chars as "_x%02X" 
+// Things being escaped:
+// - Leading digit
+// - Non alphanumeric/non-underscore characters
+// - "_" when followed by "x" and two uppercase hex digits
+public char *mangle(const char *name)
+{
+    size_t len = 0;
+    for (const char *p = name; *p; p++) {
+        if ((!isalnum(*p) && *p != '_') // Non-identifier character
+            || (p == name && isdigit(*p)) // Leading digit
+            || (p[0] == '_' && p[1] == 'x' && strspn(p+2, "ABCDEF0123456789") >= 2)) { // Looks like hex escape
+            len += strlen("_x00"); // Hex escape
+        } else {
+            len += 1;
+        }
+    }
+    char *mangled = GC_MALLOC_ATOMIC(len + 1);
+    char *dest = mangled;
+    for (const char *src = name; *src; src++) {
+        if ((!isalnum(*src) && *src != '_') // Non-identifier character
+            || (src == name && isdigit(*src)) // Leading digit
+            || (src[0] == '_' && src[1] == 'x' && strspn(src+2, "ABCDEF0123456789") >= 2)) { // Looks like hex escape
+            dest += sprintf(dest, "_x%02X", *src); // Hex escape
+        } else {
+            *(dest++) = *src;
+        }
+    }
+    mangled[len] = '\0';
+    return mangled;
+}
+
+CORD CORD_asprintf(const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    CORD c = NULL;
+    CORD_vsprintf(&c, fmt, args);
+    va_end(args);
+    return c;
+}
+
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0

util.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <assert.h>
+#include <gc.h>
+#include <gc/cord.h>
+#include <stdio.h>
+#include <string.h>
+#include <err.h>
+
+#define streq(a, b) (((a) == NULL && (b) == NULL) || (((a) == NULL) == ((b) == NULL) && strcmp(a, b) == 0))
+#define new(t, ...) ((t*)memcpy(GC_MALLOC(sizeof(t)), &(t){__VA_ARGS__}, sizeof(t)))
+#define grow(arr, new_size) ((typeof (arr))GC_REALLOC(arr, (sizeof(arr[0]))*(new_size)))
+#define Match(x, _tag) ((x)->tag == _tag ? &(x)->__data._tag : (errx(1, __FILE__ ":%d This was supposed to be a " # _tag "\n", __LINE__), &(x)->__data._tag))
+#define Tagged(t, _tag, ...) new(t, .tag=_tag, .__data._tag={__VA_ARGS__})
+
+#ifndef auto
+#define auto __auto_type
+#endif
+
+#ifndef public
+#define public __attribute__ ((visibility ("default")))
+#endif
+
+char *heap_strn(const char *str, size_t len);
+char *heap_str(const char *str);
+char *heap_strf(const char *fmt, ...);
+CORD CORD_asprintf(const char *fmt, ...);
+
+// vim: ts=4 sw=0 et cino=L2,l1,(0,W4,m1,\:0