Finished My First Scheme Compiler

No optimizations. Simply translates code like that

(test-ssa
(scheme-into-symta
'((define a 2)
(define (f x) (x (_quote +) 1))
(f a))))


into C/C++ statements as follows

#include "../runtime.h"

static int f15308_pool;
static void f15308(regs_t *regs);
static int f15309_pool;
static int f15316_pool;
static void f15316(regs_t *regs);
static int f15317_pool;
static int f15318_pool;
static void f15318(regs_t *regs);
static int f15319_pool;
static int f15321_pool;
static void f15321(regs_t *regs);
static int f15322_pool;
static int f15329_pool;
static void f15329(regs_t *regs);
static int f15330_pool;
static int f15333_pool;
static void f15333(regs_t *regs);
static void f15330(regs_t *regs);
static int f15331_pool;
static void f15331(regs_t *regs);
static int f15332_pool;
static void f15332(regs_t *regs);
static void f15322(regs_t *regs);
static int f15323_pool;
static int f15325_pool;
static void f15325(regs_t *regs);
static int f15326_pool;
static int f15327_pool;
static void f15327(regs_t *regs);
static uint8_t s15328_bytes[] = {43,0};
static void *s15328;
static void f15326(regs_t *regs);
static void f15323(regs_t *regs);
static int f15324_pool;
static void f15324(regs_t *regs);
static void f15319(regs_t *regs);
static int f15320_pool;
static void f15320(regs_t *regs);
static void f15317(regs_t *regs);
static void f15309(regs_t *regs);
static uint8_t s15310_bytes[] = {116,97,103,95,111,102,0};
static void *s15310;
static uint8_t s15311_bytes[] = {95,102,110,95,105,102,0};
static void *s15311;
static uint8_t s15312_bytes[] = {108,105,115,116,0};
static void *s15312;
static uint8_t s15313_bytes[] = {97,114,114,97,121,0};
static void *s15313;
static uint8_t s15314_bytes[] = {99,99,0};
static void *s15314;
static uint8_t s15315_bytes[] = {114,101,97,100,95,102,105,108,101,95,97,115,95,116,101,120,116,0};
static void *s15315;
static void inits15335(regs_t *regs);
void entry(regs_t *regs) {
static int done_init = 0;
if (done_init) goto skip_init;
inits15335(regs);
done_init = 1;
skip_init:;
MOVE(C, run);
ARRAY(E, 1);
ALLOC(R, f15308, f15308_pool, 0);
STORE(E, 0, R);
CALL_TAGGED(C);
}

static void f15308(regs_t *regs) {
CHECK_NARGS(2, v_empty);
ALLOC(C, f15309, f15309_pool, 1);
STORE(C, 0, E);
ARRAY(E, 1);
ALLOC(R, f15316, f15316_pool, 0);
STORE(E, 0, R);
CALL(C);
}

static void f15316(regs_t *regs) {
CHECK_NARGS(7, v_empty);
ALLOC(C, f15317, f15317_pool, 1);
STORE(C, 0, E);
ARRAY(E, 1);
ALLOC(R, f15318, f15318_pool, 0);
STORE(E, 0, R);
CALL(C);
}

static void f15318(regs_t *regs) {
CHECK_NARGS(4, v_empty);
ALLOC(C, f15319, f15319_pool, 1);
STORE(C, 0, E);
ARRAY(A, 1);
ALLOC(R, f15321, f15321_pool, 1);
STORE(R, 0, E);
/* known closure */
STORE(A, 0, R);
MOVE(E, A);
CALL(C);
}

static void f15321(regs_t *regs) {
CHECK_NARGS(2, v_empty);
ALLOC(R, f15322, f15322_pool, 2);
COPY(R, 0, P, 0);
STORE(R, 1, E);
/* known closure */
MOVE(C, R);
ARRAY(A, 1);
ALLOC(R, f15329, f15329_pool, 1);
COPY(R, 0, P, 0);
/* known closure */
STORE(A, 0, R);
MOVE(E, A);
CALL(C);
}

static void f15329(regs_t *regs) {
CHECK_NARGS(2, v_empty);
ALLOC(R, f15330, f15330_pool, 2);
COPY(R, 0, P, 0);
STORE(R, 1, E);
/* known closure */
MOVE(C, R);
ARRAY(E, 1);
ALLOC(R, f15333, f15333_pool, 0);
STORE(E, 0, R);
CALL(C);
}

static void f15333(regs_t *regs) {
CHECK_NARGS(2, v_empty);
LOAD(C, E, 0);
ARRAY(A, 1);
COPY(A, 0, E, 1);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15330(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 2);
ARRAY(A, 2);
ALLOC(R, f15331, f15331_pool, 3);
COPY(R, 0, P, 0);
STORE(R, 1, E);
COPY(R, 2, P, 1);
/* known closure */
STORE(A, 0, R);
LOAD(R, P, 0);
COPY(A, 1, R, 1);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15331(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(A, E, 0);
LOAD(R, P, 0);
STORE(R, 3, A);
ALLOC(R, f15332, f15332_pool, 2);
COPY(R, 0, P, 1);
COPY(R, 1, P, 2);
/* known closure */
MOVE(C, R);
ARRAY(A, 1);
COPY(A, 0, E, 0);
MOVE(E, A);
CALL(C);
}

static void f15332(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 0);
ARRAY(A, 2);
LOAD(R, P, 1);
COPY(A, 0, R, 0);
COPY(A, 1, E, 0);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15322(regs_t *regs) {
CHECK_NARGS(1, v_empty);
ALLOC(R, f15323, f15323_pool, 3);
COPY(R, 0, P, 0);
STORE(R, 1, E);
COPY(R, 2, P, 1);
/* known closure */
MOVE(C, R);
ARRAY(E, 1);
ALLOC(R, f15325, f15325_pool, 0);
STORE(E, 0, R);
CALL(C);
}

static void f15325(regs_t *regs) {
CHECK_NARGS(2, v_empty);
ALLOC(C, f15326, f15326_pool, 1);
STORE(C, 0, E);
ARRAY(A, 1);
ALLOC(R, f15327, f15327_pool, 1);
STORE(R, 0, E);
/* known closure */
STORE(A, 0, R);
MOVE(E, A);
CALL(C);
}

static void f15327(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 1);
ARRAY(A, 3);
COPY(A, 0, E, 0);
STORE(A, 1, s15328);
FIXNUM(R, 1);
STORE(A, 2, R);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15326(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(C, E, 0);
ARRAY(A, 1);
LOAD(R, P, 0);
COPY(A, 0, R, 0);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15323(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(A, E, 0);
LOAD(R, P, 0);
STORE(R, 2, A);
ALLOC(R, f15324, f15324_pool, 2);
COPY(R, 0, P, 1);
COPY(R, 1, P, 2);
/* known closure */
MOVE(C, R);
ARRAY(A, 1);
COPY(A, 0, E, 0);
MOVE(E, A);
CALL(C);
}

static void f15324(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 0);
ARRAY(A, 2);
LOAD(R, P, 1);
COPY(A, 0, R, 0);
COPY(A, 1, E, 0);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15319(regs_t *regs) {
CHECK_NARGS(1, v_empty);
FIXNUM(R, 2);
MOVE(A, R);
LOAD(R, P, 0);
STORE(R, 1, A);
ALLOC(R, f15320, f15320_pool, 2);
STORE(R, 0, E);
COPY(R, 1, P, 0);
/* known closure */
MOVE(C, R);
ARRAY(A, 1);
FIXNUM(R, 2);
STORE(A, 0, R);
MOVE(E, A);
CALL(C);
}

static void f15320(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 0);
ARRAY(A, 2);
LOAD(R, P, 1);
COPY(A, 0, R, 0);
COPY(A, 1, E, 0);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15317(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(C, E, 0);
ARRAY(A, 4);
LOAD(R, P, 0);
COPY(A, 0, R, 0);
STORE(A, 1, v_void);
STORE(A, 2, v_void);
STORE(A, 3, v_void);
MOVE(E, A);
CALL_TAGGED(C);
}

static void f15309(regs_t *regs) {
CHECK_NARGS(1, v_empty);
LOAD(R, P, 0);
LOAD(C, R, 1);
ARRAY(A, 8);
LOAD(R, P, 0);
COPY(A, 0, R, 0);
COPY(A, 1, E, 0);
STORE(A, 2, s15310);
STORE(A, 3, s15311);
STORE(A, 4, s15312);
STORE(A, 5, s15313);
STORE(A, 6, s15314);
STORE(A, 7, s15315);
MOVE(E, A);
CALL_TAGGED(C);
}

static void inits15335(regs_t *regs) {
TEXT(s15315, (char*)s15315_bytes);
TEXT(s15314, (char*)s15314_bytes);
TEXT(s15313, (char*)s15313_bytes);
TEXT(s15312, (char*)s15312_bytes);
TEXT(s15311, (char*)s15311_bytes);
TEXT(s15310, (char*)s15310_bytes);
f15320_pool = regs->new_pool();
f15324_pool = regs->new_pool();
TEXT(s15328, (char*)s15328_bytes);
f15327_pool = regs->new_pool();
f15326_pool = regs->new_pool();
f15325_pool = regs->new_pool();
f15323_pool = regs->new_pool();
f15332_pool = regs->new_pool();
f15331_pool = regs->new_pool();
f15333_pool = regs->new_pool();
f15330_pool = regs->new_pool();
f15329_pool = regs->new_pool();
f15322_pool = regs->new_pool();
f15321_pool = regs->new_pool();
f15319_pool = regs->new_pool();
f15318_pool = regs->new_pool();
f15317_pool = regs->new_pool();
f15316_pool = regs->new_pool();
f15309_pool = regs->new_pool();
f15308_pool = regs->new_pool();
}


>>7
your editor probably does it's own indentation.

>>8
I highly doubt it could be understood with a quick look. But the main idea is to copy links to the used arglists, during the creation of closure. This trades memory for access speed.