Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

Finished My First Scheme Compiler

Name: Anonymous 2014-05-15 11:52

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();
}

Name: Anonymous 2014-05-15 23:27

>>11

Isn't symta a one man project? Are you behind it?
Yes. Symta is a common name for a series of Lisp spin-offs. I've used previous versions to recreate Warcaft 2 engine (http://www.youtube.com/watch?v=-k8jkeFfnl0), and while they were useful at designing software, I they had cryptic syntax, were slow, centered around Common Lisp and had little modularity support. So the latest version is going to be standalone and self-hosting, while fixing all other deficiencies.

Is this common lisp?
Yes. The >>5-snipped is good old Common Lisp.

Do you code often in common lisp?
I do coding in all kinds of languages. At my workplace I had C#, JavaScript, T-SQL and C/C++.

Why common lisp?
It was my first Lisp environment and CL has good compiler. But I would still recommend Scheme over CL, because Scheme is easier to learn and has better design (i.e. simpler core, no car or cdr on empty list).
Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode + RSS -