You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
298 lines
7.3 KiB
C
298 lines
7.3 KiB
C
#include <stdint.h>
|
|
|
|
#define NAKED __attribute__((naked))
|
|
|
|
#define END_OF(arr) ((arr) + (sizeof((arr)) / sizeof(*(arr))))
|
|
#define NEXT { goto *(*++pp); }
|
|
|
|
#define LIT(x) push, (void *)(x)
|
|
#define FTH(w) enter, (w##_body)
|
|
#define EXIT doexit
|
|
|
|
#define ATTR_NATIVE (1 << 7)
|
|
#define ATTR_IMMEDIATE (1 << 6)
|
|
#define ATTR_LEN (0x3F)
|
|
|
|
#define WORD(name, tname, prev, attr) \
|
|
extern const void *name##_body[]; \
|
|
struct word_t w_##name = { \
|
|
name##_body, prev, attr + sizeof(tname) - 1, tname \
|
|
}; \
|
|
const void *name##_body[] = {
|
|
#define END EXIT, };
|
|
|
|
#define W(name, tname, prev) WORD(name, tname, prev, 0)
|
|
#define I(name, tname, prev) WORD(name, tname, prev, ATTR_IMMEDIATE)
|
|
#define N(name, tname, prev) \
|
|
extern const void *name##_body[]; \
|
|
struct word_t w_##name = { \
|
|
name##_body, prev, \
|
|
ATTR_NATIVE + sizeof(tname) - 1, tname \
|
|
}; \
|
|
const void *name##_body[] = { name, EXIT };
|
|
#define C(name, tname, prev) \
|
|
extern const void *name##_body[]; \
|
|
struct word_t w_##name = { \
|
|
name##_body, prev, \
|
|
(ATTR_NATIVE | ATTR_IMMEDIATE) + sizeof(tname) - 1, tname \
|
|
}; \
|
|
const void *name##_body[] = { name, EXIT };
|
|
|
|
struct word_t
|
|
{
|
|
const void **body;
|
|
struct word_t *prev;
|
|
unsigned char attr;
|
|
char name[];
|
|
} __attribute__ ((packed));
|
|
|
|
intptr_t dstack[32];
|
|
intptr_t **rstack[32];
|
|
intptr_t dict[8192];
|
|
struct word_t *latest;
|
|
//char inbuf [ 128];
|
|
//intptr_t inpos;
|
|
|
|
register intptr_t tmp asm("r12");
|
|
register intptr_t * sp asm("r13"); // pointer to stack cells
|
|
register intptr_t *** rp asm("r14"); // stack of pp
|
|
register intptr_t ** pp asm("r15"); // pointer to ip
|
|
|
|
#define STASH asm("push %r12; push %r13; push %r14; push %r15")
|
|
#define RESTORE asm("pop %r15; pop %r14; pop %r13; pop %r12")
|
|
|
|
NAKED
|
|
void push(void)
|
|
{
|
|
*--sp = (intptr_t)*++pp;
|
|
NEXT;
|
|
}
|
|
|
|
NAKED
|
|
void sp_at(void)
|
|
{
|
|
sp = sp - 1;
|
|
*sp = (intptr_t)(sp + 1);
|
|
NEXT;
|
|
}
|
|
|
|
NAKED
|
|
void enter(void)
|
|
{
|
|
*--rp = ++pp;
|
|
pp = (intptr_t **)*pp;
|
|
goto *(*pp);
|
|
}
|
|
|
|
void doexit(void)
|
|
{
|
|
if (rp < END_OF(rstack)) {
|
|
pp = *rp++;
|
|
NEXT;
|
|
}
|
|
|
|
pp = 0;
|
|
}
|
|
|
|
intptr_t state = 0;
|
|
intptr_t *here = dict;
|
|
|
|
NAKED void drop(void) { ++sp; NEXT; }
|
|
NAKED void swap(void) { tmp = sp[0]; sp[0] = sp[1]; sp[1] = tmp; NEXT; }
|
|
NAKED void add(void) { sp[1] += sp[0]; ++sp; NEXT; }
|
|
NAKED void sub(void) { sp[1] -= sp[0]; ++sp; NEXT; }
|
|
NAKED void mul(void) { sp[1] *= sp[0]; ++sp; NEXT; }
|
|
NAKED void div(void) { sp[1] /= sp[0]; ++sp; NEXT; }
|
|
NAKED void mod(void) { sp[1] %= sp[0]; ++sp; NEXT; }
|
|
NAKED void and(void) { sp[1] &= sp[0]; ++sp; NEXT; }
|
|
NAKED void or(void) { sp[1] |= sp[0]; ++sp; NEXT; }
|
|
NAKED void xor(void) { sp[1] ^= sp[0]; ++sp; NEXT; }
|
|
NAKED void peek(void) { *sp = *(intptr_t *)*sp; NEXT; }
|
|
NAKED void poke(void) { *(intptr_t *)sp[0] = sp[1]; sp -= 2; NEXT; }
|
|
NAKED void cpeek(void) { *sp = *(char *)*sp; NEXT; }
|
|
NAKED void cpoke(void) { *(char *)sp[0] = sp[1]; sp -= 2; NEXT; }
|
|
NAKED void comp(void) { state = -1; NEXT; }
|
|
NAKED void intr(void) { state = 0; NEXT; }
|
|
NAKED void comma(void) { *here++ = *sp++; NEXT; }
|
|
|
|
NAKED void colon(void)
|
|
{
|
|
static int ch;
|
|
|
|
tmp = (intptr_t)here++; // body
|
|
*here++ = (intptr_t)latest;
|
|
|
|
STASH;
|
|
for (;;) {
|
|
extern int getchar(void);
|
|
ch = getchar();
|
|
|
|
if (ch <= 0x20)
|
|
break;
|
|
|
|
*(unsigned char *)here += 1;
|
|
((char *)here)[*(unsigned char *)here] = ch;
|
|
}
|
|
RESTORE;
|
|
|
|
here += *(unsigned char *)here;
|
|
here = (intptr_t *)(((intptr_t)here + sizeof(intptr_t) - 1)
|
|
& ~(sizeof(intptr_t) - 1));
|
|
*(intptr_t *)tmp = (intptr_t)here;
|
|
*--sp = tmp;
|
|
state = -1;
|
|
NEXT;
|
|
}
|
|
|
|
//W(two, "2", &w_dup) LIT(2), FTH(dup), END
|
|
|
|
NAKED void dot(void);
|
|
|
|
W(dup, "dup", 0) sp_at, peek, END
|
|
N(drop, "drop", &w_dup)
|
|
N(swap, "swap", &w_drop)
|
|
N(peek, "@", &w_swap)
|
|
N(poke, "!", &w_peek)
|
|
N(cpeek, "c@", &w_poke)
|
|
N(cpoke, "c!", &w_cpeek)
|
|
N(add, "+", &w_cpoke)
|
|
N(sub, "-", &w_add)
|
|
N(mul, "*", &w_sub)
|
|
N(div, "/", &w_mul)
|
|
N(mod, "mod", &w_div)
|
|
N(and, "and", &w_mod)
|
|
N(or, "or", &w_and)
|
|
N(xor, "xor", &w_or)
|
|
W(cell, "cell", &w_xor) LIT(sizeof(*sp)), END
|
|
W(cellp, "cell+", &w_cell) FTH(cell), add, END
|
|
W(cells, "cells", &w_cellp) FTH(cell), mul, END
|
|
W(dict, "_d", &w_cells) LIT(dict), END
|
|
W(here, "here", &w_dict) LIT(&here), peek, END
|
|
W(latest, "latest", &w_here) LIT(&latest), peek, END
|
|
C(intr, "[", &w_latest)
|
|
N(comp, "]", &w_intr)
|
|
N(dot, ".", &w_comp)
|
|
W(negate, "negate", &w_dot) LIT(-1), mul, END
|
|
W(invert, "invert", &w_negate) LIT(-1), xor, END
|
|
W(dec, "1-", &w_invert) LIT(1), sub, END
|
|
W(inc, "1+", &w_dec) LIT(1), add, END
|
|
N(colon, ":", &w_inc)
|
|
W(aligned, "aligned", &w_colon) LIT(sizeof(*sp) - 1), add, LIT(~(sizeof(*sp) - 1)), and, END
|
|
W(align, "align", &w_aligned) FTH(here), FTH(aligned), LIT(&here), poke, END
|
|
N(comma, ",", &w_align)
|
|
I(semic, ";", &w_comma) LIT(doexit), comma, LIT(&latest), poke, intr, END
|
|
#define LATEST &w_semic
|
|
|
|
#include <ctype.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
NAKED void dot() { printf("%ld ", *sp++); NEXT; }
|
|
|
|
extern long strtol(char *, char **, int);
|
|
static void call(void *ptr);
|
|
static void dump(void);
|
|
static void init(void);
|
|
|
|
int base = 10;
|
|
|
|
int main()
|
|
{
|
|
char buf[128];
|
|
|
|
init();
|
|
|
|
for (;;) {
|
|
//dump();
|
|
|
|
char c;
|
|
do c = getchar();
|
|
while (!isgraph(c));
|
|
|
|
char *s = buf;
|
|
do {
|
|
*s++ = c;
|
|
c = getchar();
|
|
} while (isgraph(c));
|
|
*s = '\0';
|
|
|
|
if (strcmp(buf, "bye") == 0)
|
|
break;
|
|
|
|
struct word_t *l;
|
|
for (l = latest; l; l = l->prev) {
|
|
const int ln = l->attr & ATTR_LEN;
|
|
|
|
if (s - buf == ln && !strncmp(buf, l->name, ln))
|
|
break;
|
|
}
|
|
|
|
if (l == 0) {
|
|
char *end;
|
|
long n = strtol(buf, &end, base);
|
|
if (*end == '\0') {
|
|
if (state) {
|
|
*here++ = (intptr_t)push;
|
|
*here++ = n;
|
|
} else {
|
|
*--sp = n;
|
|
}
|
|
} else {
|
|
puts("word not found");
|
|
}
|
|
} else {
|
|
if (state && !(l->attr & ATTR_IMMEDIATE)) {
|
|
if (!(l->attr & ATTR_NATIVE)) {
|
|
*here++ = (intptr_t)enter;
|
|
*here++ = (intptr_t)l->body;
|
|
} else {
|
|
*here++ = (intptr_t)l->body[0];
|
|
}
|
|
} else {
|
|
call(l->body);
|
|
}
|
|
}
|
|
|
|
puts(state ? "compiled" : "ok");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void init(void)
|
|
{
|
|
sp = END_OF(dstack);
|
|
rp = END_OF(rstack);
|
|
pp = 0;
|
|
|
|
latest = LATEST;
|
|
}
|
|
|
|
void dump(void)
|
|
{
|
|
//printf("IP: %ld\n", (intptr_t)pp);
|
|
|
|
printf("DS: ");
|
|
intptr_t *it = END_OF(dstack) - 1;
|
|
while (it >= sp) {
|
|
printf("%ld ", *it);
|
|
--it;
|
|
}
|
|
putchar('\n');
|
|
|
|
//printf("RS: ");
|
|
//intptr_t ***rt = END_OF(rstack) - 1;
|
|
//while (rt >= rp) {
|
|
// printf("%ld ", (intptr_t)*rt);
|
|
// --rt;
|
|
//}
|
|
//putchar('\n');
|
|
}
|
|
|
|
void call(void *ptr)
|
|
{
|
|
pp = ptr;
|
|
((void (*)())*pp)();
|
|
}
|
|
|