stepus53/psil
1
0
Fork 0
mirror of https://github.com/usatiuk/psil.git synced 2025-10-28 18:57:48 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

better parser

Browse Source
This commit is contained in:
Stepan Usatiuk
2023-12-26 13:15:40 +01:00
parent a45494d861
commit 27cbe8a200
10 changed files with 283 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
src/vm/includes/Command.h
View File

@@ -1,41 +0,0 @@
#ifndef PSIL_COMMAND_H
#define PSIL_COMMAND_H
#include <cassert>
namespace Command {
enum class CommandNum {
NIL = 1,
LDC = 2,
LD = 3,
SEL = 4,
JOIN = 5,
LDF = 6,
AP = 7,
RET = 8,
DUM = 9,
RAP = 10,
STOP = 11,
ADD = 100,
SUB = 101,
READCHAR = 201,
PUTCHAR = 202,
PUTNUM = 203,
CONS = 301,
END = 1000
};
static inline CommandNum int_to_cmd(int64_t _val) {
assert((_val > 0 && static_cast<CommandNum>(_val) <= CommandNum::END));
return static_cast<CommandNum>(_val);
}
static inline int64_t cmd_to_int(CommandNum _val) {
return static_cast<int64_t>(_val);
}
};// namespace Command
#endif

5
src/vm/includes/ConsUtils.h
View File

@@ -12,12 +12,15 @@ namespace ConsUtils {
static inline MCHandle car(const MCHandle &cell) { return dynamic_cast<ConsCell &>(*cell)._car; } static inline MCHandle car(const MCHandle &cell) { return dynamic_cast<ConsCell &>(*cell)._car; }
static inline MCHandle cdr(const MCHandle &cell) { return dynamic_cast<ConsCell &>(*cell)._cdr; } static inline MCHandle cdr(const MCHandle &cell) { return dynamic_cast<ConsCell &>(*cell)._cdr; }
static inline CellValType val(const MCHandle &cell) { return dynamic_cast<NumAtomCell &>(*cell)._val; } static inline CellValType val(const MCHandle &cell) { return dynamic_cast<NumAtomCell &>(*cell)._val; }
static inline std::string_view strval(const MCHandle &cell) { return dynamic_cast<StrAtomCell &>(*cell)._val; }
MCHandle cons(const MCHandle &car, const MCHandle &cdr); MCHandle cons(const MCHandle &car, const MCHandle &cdr);
MCHandle pop(MCHandle &from); MCHandle pop(MCHandle &from);
MCHandle push(MCHandle &to, const MCHandle &what); MCHandle push(MCHandle &to, const MCHandle &what);
void append(MCHandle to, const MCHandle &what); void append(MCHandle to, const MCHandle &what);
MCHandle makeIntCell(int64_t val); MCHandle makeNumCell(int64_t val);
MCHandle makeStrCell(std::string val);
void setcar(const MCHandle &to, const MCHandle &car); void setcar(const MCHandle &to, const MCHandle &car);
void setcdr(const MCHandle &to, const MCHandle &cdr);
};// namespace ConsUtils };// namespace ConsUtils

4
src/vm/includes/MemoryContext.h
View File

@@ -54,6 +54,10 @@ public:
Cell &operator*() const { return *_target; } Cell &operator*() const { return *_target; }
Cell *get() const noexcept { return _target; } Cell *get() const noexcept { return _target; }
bool operator==(const Handle &rhs) const {
return _target == rhs._target;
}
private: private:
Cell *_target = nullptr; Cell *_target = nullptr;
}; };

9
src/vm/includes/Parser.h
View File

@@ -18,15 +18,10 @@ struct Cell;
class Parser { class Parser {
public: public:
explicit Parser(VM &vm); void loadStr(std::string_view input);
MCHandle parseExpr();
void loadSecd(std::string_view input);
private: private:
void compileBody(const std::function<void(MCHandle)> &sink);
VM &_vm;
class Tokenizer { class Tokenizer {
public: public:
void load(std::string_view input); void load(std::string_view input);

21
src/vm/includes/VM.h
View File

@@ -34,6 +34,27 @@ private:
std::istream &_instream; std::istream &_instream;
std::ostream &_outstream; std::ostream &_outstream;
MCHandle NIL = ConsUtils::makeStrCell("NIL");
MCHandle LDC = ConsUtils::makeStrCell("LDC");
MCHandle LD = ConsUtils::makeStrCell("LD");
MCHandle SEL = ConsUtils::makeStrCell("SEL");
MCHandle JOIN = ConsUtils::makeStrCell("JOIN");
MCHandle LDF = ConsUtils::makeStrCell("LDF");
MCHandle AP = ConsUtils::makeStrCell("AP");
MCHandle RET = ConsUtils::makeStrCell("RET");
MCHandle DUM = ConsUtils::makeStrCell("DUM");
MCHandle RAP = ConsUtils::makeStrCell("RAP");
MCHandle STOP = ConsUtils::makeStrCell("STOP");
MCHandle ADD = ConsUtils::makeStrCell("ADD");
MCHandle SUB = ConsUtils::makeStrCell("SUB");
MCHandle READCHAR = ConsUtils::makeStrCell("READCHAR");
MCHandle PUTCHAR = ConsUtils::makeStrCell("PUTCHAR");
MCHandle PUTNUM = ConsUtils::makeStrCell("PUTNUM");
MCHandle CONS = ConsUtils::makeStrCell("CONS");
// void gc(); // void gc();
}; };

10
src/vm/src/ConsUtils.cpp
View File

@@ -32,10 +32,18 @@ void ConsUtils::append(MCHandle to, const MCHandle &what) {
dynamic_cast<ConsCell &>(*to)._cdr = cons(what, nullptr).get(); dynamic_cast<ConsCell &>(*to)._cdr = cons(what, nullptr).get();
} }
MCHandle ConsUtils::makeIntCell(int64_t val) { MCHandle ConsUtils::makeNumCell(int64_t val) {
return CURRENT_MC.load()->create_cell<NumAtomCell>(val); return CURRENT_MC.load()->create_cell<NumAtomCell>(val);
} }
MCHandle ConsUtils::makeStrCell(std::string val) {
return CURRENT_MC.load()->create_cell<StrAtomCell>(std::move(val));
}
void ConsUtils::setcar(const MCHandle &to, const MCHandle &car) { void ConsUtils::setcar(const MCHandle &to, const MCHandle &car) {
dynamic_cast<ConsCell &>(*to)._car = car.get(); dynamic_cast<ConsCell &>(*to)._car = car.get();
} }
void ConsUtils::setcdr(const MCHandle &to, const MCHandle &cdr) {
dynamic_cast<ConsCell &>(*to)._cdr = cdr.get();
}

103
src/vm/src/Parser.cpp
View File

@@ -7,93 +7,50 @@
#include <ranges> #include <ranges>
#include <stack> #include <stack>
#include "Command.h"
#include "ConsUtils.h" #include "ConsUtils.h"
#include "MemoryContext.h" #include "MemoryContext.h"
#include "VM.h" #include "VM.h"
Parser::Parser(VM &vm) : _vm(vm) {}
void Parser::loadSecd(std::string_view input) { void Parser::loadStr(std::string_view input) {
_tokenizer.load(input); _tokenizer.load(input);
MCHandle out(ConsUtils::cons(nullptr, nullptr));
compileBody([&out](MCHandle cmd) { ConsUtils::append(out, cmd); });
_vm.loadControl(out);
} }
void Parser::compileBody(const std::function<void(MCHandle)> &sink) { MCHandle Parser::parseExpr() {
auto token = _tokenizer.getNext(); while (!_tokenizer.empty()) {
if (token != "(") throw std::invalid_argument("Expected ("); std::string token = std::string(_tokenizer.peek());
if (token == "(") {
_tokenizer.getNext();
MCHandle out(ConsUtils::cons(nullptr, nullptr));
while (token != ")") {
if (token == ".") {
_tokenizer.getNext();
while (token != ")") { ConsUtils::setcdr(out, parseExpr());
token = _tokenizer.getNext();
if (token == "NIL") { if (_tokenizer.getNext() != ")")
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); throw std::invalid_argument("Missing ) after pair");
} else if (token == "LDC") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC)));
sink(ConsUtils::makeIntCell(std::stoi(_tokenizer.getNext())));
} else if (token == "LD") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD)));
if (_tokenizer.getNext() != "(") throw std::invalid_argument("Expected (");
int64_t frame = std::stoi(_tokenizer.getNext());
if (_tokenizer.getNext() != ".") throw std::invalid_argument("Expected .");
int64_t loc = std::stoi(_tokenizer.getNext());
if (_tokenizer.getNext() != ")") throw std::invalid_argument("Expected )");
sink(ConsUtils::cons(ConsUtils::makeIntCell(frame), ConsUtils::makeIntCell(loc)));
} else if (token == "SEL") {
MCHandle outt(ConsUtils::cons(nullptr, nullptr));
compileBody([&outt](MCHandle cmd) { ConsUtils::append(outt, cmd); });
MCHandle outf(ConsUtils::cons(nullptr, nullptr));
compileBody([&outf](MCHandle cmd) { ConsUtils::append(outf, cmd);; });
if (ConsUtils::car(outt).get() == nullptr) throw std::invalid_argument("Function body empty"); return out;
if (ConsUtils::cdr(outt).get() == nullptr) throw std::invalid_argument("Function body empty"); }
ConsUtils::append(out, parseExpr());
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL))); token = _tokenizer.peek();
sink(outt); }
sink(outf); _tokenizer.getNext();
} else if (token == "JOIN") { return out;
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
} else if (token == "LDF") {
MCHandle outt(ConsUtils::cons(nullptr, nullptr));
compileBody([&outt](MCHandle cmd) { ConsUtils::append(outt, cmd); });
if (ConsUtils::car(outt).get() == nullptr) throw std::invalid_argument("Function body empty");
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDF)));
sink(outt);
} else if (token == "AP") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP)));
} else if (token == "RET") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RET)));
} else if (token == "DUM") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::DUM)));
} else if (token == "RAP") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RAP)));
} else if (token == "STOP") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::STOP)));
} else if (token == "ADD") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD)));
} else if (token == "SUB") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SUB)));
} else if (token == "READCHAR") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::READCHAR)));
} else if (token == "PUTCHAR") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
} else if (token == "PUTNUM") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTNUM)));
} else if (token == "CONS") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS)));
} else { } else {
if (token != ")") token = _tokenizer.getNext();
throw std::invalid_argument("Unknown token " + token); try {
CellValType val = std::stoi(token);
return ConsUtils::makeNumCell(val);
} catch (...) {
return ConsUtils::makeStrCell(token);
}
} }
} }
}
assert(false);
}
std::string Parser::Tokenizer::getNext() { std::string Parser::Tokenizer::getNext() {
std::string ret = std::move(_tokens.front()); std::string ret = std::move(_tokens.front());
_tokens.pop(); _tokens.pop();
@@ -101,7 +58,7 @@ std::string Parser::Tokenizer::getNext() {
} }
std::string_view Parser::Tokenizer::peek() const { std::string_view Parser::Tokenizer::peek() const {
return _tokens.back(); return _tokens.front();
} }
void Parser::Tokenizer::load(std::string_view input) { void Parser::Tokenizer::load(std::string_view input) {

227
src/vm/src/VM.cpp
View File

@@ -6,7 +6,6 @@
#include <set> #include <set>
#include <utility> #include <utility>
#include "Command.h"
#include "ConsUtils.h" #include "ConsUtils.h"
#include "VM.h" #include "VM.h"
@@ -20,158 +19,120 @@ void VM::run() {
void VM::step() { void VM::step() {
MCHandle poppedH = pop(_c); MCHandle poppedH = pop(_c);
if (poppedH == NIL) {
push(_s, nullptr);
} else if (poppedH == LDC) {
push(_s, pop(_c));
} else if (poppedH == LD) {
MCHandle poppedH2 = pop(_c);
switch (Command::int_to_cmd(val(poppedH))) { int64_t frame = val(car(poppedH2));
case Command::CommandNum::NIL: { int64_t arg = val(cdr(poppedH2));
push(_s, nullptr);
break; assert(frame > 0);
assert(arg > 0);
MCHandle curFrame = _e;
for (int i = 1; i < frame; i++) {
curFrame = cdr(curFrame);
} }
case Command::CommandNum::LDC: {
push(_s, pop(_c)); MCHandle curArg = car(curFrame);
break;
for (int i = 1; i < arg; i++) {
curArg = cdr(curArg);
} }
case Command::CommandNum::LD: {
MCHandle poppedH2 = pop(_c);
int64_t frame = val(car(poppedH2)); push(_s, car(curArg));
int64_t arg = val(cdr(poppedH2)); } else if (poppedH == SEL) {
assert(frame > 0); MCHandle popped2H = pop(_s);
assert(arg > 0);
MCHandle curFrame = _e; MCHandle ct = pop(_c);
MCHandle cf = pop(_c);
for (int i = 1; i < frame; i++) { push(_d, _c);
curFrame = cdr(curFrame); if (val(popped2H) > 0) {
} _c = ct;
} else {
MCHandle curArg = car(curFrame); _c = cf;
for (int i = 1; i < arg; i++) {
curArg = cdr(curArg);
}
push(_s, car(curArg));
break;
} }
case Command::CommandNum::SEL: { } else if (poppedH == JOIN) {
MCHandle popped2H = pop(_s); _c = pop(_d);
} else if (poppedH == LDF) {
push(_s, cons(pop(_c), _e));
} else if (poppedH == AP) {
MCHandle closureH = pop(_s);
MCHandle argsH = pop(_s);
MCHandle ct = pop(_c); push(_d, _s);
MCHandle cf = pop(_c); push(_d, _e);
push(_d, _c);
push(_d, _c); _s = cons(nullptr, nullptr);
if (val(popped2H) > 0) { _c = car(closureH);
_c = ct; _e = cdr(closureH);
} else { push(_e, argsH);
_c = cf; } else if (poppedH == RET) {
} MCHandle c = pop(_d);
MCHandle e = pop(_d);
MCHandle s = pop(_d);
break; MCHandle ret = pop(_s);
}
case Command::CommandNum::JOIN: {
_c = pop(_d);
break;
}
case Command::CommandNum::LDF: {
push(_s, cons(pop(_c), _e));
break;
}
case Command::CommandNum::AP: {
MCHandle closureH = pop(_s);
MCHandle argsH = pop(_s);
push(_d, _s); _c = c;
push(_d, _e); _e = e;
push(_d, _c); _s = s;
_s = cons(nullptr, nullptr); push(_s, ret);
_c = car(closureH); // gc();
_e = cdr(closureH); } else if (poppedH == DUM) {
push(_e, argsH); push(_e, nullptr);
break; } else if (poppedH == RAP) {
} MCHandle closureH = pop(_s);
case Command::CommandNum::RET: { MCHandle argsH = pop(_s);
MCHandle c = pop(_d);
MCHandle e = pop(_d);
MCHandle s = pop(_d);
MCHandle ret = pop(_s);
_c = c;
_e = e;
_s = s;
push(_s, ret);
// gc();
break;
}
case Command::CommandNum::DUM: {
push(_e, nullptr);
break;
}
case Command::CommandNum::RAP: {
MCHandle closureH = pop(_s);
MCHandle argsH = pop(_s);
MCHandle origE = cdr(_e); MCHandle origE = cdr(_e);
push(_d, _s); push(_d, _s);
push(_d, origE); push(_d, origE);
push(_d, _c); push(_d, _c);
_s = cons(nullptr, nullptr); _s = cons(nullptr, nullptr);
_c = car(closureH); _c = car(closureH);
_e = cdr(closureH); _e = cdr(closureH);
MCHandle fnEnv = cdr(closureH); MCHandle fnEnv = cdr(closureH);
assert(_e.get() == fnEnv.get()); assert(_e.get() == fnEnv.get());
push(_e, argsH); push(_e, argsH);
setcar(fnEnv, argsH); setcar(fnEnv, argsH);
break; } else if (poppedH == STOP) {
} _stop = true;
case Command::CommandNum::STOP: { } else if (poppedH == ADD) {
_stop = true; int64_t ret = val(pop(_s)) + val(pop(_s));
// gc(); push(_s, makeNumCell(ret));
break; } else if (poppedH == SUB) {
} assert(false);
case Command::CommandNum::ADD: { int64_t ret = val(pop(_s)) + val(pop(_s));
int64_t ret = val(pop(_s)) + val(pop(_s)); push(_s, makeNumCell(ret));
push(_s, makeIntCell(ret)); } else if (poppedH == CONS) {
break; MCHandle h1 = pop(_s);
} MCHandle h2 = pop(_s);
case Command::CommandNum::SUB: {
break;
}
case Command::CommandNum::CONS: {
MCHandle h1 = pop(_s);
MCHandle h2 = pop(_s);
push(_s, cons(h1, h2)); push(_s, cons(h1, h2));
break; } else if (poppedH == READCHAR) {
} char c;
case Command::CommandNum::READCHAR: { _instream >> c;
char c; push(_s, makeNumCell(c));
_instream >> c; } else if (poppedH == PUTCHAR) {
push(_s, makeIntCell(c)); _outstream << (char) val(pop(_s));
break; } else if (poppedH == PUTNUM) {
} _outstream << val(pop(_s));
case Command::CommandNum::PUTCHAR: { } else {
_outstream << (char) val(pop(_s)); assert(false);
break;
}
case Command::CommandNum::PUTNUM: {
_outstream << val(pop(_s));
break;
}
case Command::CommandNum::END: {
assert(false);
break;
}
default:
assert(false);
} }
} }

215
test/vm/VMTest.cpp
View File

@@ -1,6 +1,5 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include "Command.h"
#include "ConsUtils.h" #include "ConsUtils.h"
#include "VM.h" #include "VM.h"
@@ -11,11 +10,11 @@ TEST(VMTest, BasicHello) {
MemoryContext mc; MemoryContext mc;
VM vm(ssin, ssout); VM vm(ssin, ssout);
MCHandle newc(ConsUtils::cons(nullptr, nullptr)); MCHandle newc(ConsUtils::cons(nullptr, nullptr));
ConsUtils::append(newc, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); ConsUtils::append(newc, ConsUtils::makeStrCell("NIL"));
ConsUtils::append(newc, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); ConsUtils::append(newc, ConsUtils::makeStrCell("LDC"));
ConsUtils::append(newc, ConsUtils::makeIntCell('h')); ConsUtils::append(newc, ConsUtils::makeNumCell('h'));
ConsUtils::append(newc, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); ConsUtils::append(newc, ConsUtils::makeStrCell("PUTCHAR"));
ConsUtils::append(newc, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::STOP))); ConsUtils::append(newc, ConsUtils::makeStrCell("STOP"));
vm.loadControl(newc); vm.loadControl(newc);
vm.run(); vm.run();
} }
@@ -28,42 +27,42 @@ TEST(VMTest, BasicHello) {
// std::stringstream ssout; // std::stringstream ssout;
// { // {
// VM vm(ssin, ssout); // VM vm(ssin, ssout);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::STOP))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::STOP)));
// //
// // True branch true test // // True branch true test
// ConsCell *tbtt = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *tbtt = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(tbtt, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); // vm.push(tbtt, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
// vm.push(tbtt, vm.makeCell<IntCell>('1')); // vm.push(tbtt, vm.makeCell<IntCell>('1'));
// vm.push(tbtt, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(tbtt, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// // False branch true test // // False branch true test
// ConsCell *fbtt = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *fbtt = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(fbtt, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); // vm.push(fbtt, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
// vm.push(fbtt, vm.makeCell<IntCell>('2')); // vm.push(fbtt, vm.makeCell<IntCell>('2'));
// vm.push(fbtt, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(fbtt, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// // True branch false test // // True branch false test
// ConsCell *tbft = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *tbft = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(tbft, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); // vm.push(tbft, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
// vm.push(tbft, vm.makeCell<IntCell>('3')); // vm.push(tbft, vm.makeCell<IntCell>('3'));
// vm.push(tbft, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(tbft, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// // False branch false test // // False branch false test
// ConsCell *fbft = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *fbft = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(fbft, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); // vm.push(fbft, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
// vm.push(fbft, vm.makeCell<IntCell>('4')); // vm.push(fbft, vm.makeCell<IntCell>('4'));
// vm.push(fbft, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(fbft, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// vm.appendCommand(fbft); // vm.appendCommand(fbft);
// vm.appendCommand(tbft); // vm.appendCommand(tbft);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::SEL)));
// vm.appendCommand(vm.makeCell<IntCell>(0)); // vm.appendCommand(vm.makeCell<IntCell>(0));
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// vm.appendCommand(fbtt); // vm.appendCommand(fbtt);
// vm.appendCommand(tbtt); // vm.appendCommand(tbtt);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::SEL)));
// vm.appendCommand(vm.makeCell<IntCell>(1)); // vm.appendCommand(vm.makeCell<IntCell>(1));
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// vm.run(); // vm.run();
// } // }
// ssout.flush(); // ssout.flush();
@@ -75,23 +74,23 @@ TEST(VMTest, BasicHello) {
// std::stringstream ssout; // std::stringstream ssout;
// { // {
// VM vm(ssin, ssout); // VM vm(ssin, ssout);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::STOP))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::STOP)));
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
// //
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
// //
// // Add function // // Add function
// ConsCell *addfn = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RET))); // ConsCell *addfn = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::RET)));
// vm.push(addfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); // vm.push(addfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
// vm.push(addfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(2))); // vm.push(addfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(2)));
// vm.push(addfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); // vm.push(addfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// vm.push(addfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); // vm.push(addfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
// vm.push(addfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); // vm.push(addfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// vm.appendCommand(addfn); // vm.appendCommand(addfn);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDF))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDF)));
// vm.appendCommand( // vm.appendCommand(
// vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<ConsCell>(vm.makeCell<IntCell>('2')))); // vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<ConsCell>(vm.makeCell<IntCell>('2'))));
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// vm.run(); // vm.run();
// } // }
// ssout.flush(); // ssout.flush();
@@ -103,140 +102,140 @@ TEST(VMTest, BasicHello) {
// std::stringstream ssout; // std::stringstream ssout;
// { // {
// VM vm(ssin, ssout); // VM vm(ssin, ssout);
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::STOP))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::STOP)));
// //
// vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RAP))); // vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::RAP)));
// //
// // Fib function // // Fib function
// ConsCell *fibfn = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RET))); // ConsCell *fibfn = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::RET)));
// //
// // 0 case // // 0 case
// ConsCell *zcase = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *zcase = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(zcase, vm.makeCell<IntCell>(0)); // vm.push(zcase, vm.makeCell<IntCell>(0));
// vm.push(zcase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(zcase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// // 1 case // // 1 case
// ConsCell *ocase = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *ocase = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(ocase, vm.makeCell<IntCell>(1)); // vm.push(ocase, vm.makeCell<IntCell>(1));
// vm.push(ocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(ocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// //
// // >1 case // // >1 case
// ConsCell *gocase = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); // ConsCell *gocase = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
// //
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
// vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(2), vm.makeCell<IntCell>(1))); // vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(2), vm.makeCell<IntCell>(1)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// //
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
// vm.push(gocase, vm.makeCell<IntCell>(-2)); // vm.push(gocase, vm.makeCell<IntCell>(-2));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); // vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
// vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(2), vm.makeCell<IntCell>(1))); // vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(2), vm.makeCell<IntCell>(1)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// //
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
// vm.push(gocase, vm.makeCell<IntCell>(-1)); // vm.push(gocase, vm.makeCell<IntCell>(-1));
// vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); // vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
// vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); // vm.push(gocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(gocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(gocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//// >=1 case //// >=1 case
//ConsCell *geocase = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::JOIN))); //ConsCell *geocase = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::JOIN)));
//vm.push(geocase, ocase); //vm.push(geocase, ocase);
//vm.push(geocase, gocase); //vm.push(geocase, gocase);
//vm.push(geocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL))); //vm.push(geocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::SEL)));
//vm.push(geocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); //vm.push(geocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
//vm.push(geocase, vm.makeCell<IntCell>(-1)); //vm.push(geocase, vm.makeCell<IntCell>(-1));
//vm.push(geocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(geocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(geocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(geocase, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(geocase, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(geocase, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// //
//vm.push(fibfn, zcase); //vm.push(fibfn, zcase);
//vm.push(fibfn, geocase); //vm.push(fibfn, geocase);
//vm.push(fibfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL))); //vm.push(fibfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::SEL)));
//vm.push(fibfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
// //
//// Fib caller function //// Fib caller function
//ConsCell *fibcallfn = vm.makeCell<ConsCell>(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::RET))); //ConsCell *fibcallfn = vm.makeCell<ConsCell>(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::RET)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTNUM))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTNUM)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(' ')); //vm.push(fibcallfn, vm.makeCell<IntCell>(' '));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
//vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(10)); //vm.push(fibcallfn, vm.makeCell<IntCell>(10));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
//vm.push(fibcallfn, vm.makeCell<IntCell>('0')); //vm.push(fibcallfn, vm.makeCell<IntCell>('0'));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
//vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(6)); //vm.push(fibcallfn, vm.makeCell<IntCell>(6));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
//vm.push(fibcallfn, vm.makeCell<IntCell>('0')); //vm.push(fibcallfn, vm.makeCell<IntCell>('0'));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
//vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(5)); //vm.push(fibcallfn, vm.makeCell<IntCell>(5));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
//vm.push(fibcallfn, vm.makeCell<IntCell>('0')); //vm.push(fibcallfn, vm.makeCell<IntCell>('0'));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
//vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(4)); //vm.push(fibcallfn, vm.makeCell<IntCell>(4));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::PUTCHAR)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::ADD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::ADD)));
//vm.push(fibcallfn, vm.makeCell<IntCell>('0')); //vm.push(fibcallfn, vm.makeCell<IntCell>('0'));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::AP))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::AP)));
//vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1))); //vm.push(fibcallfn, vm.makeCell<ConsCell>(vm.makeCell<IntCell>(1), vm.makeCell<IntCell>(1)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LD))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LD)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.push(fibcallfn, vm.makeCell<IntCell>(3)); //vm.push(fibcallfn, vm.makeCell<IntCell>(3));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDC))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDC)));
//vm.push(fibcallfn, ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.push(fibcallfn, ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
// //
//vm.appendCommand(fibcallfn); //vm.appendCommand(fibcallfn);
//vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDF))); //vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDF)));
// //
//vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::CONS))); //vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::CONS)));
//vm.appendCommand(fibfn); //vm.appendCommand(fibfn);
//vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::LDF))); //vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::LDF)));
//vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL))); //vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::NIL)));
// //
//vm.appendCommand(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::DUM))); //vm.appendCommand(ConsUtils::makeNumCell(Command::cmd_to_int(Command::CommandNum::DUM)));
//vm.run(); //vm.run();
//} //}
//ssout.flush(); //ssout.flush();

20
test/vm/VMWithParserTest.cpp
View File

@@ -9,8 +9,9 @@ TEST(VMWithParserTest, BasicHello) {
{ {
MemoryContext mc; MemoryContext mc;
VM vm(ssin, ssout); VM vm(ssin, ssout);
Parser parser(vm); Parser parser;
parser.loadSecd("( LDC 104 PUTCHAR STOP )"); parser.loadStr("( LDC 104 PUTCHAR STOP )");
vm.loadControl(parser.parseExpr());
vm.run(); vm.run();
} }
ssout.flush(); ssout.flush();
@@ -23,9 +24,10 @@ TEST(VMWithParserTest, BasicBranch) {
{ {
MemoryContext mc; MemoryContext mc;
VM vm(ssin, ssout); VM vm(ssin, ssout);
Parser parser(vm); Parser parser;
parser.loadSecd( parser.loadStr(
"( LDC 1 SEL ( LDC 10 PUTNUM JOIN ) ( LDC 20 PUTNUM JOIN ) LDC 0 SEL ( LDC 30 PUTNUM JOIN ) ( LDC 40 PUTNUM JOIN ) STOP )"); "( LDC 1 SEL ( LDC 10 PUTNUM JOIN ) ( LDC 20 PUTNUM JOIN ) LDC 0 SEL ( LDC 30 PUTNUM JOIN ) ( LDC 40 PUTNUM JOIN ) STOP )");
vm.loadControl(parser.parseExpr());
vm.run(); vm.run();
} }
ssout.flush(); ssout.flush();
@@ -38,8 +40,9 @@ TEST(VMWithParserTest, BasicFunction) {
{ {
MemoryContext mc; MemoryContext mc;
VM vm(ssin, ssout); VM vm(ssin, ssout);
Parser parser(vm); Parser parser;
parser.loadSecd("( NIL LDC 1 CONS LDC 2 CONS LDF ( LD ( 1 . 1 ) LD ( 1 . 2 ) ADD RET ) AP PUTNUM STOP )"); parser.loadStr("( NIL LDC 1 CONS LDC 2 CONS LDF ( LD ( 1 . 1 ) LD ( 1 . 2 ) ADD RET ) AP PUTNUM STOP )");
vm.loadControl(parser.parseExpr());
vm.run(); vm.run();
} }
ssout.flush(); ssout.flush();
@@ -52,9 +55,10 @@ TEST(VMWithParserTest, RecFunction) {
{ {
MemoryContext mc; MemoryContext mc;
VM vm(ssin, ssout); VM vm(ssin, ssout);
Parser parser(vm); Parser parser;
parser.loadSecd( parser.loadStr(
"( DUM NIL LDF ( LD ( 1 . 1 ) SEL ( LD ( 1 . 1 ) LDC -1 ADD SEL ( NIL LD ( 1 . 1 ) LDC -1 ADD CONS LD ( 2 . 1 ) AP NIL LD ( 1 . 1 ) LDC -2 ADD CONS LD ( 2 . 1 ) AP ADD JOIN ) ( LDC 1 JOIN ) JOIN ) ( LDC 0 JOIN ) RET ) CONS LDF ( NIL LDC 10 CONS LD ( 1 . 1 ) AP RET ) RAP PUTNUM STOP )"); "( DUM NIL LDF ( LD ( 1 . 1 ) SEL ( LD ( 1 . 1 ) LDC -1 ADD SEL ( NIL LD ( 1 . 1 ) LDC -1 ADD CONS LD ( 2 . 1 ) AP NIL LD ( 1 . 1 ) LDC -2 ADD CONS LD ( 2 . 1 ) AP ADD JOIN ) ( LDC 1 JOIN ) JOIN ) ( LDC 0 JOIN ) RET ) CONS LDF ( NIL LDC 10 CONS LD ( 1 . 1 ) AP RET ) RAP PUTNUM STOP )");
vm.loadControl(parser.parseExpr());
vm.run(); vm.run();
} }
ssout.flush(); ssout.flush();