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 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 std::string_view strval(const MCHandle &cell) { return dynamic_cast<StrAtomCell &>(*cell)._val; }
MCHandle cons(const MCHandle &car, const MCHandle &cdr);
MCHandle pop(MCHandle &from);
MCHandle push(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 setcdr(const MCHandle &to, const MCHandle &cdr);
};// namespace ConsUtils

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

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

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

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

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

@@ -34,6 +34,27 @@ private:
std::istream &_instream;
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();
};

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();
}
MCHandle ConsUtils::makeIntCell(int64_t val) {
MCHandle ConsUtils::makeNumCell(int64_t 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) {
dynamic_cast<ConsCell &>(*to)._car = car.get();
}
void ConsUtils::setcdr(const MCHandle &to, const MCHandle &cdr) {
dynamic_cast<ConsCell &>(*to)._cdr = cdr.get();
}

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

@@ -7,93 +7,50 @@
#include <ranges>
#include <stack>
#include "Command.h"
#include "ConsUtils.h"
#include "MemoryContext.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);
}
MCHandle Parser::parseExpr() {
while (!_tokenizer.empty()) {
std::string token = std::string(_tokenizer.peek());
if (token == "(") {
_tokenizer.getNext();
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) {
auto token = _tokenizer.getNext();
if (token != "(") throw std::invalid_argument("Expected (");
while (token != ")") {
token = _tokenizer.getNext();
if (token == ".") {
_tokenizer.getNext();
if (token == "NIL") {
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::NIL)));
} 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);; });
ConsUtils::setcdr(out, parseExpr());
if (ConsUtils::car(outt).get() == nullptr) throw std::invalid_argument("Function body empty");
if (ConsUtils::cdr(outt).get() == nullptr) throw std::invalid_argument("Function body empty");
if (_tokenizer.getNext() != ")")
throw std::invalid_argument("Missing ) after pair");
sink(ConsUtils::makeIntCell(Command::cmd_to_int(Command::CommandNum::SEL)));
sink(outt);
sink(outf);
} else if (token == "JOIN") {
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)));
return out;
}
ConsUtils::append(out, parseExpr());
token = _tokenizer.peek();
}
_tokenizer.getNext();
return out;
} else {
if (token != ")")
throw std::invalid_argument("Unknown token " + token);
token = _tokenizer.getNext();
try {
CellValType val = std::stoi(token);
return ConsUtils::makeNumCell(val);
} catch (...) {
return ConsUtils::makeStrCell(token);
}
}
}
}
assert(false);
}
std::string Parser::Tokenizer::getNext() {
std::string ret = std::move(_tokens.front());
_tokens.pop();
@@ -101,7 +58,7 @@ std::string Parser::Tokenizer::getNext() {
}
std::string_view Parser::Tokenizer::peek() const {
return _tokens.back();
return _tokens.front();
}
void Parser::Tokenizer::load(std::string_view input) {

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

@@ -6,7 +6,6 @@
#include <set>
#include <utility>
#include "Command.h"
#include "ConsUtils.h"
#include "VM.h"
@@ -20,17 +19,11 @@ void VM::run() {
void VM::step() {
MCHandle poppedH = pop(_c);
switch (Command::int_to_cmd(val(poppedH))) {
case Command::CommandNum::NIL: {
if (poppedH == NIL) {
push(_s, nullptr);
break;
}
case Command::CommandNum::LDC: {
} else if (poppedH == LDC) {
push(_s, pop(_c));
break;
}
case Command::CommandNum::LD: {
} else if (poppedH == LD) {
MCHandle poppedH2 = pop(_c);
int64_t frame = val(car(poppedH2));
@@ -52,9 +45,8 @@ void VM::step() {
}
push(_s, car(curArg));
break;
}
case Command::CommandNum::SEL: {
} else if (poppedH == SEL) {
MCHandle popped2H = pop(_s);
MCHandle ct = pop(_c);
@@ -66,18 +58,11 @@ void VM::step() {
} else {
_c = cf;
}
break;
}
case Command::CommandNum::JOIN: {
} else if (poppedH == JOIN) {
_c = pop(_d);
break;
}
case Command::CommandNum::LDF: {
} else if (poppedH == LDF) {
push(_s, cons(pop(_c), _e));
break;
}
case Command::CommandNum::AP: {
} else if (poppedH == AP) {
MCHandle closureH = pop(_s);
MCHandle argsH = pop(_s);
@@ -89,9 +74,7 @@ void VM::step() {
_c = car(closureH);
_e = cdr(closureH);
push(_e, argsH);
break;
}
case Command::CommandNum::RET: {
} else if (poppedH == RET) {
MCHandle c = pop(_d);
MCHandle e = pop(_d);
MCHandle s = pop(_d);
@@ -104,13 +87,9 @@ void VM::step() {
push(_s, ret);
// gc();
break;
}
case Command::CommandNum::DUM: {
} else if (poppedH == DUM) {
push(_e, nullptr);
break;
}
case Command::CommandNum::RAP: {
} else if (poppedH == RAP) {
MCHandle closureH = pop(_s);
MCHandle argsH = pop(_s);
@@ -130,47 +109,29 @@ void VM::step() {
push(_e, argsH);
setcar(fnEnv, argsH);
break;
}
case Command::CommandNum::STOP: {
} else if (poppedH == STOP) {
_stop = true;
// gc();
break;
}
case Command::CommandNum::ADD: {
} else if (poppedH == ADD) {
int64_t ret = val(pop(_s)) + val(pop(_s));
push(_s, makeIntCell(ret));
break;
}
case Command::CommandNum::SUB: {
break;
}
case Command::CommandNum::CONS: {
push(_s, makeNumCell(ret));
} else if (poppedH == SUB) {
assert(false);
int64_t ret = val(pop(_s)) + val(pop(_s));
push(_s, makeNumCell(ret));
} else if (poppedH == CONS) {
MCHandle h1 = pop(_s);
MCHandle h2 = pop(_s);
push(_s, cons(h1, h2));
break;
}
case Command::CommandNum::READCHAR: {
} else if (poppedH == READCHAR) {
char c;
_instream >> c;
push(_s, makeIntCell(c));
break;
}
case Command::CommandNum::PUTCHAR: {
push(_s, makeNumCell(c));
} else if (poppedH == PUTCHAR) {
_outstream << (char) val(pop(_s));
break;
}
case Command::CommandNum::PUTNUM: {
} else if (poppedH == PUTNUM) {
_outstream << val(pop(_s));
break;
}
case Command::CommandNum::END: {
assert(false);
break;
}
default:
} else {
assert(false);
}
}

215
test/vm/VMTest.cpp
View File

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

20
test/vm/VMWithParserTest.cpp
View File

@@ -9,8 +9,9 @@ TEST(VMWithParserTest, BasicHello) {
{
MemoryContext mc;
VM vm(ssin, ssout);
Parser parser(vm);
parser.loadSecd("( LDC 104 PUTCHAR STOP )");
Parser parser;
parser.loadStr("( LDC 104 PUTCHAR STOP )");
vm.loadControl(parser.parseExpr());
vm.run();
}
ssout.flush();
@@ -23,9 +24,10 @@ TEST(VMWithParserTest, BasicBranch) {
{
MemoryContext mc;
VM vm(ssin, ssout);
Parser parser(vm);
parser.loadSecd(
Parser parser;
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 )");
vm.loadControl(parser.parseExpr());
vm.run();
}
ssout.flush();
@@ -38,8 +40,9 @@ TEST(VMWithParserTest, BasicFunction) {
{
MemoryContext mc;
VM vm(ssin, ssout);
Parser parser(vm);
parser.loadSecd("( NIL LDC 1 CONS LDC 2 CONS LDF ( LD ( 1 . 1 ) LD ( 1 . 2 ) ADD RET ) AP PUTNUM STOP )");
Parser parser;
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();
}
ssout.flush();
@@ -52,9 +55,10 @@ TEST(VMWithParserTest, RecFunction) {
{
MemoryContext mc;
VM vm(ssin, ssout);
Parser parser(vm);
parser.loadSecd(
Parser parser;
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 )");
vm.loadControl(parser.parseExpr());
vm.run();
}
ssout.flush();