tesses50/crosslang
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 4 Wiki Activity
Files
bdbdfde646ff34e6f4c170c3b6aefbc7d118c21b
crosslang/src/compiler/codegen.cpp

2289 lines
102 KiB
C++
Raw Blame History

#include "CrossLang.hpp"
#include <array>
#include <cstring>
#include <iostream>
#include <map>
#include <variant>
namespace Tesses::CrossLang {
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,
uint8_t *buffer, size_t len) {
strm->WriteBlock(buffer, len);
}
void WriteInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,
uint32_t v) {
uint8_t buffer[4];
BitConverter::FromUint32BE(buffer[0], v);
Write(strm, buffer, 4);
}
void WriteString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,
std::string v) {
WriteInt(strm, (uint32_t)v.size());
Write(strm, (uint8_t *)v.data(), v.size());
}
CodeGen::~CodeGen() {
for (auto &item : this->chunks) {
for (auto instr : item.second)
delete instr;
}
}
SyntaxNode CodeGen::OptimizeNode(SyntaxNode n) {
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto &asn = std::get<AdvancedSyntaxNode>(n);
if (asn.nodeName == AddExpression && asn.nodes.size() == 2) {
auto leftNode = OptimizeNode(asn.nodes[0]);
auto rightNode = OptimizeNode(asn.nodes[1]);
if (std::holds_alternative<int64_t>(leftNode) &&
std::holds_alternative<int64_t>(rightNode)) {
return std::get<int64_t>(leftNode) +
std::get<int64_t>(rightNode);
}
if (std::holds_alternative<double>(leftNode) &&
std::holds_alternative<double>(rightNode)) {
return std::get<double>(leftNode) + std::get<double>(rightNode);
}
if (std::holds_alternative<int64_t>(leftNode) &&
std::holds_alternative<double>(rightNode)) {
return (double)std::get<int64_t>(leftNode) +
std::get<double>(rightNode);
}
if (std::holds_alternative<double>(leftNode) &&
std::holds_alternative<int64_t>(rightNode)) {
return std::get<double>(leftNode) +
(double)std::get<int64_t>(rightNode);
}
if (std::holds_alternative<std::string>(leftNode) &&
std::holds_alternative<std::string>(rightNode)) {
return std::get<std::string>(leftNode) +
std::get<std::string>(rightNode);
}
if (std::holds_alternative<std::string>(leftNode) &&
std::holds_alternative<char>(rightNode)) {
return std::get<std::string>(leftNode) +
std::get<char>(rightNode);
}
if (std::holds_alternative<char>(leftNode) &&
std::holds_alternative<std::string>(rightNode)) {
return std::get<char>(leftNode) +
std::get<std::string>(rightNode);
}
}
if (asn.nodeName == SubExpression && asn.nodes.size() == 2) {
auto leftNode = OptimizeNode(asn.nodes[0]);
auto rightNode = OptimizeNode(asn.nodes[1]);
if (std::holds_alternative<int64_t>(leftNode) &&
std::holds_alternative<int64_t>(rightNode)) {
return std::get<int64_t>(leftNode) -
std::get<int64_t>(rightNode);
}
if (std::holds_alternative<double>(leftNode) &&
std::holds_alternative<double>(rightNode)) {
return std::get<double>(leftNode) - std::get<double>(rightNode);
}
if (std::holds_alternative<int64_t>(leftNode) &&
std::holds_alternative<double>(rightNode)) {
return (double)std::get<int64_t>(leftNode) -
std::get<double>(rightNode);
}
if (std::holds_alternative<double>(leftNode) &&
std::holds_alternative<int64_t>(rightNode)) {
return std::get<double>(leftNode) -
(double)std::get<int64_t>(rightNode);
}
}
if (asn.nodeName == CommaExpression && asn.nodes.size() == 2) {
return AdvancedSyntaxNode::Create(
CommaExpression, true,
{OptimizeNode(asn.nodes[0]), OptimizeNode(asn.nodes[1])});
}
if (asn.nodeName == ScopeNode) {
if (asn.nodes.empty()) {
asn.nodeName = NodeList;
return asn;
} else {
for (auto &item : asn.nodes) {
item = OptimizeNode(item);
}
}
}
}
return n;
}
/*
0: false,
1: true,
2: null,
3: Long,
4: Double,
5: Char
6: String,
7: List,
8: Dictionary,
9: ByteArray (embed),
10: Stream (embedstrm),
11: VFS (embeddir),
12: ClosureOfEmbedStream (used by embeddir)
*/
void CodeGen::WriteMetadataObject(std::vector<uint8_t> &bytes, SyntaxNode n) {
if (std::holds_alternative<bool>(n)) {
bytes.push_back(std::get<bool>(n) ? 1 : 0);
return;
}
if (std::holds_alternative<std::nullptr_t>(n)) {
bytes.push_back(2);
return;
}
if (std::holds_alternative<int64_t>(n)) {
auto num = std::get<int64_t>(n);
bytes.push_back(3);
size_t offset = bytes.size();
bytes.resize(offset + 8);
BitConverter::FromUint64BE(bytes[offset], num);
return;
}
if (std::holds_alternative<double>(n)) {
auto num = std::get<double>(n);
bytes.push_back(4);
size_t offset = bytes.size();
bytes.resize(offset + 8);
BitConverter::FromDoubleBE(bytes[offset], num);
return;
}
if (std::holds_alternative<char>(n)) {
auto chr = std::get<char>(n);
bytes.push_back(5);
bytes.push_back((uint8_t)chr);
return;
}
if (std::holds_alternative<std::string>(n)) {
auto &str = std::get<std::string>(n);
bytes.push_back(6);
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(bytes[offset], GetString(str));
return;
}
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto &asn = std::get<AdvancedSyntaxNode>(n);
if (asn.nodeName == ArrayExpression) {
std::vector<SyntaxNode> itms;
if (asn.nodes.size() > 0)
GetFunctionArgs(itms, asn.nodes[0]);
bytes.push_back(7);
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(bytes[offset], (uint32_t)itms.size());
for (auto &item : itms) {
WriteMetadataObject(bytes, item);
}
return;
}
if (asn.nodeName == DictionaryExpression) {
std::vector<SyntaxNode> itms;
if (asn.nodes.size() > 0)
GetFunctionArgs(itms, asn.nodes[0]);
bytes.push_back(8);
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(bytes[offset], (uint32_t)itms.size());
for (auto &item : itms) {
if (std::holds_alternative<AdvancedSyntaxNode>(item)) {
auto tkn = std::get<AdvancedSyntaxNode>(item);
if (tkn.nodeName == GetVariableExpression &&
!tkn.nodes.empty()) {
if (std::holds_alternative<std::string>(tkn.nodes[0])) {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(
bytes[offset2],
GetString(std::get<std::string>(tkn.nodes[0])));
bytes.push_back(2);
} else {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(bytes[offset2],
GetString("__unknown"));
bytes.push_back(2);
}
} else if (tkn.nodeName == AssignExpression &&
tkn.nodes.size() == 2 &&
std::holds_alternative<AdvancedSyntaxNode>(
tkn.nodes[0])) {
auto myTn = std::get<AdvancedSyntaxNode>(tkn.nodes[0]);
if (myTn.nodeName == GetVariableExpression &&
!myTn.nodes.empty()) {
if (std::holds_alternative<std::string>(
myTn.nodes[0])) {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(
bytes[offset2],
GetString(
std::get<std::string>(myTn.nodes[0])));
WriteMetadataObject(bytes, tkn.nodes[1]);
} else {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(
bytes[offset2], GetString("__unknown"));
bytes.push_back(2);
}
} else {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(bytes[offset2],
GetString("__unknown"));
bytes.push_back(2);
}
} else {
size_t offset2 = bytes.size();
bytes.resize(offset2 + 4);
BitConverter::FromUint32BE(bytes[offset2],
GetString("__unknown"));
bytes.push_back(2);
}
}
}
return;
}
if (asn.nodeName == EmbedExpression) {
if (!asn.nodes.empty() &&
std::holds_alternative<std::string>(asn.nodes[0])) {
auto &filename = std::get<std::string>(asn.nodes[0]);
bytes.push_back(9);
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(
bytes[offset],
GetResource(std::make_shared<ResourceFile>(filename)));
return;
}
}
if (asn.nodeName == EmbedStreamExpression) {
if (!asn.nodes.empty() &&
std::holds_alternative<std::string>(asn.nodes[0])) {
auto &filename = std::get<std::string>(asn.nodes[0]);
bytes.push_back(10);
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(
bytes[offset],
GetResource(std::make_shared<ResourceFile>(filename)));
return;
}
}
if (asn.nodeName == EmbedDirectoryExpression) {
if (!asn.nodes.empty() &&
std::holds_alternative<std::string>(asn.nodes[0])) {
auto &filename = std::get<std::string>(asn.nodes[0]);
bytes.push_back(11);
std::function<void(Tesses::Framework::Filesystem::VFSPath path)>
embedDir;
embedDir =
[&](Tesses::Framework::Filesystem::VFSPath path) -> void {
bytes.push_back(8);
std::vector<
std::pair<Tesses::Framework::Filesystem::VFSPath, bool>>
entries;
if (embedFS != nullptr && embedFS->DirectoryExists(path))
for (auto &item : embedFS->EnumeratePaths(path)) {
if (embedFS->DirectoryExists(item))
entries.emplace_back(item, true);
else if (embedFS->FileExists(item))
entries.emplace_back(item, false);
/*GenNode(instructions,item.GetFileName(),scope,contscope,brkscope,contI,brkI);
if(embedFS->DirectoryExists(item))
{
embedDir(item);
}
else if(embedFS->RegularFileExists(item))
{
auto ce =
AdvancedSyntaxNode::Create(ClosureExpression,true,{
AdvancedSyntaxNode::Create(ParenthesesExpression,true,{}),
AdvancedSyntaxNode::Create(ReturnStatement,false,{
AdvancedSyntaxNode::Create(EmbedStreamExpression,true,{item.ToString()})
})
});
GenNode(instructions,ce,scope,contscope,brkscope,contI,brkI);
}
else {
instructions.push_back(new
SimpleInstruction(PUSHUNDEFINED));
}
instructions.push_back(new
SimpleInstruction(APPENDDICT));*/
}
size_t offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(bytes[offset],
(uint32_t)entries.size());
for (auto &item : entries) {
offset = bytes.size();
bytes.resize(offset + 4);
BitConverter::FromUint32BE(
bytes[offset], GetString(item.first.GetFileName()));
if (item.second)
embedDir(item.first);
else {
bytes.push_back(12);
offset = bytes.size();
bytes.resize(offset + 4);
bytes.resize(offset + 4);
BitConverter::FromUint32BE(
bytes[offset],
GetResource(std::make_shared<ResourceFile>(
item.first.ToString())));
}
}
};
embedDir(filename);
return;
}
}
}
bytes.push_back(2);
}
void CodeGen::Save(std::shared_ptr<Tesses::Framework::Streams::Stream> stream) {
TVMVersion runtime_version(
CROSSLANG_BYTECODE_MAJOR, CROSSLANG_BYTECODE_MINOR,
CROSSLANG_BYTECODE_PATCH, CROSSLANG_BYTECODE_BUILD,
CROSSLANG_BYTECODE_VERSIONSTAGE);
uint8_t buffer[18];
memcpy(buffer, "TCROSSVM", 8);
runtime_version.ToArray(buffer + 8);
version.ToArray(buffer + 13);
Write(stream, buffer, 18);
uint32_t sections = 5;
uint32_t name = GetString(this->name);
uint32_t info = GetString(this->info);
for (auto &dep : this->dependencies) {
GetString(dep.first);
sections++;
}
for (auto &tool : this->tools) {
GetString(tool.first);
sections++;
}
for (auto &meta : this->meta) {
sections++;
}
if (!this->icon.empty()) {
this->GetResource(std::make_shared<ResourceFile>(this->icon));
}
for (auto &res : this->res)
sections++;
if (!this->icon.empty())
sections++;
if (!this->classes.empty())
sections++;
WriteInt(stream, sections);
uint32_t strSz = 4;
for (auto &s : this->strs) {
strSz += (uint32_t)s.size() + 4;
}
memcpy(buffer, "STRS", 4);
Write(stream, buffer, 4);
WriteInt(stream, strSz); // even though its ignored
WriteInt(stream, this->strs.size());
for (auto &str : this->strs)
WriteString(stream, str);
memcpy(buffer, "NAME", 4);
Write(stream, buffer, 4);
WriteInt(stream, 4);
WriteInt(stream, name);
memcpy(buffer, "INFO", 4);
Write(stream, buffer, 4);
WriteInt(stream, 4);
WriteInt(stream, info);
for (auto &dep : this->dependencies) {
memcpy(buffer, "DEPS", 4);
Write(stream, buffer, 4);
WriteInt(stream, 9); // even though its ignored
WriteInt(stream, GetString(dep.first));
dep.second.ToArray(buffer);
Write(stream, buffer, 5);
}
for (auto &tool : this->tools) {
memcpy(buffer, "TOOL", 4);
Write(stream, buffer, 4);
WriteInt(stream, 9); // even though its ignored
WriteInt(stream, GetString(tool.first));
tool.second.ToArray(buffer);
Write(stream, buffer, 5);
}
uint32_t fnLen = 4;
for (auto &fn : this->funcs) {
fnLen += (fn.first.size() + 2) * 4;
}
memcpy(buffer, "FUNS", 4);
Write(stream, buffer, 4);
WriteInt(stream, fnLen);
WriteInt(stream, (uint32_t)this->funcs.size());
for (auto &fn : this->funcs) {
WriteInt(stream, (uint32_t)fn.first.size());
for (auto namePart : fn.first) {
WriteInt(stream, namePart);
}
WriteInt(stream, fn.second);
}
uint32_t clength = 4;
for (auto &chunk : this->chunks) {
clength += (2 + chunk.first.size()) * 4;
size_t offset = 0;
std::map<std::string, int64_t> items;
for (auto instr : chunk.second) {
auto lbl = dynamic_cast<LabelInstruction *>(instr);
if (lbl != nullptr) {
items[lbl->label] = offset;
}
offset += instr->Size();
}
clength += (uint32_t)offset;
for (auto instr : chunk.second) {
auto jmp = dynamic_cast<LabelableInstruction *>(instr);
if (jmp != nullptr) {
jmp->n = items[jmp->label];
}
}
}
memcpy(buffer, "CHKS", 4);
Write(stream, buffer, 4);
WriteInt(stream, clength);
WriteInt(stream, (uint32_t)this->chunks.size());
for (auto &chunk : this->chunks) {
std::vector<uint8_t> buffer;
WriteInt(stream, (uint32_t)chunk.first.size());
for (auto arg : chunk.first) {
WriteInt(stream, arg);
}
for (auto instr : chunk.second) {
instr->Write(buffer);
}
WriteInt(stream, (uint32_t)buffer.size());
Write(stream, buffer.data(), buffer.size());
}
if (!classes.empty()) {
uint32_t len = 4;
for (auto &cls : classes) {
len += 8;
len += cls.name.size() * 4;
len += 4;
len += cls.inherits.size() * 4;
len += 4;
for (auto &clsEnt : cls.entries) {
len += 17;
for (auto &arg : clsEnt.arguments)
len += 4;
}
}
memcpy(buffer, "CLSS", 4);
Write(stream, buffer, 4);
WriteInt(stream, len);
WriteInt(stream, (uint32_t)classes.size());
for (auto &cls : classes) {
WriteInt(stream, cls.documentation);
WriteInt(stream, (uint32_t)cls.name.size());
for (auto namePart : cls.name)
WriteInt(stream, namePart);
WriteInt(stream, (uint32_t)cls.inherits.size());
for (auto inhPart : cls.inherits)
WriteInt(stream, inhPart);
WriteInt(stream, (uint32_t)cls.entries.size());
for (auto &ent : cls.entries) {
buffer[0] = ent.type;
Write(stream, buffer, 1);
WriteInt(stream, ent.documentation);
WriteInt(stream, ent.name);
WriteInt(stream, (uint32_t)ent.arguments.size());
for (auto ar : ent.arguments) {
WriteInt(stream, ar);
}
WriteInt(stream, ent.closure);
}
}
}
for (auto &reso : res) {
memcpy(buffer, "RESO", 4);
Write(stream, buffer, 4);
WriteInt(stream, reso->GetLength(embedFS));
reso->Write(stream);
}
if (!this->icon.empty()) {
memcpy(buffer, "ICON", 4);
Write(stream, buffer, 4);
WriteInt(stream, 4);
WriteInt(stream,
this->GetResource(std::make_shared<ResourceFile>(this->icon)));
}
for (auto &meta : this->meta) {
memcpy(buffer, "META", 4);
Write(stream, buffer, 4);
WriteInt(stream, (uint32_t)meta.size());
Write(stream, meta.data(), meta.size());
}
}
size_t SimpleInstruction::Size() { return 1; }
SimpleInstruction::SimpleInstruction(Instruction instr) {
this->instruction = instr;
}
void SimpleInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(instruction);
}
ScopeEndTimesInstruction::ScopeEndTimesInstruction(uint32_t s) { this->n = s; }
size_t ScopeEndTimesInstruction::Size() { return 5; }
void ScopeEndTimesInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(SCOPEENDTIMES);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
LabelInstruction::LabelInstruction(std::string lbl) { this->label = lbl; }
size_t LabelInstruction::Size() { return 0; }
void LabelInstruction::Write(std::vector<uint8_t> &instr) {
// label instructions do not write a thing
}
JumpStyleInstruction::JumpStyleInstruction(Instruction instr, std::string lbl) {
this->type = instr;
this->label = lbl;
this->n = 0;
}
size_t JumpStyleInstruction::Size() { return 5; }
void JumpStyleInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back((uint8_t)type);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
size_t LabelableInstruction::Size() { return 4; }
void LabelableInstruction::Write(std::vector<uint8_t> &instr) {
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
StringInstruction::StringInstruction(uint32_t s) { this->n = s; }
size_t StringInstruction::Size() { return 5; }
void StringInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHSTRING);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
EmbedInstruction::EmbedInstruction(uint32_t s) { this->n = s; }
size_t EmbedInstruction::Size() { return 5; }
void EmbedInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHRESOURCE);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
EmbedStreamInstruction::EmbedStreamInstruction(uint32_t s) { this->n = s; }
size_t EmbedStreamInstruction::Size() { return 5; }
void EmbedStreamInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHRESOURCESTREAM);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
ClosureInstruction::ClosureInstruction(uint32_t s, bool hasScope) {
this->n = s;
this->hasScope = hasScope;
}
size_t ClosureInstruction::Size() { return 5; }
void ClosureInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(this->hasScope ? PUSHCLOSURE : PUSHSCOPELESSCLOSURE);
std::array<uint8_t, 4> buff;
BitConverter::FromUint32BE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
DoubleInstruction::DoubleInstruction(double s) { this->n = s; }
size_t DoubleInstruction::Size() { return 9; }
void DoubleInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHDOUBLE);
std::array<uint8_t, 8> buff;
BitConverter::FromDoubleBE(buff[0], this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
CharInstruction::CharInstruction(char s) { this->n = s; }
size_t CharInstruction::Size() { return 2; }
void CharInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHCHAR);
uint8_t buff[8];
instr.push_back((uint8_t)this->n);
}
LongInstruction::LongInstruction(int64_t s) { this->n = s; }
size_t LongInstruction::Size() { return 9; }
void LongInstruction::Write(std::vector<uint8_t> &instr) {
instr.push_back(PUSHLONG);
std::array<uint8_t, 8> buff;
BitConverter::FromUint64BE(buff[0], (uint64_t)this->n);
instr.insert(instr.end(), buff.begin(), buff.end());
}
uint32_t CodeGen::GetString(std::string str) {
for (uint32_t i = 0; i < (uint32_t)this->strs.size(); i++) {
if (this->strs[i] == str)
return i;
}
uint32_t strI = (uint32_t)this->strs.size();
this->strs.push_back(str);
return strI;
}
uint32_t CodeGen::GetResource(std::shared_ptr<ResourceBase> resource) {
for (uint32_t i = 0; i < (uint32_t)this->res.size(); i++) {
if (this->res[i]->IsEqual(resource.get()))
return i;
}
uint32_t resI = (uint32_t)this->res.size();
this->res.push_back(resource);
return resI;
}
#define ONE_EXPR(EXPRESSION, INSTRUCTION) \
if (adv.nodeName == EXPRESSION && adv.nodes.size() == 1) { \
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope, contI, \
brkI); \
instructions.push_back(new SimpleInstruction(INSTRUCTION)); \
}
#define TWO_EXPR(EXPRESSION, INSTRUCTION) \
if (adv.nodeName == EXPRESSION && adv.nodes.size() == 2) { \
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope, contI, \
brkI); \
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope, contI, \
brkI); \
instructions.push_back(new SimpleInstruction(INSTRUCTION)); \
}
SyntaxNode CodeGen::StringifyListOfVars(SyntaxNode n) {
if (std::holds_alternative<std::string>(n)) {
return n;
} else if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto itemA = std::get<AdvancedSyntaxNode>(n);
if (itemA.nodeName == GetVariableExpression &&
itemA.nodes.size() == 1 &&
std::holds_alternative<std::string>(itemA.nodes[0])) {
return std::get<std::string>(itemA.nodes[0]);
} else if (itemA.nodeName == CommaExpression &&
itemA.nodes.size() == 2) {
return AdvancedSyntaxNode::Create(
CommaExpression, true,
{StringifyListOfVars(itemA.nodes[0]),
StringifyListOfVars(itemA.nodes[1])});
}
}
return nullptr;
}
void CodeGen::GenNode(std::vector<ByteCodeInstruction *> &instructions,
SyntaxNode n, int32_t scope, int32_t contscope,
int32_t brkscope, int32_t contI, int32_t brkI) {
if (std::holds_alternative<std::nullptr_t>(n)) {
instructions.push_back(new SimpleInstruction(PUSHNULL));
} else if (std::holds_alternative<Undefined>(n)) {
instructions.push_back(new SimpleInstruction(PUSHUNDEFINED));
} else if (std::holds_alternative<bool>(n)) {
instructions.push_back(
new SimpleInstruction(std::get<bool>(n) ? PUSHTRUE : PUSHFALSE));
} else if (std::holds_alternative<std::string>(n)) {
instructions.push_back(
new StringInstruction(GetString(std::get<std::string>(n))));
} else if (std::holds_alternative<char>(n)) {
instructions.push_back(new CharInstruction(std::get<char>(n)));
} else if (std::holds_alternative<int64_t>(n)) {
instructions.push_back(new LongInstruction(std::get<int64_t>(n)));
} else if (std::holds_alternative<double>(n)) {
instructions.push_back(new DoubleInstruction(std::get<double>(n)));
} else if (std::holds_alternative<std::vector<uint8_t>>(n)) {
ResourceByteArray ba;
ba.data = std::get<std::vector<uint8_t>>(n);
instructions.push_back(new EmbedInstruction(
GetResource(std::make_shared<ResourceByteArray>(ba))));
} else if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto adv = std::get<AdvancedSyntaxNode>(n);
ONE_EXPR(NotExpression, NOT)
ONE_EXPR(BitwiseNotExpression, BITWISENOT)
ONE_EXPR(NegativeExpression, NEGATIVE)
TWO_EXPR(AddExpression, ADD)
TWO_EXPR(SubExpression, SUB)
TWO_EXPR(TimesExpression, TIMES)
TWO_EXPR(DivideExpression, DIVIDE)
TWO_EXPR(ModExpression, MODULO)
TWO_EXPR(LeftShiftExpression, LEFTSHIFT)
TWO_EXPR(RightShiftExpression, RIGHTSHIFT)
TWO_EXPR(BitwiseOrExpression, BITWISEOR)
TWO_EXPR(BitwiseAndExpression, BITWISEAND)
TWO_EXPR(LessThanExpression, LESSTHAN)
TWO_EXPR(GreaterThanExpression, GREATERTHAN)
TWO_EXPR(LessThanEqualsExpression, LESSTHANEQ)
TWO_EXPR(GreaterThanEqualsExpression, GREATERTHANEQ)
TWO_EXPR(NotEqualsExpression, NEQ)
TWO_EXPR(EqualsExpression, EQ)
TWO_EXPR(XOrExpression, XOR)
if (adv.nodeName == GetPrivateExpression) {
instructions.push_back(new SimpleInstruction(PUSHPRIVATEXPRESSION));
}
if (adv.nodeName == LineNode && adv.nodes.size() == 2) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(LINEINFO));
} else if (adv.nodeName == NullCoalescingExpression &&
adv.nodes.size() == 2) {
uint32_t ifId = NewId();
std::string ifIdTrue = "__compGenTrue";
ifIdTrue.append(std::to_string(ifId));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new JumpStyleInstruction(Instruction::JMPIFDEFINED, ifIdTrue));
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new LabelInstruction(ifIdTrue));
} else if (adv.nodeName == ClassStatement && adv.nodes.size() >= 3 &&
std::holds_alternative<std::string>(adv.nodes[0])) {
CodeGenClass cls;
cls.documentation = GetString(std::get<std::string>(adv.nodes[0]));
GetFunctionName(cls.name, adv.nodes[1]);
GetFunctionName(cls.inherits, adv.nodes[2]);
for (size_t i = 3; i < adv.nodes.size(); i++) {
auto &node = adv.nodes[i];
if (std::holds_alternative<AdvancedSyntaxNode>(node)) {
auto &adv2 = std::get<AdvancedSyntaxNode>(node);
CodeGenClassEntry ent;
ent.type = 0;
if (adv2.nodes.size() >= 2 &&
std::holds_alternative<std::string>(adv2.nodes[0]) &&
std::holds_alternative<std::string>(adv2.nodes[1])) {
ent.documentation =
GetString(std::get<std::string>(adv2.nodes[0]));
std::string type = std::get<std::string>(adv2.nodes[1]);
if (type == "private")
ent.type = 0;
else if (type == "protected")
ent.type = 1;
else if (type == "public")
ent.type = 2;
else if (type == "static")
ent.type = 3;
}
if (adv2.nodeName == MethodStatement &&
adv2.nodes.size() == 4 &&
std::holds_alternative<AdvancedSyntaxNode>(
adv2.nodes[2])) {
// documentation,myTkn.text,nameAndArgs,closureData
size_t fnindex = this->chunks.size();
ent.closure = (uint32_t)fnindex;
this->chunks.resize(fnindex + 1);
auto &nameAndArgs =
std::get<AdvancedSyntaxNode>(adv2.nodes[2]);
if (nameAndArgs.nodeName == FunctionCallExpression &&
!nameAndArgs.nodes.empty() &&
std::holds_alternative<AdvancedSyntaxNode>(
nameAndArgs.nodes[0])) {
auto &getvar = std::get<AdvancedSyntaxNode>(
nameAndArgs.nodes[0]);
if (getvar.nodeName == GetVariableExpression &&
getvar.nodes.size() == 1 &&
std::holds_alternative<std::string>(
getvar.nodes[0])) {
ent.name = GetString(
std::get<std::string>(getvar.nodes[0]));
if (nameAndArgs.nodes.size() > 1) {
GetFunctionArgs(ent.arguments,
nameAndArgs.nodes[1]);
}
} else
continue;
}
std::vector<ByteCodeInstruction *> fnInstructions;
GenNode(fnInstructions, adv2.nodes[3], 0, -1, -1, -1,
-1);
this->chunks[fnindex] =
std::pair<std::vector<uint32_t>,
std::vector<ByteCodeInstruction *>>(
ent.arguments, fnInstructions);
} else if (adv2.nodeName == AbstractMethodStatement &&
adv2.nodes.size() == 3 &&
std::holds_alternative<AdvancedSyntaxNode>(
adv2.nodes[2])) {
ent.closure = 0;
ent.type |= 0b00001000;
// documentation,myTkn.text,nameAndArgs
auto &nameAndArgs =
std::get<AdvancedSyntaxNode>(adv2.nodes[2]);
if (nameAndArgs.nodeName == FunctionCallExpression &&
!nameAndArgs.nodes.empty() &&
std::holds_alternative<AdvancedSyntaxNode>(
nameAndArgs.nodes[0])) {
auto &getvar = std::get<AdvancedSyntaxNode>(
nameAndArgs.nodes[0]);
if (getvar.nodeName == GetVariableExpression &&
getvar.nodes.size() == 1 &&
std::holds_alternative<std::string>(
getvar.nodes[0])) {
ent.name = GetString(
std::get<std::string>(getvar.nodes[0]));
if (nameAndArgs.nodes.size() > 1) {
GetFunctionArgs(ent.arguments,
nameAndArgs.nodes[1]);
}
} else
continue;
}
} else if (adv2.nodeName == FieldStatement &&
adv2.nodes.size() == 3 &&
std::holds_alternative<AdvancedSyntaxNode>(
adv2.nodes[2])) {
auto &setter =
std::get<AdvancedSyntaxNode>(adv2.nodes[2]);
if (setter.nodeName == GetVariableExpression &&
setter.nodes.size() == 1 &&
std::holds_alternative<std::string>(
setter.nodes[0])) {
ent.closure = 0;
ent.type |= 0b00001100;
ent.name = GetString(
std::get<std::string>(setter.nodes[0]));
} else if (setter.nodeName == AssignExpression &&
setter.nodes.size() == 2 &&
std::holds_alternative<AdvancedSyntaxNode>(
setter.nodes[0])) {
auto &getvar =
std::get<AdvancedSyntaxNode>(setter.nodes[0]);
if (getvar.nodeName == GetVariableExpression &&
getvar.nodes.size() == 1 &&
std::holds_alternative<std::string>(
getvar.nodes[0])) {
ent.type |= 0b00000100;
ent.name = GetString(
std::get<std::string>(getvar.nodes[0]));
size_t fnindex = this->chunks.size();
ent.closure = (uint32_t)fnindex;
ent.arguments = {};
this->chunks.resize(fnindex + 1);
std::vector<ByteCodeInstruction *>
fnInstructions;
GenNode(fnInstructions,
AdvancedSyntaxNode::Create(
ReturnStatement, false,
{setter.nodes[1]}),
0, -1, -1, -1, -1);
this->chunks[fnindex] = std::pair<
std::vector<uint32_t>,
std::vector<ByteCodeInstruction *>>(
{}, fnInstructions);
} else
continue;
} else
continue;
}
cls.entries.push_back(ent);
}
}
classes.push_back(cls);
} else if (adv.nodeName == RelativePathExpression) {
instructions.push_back(
new SimpleInstruction(Instruction::PUSHRELATIVEPATH));
} else if (adv.nodeName == RootPathExpression) {
instructions.push_back(
new SimpleInstruction(Instruction::PUSHROOTPATH));
} else if (adv.nodeName == SwitchStatement && adv.nodes.size() == 2) {
// THIS CODE WORKED FIRST TRY, I DON'T SEE THAT EVERY DAY, PRAISE
// GOD!!!!!!!
auto expr = adv.nodes[0];
std::vector<SyntaxNode> nodes_before;
SyntaxNode currentCase = nullptr;
std::vector<SyntaxNode> currentNodes;
std::string defaultJmp = {};
std::vector<std::pair<std::pair<std::string, AdvancedSyntaxNode>,
std::vector<SyntaxNode>>>
snodes;
if (std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[1])) {
auto body = std::get<AdvancedSyntaxNode>(adv.nodes[1]);
if (body.nodeName == ScopeNode) {
for (auto item : body.nodes) {
if (std::holds_alternative<AdvancedSyntaxNode>(item)) {
auto no = std::get<AdvancedSyntaxNode>(item);
if (no.nodeName == CaseStatement ||
no.nodeName == DefaultStatement) {
if (std::holds_alternative<AdvancedSyntaxNode>(
currentCase)) {
uint32_t jmpId = NewId();
std::string jmpIdStr = "__compGenJmp";
jmpIdStr.append(std::to_string(jmpId));
snodes.push_back(
std::pair<std::pair<std::string,
AdvancedSyntaxNode>,
std::vector<SyntaxNode>>(
std::pair<std::string,
AdvancedSyntaxNode>(
jmpIdStr,
std::get<AdvancedSyntaxNode>(
currentCase)),
currentNodes));
currentNodes = {};
}
currentCase = no;
continue;
}
}
if (std::holds_alternative<AdvancedSyntaxNode>(
currentCase)) {
currentNodes.push_back(item);
} else {
nodes_before.push_back(item);
}
}
if (std::holds_alternative<AdvancedSyntaxNode>(
currentCase)) {
uint32_t jmpId = NewId();
std::string jmpIdStr = "__compGenJmp";
jmpIdStr.append(std::to_string(jmpId));
snodes.push_back(
std::pair<
std::pair<std::string, AdvancedSyntaxNode>,
std::vector<SyntaxNode>>(
std::pair<std::string, AdvancedSyntaxNode>(
jmpIdStr,
std::get<AdvancedSyntaxNode>(currentCase)),
currentNodes));
currentNodes = {};
}
uint32_t endId = NewId();
std::string endIdStr = "__compGenBrk";
endIdStr.append(std::to_string(endId));
for (auto item : nodes_before) {
GenNode(instructions, item, scope, contscope, brkscope,
contI, brkI);
}
for (auto item : snodes) {
if (item.first.second.nodeName == CaseStatement) {
auto eq = AdvancedSyntaxNode::Create(
EqualsExpression, true,
{item.first.second.nodes[0], adv.nodes[0]});
GenNode(instructions, eq, scope, contscope,
brkscope, contI, brkI);
instructions.push_back(new JumpStyleInstruction(
JMPC, item.first.first));
}
if (item.first.second.nodeName == DefaultStatement) {
if (!defaultJmp.empty())
std::cout << "ERROR: multiple default in "
"switch statement will cause "
"undefined behaviour, this is not "
"an exception due to not allowing "
"exceptions in codegen stage (the "
"compilation shouldn't fail)"
<< std::endl;
defaultJmp = item.first.first;
}
}
if (defaultJmp.empty()) {
instructions.push_back(
new JumpStyleInstruction(JMP, endIdStr));
} else {
instructions.push_back(
new JumpStyleInstruction(JMP, defaultJmp));
}
for (auto item : snodes) {
instructions.push_back(
new LabelInstruction(item.first.first));
for (auto item2 : item.second) {
GenNode(instructions, item2, scope, contscope,
scope, contI, endId);
}
}
instructions.push_back(new LabelInstruction(endIdStr));
}
}
return;
}
if (adv.nodeName == TernaryExpression && adv.nodes.size() == 3) {
uint32_t ifId = NewId();
std::string ifIdTrue = "__compGenTrue";
ifIdTrue.append(std::to_string(ifId));
std::string ifIdEnd = "__compGenEnd";
ifIdEnd.append(std::to_string(ifId));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new JumpStyleInstruction(JMPC, ifIdTrue));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[2])) {
GenNode(instructions, adv.nodes[2], scope, contscope, brkscope,
contI, brkI);
}
instructions.push_back(new JumpStyleInstruction(JMP, ifIdEnd));
instructions.push_back(new LabelInstruction(ifIdTrue));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[1])) {
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
}
instructions.push_back(new LabelInstruction(ifIdEnd));
} else if (adv.nodeName == CompoundAssignExpression &&
adv.nodes.size() == 1 &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[0])) {
auto data = std::get<AdvancedSyntaxNode>(adv.nodes[0]);
if (data.nodes.size() == 2) {
auto d = AdvancedSyntaxNode::Create(AssignExpression, true,
{data.nodes[0], data});
GenNode(instructions, d, scope, contscope, brkscope, contI,
brkI);
}
} else if (adv.nodeName == PrefixIncrementExpression &&
adv.nodes.size() == 1) {
GenNode(instructions,
AdvancedSyntaxNode::Create(
CompoundAssignExpression, true,
{AdvancedSyntaxNode::Create(
AddExpression, true, {adv.nodes[0], (int64_t)1})}),
scope, contscope, brkscope, contI, brkI);
} else if (adv.nodeName == PrefixDecrementExpression &&
adv.nodes.size() == 1) {
GenNode(instructions,
AdvancedSyntaxNode::Create(
CompoundAssignExpression, true,
{AdvancedSyntaxNode::Create(
SubExpression, true, {adv.nodes[0], (int64_t)1})}),
scope, contscope, brkscope, contI, brkI);
} else if (adv.nodeName == PostfixIncrementExpression &&
adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenNode(instructions,
AdvancedSyntaxNode::Create(
CompoundAssignExpression, true,
{AdvancedSyntaxNode::Create(
AddExpression, true, {adv.nodes[0], (int64_t)1})}),
scope, contscope, brkscope, contI, brkI);
instructions.push_back(new SimpleInstruction(POP));
} else if (adv.nodeName == PostfixDecrementExpression &&
adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenNode(instructions,
AdvancedSyntaxNode::Create(
CompoundAssignExpression, true,
{AdvancedSyntaxNode::Create(
SubExpression, true, {adv.nodes[0], (int64_t)1})}),
scope, contscope, brkscope, contI, brkI);
instructions.push_back(new SimpleInstruction(POP));
} else if (adv.nodeName == LogicalOrExpression &&
adv.nodes.size() == 2) {
auto data = AdvancedSyntaxNode::Create(
TernaryExpression, true,
{adv.nodes[0], true,
AdvancedSyntaxNode::Create(TernaryExpression, true,
{adv.nodes[1], true, false})});
GenNode(instructions, data, scope, contscope, brkscope, contI,
brkI);
} else if (adv.nodeName == LogicalAndExpression &&
adv.nodes.size() == 2) {
auto data = AdvancedSyntaxNode::Create(
TernaryExpression, true,
{adv.nodes[0],
AdvancedSyntaxNode::Create(TernaryExpression, true,
{adv.nodes[1], true, false}),
false});
GenNode(instructions, data, scope, contscope, brkscope, contI,
brkI);
} else if (adv.nodeName == EachStatement && adv.nodes.size() == 3) {
auto item = adv.nodes[0];
auto list = adv.nodes[1];
auto body = adv.nodes[2];
uint32_t compGenId = NewId();
std::string compGenIttr = "__compGenIttr";
compGenIttr.append(std::to_string(compGenId));
auto each = AdvancedSyntaxNode::Create(
NodeList, false,
{AdvancedSyntaxNode::Create(
AssignExpression, true,
{AdvancedSyntaxNode::Create(DeclareExpression, true,
{compGenIttr}),
AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{list, "GetEnumerator"})})}),
AdvancedSyntaxNode::Create(
DeferStatement, false,
{AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{AdvancedSyntaxNode::Create(GetVariableExpression,
true, {compGenIttr}),
"Dispose"})})}),
AdvancedSyntaxNode::Create(
WhileStatement, false,
{AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{
AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{AdvancedSyntaxNode::Create(
GetVariableExpression, true,
{compGenIttr}),
"MoveNext"}),
}),
AdvancedSyntaxNode::Create(
NodeList, false,
{AdvancedSyntaxNode::Create(
AssignExpression, true,
{item, AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{AdvancedSyntaxNode::Create(
GetVariableExpression, true,
{compGenIttr}),
"Current"})}),
body})})});
GenNode(instructions, each, scope, contscope, brkscope, contI,
brkI);
} else if (adv.nodeName == ArrayExpression) {
instructions.push_back(new SimpleInstruction(CREATEARRAY));
std::vector<SyntaxNode> itms;
if (adv.nodes.size() > 0)
GetFunctionArgs(itms, adv.nodes[0]);
for (auto item : itms) {
GenNode(instructions, item, scope, contscope, brkscope, contI,
brkI);
instructions.push_back(new SimpleInstruction(APPENDLIST));
}
} else if (adv.nodeName == DictionaryExpression) {
instructions.push_back(new SimpleInstruction(CREATEDICTIONARY));
std::vector<SyntaxNode> itms;
if (adv.nodes.size() > 0)
GetFunctionArgs(itms, adv.nodes[0]);
for (auto item : itms) {
if (std::holds_alternative<AdvancedSyntaxNode>(item)) {
auto tkn = std::get<AdvancedSyntaxNode>(item);
if (tkn.nodeName == GetVariableExpression &&
!tkn.nodes.empty()) {
GenNode(instructions, tkn.nodes[0], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, item, scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new SimpleInstruction(APPENDDICT));
} else if (tkn.nodeName == AssignExpression &&
tkn.nodes.size() == 2 &&
std::holds_alternative<AdvancedSyntaxNode>(
tkn.nodes[0])) {
auto myTn = std::get<AdvancedSyntaxNode>(tkn.nodes[0]);
if (myTn.nodeName == GetVariableExpression &&
!myTn.nodes.empty()) {
GenNode(instructions, myTn.nodes[0], scope,
contscope, brkscope, contI, brkI);
GenNode(instructions, tkn.nodes[1], scope,
contscope, brkscope, contI, brkI);
instructions.push_back(
new SimpleInstruction(APPENDDICT));
}
}
}
}
} else if (adv.nodeName == FunctionCallExpression &&
adv.nodes.size() >= 1 &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[0])) {
auto v = std::get<AdvancedSyntaxNode>(adv.nodes[0]);
if (v.nodeName == GetFieldExpression && v.nodes.size() == 2) {
GenNode(instructions, v.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenNode(instructions, v.nodes[1], scope, contscope, brkscope,
contI, brkI);
if (adv.nodes.size() == 2) {
std::vector<SyntaxNode> nodes;
GetFunctionArgs(nodes, adv.nodes[1]);
for (auto item : nodes)
GenNode(instructions, item, scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new LongInstruction((int64_t)nodes.size()));
} else {
instructions.push_back(new LongInstruction(0));
}
instructions.push_back(new SimpleInstruction(CALLMETHOD));
} else if (v.nodeName != GetFieldExpression) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
if (adv.nodes.size() == 2) {
std::vector<SyntaxNode> nodes;
GetFunctionArgs(nodes, adv.nodes[1]);
for (auto item : nodes)
GenNode(instructions, item, scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new LongInstruction((int64_t)nodes.size()));
} else {
instructions.push_back(new LongInstruction(0));
}
instructions.push_back(new SimpleInstruction(CALLFUNCTION));
}
} else if (adv.nodeName == IfStatement && adv.nodes.size() == 3) {
uint32_t ifId = NewId();
std::string ifIdTrue = "__compGenTrue";
ifIdTrue.append(std::to_string(ifId));
std::string ifIdEnd = "__compGenEnd";
ifIdEnd.append(std::to_string(ifId));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new JumpStyleInstruction(JMPC, ifIdTrue));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[2])) {
GenNode(instructions, adv.nodes[2], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[2]);
}
instructions.push_back(new JumpStyleInstruction(JMP, ifIdEnd));
instructions.push_back(new LabelInstruction(ifIdTrue));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[1])) {
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[1]);
}
instructions.push_back(new LabelInstruction(ifIdEnd));
} else if (adv.nodeName == UsingStatement && adv.nodes.size() == 2) {
// using(EXPRESSION) {}
// using(EXPRESSION) STATEMENT;
//{ __compGen = EXPRESSION; defer { __compGen.Dispose(); }
//{}(unrolled) OR STATEMENT; }
if (std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[1])) {
auto asn2 = std::get<AdvancedSyntaxNode>(adv.nodes[1]);
if (asn2.nodeName == ScopeNode) {
scope++;
instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
uint32_t exprId = NewId();
std::string exprStr = "__compGenUsing";
exprStr.append(std::to_string(exprId));
auto _assign = AdvancedSyntaxNode::Create(
AssignExpression, true,
{AdvancedSyntaxNode::Create(DeclareExpression, true,
{exprStr}),
adv.nodes[0]});
GenNode(instructions, _assign, scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, _assign);
auto _defer = AdvancedSyntaxNode::Create(
DeferStatement, false,
{AdvancedSyntaxNode::Create(
ReturnStatement, false,
{AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{AdvancedSyntaxNode::Create(
GetVariableExpression, true,
{exprStr}),
"Dispose"})})})});
GenNode(instructions, _defer, scope, contscope, brkscope,
contI, brkI);
for (size_t i = 0; i < asn2.nodes.size(); i++) {
GenNode(instructions, asn2.nodes[i], scope, contscope,
brkscope, contI, brkI);
if (!asn2.isExpression || i < asn2.nodes.size() - 1)
GenPop(instructions, asn2.nodes[i]);
}
instructions.push_back(new SimpleInstruction(SCOPEEND));
scope--;
return;
}
}
{
scope++;
instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
uint32_t exprId = NewId();
std::string exprStr = "__compGenUsing";
exprStr.append(std::to_string(exprId));
auto _assign = AdvancedSyntaxNode::Create(
AssignExpression, true,
{AdvancedSyntaxNode::Create(DeclareExpression, true,
{exprStr}),
adv.nodes[0]});
GenNode(instructions, _assign, scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, _assign);
auto _defer = AdvancedSyntaxNode::Create(
DeferStatement, false,
{AdvancedSyntaxNode::Create(
ReturnStatement, false,
{AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(
GetFieldExpression, true,
{AdvancedSyntaxNode::Create(
GetVariableExpression, true, {exprStr}),
"Dispose"})})})});
GenNode(instructions, _defer, scope, contscope, brkscope, contI,
brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
if (!adv.isExpression)
GenPop(instructions, adv.nodes[1]);
instructions.push_back(new SimpleInstruction(SCOPEEND));
scope--;
}
} else if (adv.nodeName == WhileStatement && adv.nodes.size() == 2) {
auto old_contI = contI;
auto old_brkI = brkI;
auto old_contscope = contscope;
auto old_brkscope = brkscope;
contscope = scope;
brkscope = scope;
uint32_t whileId = NewId();
std::string whileIdCont = "__compGenCont";
whileIdCont.append(std::to_string(whileId));
std::string whileIdBrk = "__compGenBrk";
whileIdBrk.append(std::to_string(whileId));
contI = whileId;
brkI = whileId;
instructions.push_back(new LabelInstruction(whileIdCont));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(NOT));
instructions.push_back(new JumpStyleInstruction(JMPC, whileIdBrk));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[1])) {
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[1]);
}
instructions.push_back(new JumpStyleInstruction(JMP, whileIdCont));
instructions.push_back(new LabelInstruction(whileIdBrk));
contI = old_contI;
brkI = old_brkI;
contscope = old_contscope;
brkscope = old_brkscope;
} else if (adv.nodeName == DoStatement && adv.nodes.size() == 2) {
auto old_contI = contI;
auto old_brkI = brkI;
auto old_contscope = contscope;
auto old_brkscope = brkscope;
contscope = scope;
brkscope = scope;
uint32_t doId = NewId();
std::string doIdCont = "__compGenCont";
doIdCont.append(std::to_string(doId));
std::string doIdBrk = "__compGenBrk";
doIdBrk.append(std::to_string(doId));
std::string doIdStart = "__compGenStart";
doIdStart.append(std::to_string(doId));
contI = doId;
brkI = doId;
instructions.push_back(new LabelInstruction(doIdStart));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[1])) {
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[1]);
}
instructions.push_back(new LabelInstruction(doIdCont));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new JumpStyleInstruction(JMPC, doIdStart));
instructions.push_back(new LabelInstruction(doIdBrk));
contI = old_contI;
brkI = old_brkI;
contscope = old_contscope;
brkscope = old_brkscope;
} else if (adv.nodeName == ForStatement && adv.nodes.size() == 4) {
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[0])) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[0]);
}
auto old_contI = contI;
auto old_brkI = brkI;
auto old_contscope = contscope;
auto old_brkscope = brkscope;
contscope = scope;
brkscope = scope;
uint32_t doId = NewId();
std::string doIdCont = "__compGenCont";
doIdCont.append(std::to_string(doId));
std::string doIdBrk = "__compGenBrk";
doIdBrk.append(std::to_string(doId));
std::string doIdStart = "__compGenStart";
doIdStart.append(std::to_string(doId));
std::string doIdStart2 = "__compGenCond";
doIdStart2.append(std::to_string(doId));
contI = doId;
brkI = doId;
instructions.push_back(new JumpStyleInstruction(JMP, doIdStart2));
instructions.push_back(new LabelInstruction(doIdStart));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[3])) {
GenNode(instructions, adv.nodes[3], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[3]);
}
instructions.push_back(new LabelInstruction(doIdCont));
if (!std::holds_alternative<std::nullptr_t>(adv.nodes[2])) {
GenNode(instructions, adv.nodes[2], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[2]);
}
instructions.push_back(new LabelInstruction(doIdStart2));
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new JumpStyleInstruction(JMPC, doIdStart));
instructions.push_back(new LabelInstruction(doIdBrk));
contI = old_contI;
brkI = old_brkI;
contscope = old_contscope;
brkscope = old_brkscope;
} else if (adv.nodeName == CommaExpression && adv.nodes.size() == 2) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[0]);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
} else if (adv.nodeName == ContinueStatement) {
if (contscope == -1) {
std::cout << "WARN: continue does nothing here\n";
} else if (contscope == -2) {
instructions.push_back(new SimpleInstruction(PUSHCONTINUE));
instructions.push_back(new SimpleInstruction(RET));
} else {
auto cont = scope - contscope;
if (cont > 0)
instructions.push_back(
new ScopeEndTimesInstruction((uint32_t)cont));
std::string myJmp = "__compGenCont";
myJmp.append(std::to_string(contI));
instructions.push_back(new JumpStyleInstruction(JMP, myJmp));
}
} else if (adv.nodeName == BreakStatement) {
if (brkscope == -1) {
std::cout << "WARN: break does nothing here\n";
} else if (brkscope == -2) {
instructions.push_back(new SimpleInstruction(PUSHBREAK));
instructions.push_back(new SimpleInstruction(RET));
} else {
auto _brk = scope - brkscope;
if (_brk > 0)
instructions.push_back(
new ScopeEndTimesInstruction((uint32_t)_brk));
std::string myJmp = "__compGenBrk";
myJmp.append(std::to_string(brkI));
instructions.push_back(new JumpStyleInstruction(JMP, myJmp));
}
} else if (adv.nodeName == GetVariableExpression &&
adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(GETVARIABLE));
} else if (adv.nodeName == GetFieldExpression &&
adv.nodes.size() == 2) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(GETFIELD));
} else if (adv.nodeName == GetArrayExpression &&
adv.nodes.size() == 2) {
SyntaxNode n = AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(GetFieldExpression, true,
{adv.nodes[0], "GetAt"}),
adv.nodes[1]});
GenNode(instructions, n, scope, contscope, brkscope, contI, brkI);
} else if (adv.nodeName == AssignExpression && adv.nodes.size() == 2 &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[0])) {
auto varNode = std::get<AdvancedSyntaxNode>(adv.nodes[0]);
if (varNode.nodeName == GetVariableExpression &&
varNode.nodes.size() == 1) {
GenNode(instructions, varNode.nodes[0], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(SETVARIABLE));
} else if (varNode.nodeName == ArrayExpression &&
varNode.nodes.size() >= 1) {
auto vars = StringifyListOfVars(varNode.nodes[0]);
auto nArray =
AdvancedSyntaxNode::Create(ArrayExpression, true, {vars});
this->GenNode(instructions, nArray, scope, contscope, brkscope,
contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(SETVARIABLE));
} else if (varNode.nodeName == DeclareExpression &&
varNode.nodes.size() == 1 &&
std::holds_alternative<std::string>(varNode.nodes[0])) {
GenNode(instructions, varNode.nodes[0], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(DECLAREVARIABLE));
} else if (varNode.nodeName == DeclareExpression &&
varNode.nodes.size() == 1 &&
std::holds_alternative<AdvancedSyntaxNode>(
varNode.nodes[0])) {
auto adv2 = std::get<AdvancedSyntaxNode>(varNode.nodes[0]);
if (adv2.nodeName == ArrayExpression &&
adv2.nodes.size() == 1) {
auto vars = StringifyListOfVars(adv2.nodes[0]);
auto nArray = AdvancedSyntaxNode::Create(ArrayExpression,
true, {vars});
this->GenNode(instructions, nArray, scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope,
brkscope, contI, brkI);
instructions.push_back(
new SimpleInstruction(DECLAREVARIABLE));
}
} else if (varNode.nodeName == ConstExpression &&
varNode.nodes.size() == 1 &&
std::holds_alternative<std::string>(varNode.nodes[0])) {
GenNode(instructions, varNode.nodes[0], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new SimpleInstruction(DECLARECONSTVARIABLE));
} else if (varNode.nodeName == ConstExpression &&
varNode.nodes.size() == 1 &&
std::holds_alternative<AdvancedSyntaxNode>(
varNode.nodes[0])) {
auto adv2 = std::get<AdvancedSyntaxNode>(varNode.nodes[0]);
if (adv2.nodeName == ArrayExpression &&
adv2.nodes.size() == 1) {
auto vars = StringifyListOfVars(adv2.nodes[0]);
auto nArray = AdvancedSyntaxNode::Create(ArrayExpression,
true, {vars});
this->GenNode(instructions, nArray, scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope,
brkscope, contI, brkI);
instructions.push_back(
new SimpleInstruction(DECLARECONSTVARIABLE));
}
} else if (varNode.nodeName == GetFieldExpression &&
varNode.nodes.size() == 2) {
GenNode(instructions, varNode.nodes[0], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, varNode.nodes[1], scope, contscope,
brkscope, contI, brkI);
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(SETFIELD));
} else if (varNode.nodeName == GetArrayExpression &&
varNode.nodes.size() == 2) {
SyntaxNode n = AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(GetFieldExpression, true,
{varNode.nodes[0], "SetAt"}),
AdvancedSyntaxNode::Create(
CommaExpression, true,
{varNode.nodes[1], adv.nodes[1]})});
GenNode(instructions, n, scope, contscope, brkscope, contI,
brkI);
}
} else if (adv.nodeName == BreakpointStatement &&
adv.nodes.size() == 5) {
instructions.push_back(new SimpleInstruction(CREATEDICTIONARY));
instructions.push_back(new StringInstruction(GetString("Data")));
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(
new StringInstruction(GetString("Filename")));
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Line")));
GenNode(instructions, adv.nodes[2], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Column")));
GenNode(instructions, adv.nodes[3], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Offset")));
GenNode(instructions, adv.nodes[4], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new SimpleInstruction(BREAKPOINT));
} else if (adv.nodeName == ThrowStatement && adv.nodes.size() == 5) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(
new StringInstruction(GetString("Filename")));
GenNode(instructions, adv.nodes[1], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Line")));
GenNode(instructions, adv.nodes[2], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Column")));
GenNode(instructions, adv.nodes[3], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new StringInstruction(GetString("Offset")));
GenNode(instructions, adv.nodes[4], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(APPENDDICT));
instructions.push_back(new SimpleInstruction(THROW));
} else if (adv.nodeName == ReturnStatement && adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(RET));
} else if (adv.nodeName == YieldStatement && adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
instructions.push_back(new SimpleInstruction(YIELD));
} else if (adv.nodeName == ParenthesesExpression &&
adv.nodes.size() == 1) {
GenNode(instructions, adv.nodes[0], scope, contscope, brkscope,
contI, brkI);
} else if (adv.nodeName == EmbedExpression && adv.nodes.size() == 1 &&
std::holds_alternative<std::string>(adv.nodes[0])) {
std::string filename = std::get<std::string>(adv.nodes[0]);
instructions.push_back(new EmbedInstruction(
GetResource(std::make_shared<ResourceFile>(filename))));
} else if (adv.nodeName == MetadataStatement && adv.nodes.size() == 2 &&
std::holds_alternative<std::string>(adv.nodes[0])) {
auto &name = std::get<std::string>(adv.nodes[0]);
auto &metabytes = this->meta.emplace_back();
metabytes.resize(4);
BitConverter::FromUint32BE(metabytes[0], GetString(name));
WriteMetadataObject(metabytes, adv.nodes[1]);
} else if (adv.nodeName == EmbedStreamExpression &&
adv.nodes.size() == 1 &&
std::holds_alternative<std::string>(adv.nodes[0])) {
std::string filename = std::get<std::string>(adv.nodes[0]);
instructions.push_back(new EmbedStreamInstruction(
GetResource(std::make_shared<ResourceFile>(filename))));
} else if (adv.nodeName == EmbedDirectoryExpression &&
adv.nodes.size() == 1 &&
std::holds_alternative<std::string>(adv.nodes[0])) {
std::string filename = std::get<std::string>(adv.nodes[0]);
std::function<void(Tesses::Framework::Filesystem::VFSPath path)>
embedDir;
embedDir =
[&](Tesses::Framework::Filesystem::VFSPath path) -> void {
instructions.push_back(new SimpleInstruction(CREATEDICTIONARY));
if (embedFS != nullptr && embedFS->DirectoryExists(path))
for (auto &item : embedFS->EnumeratePaths(path)) {
GenNode(instructions, item.GetFileName(), scope,
contscope, brkscope, contI, brkI);
if (embedFS->DirectoryExists(item)) {
embedDir(item);
} else if (embedFS->RegularFileExists(item)) {
auto ce = AdvancedSyntaxNode::Create(
ClosureExpression, true,
{AdvancedSyntaxNode::Create(
ParenthesesExpression, true, {}),
AdvancedSyntaxNode::Create(
ReturnStatement, false,
{AdvancedSyntaxNode::Create(
EmbedStreamExpression, true,
{item.ToString()})})});
GenNode(instructions, ce, scope, contscope,
brkscope, contI, brkI);
} else {
instructions.push_back(
new SimpleInstruction(PUSHUNDEFINED));
}
instructions.push_back(
new SimpleInstruction(APPENDDICT));
}
};
embedDir(filename);
//
// instructions.push_back(new
// EmbedStreamInstruction(GetResource(std::make_shared<ResourceFile>(filename))));
instructions.push_back(new SimpleInstruction(PUSHRESOUURCEDIR));
} else if (adv.nodeName == HtmlRootExpression) {
scope++;
instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
instructions.push_back(new StringInstruction(
GetString(std::get<std::string>(adv.nodes[0]))));
instructions.push_back(new StringInstruction(GetString("")));
instructions.push_back(new SimpleInstruction(DECLAREVARIABLE));
instructions.push_back(new SimpleInstruction(POP));
for (size_t i = 1; i < adv.nodes.size(); i++) {
GenNode(instructions, adv.nodes[i], scope, contscope, brkscope,
contI, brkI);
GenPop(instructions, adv.nodes[i]);
}
instructions.push_back(new StringInstruction(
GetString(std::get<std::string>(adv.nodes[0]))));
instructions.push_back(new SimpleInstruction(GETVARIABLE));
instructions.push_back(new SimpleInstruction(SCOPEEND));
scope--;
} else if (adv.nodeName == ScopeNode) {
scope++;
instructions.push_back(new SimpleInstruction(SCOPEBEGIN));
for (size_t i = 0; i < adv.nodes.size(); i++) {
GenNode(instructions, adv.nodes[i], scope, contscope, brkscope,
contI, brkI);
if (!adv.isExpression || i < adv.nodes.size() - 1)
GenPop(instructions, adv.nodes[i]);
}
instructions.push_back(new SimpleInstruction(SCOPEEND));
scope--;
} else if (adv.nodeName == NodeList) {
for (auto item : adv.nodes) {
GenNode(instructions, item, scope, contscope, brkscope, contI,
brkI);
GenPop(instructions, item);
}
} else if (adv.nodeName == DeferStatement && adv.nodes.size() == 1) {
GenNode(instructions,
AdvancedSyntaxNode::Create(
ScopelessClosureExpression, true,
{AdvancedSyntaxNode::Create(ParenthesesExpression, true,
{}),
adv.nodes[0]}),
scope, contscope, brkscope, contI, brkI);
instructions.push_back(new SimpleInstruction(DEFER));
} else if (adv.nodeName == TryStatement && adv.nodes.size() == 4) {
// AdvancedSyntaxNode::Create(TryStatement, false,
// {tryBody,catchNode,catchEx, finally});
if (std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[3])) {
GenNode(instructions,
AdvancedSyntaxNode::Create(DeferStatement, false,
{adv.nodes[3]}),
scope, contscope, brkscope, contI, brkI);
}
if (std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[0]) &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[1]) &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[2])) {
GenNode(instructions,
AdvancedSyntaxNode::Create(
ScopelessClosureExpression, true,
{AdvancedSyntaxNode::Create(ParenthesesExpression,
true, {}),
adv.nodes[0]}),
scope, contscope == -1 ? -1 : -2,
brkscope == -1 ? -1 : -2, contI, brkI);
GenNode(instructions,
AdvancedSyntaxNode::Create(
ScopelessClosureExpression, true,
{AdvancedSyntaxNode::Create(ParenthesesExpression,
true, {adv.nodes[2]}),
adv.nodes[1]}),
scope, contscope == -1 ? -1 : -2,
brkscope == -1 ? -1 : -2, contI, brkI);
instructions.push_back(new SimpleInstruction(TRYCATCH));
uint32_t compGenId = NewId();
std::string compGenIttr = "__compGenRetThing";
compGenIttr.append(std::to_string(compGenId));
if (contscope != -1) {
instructions.push_back(new JumpStyleInstruction(
JMPIFCONTINUE, compGenIttr + "_cont"));
}
if (brkscope != -1) {
instructions.push_back(new JumpStyleInstruction(
JMPIFBREAK, compGenIttr + "_brk"));
}
instructions.push_back(
new JumpStyleInstruction(JMPUNDEFINED, compGenIttr));
instructions.push_back(new SimpleInstruction(RET));
if (contscope == -2) {
instructions.push_back(
new LabelInstruction(compGenIttr + "_cont"));
instructions.push_back(new SimpleInstruction(PUSHCONTINUE));
instructions.push_back(new SimpleInstruction(RET));
} else if (contscope != -1) {
instructions.push_back(
new LabelInstruction(compGenIttr + "_cont"));
auto cont = scope - contscope;
if (cont > 0)
instructions.push_back(
new ScopeEndTimesInstruction((uint32_t)cont));
std::string myJmp = "__compGenCont";
myJmp.append(std::to_string(contI));
instructions.push_back(
new JumpStyleInstruction(JMP, myJmp));
}
if (brkscope == -2) {
instructions.push_back(
new LabelInstruction(compGenIttr + "_brk"));
instructions.push_back(new SimpleInstruction(PUSHBREAK));
instructions.push_back(new SimpleInstruction(RET));
} else if (brkscope != -1) {
instructions.push_back(
new LabelInstruction(compGenIttr + "_brk"));
auto _brk = scope - brkscope;
if (_brk > 0)
instructions.push_back(
new ScopeEndTimesInstruction((uint32_t)_brk));
std::string myJmp = "__compGenBrk";
myJmp.append(std::to_string(brkI));
instructions.push_back(
new JumpStyleInstruction(JMP, myJmp));
}
instructions.push_back(new LabelInstruction(compGenIttr));
}
} else if (adv.nodeName == ScopelessClosureExpression &&
adv.nodes.size() == 2) {
//()=>{}
// Name => {}
//(a,b) => {}
// it has two args
std::vector<uint32_t> args;
GetFunctionArgs(args, adv.nodes[0]);
std::vector<ByteCodeInstruction *> fnInstructions;
size_t fnindex = this->chunks.size();
this->chunks.resize(fnindex + 1);
auto body = adv.nodes[1];
if (std::holds_alternative<AdvancedSyntaxNode>(body)) {
auto res = std::get<AdvancedSyntaxNode>(body);
if (res.nodeName == ScopeNode) {
res.nodeName = NodeList;
}
body = res;
}
GenNode(fnInstructions, body, 0, contscope == -2 ? -2 : -1,
brkscope == -2 ? -2 : -1, -1, -1);
this->chunks[fnindex] =
std::pair<std::vector<uint32_t>,
std::vector<ByteCodeInstruction *>>(args,
fnInstructions);
instructions.push_back(
new ClosureInstruction((uint32_t)fnindex, false));
} else if (adv.nodeName == ClosureExpression && adv.nodes.size() == 2) {
//()=>{}
// Name => {}
//(a,b) => {}
// it has two args
std::vector<uint32_t> args;
GetFunctionArgs(args, adv.nodes[0]);
std::vector<ByteCodeInstruction *> fnInstructions;
size_t fnindex = this->chunks.size();
this->chunks.resize(fnindex + 1);
auto body = adv.nodes[1];
if (std::holds_alternative<AdvancedSyntaxNode>(body)) {
auto res = std::get<AdvancedSyntaxNode>(body);
if (res.nodeName == ScopeNode) {
res.nodeName = NodeList;
}
body = res;
}
GenNode(fnInstructions, body, 0, -1, -1, -1, -1);
this->chunks[fnindex] =
std::pair<std::vector<uint32_t>,
std::vector<ByteCodeInstruction *>>(args,
fnInstructions);
instructions.push_back(new ClosureInstruction((uint32_t)fnindex));
} else if (adv.nodeName == FunctionStatement && adv.nodes.size() == 2 &&
std::holds_alternative<AdvancedSyntaxNode>(adv.nodes[0])) {
// func NAME(ARGS) {}
// we need to disect NAME(ARGS) and {}
// then disect NAME and (ARGS)
auto fcall = std::get<AdvancedSyntaxNode>(adv.nodes[0]);
if (fcall.nodeName == FunctionCallExpression &&
adv.nodes.size() >= 1 &&
std::holds_alternative<AdvancedSyntaxNode>(fcall.nodes[0])) {
SyntaxNode args =
AdvancedSyntaxNode::Create(ParenthesesExpression, true, {});
if (fcall.nodes.size() == 2) {
args = AdvancedSyntaxNode::Create(ParenthesesExpression,
true, {fcall.nodes[1]});
}
SyntaxNode closure = AdvancedSyntaxNode::Create(
ClosureExpression, true, {args, adv.nodes[1]});
SyntaxNode assign = AdvancedSyntaxNode::Create(
AssignExpression, false, {fcall.nodes[0], closure});
GenNode(instructions, assign, scope, contscope, brkscope, contI,
brkI);
instructions.push_back(new SimpleInstruction(POP));
}
}
}
}
void CodeGen::GetFunctionArgs(std::vector<SyntaxNode> &args, SyntaxNode n) {
AdvancedSyntaxNode sn;
if (std::holds_alternative<AdvancedSyntaxNode>(n) &&
(sn = std::get<AdvancedSyntaxNode>(n)).nodeName == CommaExpression &&
sn.nodes.size() == 2) {
GetFunctionArgs(args, sn.nodes[0]);
GetFunctionArgs(args, sn.nodes[1]);
} else {
args.push_back(n);
}
}
void CodeGen::GetFunctionArgs(std::vector<uint32_t> &name, SyntaxNode n) {
if (std::holds_alternative<std::nullptr_t>(n))
return;
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto res = std::get<AdvancedSyntaxNode>(n);
if (res.nodeName == ParenthesesExpression) {
for (auto n : res.nodes)
GetFunctionArgs(name, n);
} else if (res.nodeName == CommaExpression && res.nodes.size() == 2) {
GetFunctionArgs(name, res.nodes[0]);
GetFunctionArgs(name, res.nodes[1]);
} else if (res.nodeName == GetVariableExpression &&
res.nodes.size() == 1) {
if (std::holds_alternative<std::string>(res.nodes[0])) {
name.push_back(GetString(std::get<std::string>(res.nodes[0])));
}
}
}
}
void CodeGen::GetFunctionName(std::vector<uint32_t> &name, SyntaxNode n) {
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto res = std::get<AdvancedSyntaxNode>(n);
if (res.nodeName == GetFieldExpression && res.nodes.size() == 2) {
GetFunctionName(name, res.nodes[0]);
if (std::holds_alternative<std::string>(res.nodes[1])) {
name.push_back(GetString(std::get<std::string>(res.nodes[1])));
}
} else if (res.nodeName == GetVariableExpression &&
res.nodes.size() == 1) {
if (std::holds_alternative<std::string>(res.nodes[0])) {
name.push_back(GetString(std::get<std::string>(res.nodes[0])));
}
}
}
}
void CodeGen::GenRoot(SyntaxNode n) {
this->id = 0;
std::vector<ByteCodeInstruction *> rootInstructions;
size_t index = this->chunks.size();
this->chunks.resize(index + 1);
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
auto res = std::get<AdvancedSyntaxNode>(n);
if (res.nodeName == NodeList) {
for (auto item : res.nodes) {
if (std::holds_alternative<AdvancedSyntaxNode>(item)) {
std::string documentation = "";
auto res2 = std::get<AdvancedSyntaxNode>(item);
if (res2.nodeName == DocumentationStatement) {
if (res2.nodes.size() == 2) {
if (std::holds_alternative<std::string>(
res2.nodes[0]) &&
std::holds_alternative<AdvancedSyntaxNode>(
res2.nodes[1])) {
documentation =
std::get<std::string>(res2.nodes[0]);
auto j =
std::get<AdvancedSyntaxNode>(res2.nodes[1]);
if (j.nodeName == FunctionStatement ||
j.nodeName == EnumerableStatement) {
res2 = j;
}
}
}
}
if (res2.nodeName == EnumerableStatement) {
res2 = AdvancedSyntaxNode::Create(
FunctionStatement, false,
{res2.nodes[0],
AdvancedSyntaxNode::Create(
ReturnStatement, false,
{AdvancedSyntaxNode::Create(
FunctionCallExpression, true,
{AdvancedSyntaxNode::Create(
GetVariableExpression, true,
{"YieldEmumerable"}),
AdvancedSyntaxNode::Create(
ClosureExpression, true,
{AdvancedSyntaxNode::Create(
ParenthesesExpression, true, {}),
res2.nodes[1]})})})});
}
if (res2.nodeName == FunctionStatement) {
if (res2.nodes.size() == 2) {
auto fcall = res2.nodes[0];
if (std::holds_alternative<AdvancedSyntaxNode>(
fcall)) {
auto fcalli =
std::get<AdvancedSyntaxNode>(fcall);
if (fcalli.nodeName == FunctionCallExpression) {
if (fcalli.nodes.size() >= 1) {
std::vector<uint32_t> functionName;
std::vector<uint32_t> args;
GetFunctionName(functionName,
fcalli.nodes[0]);
functionName.insert(
functionName.begin(),
{GetString(documentation)});
if (fcalli.nodes.size() == 2)
GetFunctionArgs(args,
fcalli.nodes[1]);
std::vector<ByteCodeInstruction *>
fnInstructions;
size_t fnindex = this->chunks.size();
this->chunks.resize(fnindex + 1);
GenNode(fnInstructions, res2.nodes[1],
0, -1, -1, -1, -1);
this->funcs.push_back(
std::pair<std::vector<uint32_t>,
uint32_t>(
functionName,
(uint32_t)fnindex));
this->chunks[fnindex] = std::pair<
std::vector<uint32_t>,
std::vector<ByteCodeInstruction *>>(
args, fnInstructions);
} else {
GenNode(rootInstructions, item, 0, -1,
-1, -1, -1);
GenPop(rootInstructions, item);
}
} else {
GenNode(rootInstructions, item, 0, -1, -1,
-1, -1);
GenPop(rootInstructions, item);
}
}
} else {
GenNode(rootInstructions, item, 0, -1, -1, -1, -1);
GenPop(rootInstructions, item);
}
} else {
GenNode(rootInstructions, item, 0, -1, -1, -1, -1);
GenPop(rootInstructions, item);
}
}
}
} else {
GenNode(rootInstructions, n, 0, -1, -1, -1, -1);
GenPop(rootInstructions, n);
}
} else {
GenNode(rootInstructions, n, 0, -1, -1, -1, -1);
GenPop(rootInstructions, n);
}
this->chunks[index] =
std::pair<std::vector<uint32_t>, std::vector<ByteCodeInstruction *>>(
{}, rootInstructions);
}
uint32_t CodeGen::NewId() { return id++; }
void CodeGen::GenPop(std::vector<ByteCodeInstruction *> &instrs, SyntaxNode n) {
if (std::holds_alternative<AdvancedSyntaxNode>(n)) {
if (std::get<AdvancedSyntaxNode>(n).isExpression)
instrs.push_back(new SimpleInstruction(POP));
} else {
instrs.push_back(new SimpleInstruction(POP));
}
}
ResourceBase::~ResourceBase() {}
bool ResourceBase::IsEqual(ResourceBase *base) { return this == base; }
ResourceFile::ResourceFile() {}
ResourceFile::ResourceFile(std::string f) { this->file = f; }
ResourceFile::~ResourceFile() {}
uint32_t ResourceFile::GetLength(
std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS) {
if (embedFS == nullptr)
return 0;
if (strm != nullptr)
return strm->GetLength();
this->strm = embedFS->OpenFile(this->file, "rb");
if (strm != nullptr)
return this->strm->GetLength();
return 0;
}
bool ResourceFile::IsEqual(ResourceBase *base) {
auto res = dynamic_cast<ResourceFile *>(base);
if (res != nullptr)
return this->file == res->file;
return ResourceBase::IsEqual(base);
}
void ResourceFile::Write(
std::shared_ptr<Tesses::Framework::Streams::Stream> output) {
if (this->strm != nullptr)
this->strm->CopyTo(output);
}
uint32_t ResourceByteArray::GetLength(
std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS) {
return (uint32_t)this->data.size();
}
void ResourceByteArray::Write(
std::shared_ptr<Tesses::Framework::Streams::Stream> output) {
output->WriteBlock(this->data.data(), this->data.size());
}
} // namespace Tesses::CrossLang
View Git Blame Copy Permalink