removed "active file" concept from minijort in favour of taking a file pointer on the stack
897 lines
15 KiB
C
Executable file
897 lines
15 KiB
C
Executable file
//#define TRACE
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <dos.h>
|
|
#include <dir.h>
|
|
#include <alloc.h>
|
|
#include "minijort.h"
|
|
|
|
#define STACK_OFFSET 0
|
|
#define RSTACK_OFFSET STACK_SIZE
|
|
|
|
char mem[MEM_SIZE] = { 0 };
|
|
cell *HERE = ((cell*)mem) + STACK_SIZE + RSTACK_SIZE;
|
|
cell *LATEST = NULL;
|
|
cell IP = NULL;
|
|
cell W = NULL;
|
|
cell STATE = 0;
|
|
cell *stack = ((cell*)mem);
|
|
cell *rstack = ((cell*)mem) + STACK_SIZE;
|
|
#ifdef TRACE
|
|
int TRACING = 0;
|
|
#endif
|
|
|
|
FILE *IN_FILE = stdin;
|
|
FILE *OUT_FILE = stdout;
|
|
|
|
void DROP(n) {
|
|
stack -= n;
|
|
if (stack < mem + STACK_OFFSET) {
|
|
stack = mem + STACK_OFFSET;
|
|
PUSHS("underflow!\n");
|
|
f_puts();
|
|
}
|
|
}
|
|
|
|
void PUSHC(cell c) { *stack = c; stack++; }
|
|
void PUSHI(int i) { stack->i = i; stack++; }
|
|
void PUSHU(unsigned int u) { stack->u = u; stack++; }
|
|
void PUSHCP(cell *c) { stack->p = c; stack++; }
|
|
void PUSHS(char *s) { stack->s = s; stack++; }
|
|
void RPUSH(cell c) { *rstack = c; rstack++; }
|
|
|
|
void f_here() {
|
|
PUSHCP(HERE);
|
|
}
|
|
|
|
void f_here_set() {
|
|
HERE = TOP().p;
|
|
DROP(1);
|
|
}
|
|
void f_there() {
|
|
PUSHCP(&mem[MEM_SIZE]);
|
|
}
|
|
|
|
void f_latest() {
|
|
PUSHCP(LATEST);
|
|
}
|
|
|
|
void f_latest_set() {
|
|
LATEST = TOP().p;
|
|
DROP(1);
|
|
}
|
|
|
|
void f_state() {
|
|
PUSHC(STATE);
|
|
}
|
|
|
|
#define BINOP(name, type, op) \
|
|
void name() { \
|
|
cell r = TOP(); \
|
|
DROP(1); \
|
|
TOP().type = TOP().type op r.type; \
|
|
}
|
|
|
|
BINOP(f_add, i, +)
|
|
BINOP(f_sub, i, -)
|
|
BINOP(f_mul, i, *)
|
|
BINOP(f_div, i, /)
|
|
BINOP(f_mod, u, %)
|
|
BINOP(f_eq, i, ==)
|
|
BINOP(f_neq, i, !=)
|
|
BINOP(f_ge, i, >=)
|
|
BINOP(f_gt, i, >)
|
|
BINOP(f_lt, i, <)
|
|
BINOP(f_le, i, <=)
|
|
BINOP(f_uge, u, >=)
|
|
BINOP(f_ugt, u, >)
|
|
BINOP(f_ult, u, <)
|
|
BINOP(f_ule, u, <=)
|
|
BINOP(f_and, u, &&)
|
|
BINOP(f_or, u, ||)
|
|
BINOP(f_bitand, u, &)
|
|
BINOP(f_bitor, u, |)
|
|
BINOP(f_bitxor, u, ^)
|
|
BINOP(f_shr, u, >>)
|
|
BINOP(f_shl, u, <<)
|
|
|
|
#define RATIO_FRACTIONAL_BITS 14
|
|
|
|
void f_toratio() { // a/b ( a b -- r )
|
|
ST1().i = ((long)ST1().i * (1 << RATIO_FRACTIONAL_BITS)) / TOP().i;
|
|
DROP(1);
|
|
}
|
|
|
|
void f_fromratio() { // a*r ( a r -- b )
|
|
ST1().i = ((long)ST1().i * (long)TOP().i) / (1 << RATIO_FRACTIONAL_BITS);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_not() {
|
|
TOP().i = !TOP().i;
|
|
}
|
|
|
|
void f_get() {
|
|
TOP() = (*(TOP().p));
|
|
}
|
|
|
|
void f_set() {
|
|
cell *p = TOP().p;
|
|
DROP(1);
|
|
(*p) = TOP();
|
|
DROP(1);
|
|
}
|
|
|
|
void f_bget() {
|
|
TOP().i = *((char*)TOP().p);
|
|
}
|
|
|
|
void f_ubget() {
|
|
TOP().u = *((unsigned char*)TOP().p);
|
|
}
|
|
|
|
void f_bset() {
|
|
char *p = (char*)TOP().p;
|
|
DROP(1);
|
|
(*p) = TOP().i;
|
|
DROP(1);
|
|
}
|
|
|
|
void f_farset() {
|
|
*((cell far *)MK_FP(TOP().u, ST1().u)) = ST2();
|
|
DROP(3);
|
|
}
|
|
|
|
void f_farget() {
|
|
ST1() = *((cell far *)MK_FP(TOP().u, ST1().u));
|
|
DROP(1);
|
|
}
|
|
|
|
void f_farbset() {
|
|
*((char far *)MK_FP(TOP().u, ST1().u)) = ST2().i;
|
|
DROP(3);
|
|
}
|
|
|
|
void f_farbget() {
|
|
ST1().i = *((char far *)MK_FP(TOP().u, ST1().u));
|
|
DROP(1);
|
|
}
|
|
|
|
void f_addset() {
|
|
TOP().p->i += ST1().i;
|
|
DROP(2);
|
|
}
|
|
|
|
void f_drop() {
|
|
DROP(1);
|
|
}
|
|
|
|
void f_dup() {
|
|
PUSHC(TOP());
|
|
}
|
|
|
|
void f_over() {
|
|
PUSHC(ST1());
|
|
}
|
|
|
|
void f_swap() {
|
|
cell top = TOP();
|
|
cell st1 = ST1();
|
|
TOP() = st1;
|
|
ST1() = top;
|
|
}
|
|
|
|
void f_rot() { // a b c -- b c a
|
|
cell c = TOP();
|
|
cell b = ST1();
|
|
cell a = ST2();
|
|
TOP() = a;
|
|
ST1() = c;
|
|
ST2() = b;
|
|
}
|
|
|
|
void f_rput() {
|
|
RPUSH(TOP());
|
|
DROP(1);
|
|
}
|
|
|
|
void f_rtake() {
|
|
PUSHC(*RPOP());
|
|
}
|
|
|
|
void f_rtop() {
|
|
PUSHC(*(rstack - 1));
|
|
}
|
|
|
|
void f_rdrop() {
|
|
RPOP();
|
|
}
|
|
|
|
void f_rswap() {
|
|
cell top = *(rstack - 1);
|
|
cell under = *(rstack - 2);
|
|
*(rstack - 1) = under;
|
|
*(rstack - 2) = top;
|
|
}
|
|
|
|
void f_cexecute();
|
|
|
|
void f_emit() {
|
|
if (OUT_FILE) {
|
|
fprintf(OUT_FILE, "%c", TOP().i);
|
|
}
|
|
DROP(1);
|
|
}
|
|
|
|
void f_key() {
|
|
if (IN_FILE) {
|
|
PUSHI(fgetc(IN_FILE));
|
|
} else {
|
|
PUSHI(EOF);
|
|
}
|
|
}
|
|
|
|
void f_word() {
|
|
static char buf[32] = {0};
|
|
int key = ' ';
|
|
int ibuf = 0;
|
|
|
|
while (key == ' ' || key == '\t' || key == '\n' || key == '\r') {
|
|
f_key();
|
|
key = TOP().i;
|
|
DROP(1);
|
|
}
|
|
|
|
while (key != ' ' && key != '\t' && key != '\n' && key != '\r' && key != 0 && key != EOF) {
|
|
buf[ibuf++] = key;
|
|
f_key();
|
|
key = TOP().i;
|
|
DROP(1);
|
|
}
|
|
buf[ibuf] = 0;
|
|
PUSHS(buf);
|
|
}
|
|
|
|
void f_fputc() {
|
|
fwrite(&ST1().i, 1, 1, TOP().fp);
|
|
DROP(2);
|
|
}
|
|
|
|
void f_gets() {
|
|
gets(TOP().s);
|
|
}
|
|
|
|
void f_fwrite() { // ( length p fp )
|
|
fwrite(ST1().p, ST2().u, 1, TOP().fp);
|
|
DROP(3);
|
|
}
|
|
|
|
void f_fgetc() {
|
|
int result;
|
|
result = fgetc(TOP().fp);
|
|
TOP().i = result;
|
|
}
|
|
|
|
void f_fread() { // ( length p fp )
|
|
fread(ST1().p, ST2().u, 1, TOP().fp);
|
|
DROP(3);
|
|
}
|
|
|
|
void f_feof() {
|
|
PUSHI(feof(TOP().fp));
|
|
}
|
|
|
|
void f_puts() {
|
|
char *s = TOP().s;
|
|
while (s && *s) {
|
|
PUSHI(*s);
|
|
f_emit();
|
|
s++;
|
|
}
|
|
DROP(1);
|
|
}
|
|
|
|
void f_dot() {
|
|
static char num[16];
|
|
sprintf(num, "%d ", TOP().i);
|
|
TOP().s = num;
|
|
f_puts();
|
|
}
|
|
|
|
void f_udot() {
|
|
static char num[16];
|
|
sprintf(num, "%u ", TOP().i);
|
|
TOP().s = num;
|
|
f_puts();
|
|
}
|
|
|
|
void f_printstack() {
|
|
cell *v = mem + STACK_OFFSET;
|
|
while (v != stack) {
|
|
PUSHC(*v++);
|
|
f_dot();
|
|
}
|
|
}
|
|
|
|
void f_printrstack() {
|
|
cell *v = mem + RSTACK_OFFSET;
|
|
while (v != rstack) {
|
|
PUSHC(*v++);
|
|
f_dot();
|
|
}
|
|
}
|
|
|
|
void f_cr() {
|
|
PUSHI('\n');
|
|
f_emit();
|
|
}
|
|
|
|
void f_comma() {
|
|
*HERE++ = TOP();
|
|
DROP(1);
|
|
}
|
|
|
|
void f_allot() {
|
|
memset(HERE, 0, TOP().u);
|
|
HERE = CELL_OFFSET(HERE, TOP().u);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_bcomma() {
|
|
*((char*)HERE) = TOP().i;
|
|
HERE = CELL_OFFSET(HERE, 1);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_create() { // name --
|
|
int namelen;
|
|
HERE->p = LATEST;
|
|
LATEST = HERE;
|
|
HERE++;
|
|
namelen = strlen(TOP().s);
|
|
HERE->u = namelen; HERE ++;
|
|
memcpy(HERE, TOP().s, namelen + 1);
|
|
HERE = CELL_OFFSET(HERE, namelen + 1);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_cdef() { // func name --
|
|
f_create();
|
|
f_comma();
|
|
}
|
|
|
|
void f_revlookup();
|
|
|
|
#ifdef TRACE
|
|
void f_traceon() {
|
|
TRACING = 1;
|
|
}
|
|
void f_traceoff() {
|
|
TRACING = 0;
|
|
}
|
|
|
|
void f_colondispatch() {
|
|
static int printing = 0;
|
|
|
|
if (TRACING && !printing) {
|
|
printing = 1;
|
|
PUSHCP(W.p);
|
|
f_revlookup();
|
|
if (TOP().s) {
|
|
f_puts();
|
|
PUSHU(' ');
|
|
f_emit();
|
|
} else {
|
|
TOP().p = W.p;
|
|
f_dot();
|
|
}
|
|
printing = 0;
|
|
}
|
|
W.p->f();
|
|
}
|
|
#else
|
|
#define f_colondispatch() W.p->f()
|
|
#endif
|
|
|
|
void f_colonloop() {
|
|
while (IP.p) {
|
|
W = *IP.p;
|
|
IP.p++;
|
|
f_colondispatch();
|
|
}
|
|
}
|
|
|
|
// this version of f_execute can be run from a colon word
|
|
void f_execute() {
|
|
W = TOP();
|
|
DROP(1);
|
|
f_colondispatch();
|
|
}
|
|
|
|
// C code must always call a colon word through f_cexecute()
|
|
void f_cexecute() {
|
|
cell oldW = W;
|
|
cell oldIP = IP;
|
|
IP.p = NULL;
|
|
f_execute();
|
|
f_colonloop();
|
|
W = oldW;
|
|
IP = oldIP;
|
|
}
|
|
|
|
void f_docolon() {
|
|
RPUSH(IP);
|
|
IP.p = W.p + 1;
|
|
}
|
|
|
|
void f_dodeferred() {
|
|
W = *(W.p + 1);
|
|
f_colondispatch();
|
|
}
|
|
|
|
void f_lit_() {
|
|
PUSHC(*IP.p);
|
|
IP.p++;
|
|
}
|
|
|
|
void f_number() { // str -- (num 1 | str 0)
|
|
int num = 0, result;
|
|
result = sscanf(TOP().s, "0x%x", &num);
|
|
if (result != 1) {
|
|
result = sscanf(TOP().s, "%d", &num);
|
|
}
|
|
if (result == 1) {
|
|
TOP().i = num;
|
|
PUSHI(result == 1);
|
|
} else {
|
|
PUSHI(0);
|
|
}
|
|
}
|
|
|
|
void f_streq() {
|
|
int result = strcmp(TOP().s, ST1().s);
|
|
DROP(1);
|
|
TOP().i = result == 0;
|
|
}
|
|
|
|
void f_wordname() {
|
|
TOP().p = TOP().p + 2;
|
|
}
|
|
void f_wordflags() {
|
|
TOP().p = TOP().p + 1;
|
|
}
|
|
|
|
void f_codepointer() {
|
|
unsigned int flags = TOP().p[1].u;
|
|
TOP().p = CELL_OFFSET(TOP().p + 2, (flags & F_NAMELEN_MASK) + 1);
|
|
}
|
|
|
|
void f_lookup() { // name -- (codepointer flags) | (name 0)
|
|
cell *entry = LATEST;
|
|
char *name = TOP().s;
|
|
int len = strlen(name);
|
|
DROP(1);
|
|
|
|
while (entry) {
|
|
PUSHP(entry);
|
|
f_wordflags(); f_get();
|
|
if (len == (TOP().u & F_NAMELEN_MASK)) {
|
|
PUSHS(name);
|
|
PUSHP(entry);
|
|
f_wordname();
|
|
f_streq();
|
|
if (TOP().i) {
|
|
TOP().p = entry;
|
|
f_codepointer();
|
|
f_swap();
|
|
return;
|
|
}
|
|
DROP(2);
|
|
} else {
|
|
DROP(1);
|
|
}
|
|
entry = entry->p;
|
|
}
|
|
PUSHS(name);
|
|
PUSHU(0);
|
|
}
|
|
|
|
void f_revlookup() { // codepointer -- name
|
|
cell *entry = LATEST;
|
|
while (entry) {
|
|
PUSHCP(entry);
|
|
f_codepointer();
|
|
if (TOP().p == ST1().p) {
|
|
DROP(1);
|
|
TOP().p = entry;
|
|
f_wordname();
|
|
return;
|
|
}
|
|
DROP(1);
|
|
entry = entry->p;
|
|
}
|
|
TOP().p = NULL;
|
|
}
|
|
|
|
void f_compileon() {
|
|
STATE.i = 1;
|
|
}
|
|
void f_compileoff() {
|
|
STATE.i = 0;
|
|
}
|
|
|
|
void f_immediate() {
|
|
cell *flags = LATEST + 1;
|
|
flags->u |= F_IMMEDIATE;
|
|
}
|
|
void f_compileword();
|
|
|
|
void f_semicolon() {
|
|
PUSHS("return");
|
|
f_compileword();
|
|
f_compileoff();
|
|
}
|
|
|
|
void f_ret() {
|
|
if (rstack == mem + RSTACK_OFFSET) {
|
|
IP.p = NULL;
|
|
} else {
|
|
IP = *RPOP();
|
|
}
|
|
}
|
|
|
|
void f_colon() {
|
|
f_word();
|
|
f_create();
|
|
PUSHP(f_docolon);
|
|
f_comma();
|
|
f_compileon();
|
|
}
|
|
|
|
void f_interpretword() { // codefield flags --
|
|
if (!STATE.i || (TOP().u & F_IMMEDIATE)) {
|
|
DROP(1);
|
|
f_cexecute();
|
|
} else {
|
|
DROP(1);
|
|
f_comma();
|
|
}
|
|
}
|
|
|
|
void f_interpretnumber() { // number --
|
|
if (STATE.i) {
|
|
PUSHS("LIT_");
|
|
f_compileword();
|
|
f_comma();
|
|
}
|
|
}
|
|
|
|
void f_interpretunknown() { // name --
|
|
f_puts();
|
|
PUSHS("?\n");
|
|
f_puts();
|
|
}
|
|
|
|
void f_compileword() { // name --
|
|
f_lookup();
|
|
if (!TOP().u) { // name 0
|
|
DROP(1); // name
|
|
f_number(); // n isnum
|
|
if (TOP().i) {
|
|
DROP(1);
|
|
f_interpretnumber();
|
|
} else {
|
|
DROP(1);
|
|
f_interpretunknown();
|
|
}
|
|
} else { // codepointer flags
|
|
f_interpretword();
|
|
}
|
|
}
|
|
|
|
void f_interpreter() {
|
|
while(1) {
|
|
f_word(); // w
|
|
if (TOP().s[0] == '\0') {
|
|
PUSHS("ok\n");
|
|
f_puts();
|
|
DROP(1);
|
|
return;
|
|
}
|
|
f_compileword();
|
|
}
|
|
}
|
|
|
|
void f_close() {
|
|
fclose(TOP().fp);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_open() {
|
|
FILE *fp;
|
|
fp = fopen(TOP().s, "ab+");
|
|
fseek(fp, 0, SEEK_SET);
|
|
TOP().fp = fp;
|
|
}
|
|
|
|
void f_overwrite() {
|
|
FILE *fp;
|
|
fp = fopen(TOP().s, "wb+");
|
|
TOP().fp = fp;
|
|
}
|
|
|
|
void f_seek() {
|
|
fseek(TOP().fp, ST1().u, SEEK_SET);
|
|
DROP(2);
|
|
}
|
|
|
|
void f_seekend() {
|
|
fseek(TOP().fp, 0, SEEK_END);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_tell() {
|
|
unsigned int pos = ftell(TOP().fp);
|
|
TOP().u = pos;
|
|
}
|
|
|
|
void f_exists() {
|
|
struct stat statbuf;
|
|
int rc = stat(TOP().s, &statbuf);
|
|
TOP().i = rc == 0;
|
|
}
|
|
|
|
struct ffblk findfile;
|
|
void f_findfirst() {
|
|
int result = findfirst(TOP().s, &findfile, 0);
|
|
if (result == 0) {
|
|
TOP().s = findfile.ff_name;
|
|
} else {
|
|
TOP().u = 0;
|
|
}
|
|
}
|
|
|
|
void f_findnext() {
|
|
int result = findnext(&findfile);
|
|
if (result == 0) {
|
|
PUSHS(findfile.ff_name);
|
|
} else {
|
|
PUSHU(0);
|
|
}
|
|
}
|
|
|
|
void f_chdir() {
|
|
chdir(TOP().s);
|
|
DROP(1);
|
|
}
|
|
|
|
void f_doconst() {
|
|
PUSHC(*(W.p + 1));
|
|
}
|
|
|
|
void f_const() {
|
|
f_word();
|
|
f_create();
|
|
PUSHP(f_doconst);
|
|
f_comma();
|
|
f_comma();
|
|
}
|
|
|
|
void f_dovar() {
|
|
PUSHCP(W.p + 1);
|
|
}
|
|
|
|
void f_var() {
|
|
f_word();
|
|
f_create();
|
|
PUSHP(f_dovar);
|
|
f_comma();
|
|
PUSHI(0);
|
|
f_comma();
|
|
}
|
|
|
|
void f_docreate() {
|
|
PUSHCP(W.p + 2);
|
|
RPUSH(IP);
|
|
IP = *(W.p + 1);
|
|
}
|
|
|
|
void f_bz_() {
|
|
if (!TOP().u) {
|
|
IP.p = IP.p->p; // branch
|
|
} else {
|
|
IP.p ++; // skip branch destination cell
|
|
}
|
|
DROP(1);
|
|
}
|
|
|
|
void f_bnz_() {
|
|
if (TOP().u) {
|
|
IP.p = IP.p->p; // branch
|
|
} else {
|
|
IP.p ++; // skip branch destination cell
|
|
}
|
|
DROP(1);
|
|
}
|
|
|
|
void f_goto_() {
|
|
IP.p = IP.p->p;
|
|
}
|
|
|
|
void f_inline_data_() {
|
|
PUSHCP(IP.p + 1);
|
|
IP = *IP.p;
|
|
}
|
|
|
|
void f_memmove() { // ( dst src size -- )
|
|
memmove(ST2().p, ST1().p, TOP().u);
|
|
DROP(3);
|
|
}
|
|
|
|
void f_quote() {
|
|
if (STATE.i) {
|
|
PUSHS("LIT_");
|
|
f_compileword();
|
|
} else {
|
|
f_word();
|
|
f_lookup();
|
|
DROP(1);
|
|
}
|
|
}
|
|
|
|
void f_rand() {
|
|
PUSHI(rand());
|
|
}
|
|
|
|
void f_segalloc() {
|
|
void far* ptr = farmalloc(0x10010UL);
|
|
unsigned long linearaddr = ((unsigned long)FP_SEG(ptr) << 4) +
|
|
((unsigned long)FP_OFF(ptr));
|
|
int segment = ((linearaddr & 0x000ffff0UL) >> 4);
|
|
if (ptr == NULL) {
|
|
exit(1);
|
|
}
|
|
|
|
PUSHI(segment);
|
|
}
|
|
|
|
void f_init() {
|
|
CDEF("[", f_compileoff); f_immediate();
|
|
CDEF("]", f_compileon);
|
|
CDEF("key", f_key);
|
|
CDEF("emit", f_emit);
|
|
CDEF("word", f_word);
|
|
CDEF("immediate", f_immediate);
|
|
CDEF("execute", f_execute);
|
|
CDEF("new-word", f_create);
|
|
CDEF("here", f_here);
|
|
CDEF("here!", f_here_set);
|
|
CDEF("there", f_there);
|
|
CDEF("latest", f_latest);
|
|
CDEF("latest!", f_latest_set);
|
|
CDEF("state", f_state);
|
|
CDEF("'", f_quote); f_immediate();
|
|
CDEF("`", f_revlookup);
|
|
CDEF("wordname", f_wordname);
|
|
CDEF("wordflags", f_wordflags);
|
|
CDEF("codepointer", f_codepointer);
|
|
CDEF("lookup", f_lookup);
|
|
CDEF(":", f_colon);
|
|
CDEF(";", f_semicolon); f_immediate();
|
|
CDEF("const", f_const);
|
|
CDEF("var", f_var);
|
|
CDEF("allot", f_allot);
|
|
CDEF("+", f_add);
|
|
CDEF("-", f_sub);
|
|
CDEF("*", f_mul);
|
|
CDEF("/", f_div);
|
|
CDEF("%", f_mod);
|
|
CDEF("not", f_not);
|
|
CDEF("=", f_eq);
|
|
CDEF("!=", f_neq);
|
|
CDEF(">=", f_ge);
|
|
CDEF(">", f_gt);
|
|
CDEF("<", f_lt);
|
|
CDEF("<=", f_le);
|
|
CDEF("u>=", f_uge);
|
|
CDEF("u>", f_ugt);
|
|
CDEF("u<", f_ult);
|
|
CDEF("u<=", f_ule);
|
|
CDEF("and", f_and);
|
|
CDEF("or", f_or);
|
|
CDEF("&", f_bitand);
|
|
CDEF("|", f_bitor);
|
|
CDEF("^", f_bitxor);
|
|
CDEF("<<", f_shl);
|
|
CDEF(">>", f_shr);
|
|
CDEF("/>ratio", f_toratio);
|
|
CDEF("*<ratio", f_fromratio);
|
|
CDEF("@", f_get);
|
|
CDEF("!", f_set);
|
|
CDEF("+!", f_addset);
|
|
CDEF("b@", f_bget);
|
|
CDEF("ub@", f_ubget);
|
|
CDEF("b!", f_bset);
|
|
CDEF("!far", f_farset);
|
|
CDEF("@far", f_farget);
|
|
CDEF("b!far", f_farbset);
|
|
CDEF("b@far", f_farbget);
|
|
CDEF("dup", f_dup);
|
|
CDEF("over", f_over);
|
|
CDEF("drop", f_drop);
|
|
CDEF("swap", f_swap);
|
|
CDEF("<rot", f_rot);
|
|
CDEF(">r", f_rput);
|
|
CDEF("<r", f_rtake);
|
|
CDEF("r@", f_rtop);
|
|
CDEF("rdrop", f_rdrop);
|
|
CDEF("rswap", f_rswap);
|
|
CDEF("gets", f_gets);
|
|
CDEF("number", f_number);
|
|
CDEF("LIT_", f_lit_);
|
|
CDEF("GOTO_", f_goto_);
|
|
CDEF("BZ_", f_bz_);
|
|
CDEF("BNZ_", f_bnz_);
|
|
CDEF("INLINEDATA_", f_inline_data_);
|
|
CDEF("return", f_ret);
|
|
CDEF(".", f_dot);
|
|
CDEF("u.", f_udot);
|
|
CDEF("type", f_puts);
|
|
CDEF(".s", f_printstack);
|
|
CDEF(".rs", f_printrstack);
|
|
CDEF(",", f_comma);
|
|
CDEF("b,", f_bcomma);
|
|
CDEF("open", f_open);
|
|
CDEF("overwrite", f_overwrite);
|
|
CDEF("close", f_close);
|
|
CDEF("exists", f_exists);
|
|
CDEF("seek", f_seek);
|
|
CDEF("seekend", f_seekend);
|
|
CDEF("tell", f_tell);
|
|
CDEF("fputc", f_fputc);
|
|
CDEF("fgetc", f_fgetc);
|
|
CDEF("fread", f_fread);
|
|
CDEF("fwrite", f_fwrite);
|
|
CDEF("findfile", f_findfirst);
|
|
CDEF("nextfile", f_findnext);
|
|
CDEF("chdir", f_chdir);
|
|
CDEF("memmove", f_memmove);
|
|
CDEF("rand", f_rand);
|
|
CDEF("segalloc", f_segalloc);
|
|
PCONST("$DOCREATE", f_docreate);
|
|
PCONST("$DOVAR", f_dovar);
|
|
PCONST("$DODEFERRED", f_dodeferred);
|
|
PCONST("infile", &IN_FILE);
|
|
PCONST("outfile", &OUT_FILE);
|
|
PCONST("stdin", stdin);
|
|
PCONST("stdout", stdout);
|
|
#ifdef TRACE
|
|
CDEF("traceon", f_traceon);
|
|
CDEF("traceoff", f_traceoff);
|
|
#endif
|
|
}
|
|
|
|
cell f_lookupcp(char *name) {
|
|
cell result = {0};
|
|
PUSHS(name);
|
|
f_lookup();
|
|
if (TOP().u) {
|
|
result = ST1();
|
|
}
|
|
DROP(2);
|
|
return result;
|
|
}
|
|
|
|
void f_execcp(cell cp) {
|
|
PUSHC(cp);
|
|
f_cexecute();
|
|
}
|
|
|
|
int DIE = 0;
|
|
void f_quit() {
|
|
DIE = 1;
|
|
}
|
|
|