InventorX/Lisp
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

registers can now only store addresses

Browse source
This commit is contained in:
IXtreme 2026-07-26 16:18:45 -04:00
parent 250382793c
commit fb3477d5ba
1 changed files with 39 additions and 34 deletions
Download patch file Download diff file Expand all files Collapse all files

73
src/main.cpp
View file

@ -75,24 +75,24 @@ enum class special_indef_eval {NONE, PROGN, IF_BEGIN, FORCE_RETURN_NEXT_ARG};
struct Registers { struct Registers {
std::variant<size_t, Data *> Exp; size_t Exp;
size_t args_front; size_t args_front;
size_t args_current; size_t args_current;
size_t args_left; size_t args_left;
// general registers // general registers
std::variant<size_t, Data *> A; size_t A;
std::variant<size_t, Data *> B; size_t B;
std::variant<size_t, Data *> C; size_t C;
std::variant<size_t, Data *> D; size_t D;
bool argflag = false; bool argflag = false;
std::variant<size_t, Data *> op; size_t op;
locs RP; locs RP;
std::variant<size_t, Data *> R; size_t R;
Env E; Env E;
special_indef_eval screen = special_indef_eval::NONE; special_indef_eval screen = special_indef_eval::NONE;
@ -129,38 +129,42 @@ struct Machine {
while (true) { while (true) {
switch (reg.RP) { switch (reg.RP) {
case locs::EVAL_START: { // Expects data* in D; case locs::EVAL_START: { // Expects data* in D;
Data *d = std::get<Data *>(reg.D); size_t loc = reg.D;
Data * d = mem[loc].d;
//Data *d = std::get<Data *>(reg.D);
if (SelfEval *h = dynamic_cast<SelfEval *>(d)) { if (SelfEval *h = dynamic_cast<SelfEval *>(d)) {
if(stack.empty()) { if(stack.empty()) {
reg.R = h; reg.R = loc; //return addressof
return; return;
} }
reg = stack.back(); reg = stack.back();
stack.pop_back(); stack.pop_back();
reg.R = h; reg.R = loc; //return addressof
// return h; // return h;
} else if (Symbol *h = dynamic_cast<Symbol *>(d)) { } else if (Symbol *h = dynamic_cast<Symbol *>(d)) {
if (reg.E.builtin.contains(h->data)) { if (reg.E.builtin.contains(h->data)) {
if(stack.empty()) { if(stack.empty()) {
reg.R = h; reg.R = loc; //return addressof
return; return;
} }
reg = stack.back(); reg = stack.back();
stack.pop_back(); stack.pop_back();
reg.R = h; reg.R = loc; //return addressof
} else { } else {
if(stack.empty()) { if(stack.empty()) {
reg.R = mem[reg.E.userdef[h->data]].d; reg.R = reg.E.userdef[h->data];
return; return;
} }
reg = stack.back(); reg = stack.back();
stack.pop_back(); stack.pop_back();
reg.R = mem[reg.E.userdef[h->data]].d; reg.R = reg.E.userdef[h->data];
} }
} else if (Fork *h = dynamic_cast<Fork *>(d)) { } else if (Fork *h = dynamic_cast<Fork *>(d)) {
reg.Exp = h; reg.Exp = loc; //set exp to addressof
reg.D = mem[h->data].d; // pass car into eval reg.D = h->data; // pass car into eval
reg.RP = locs::EVAL_OP_FIN; reg.RP = locs::EVAL_OP_FIN;
reg.argflag = false; reg.argflag = false;
stack.push_back(reg); stack.push_back(reg);
@ -174,11 +178,11 @@ struct Machine {
case locs::EVAL_OP_FIN: { case locs::EVAL_OP_FIN: {
reg.op = reg.R; // save op reg.op = reg.R; // save op
reg.screen = special_indef_eval::NONE; reg.screen = special_indef_eval::NONE;
if (Symbol * c = dynamic_cast<Symbol*>(std::get<Data*>(reg.op))) { if (Symbol * c = dynamic_cast<Symbol*>(mem[reg.op].d)) {
if(c->data == "lambda") { if(c->data == "lambda") {
reg.args_left = 0; reg.args_left = 0;
reg.args_current = 0; reg.args_current = 0;
reg.args_front = mem[((Fork *)std::get<Data *>(reg.Exp))->data].cdr; reg.args_front = mem[((Fork *) mem[reg.Exp].d)->data].cdr;
reg.RP = locs::EVAL_TOP_ARG; reg.RP = locs::EVAL_TOP_ARG;
reg.argflag=false; reg.argflag=false;
break; break;
@ -190,7 +194,7 @@ struct Machine {
reg.screen = special_indef_eval::IF_BEGIN; reg.screen = special_indef_eval::IF_BEGIN;
} }
} }
reg.args_left = mem[((Fork *)std::get<Data *>(reg.Exp))->data].cdr; reg.args_left = mem[((Fork *) mem[reg.Exp].d)->data].cdr;
reg.args_current = 0; reg.args_current = 0;
reg.args_front = 0; reg.args_front = 0;
reg.RP = locs::EVAL_TOP_ARG; reg.RP = locs::EVAL_TOP_ARG;
@ -207,7 +211,7 @@ struct Machine {
mem[reg.args_current].cdr = temp; mem[reg.args_current].cdr = temp;
reg.args_current = temp; reg.args_current = temp;
} }
mem[reg.args_current].d = std::get<Data*>(reg.R); mem[reg.args_current].d = mem[reg.R].d;
// is in an 'if' statement but got first arg back // is in an 'if' statement but got first arg back
if (reg.screen == special_indef_eval::IF_BEGIN) { if (reg.screen == special_indef_eval::IF_BEGIN) {
@ -238,7 +242,7 @@ struct Machine {
newframe = true; newframe = true;
} }
reg.D = mem[reg.args_left].d; reg.D = reg.args_left;
reg.args_left = mem[reg.args_left].cdr; reg.args_left = mem[reg.args_left].cdr;
if (newframe) { if (newframe) {
stack.back().args_left = reg.args_left; stack.back().args_left = reg.args_left;
@ -251,17 +255,18 @@ struct Machine {
break; break;
} }
case locs::APPLY: { case locs::APPLY: {
Data *d = std::get<Data *>(reg.op); size_t loc = reg.op;
Data *d = mem[loc].d;
if (Symbol *fname = dynamic_cast<Symbol *>(d)) { if (Symbol *fname = dynamic_cast<Symbol *>(d)) {
if (reg.E.builtin.contains(fname->data)) { if (reg.E.builtin.contains(fname->data)) {
auto temp = ApplyBuiltin(fname->data, reg.args_front); auto temp = ApplyBuiltin(fname->data, reg.args_front);
if(stack.empty()) { if(stack.empty()) {
reg.R = mem[temp].d; //special case for term; reg.R = temp; //special case for term;
return; return;
} }
reg = stack.back(); reg = stack.back();
stack.pop_back(); stack.pop_back();
reg.R = mem[temp].d; reg.R = temp;
break; break;
} else { } else {
throw "err2"; throw "err2";
@ -269,7 +274,7 @@ struct Machine {
} else if (Lambda *f = dynamic_cast<Lambda *>(d)) { } else if (Lambda *f = dynamic_cast<Lambda *>(d)) {
reg.A = f->args; reg.A = f->args;
reg.A = ((Fork *) mem[std::get<size_t>(reg.A)].d)->data; reg.A = ((Fork *) mem[reg.A].d)->data;
//reg.A = ( (Fork *) (std::get<Cell>(reg.A)).d) ->data; //reg.A = ( (Fork *) (std::get<Cell>(reg.A)).d) ->data;
@ -277,23 +282,23 @@ struct Machine {
reg.B = reg.args_front; reg.B = reg.args_front;
// reg.E = f->env; // reg.E = f->env;
reg.E.userdef = f->env.userdef; reg.E.userdef = f->env.userdef;
while (std::get<size_t>(reg.A) != 0) { while (reg.A != 0) {
reg.E.userdef[((Symbol *)mem[std::get<size_t>(reg.A)].d)->data] = reg.E.userdef[((Symbol *)mem[reg.A].d)->data] =
std::get<size_t>(reg.B); reg.B;
reg.A = mem[std::get<size_t>(reg.A)].cdr; reg.A = mem[reg.A].cdr;
reg.B = mem[std::get<size_t>(reg.B)].cdr; reg.B = mem[reg.B].cdr;
} }
//reg.D = f->f.d; //reg.D = f->f.d;
reg.D = mem[f->f].d; reg.D = f->f;
//reg.E.userdef.merge(f->env.userdef); //reg.E.userdef.merge(f->env.userdef);
reg.RP = locs::EVAL_START; reg.RP = locs::EVAL_START;
break; break;
} else { } else {
throw "err"; throw "err wrong type";
} }
} }
@ -568,7 +573,7 @@ int main() {
m.stack = std::vector<Registers>(); m.stack = std::vector<Registers>();
auto exp = m.read_expr(std::cin); auto exp = m.read_expr(std::cin);
r.D = m.mem[exp].d; r.D = exp;
m.reg = r; m.reg = r;
m.reg.RP = locs::EVAL_START; m.reg.RP = locs::EVAL_START;
m.reg.E.builtin.insert("+"); m.reg.E.builtin.insert("+");
@ -589,7 +594,7 @@ int main() {
} }
std::cout << "out of loop" << std::endl; std::cout << "out of loop" << std::endl;
c.d = std::get<Data *>(m.reg.R); c.d = m.mem[m.reg.R].d;
m.ListPrint(c); m.ListPrint(c);
std::cout << std::endl; std::cout << std::endl;
} }