tesses50/crosslang
1
0
Fork 0
mirror of https://git.tesses.org/tesses50/crosslang.git synced 2026-08-02 08:35:32 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix bug with classes, use slim exclusively, add package private data and change rehaul cmake configs

Browse Source
This commit is contained in:
Mike Nolan
2026-05-29 20:52:26 -05:00
parent d26e357448
commit abea319ea0
110 changed files with 25716 additions and 31016 deletions
Download Patch File Download Diff File Expand all files Collapse all files

289
src/vm/bc/add.cpp
View File

@@ -2,163 +2,164 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool InterperterThread::Add(std::shared_ptr<GC> gc)
{
std::vector<CallStackEntry*>& cse=this->call_stack_entries;
GCList ls(gc);
auto right = cse.back()->Pop(ls);
auto left = cse.back()->Pop(ls);
bool InterperterThread::Add(std::shared_ptr<GC> gc) {
std::vector<CallStackEntry *> &cse = this->call_stack_entries;
GCList ls(gc);
auto right = cse.back()->Pop(ls);
auto left = cse.back()->Pop(ls);
if (std::holds_alternative<std::string>(left) &&
std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(right)) {
cse.back()->Push(
gc, std::get<std::string>(left) +
std::get<Tesses::Framework::Filesystem::VFSPath>(right));
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<char>(right)) {
cse.back()->Push(gc,
(char)(std::get<char>(left) + std::get<char>(right)));
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<char>(right)) {
cse.back()->Push(
gc, (char)(std::get<int64_t>(left) + std::get<char>(right)));
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(
gc, (char)(std::get<char>(left) + std::get<int64_t>(right)));
} else if (std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(
left) &&
std::holds_alternative<std::string>(right)) {
cse.back()->Push(
gc, std::get<Tesses::Framework::Filesystem::VFSPath>(left) +
std::get<std::string>(right));
if(std::holds_alternative<std::string>(left) && std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(right))
{
cse.back()->Push(gc,std::get<std::string>(left) + std::get<Tesses::Framework::Filesystem::VFSPath>(right));
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
{
cse.back()->Push(gc,(char)(std::get<char>(left) + std::get<char>(right)));
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
{
cse.back()->Push(gc, (char)(std::get<int64_t>(left) + std::get<char>(right)));
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc, (char)(std::get<char>(left) + std::get<int64_t>(right)));
}
else if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(left) && std::holds_alternative<std::string>(right))
{
cse.back()->Push(gc,std::get<Tesses::Framework::Filesystem::VFSPath>(left) + std::get<std::string>(right));
}
}
else if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(left) && std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(right))
{
cse.back()->Push(gc,std::get<Tesses::Framework::Filesystem::VFSPath>(left) + std::get<Tesses::Framework::Filesystem::VFSPath>(right));
}
else if (std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(
left) &&
std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(
right)) {
cse.back()->Push(
gc, std::get<Tesses::Framework::Filesystem::VFSPath>(left) +
std::get<Tesses::Framework::Filesystem::VFSPath>(right));
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc,std::get<int64_t>(left) + std::get<int64_t>(right));
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
cse.back()->Push(gc,std::get<double>(left) + std::get<double>(right));
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc,std::get<double>(left) + std::get<int64_t>(right));
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
cse.back()->Push(gc,std::get<int64_t>(left) + std::get<double>(right));
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
{
auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) + (*r)));
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
{
auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
{
auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
}
else if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
{
std::string str={};
str.append(std::get<std::string>(left));
str.append(std::get<std::string>(right));
cse.back()->Push(gc,str);
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<std::string>(right))
{
std::string str={};
str.push_back(std::get<char>(left));
str.append(std::get<std::string>(right));
cse.back()->Push(gc,str);
}
else if(std::holds_alternative<std::string>(left) && std::holds_alternative<char>(right))
{
std::string str={};
str.append(std::get<std::string>(left));
str.push_back(std::get<char>(right));
cse.back()->Push(gc,str);
}
else if(std::holds_alternative<THeapObjectHolder>(left))
{
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary*>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
auto natObj = dynamic_cast<TNativeObject*>(obj);
auto cls = dynamic_cast<TClassObject*>(obj);
if(cls != nullptr)
{
gc->BarrierBegin();
auto obj=cls->GetValue(cse.back()->callable->className,"operator+");
gc->BarrierEnd();
TClosure* clos;
TCallable* callable;
if(GetObjectHeap(obj,clos))
{
this->AddCallStackEntry(ls,clos,{right});
return true;
}
else if(GetObjectHeap(obj,callable))
{
cse.back()->Push(gc,callable->Call(ls,{right}));
return false;
}
cse.back()->Push(gc,Undefined());
return false;
}
else if(natObj != nullptr)
{
cse.back()->Push(gc, natObj->CallMethod(ls,"operator+",{right}));
}
else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(gc,
std::get<int64_t>(left) + std::get<int64_t>(right));
}
else if (std::holds_alternative<double>(left) &&
std::holds_alternative<double>(right)) {
cse.back()->Push(gc, std::get<double>(left) + std::get<double>(right));
} else if (std::holds_alternative<double>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(gc, std::get<double>(left) + std::get<int64_t>(right));
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<double>(right)) {
cse.back()->Push(gc, std::get<int64_t>(left) + std::get<double>(right));
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)) {
auto &l =
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
auto &r =
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(
gc,
std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) + (*r)));
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)) {
auto &l =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto &r =
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(
gc,
std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(right)) {
auto &l =
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left);
auto &r =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
cse.back()->Push(
gc,
std::make_shared<Tesses::Framework::Date::DateTime>((*l) + (*r)));
} else if (std::holds_alternative<std::string>(left) &&
std::holds_alternative<std::string>(right)) {
std::string str = {};
str.append(std::get<std::string>(left));
str.append(std::get<std::string>(right));
cse.back()->Push(gc, str);
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<std::string>(right)) {
std::string str = {};
str.push_back(std::get<char>(left));
str.append(std::get<std::string>(right));
cse.back()->Push(gc, str);
} else if (std::holds_alternative<std::string>(left) &&
std::holds_alternative<char>(right)) {
std::string str = {};
str.append(std::get<std::string>(left));
str.push_back(std::get<char>(right));
cse.back()->Push(gc, str);
} else if (std::holds_alternative<THeapObjectHolder>(left)) {
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary *>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
auto natObj = dynamic_cast<TNativeObject *>(obj);
auto cls = dynamic_cast<TClassObject *>(obj);
if (cls != nullptr) {
gc->BarrierBegin();
auto obj =
cls->GetValue(cse.back()->callable->className, "operator+");
gc->BarrierEnd();
TClosure *clos;
TCallable *callable;
if (GetObjectHeap(obj, clos)) {
this->AddCallStackEntry(ls, clos, {right});
return true;
} else if (GetObjectHeap(obj, callable)) {
cse.back()->Push(gc, callable->Call(ls, {right}));
return false;
}
else if(dict != nullptr)
{
gc->BarrierBegin();
TObject fn = dict->GetValue("operator+");
gc->BarrierEnd();
return InvokeTwo(ls,fn,left,right);
}
else if(dynDict != nullptr)
{
cse.back()->Push(gc,dynDict->CallMethod(ls,"operator+",{right}));
return false;
}
else
{
cse.back()->Push(gc, Undefined());
}
}
else
{
cse.back()->Push(gc, Undefined());
return false;
} else if (natObj != nullptr) {
cse.back()->Push(gc, natObj->CallMethod(ls, "operator+", {right}));
return false;
} else if (dict != nullptr) {
gc->BarrierBegin();
TObject fn = dict->GetValue("operator+");
gc->BarrierEnd();
return InvokeTwo(ls, fn, left, right);
} else if (dynDict != nullptr) {
cse.back()->Push(gc, dynDict->CallMethod(ls, "operator+", {right}));
return false;
} else {
cse.back()->Push(gc, Undefined());
}
return false;
} else {
cse.back()->Push(gc, Undefined());
}
}
return false;
}
} // namespace Tesses::CrossLang

356
src/vm/bc/equals.cpp
View File

@@ -2,235 +2,199 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right)
{
GCList ls(gc);
if(std::holds_alternative<std::nullptr_t>(left) && std::holds_alternative<std::nullptr_t>(right))
{
bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right) {
GCList ls(gc);
if (std::holds_alternative<std::nullptr_t>(left) &&
std::holds_alternative<std::nullptr_t>(right)) {
return true;
}
return true;
}
else if(std::holds_alternative<Undefined>(left) && std::holds_alternative<Undefined>(right))
{
return true;
}
else if (std::holds_alternative<Undefined>(left) &&
std::holds_alternative<Undefined>(right)) {
return true;
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) == std::get<int64_t>(right);
}
else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<int64_t>(right)) {
return std::get<int64_t>(left) == std::get<int64_t>(right);
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) == std::get<double>(right);
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) == std::get<int64_t>(right);
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return std::get<int64_t>(left) == std::get<double>(right);
}
else if (std::holds_alternative<double>(left) &&
std::holds_alternative<double>(right)) {
return std::get<double>(left) == std::get<double>(right);
} else if (std::holds_alternative<double>(left) &&
std::holds_alternative<int64_t>(right)) {
return std::get<double>(left) == std::get<int64_t>(right);
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<double>(right)) {
return std::get<int64_t>(left) == std::get<double>(right);
}
else if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
{
return std::get<std::string>(left) == std::get<std::string>(right);
}
else if (std::holds_alternative<std::string>(left) &&
std::holds_alternative<std::string>(right)) {
return std::get<std::string>(left) == std::get<std::string>(right);
}
else if(std::holds_alternative<bool>(left) && std::holds_alternative<bool>(right))
{
return std::get<bool>(left) == std::get<bool>(right);
}
else if (std::holds_alternative<bool>(left) &&
std::holds_alternative<bool>(right)) {
return std::get<bool>(left) == std::get<bool>(right);
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
{
return std::get<char>(left) == std::get<char>(right);
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<char>(left) == std::get<int64_t>(right);
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
{
return std::get<int64_t>(left) == std::get<char>(right);
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
{
return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left)->ToEpoch() == std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right)->ToEpoch();
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
{
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left)->TotalSeconds() == std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)->TotalSeconds();
}
else if(std::holds_alternative<TVMVersion>(left) && std::holds_alternative<TVMVersion>(right))
{
auto lver= std::get<TVMVersion>(left);
auto rver = std::get<TVMVersion>(right);
auto r = lver.CompareTo(rver);
return r == 0;
}
else if(std::holds_alternative<Tesses::Framework::Uuid>(left) && std::holds_alternative<Tesses::Framework::Uuid>(right))
{
auto l= std::get<Tesses::Framework::Uuid>(left);
auto r = std::get<Tesses::Framework::Uuid>(right);
return l == r;
}
else if(std::holds_alternative<THeapObjectHolder>(left))
{
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary*>(obj);
else if (std::holds_alternative<char>(left) &&
std::holds_alternative<char>(right)) {
return std::get<char>(left) == std::get<char>(right);
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<int64_t>(right)) {
return std::get<char>(left) == std::get<int64_t>(right);
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<char>(right)) {
return std::get<int64_t>(left) == std::get<char>(right);
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(right)) {
return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(
left)
->ToEpoch() ==
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(
right)
->ToEpoch();
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)) {
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(
left)
->TotalSeconds() ==
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(
right)
->TotalSeconds();
} else if (std::holds_alternative<TVMVersion>(left) &&
std::holds_alternative<TVMVersion>(right)) {
auto lver = std::get<TVMVersion>(left);
auto rver = std::get<TVMVersion>(right);
auto r = lver.CompareTo(rver);
return r == 0;
} else if (std::holds_alternative<Tesses::Framework::Uuid>(left) &&
std::holds_alternative<Tesses::Framework::Uuid>(right)) {
auto l = std::get<Tesses::Framework::Uuid>(left);
auto r = std::get<Tesses::Framework::Uuid>(right);
auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
auto native = dynamic_cast<TNative*>(obj);
auto natObj = dynamic_cast<TNativeObject*>(obj);
auto cls = dynamic_cast<TClassObject*>(obj);
if(cls != nullptr)
{
gc->BarrierBegin();
auto obj=cls->GetValue("","operator==");
gc->BarrierEnd();
TCallable* callable;
if(GetObjectHeap(obj,callable))
{
return ToBool(callable->Call(ls,{right}));
}
else if(std::holds_alternative<std::nullptr_t>(right)) {
return false;
}
else if(std::holds_alternative<Undefined>(right))
{
return false;
}
else if(std::holds_alternative<THeapObjectHolder>(right))
{
return cls == std::get<THeapObjectHolder>(right).obj;
}
return l == r;
} else if (std::holds_alternative<THeapObjectHolder>(left)) {
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary *>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
auto native = dynamic_cast<TNative *>(obj);
auto natObj = dynamic_cast<TNativeObject *>(obj);
auto cls = dynamic_cast<TClassObject *>(obj);
if (cls != nullptr) {
gc->BarrierBegin();
auto obj = cls->GetValue("", "operator==");
gc->BarrierEnd();
TCallable *callable;
if (GetObjectHeap(obj, callable)) {
return ToBool(callable->Call(ls, {right}));
} else if (std::holds_alternative<std::nullptr_t>(right)) {
return false;
} else if (std::holds_alternative<Undefined>(right)) {
return false;
} else if (std::holds_alternative<THeapObjectHolder>(right)) {
return cls == std::get<THeapObjectHolder>(right).obj;
}
else
if(natObj != nullptr)
{
return natObj->Equals(gc, right);
}
if(dict != nullptr)
{
gc->BarrierBegin();
TObject fn = dict->GetValue("operator==");
gc->BarrierEnd();
if(!std::holds_alternative<Undefined>(fn))
{
if(std::holds_alternative<THeapObjectHolder>(fn))
{
} else if (natObj != nullptr) {
return natObj->Equals(gc, right);
}
if (dict != nullptr) {
gc->BarrierBegin();
TObject fn = dict->GetValue("operator==");
gc->BarrierEnd();
if (!std::holds_alternative<Undefined>(fn)) {
if (std::holds_alternative<THeapObjectHolder>(fn)) {
auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
if(obj != nullptr)
{
auto closure = dynamic_cast<TClosure*>(obj);
if(closure != nullptr)
{
if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
{
return ToBool(obj->Call(ls,{left,right}));
}
else
{
return ToBool(obj->Call(ls,{right}));
}
auto obj = dynamic_cast<TCallable *>(
std::get<THeapObjectHolder>(fn).obj);
if (obj != nullptr) {
auto closure = dynamic_cast<TClosure *>(obj);
if (closure != nullptr) {
if (!closure->closure->args.empty() &&
closure->closure->args[0] == "this") {
return ToBool(obj->Call(ls, {left, right}));
} else {
return ToBool(obj->Call(ls, {right}));
}
else
{
return ToBool(obj->Call(ls,{right}));
}
} else {
return ToBool(obj->Call(ls, {right}));
}
else {
return dict == std::get<THeapObjectHolder>(right).obj;
}
} else {
return dict == std::get<THeapObjectHolder>(right).obj;
}
return dict == std::get<THeapObjectHolder>(right).obj;
}
}
else {
} else {
return dict == std::get<THeapObjectHolder>(right).obj;
}
return false;
} else {
return dict == std::get<THeapObjectHolder>(right).obj;
}
else if(dynDict != nullptr)
{
auto res = dynDict->CallMethod(ls,"operator==",{right});
if(!std::holds_alternative<std::nullptr_t>(res) && std::holds_alternative<Undefined>(res))
{
return ToBool(res);
}
}
else if(native != nullptr && std::holds_alternative<std::nullptr_t>(right))
{
return native->GetDestroyed();
}
if(std::holds_alternative<THeapObjectHolder>(right))
{
return obj == std::get<THeapObjectHolder>(right).obj;
}
else if(std::holds_alternative<std::nullptr_t>(right))
{
return false;
}
else if(std::holds_alternative<Undefined>(right))
{
return false;
}
else
{
return false;
}
}
else if(std::holds_alternative<std::nullptr_t>(right))
{
return false;
}
else if(std::holds_alternative<Undefined>(right))
{
return false;
}
else
{
return false;
}
return false;
else if (dynDict != nullptr) {
auto res = dynDict->CallMethod(ls, "operator==", {right});
if (!std::holds_alternative<std::nullptr_t>(res) &&
std::holds_alternative<Undefined>(res)) {
return ToBool(res);
}
} else if (native != nullptr &&
std::holds_alternative<std::nullptr_t>(right)) {
return native->GetDestroyed();
}
if (std::holds_alternative<THeapObjectHolder>(right)) {
return obj == std::get<THeapObjectHolder>(right).obj;
}
else if (std::holds_alternative<std::nullptr_t>(right)) {
return false;
} else if (std::holds_alternative<Undefined>(right)) {
return false;
} else {
return false;
}
}
}
else if (std::holds_alternative<std::nullptr_t>(right)) {
return false;
} else if (std::holds_alternative<Undefined>(right)) {
return false;
} else {
return false;
}
return false;
}
} // namespace Tesses::CrossLang

7214
src/vm/bc/executemethod2.cpp
View File

File diff suppressed because it is too large Load Diff

1432
src/vm/bc/getfield.cpp
View File

File diff suppressed because it is too large Load Diff

69
src/vm/bc/invokemethod.cpp
View File

@@ -2,53 +2,46 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool InterperterThread::InvokeMethod(GCList& ls, TObject fn, TObject instance, std::vector<TObject> args)
{
if(std::holds_alternative<THeapObjectHolder>(fn))
{
auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
if(obj != nullptr)
{
auto closure = dynamic_cast<TClosure*>(obj);
if(closure != nullptr)
{
if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
{
std::vector<TObject> args2;
args2.push_back(instance);
args2.insert(args2.end(), args.begin(),args.end());
this->AddCallStackEntry(ls,closure,args2);
}
else
{
this->AddCallStackEntry(ls,closure,args);
}
bool InterperterThread::InvokeMethod(GCList &ls, TObject fn, TObject instance,
std::vector<TObject> args) {
if (std::holds_alternative<THeapObjectHolder>(fn)) {
auto obj =
dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
if (obj != nullptr) {
auto closure = dynamic_cast<TClosure *>(obj);
if (closure != nullptr) {
if (!closure->closure->args.empty() &&
closure->closure->args[0] == "this") {
std::vector<TObject> args2;
args2.push_back(instance);
args2.insert(args2.end(), args.begin(), args.end());
this->AddCallStackEntry(ls, closure, args2);
} else {
this->AddCallStackEntry(ls, closure, args);
}
else
{
auto val = obj->Call(ls,args);
this->call_stack_entries.back()->Push(ls.GetGC(), val);
return false;
}
return true;
} else {
auto val = obj->Call(ls, args);
this->call_stack_entries.back()->Push(ls.GetGC(), val);
return false;
}
return true;
}
this->call_stack_entries.back()->Push(ls.GetGC(),Undefined());
return false;
}
}
this->call_stack_entries.back()->Push(ls.GetGC(), Undefined());
return false;
}
} // namespace Tesses::CrossLang

60
src/vm/bc/invoketwo.cpp
View File

@@ -2,46 +2,40 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool InterperterThread::InvokeTwo(GCList& ls, TObject fn, TObject left, TObject right)
{
if(std::holds_alternative<THeapObjectHolder>(fn))
{
auto obj = dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj);
if(obj != nullptr)
{
auto closure = dynamic_cast<TClosure*>(obj);
if(closure != nullptr)
{
if(!closure->closure->args.empty() && closure->closure->args[0] == "this")
{
this->AddCallStackEntry(ls,closure,{left,right});
}
else
{
this->AddCallStackEntry(ls,closure,{right});
}
bool InterperterThread::InvokeTwo(GCList &ls, TObject fn, TObject left,
TObject right) {
if (std::holds_alternative<THeapObjectHolder>(fn)) {
auto obj =
dynamic_cast<TCallable *>(std::get<THeapObjectHolder>(fn).obj);
if (obj != nullptr) {
auto closure = dynamic_cast<TClosure *>(obj);
if (closure != nullptr) {
if (!closure->closure->args.empty() &&
closure->closure->args[0] == "this") {
this->AddCallStackEntry(ls, closure, {left, right});
} else {
this->AddCallStackEntry(ls, closure, {right});
}
else
{
this->call_stack_entries[this->call_stack_entries.size()-1]->Push(ls.GetGC(), obj->Call(ls,{right}));
return false;
}
return true;
} else {
this->call_stack_entries[this->call_stack_entries.size() - 1]
->Push(ls.GetGC(), obj->Call(ls, {right}));
return false;
}
return true;
}
return false;
}
}
return false;
}
} // namespace Tesses::CrossLang

632
src/vm/bc/setfield.cpp
View File

@@ -2,371 +2,333 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
static void empty()
{
}
bool InterperterThread::SetField(std::shared_ptr<GC> gc)
{
std::vector<CallStackEntry*>& cse=this->call_stack_entries;
static void empty() {}
bool InterperterThread::SetField(std::shared_ptr<GC> gc) {
std::vector<CallStackEntry *> &cse = this->call_stack_entries;
if(!cse.empty())
{
auto stk = cse.back();
GCList ls(gc);
TObject value = stk->Pop(ls);
TObject _key = stk->Pop(ls);
TObject instance = stk->Pop(ls);
if(!std::holds_alternative<std::string>(_key))
{
stk->Push(gc,Undefined());
return false;
}
if (!cse.empty()) {
auto stk = cse.back();
GCList ls(gc);
TObject value = stk->Pop(ls);
TObject _key = stk->Pop(ls);
TObject instance = stk->Pop(ls);
std::string key = std::get<std::string>(_key);
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance))
{
auto handle = std::get<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(instance);
if(handle)
{
int64_t ms;
bool b;
if(key == "Enabled" && GetObject(value,b))
{
if (!std::holds_alternative<std::string>(_key)) {
stk->Push(gc, Undefined());
return false;
}
handle->SetEnabled(b);
std::string key = std::get<std::string>(_key);
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(
instance)) {
auto handle =
std::get<std::shared_ptr<Tesses::Framework::TF_Timer_Handle>>(
instance);
if (handle) {
int64_t ms;
bool b;
if (key == "Enabled" && GetObject(value, b)) {
cse.back()->Push(gc,b);
return false;
}
handle->SetEnabled(b);
if(key == "Interval" && GetObject(value, ms))
{
handle->SetIntervalFromMilliseconds(ms);
cse.back()->Push(gc,ms);
return false;
}
if(key == "Callback")
{
TCallable* callable;
if(GetObjectHeap(value,callable))
{
auto obj = CreateMarkedTObject(ls.GetGC(), callable);
handle->SetCallback([obj]()->void {
TCallable* callable;
if(GetObjectHeap(obj->GetObject(), callable))
{
GCList ls(obj->GetGC());
callable->Call(ls,{});
}
});
cse.back()->Push(gc, callable);
return false;
}
else
{
handle->SetCallback(empty);
cse.back()->Push(gc, nullptr);
return false;
}
}
}
cse.back()->Push(gc, Undefined());
return false;
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance))
{
auto writer = std::get<std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(instance);
auto stringWriter = std::dynamic_pointer_cast<Tesses::Framework::TextStreams::StringWriter>(writer);
if(stringWriter != nullptr)
{
if(key == "Text")
{
if(std::holds_alternative<std::string>(value))
{
stringWriter->GetString() = std::get<std::string>(value);
}
cse.back()->Push(gc, stringWriter->GetString());
return false;
}
}
if(key == "NewLine")
{
if(std::holds_alternative<std::string>(value))
{
writer->newline = std::get<std::string>(value);
}
cse.back()->Push(gc,writer->newline);
cse.back()->Push(gc, b);
return false;
}
cse.back()->Push(gc,Undefined());
return false;
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(instance))
{
auto vfs = std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(instance);
auto relative = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
if(relative)
{
if(key == "Working")
{
Tesses::Framework::Filesystem::VFSPath path;
if(GetObjectAsPath(value,path))
{
if(path.relative)
{
relative->SetWorking(path.MakeAbsolute(relative->GetWorking()));
if (key == "Interval" && GetObject(value, ms)) {
handle->SetIntervalFromMilliseconds(ms);
cse.back()->Push(gc, ms);
return false;
}
if (key == "Callback") {
TCallable *callable;
if (GetObjectHeap(value, callable)) {
auto obj = CreateMarkedTObject(ls.GetGC(), callable);
handle->SetCallback([obj]() -> void {
TCallable *callable;
if (GetObjectHeap(obj->GetObject(), callable)) {
GCList ls(obj->GetGC());
callable->Call(ls, {});
}
else {
relative->SetWorking(path);
});
cse.back()->Push(gc, callable);
return false;
} else {
handle->SetCallback(empty);
cse.back()->Push(gc, nullptr);
return false;
}
}
}
cse.back()->Push(gc, Undefined());
return false;
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(
instance)) {
auto writer = std::get<
std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>(
instance);
auto stringWriter = std::dynamic_pointer_cast<
Tesses::Framework::TextStreams::StringWriter>(writer);
if (stringWriter != nullptr) {
if (key == "Text") {
if (std::holds_alternative<std::string>(value)) {
stringWriter->GetString() =
std::get<std::string>(value);
}
cse.back()->Push(gc, stringWriter->GetString());
return false;
}
}
if (key == "NewLine") {
if (std::holds_alternative<std::string>(value)) {
writer->newline = std::get<std::string>(value);
}
cse.back()->Push(gc, writer->newline);
return false;
}
cse.back()->Push(gc, Undefined());
return false;
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(
instance)) {
auto vfs =
std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(
instance);
auto relative = std::dynamic_pointer_cast<
Tesses::Framework::Filesystem::RelativeFilesystem>(vfs);
if (relative) {
if (key == "Working") {
Tesses::Framework::Filesystem::VFSPath path;
if (GetObjectAsPath(value, path)) {
if (path.relative) {
relative->SetWorking(
path.MakeAbsolute(relative->GetWorking()));
} else {
relative->SetWorking(path);
}
}
}
}
cse.back()->Push(gc, Undefined());
return false;
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(
instance)) {
auto svr =
std::get<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(
instance);
auto bas = std::dynamic_pointer_cast<
Tesses::Framework::Http::BasicAuthServer>(svr);
auto cgi =
std::dynamic_pointer_cast<Tesses::Framework::Http::CGIServer>(
svr);
auto changable = std::dynamic_pointer_cast<
Tesses::Framework::Http::ChangeableServer>(svr);
if (changable != nullptr) {
if (key == "Server") {
bas->server = ToHttpServer(gc, value);
stk->Push(gc, value);
return false;
}
}
if (bas != nullptr) {
if (key == "Realm") {
bool val;
if (GetObject(value, val)) {
bas->realm = val;
stk->Push(gc, val);
return false;
}
}
if (key == "Server") {
bas->server = ToHttpServer(gc, value);
stk->Push(gc, value);
return false;
}
if (key == "Authorization") {
TCallable *val;
if (GetObjectHeap(value, val)) {
auto marked = CreateMarkedTObject(ls, val);
bas->authorization =
[marked](std::string user,
std::string password) -> bool {
GCList ls(marked->GetGC());
TCallable *callable;
if (GetObjectHeap(marked->GetObject(), callable)) {
return ToBool(
callable->Call(ls, {user, password}));
}
}
return false;
};
stk->Push(gc, val);
return false;
}
}
cse.back()->Push(gc,Undefined());
return false;
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(instance))
{
auto svr = std::get<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(instance);
auto bas = std::dynamic_pointer_cast<Tesses::Framework::Http::BasicAuthServer>(svr);
auto cgi = std::dynamic_pointer_cast<Tesses::Framework::Http::CGIServer>(svr);
auto changable = std::dynamic_pointer_cast<Tesses::Framework::Http::ChangeableServer>(svr);
if(changable != nullptr)
{
if(key == "Server")
{
bas->server = ToHttpServer(gc,value);
stk->Push(gc,value);
if (cgi != nullptr) {
if (key == "WorkingDirectory") {
Tesses::Framework::Filesystem::VFSPath path;
if (GetObjectAsPath(value, path)) {
cgi->workingDirectory = path;
stk->Push(gc, path);
return false;
} else {
cgi->workingDirectory = std::nullopt;
stk->Push(gc, nullptr);
return false;
}
}
if(bas != nullptr)
{
if(key == "Realm")
{
bool val;
if(GetObject(value,val))
{
bas->realm = val;
stk->Push(gc,val );
return false;
}
}
if(key == "Server")
{
bas->server = ToHttpServer(gc,value);
stk->Push(gc,value);
if (key == "DocumentRoot") {
Tesses::Framework::Filesystem::VFSPath path;
if (GetObjectAsPath(value, path)) {
cgi->document_root = path;
stk->Push(gc, path);
return false;
} else {
cgi->document_root = std::nullopt;
stk->Push(gc, nullptr);
return false;
}
if(key == "Authorization")
{
TCallable* val;
if(GetObjectHeap(value,val))
{
auto marked= CreateMarkedTObject(ls, val);
bas->authorization = [marked](std::string user,std::string password)->bool {
GCList ls(marked->GetGC());
TCallable* callable;
if(GetObjectHeap(marked->GetObject(), callable))
{
return ToBool(callable->Call(ls,{user,password}));
}
return false;
};
stk->Push(gc,val);
return false;
}
}
if (key == "AdminEmail") {
std::string str;
if (GetObject(value, str)) {
cgi->adminEmail = str;
stk->Push(gc, str);
return false;
} else {
cgi->adminEmail = std::nullopt;
stk->Push(gc, nullptr);
return false;
}
}
if(cgi != nullptr)
{
if(key == "WorkingDirectory")
{
Tesses::Framework::Filesystem::VFSPath path;
if(GetObjectAsPath(value,path))
{
cgi->workingDirectory = path;
stk->Push(gc,path);
return false;
}
else {
cgi->workingDirectory = std::nullopt;
stk->Push(gc,nullptr);
return false;
}
}
if(key == "DocumentRoot")
{
Tesses::Framework::Filesystem::VFSPath path;
if(GetObjectAsPath(value,path))
{
cgi->document_root= path;
stk->Push(gc,path);
return false;
}
else {
cgi->document_root= std::nullopt;
stk->Push(gc,nullptr);
return false;
}
}
if(key == "AdminEmail")
{
std::string str;
if(GetObject(value,str))
{
cgi->adminEmail = str;
stk->Push(gc,str);
return false;
}
else {
cgi->adminEmail= std::nullopt;
stk->Push(gc,nullptr);
return false;
}
}
}
stk->Push(gc, Undefined());
return false;
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance))
{
auto strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(instance);
auto netStrm = std::dynamic_pointer_cast<Tesses::Framework::Streams::NetworkStream>(strm);
if(netStrm != nullptr)
{
int64_t n0;
bool bc;
if(key == "Broadcast" && GetObject(value,bc))
netStrm->SetBroadcast(bc);
if(key == "NoDelay" && GetObject(value,bc))
netStrm->SetNoDelay(bc);
if(key == "ReuseAddress" && GetObject(value,bc))
netStrm->SetReuseAddress(bc);
if(key == "ReusePort" && GetObject(value,bc))
netStrm->SetReusePort(bc);
if(key == "MulticastTTL" && GetObject(value,n0))
netStrm->SetMulticastTTL((uint8_t)n0);
}
stk->Push(gc, Undefined());
return false;
}
if(std::holds_alternative<THeapObjectHolder>(instance))
{
auto obj = std::get<THeapObjectHolder>(instance).obj;
auto dict = dynamic_cast<TDictionary*>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
auto natObj = dynamic_cast<TNativeObject*>(obj);
auto cls = dynamic_cast<TClassObject*>(obj);
if(cls != nullptr)
{
gc->BarrierBegin();
auto obj=cls->GetValue(cse.back()->callable->className,"set"+key);
gc->BarrierEnd();
TClosure* clos;
TCallable* callable;
if(GetObjectHeap(obj,clos))
{
this->AddCallStackEntry(ls,clos,{value});
return true;
}
else if(GetObjectHeap(obj,callable))
{
cse.back()->Push(gc,callable->Call(ls,{value}));
return false;
}
gc->BarrierBegin();
cls->SetValue(cse.back()->callable->className,key,value);
gc->BarrierEnd();
cse.back()->Push(gc,value);
return false;
}
else
if(natObj != nullptr)
{
cse.back()->Push(gc,natObj->CallMethod(ls,"set"+key,{value}));
return false;
}
auto tcallable = dynamic_cast<TCallable*>(obj);
if(tcallable != nullptr)
{
if(key == "Tag")
{
gc->BarrierBegin();
tcallable->tag = value;
gc->BarrierEnd();
cse.back()->Push(gc,nullptr);
return false;
}
}
if(dynDict != nullptr)
{
if(dynDict->MethodExists(ls,"set" + key))
{
cse.back()->Push(gc,dynDict->CallMethod(ls,"set" + key, {value}));
}
else
{
dynDict->SetField(ls,key,value);
cse.back()->Push(gc,value);
}
return false;
}
if(dict != nullptr)
{
gc->BarrierBegin();
TObject fn = dict->GetValue("set" + key);
gc->BarrierEnd();
if(std::holds_alternative<THeapObjectHolder>(fn) && dynamic_cast<TCallable*>(std::get<THeapObjectHolder>(fn).obj) != nullptr)
{
return InvokeTwo(ls,fn, dict, value);
}
else
{
gc->BarrierBegin();
dict->SetValue(key, value);
stk->Push(gc, value);
gc->BarrierEnd();
return false;
}
}
stk->Push(gc, Undefined());
return false;
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Streams::Stream>>(
instance)) {
auto strm =
std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(
instance);
auto netStrm = std::dynamic_pointer_cast<
Tesses::Framework::Streams::NetworkStream>(strm);
if (netStrm != nullptr) {
int64_t n0;
bool bc;
if (key == "Broadcast" && GetObject(value, bc))
netStrm->SetBroadcast(bc);
if (key == "NoDelay" && GetObject(value, bc))
netStrm->SetNoDelay(bc);
if (key == "ReuseAddress" && GetObject(value, bc))
netStrm->SetReuseAddress(bc);
if (key == "ReusePort" && GetObject(value, bc))
netStrm->SetReusePort(bc);
if (key == "MulticastTTL" && GetObject(value, n0))
netStrm->SetMulticastTTL((uint8_t)n0);
}
stk->Push(gc, Undefined());
return false;
}
return false;
}
if (std::holds_alternative<THeapObjectHolder>(instance)) {
auto obj = std::get<THeapObjectHolder>(instance).obj;
}
auto dict = dynamic_cast<TDictionary *>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
auto natObj = dynamic_cast<TNativeObject *>(obj);
auto cls = dynamic_cast<TClassObject *>(obj);
if (cls != nullptr) {
gc->BarrierBegin();
auto obj =
cls->GetValue(cse.back()->callable->className, "set" + key);
gc->BarrierEnd();
TClosure *clos;
TCallable *callable;
if (GetObjectHeap(obj, clos)) {
this->AddCallStackEntry(ls, clos, {value});
return true;
} else if (GetObjectHeap(obj, callable)) {
cse.back()->Push(gc, callable->Call(ls, {value}));
return false;
}
gc->BarrierBegin();
cls->SetValue(cse.back()->callable->className, key, value);
gc->BarrierEnd();
cse.back()->Push(gc, value);
return false;
} else if (natObj != nullptr) {
cse.back()->Push(gc,
natObj->CallMethod(ls, "set" + key, {value}));
return false;
}
auto tcallable = dynamic_cast<TCallable *>(obj);
if (tcallable != nullptr) {
if (key == "Tag") {
gc->BarrierBegin();
tcallable->tag = value;
gc->BarrierEnd();
cse.back()->Push(gc, nullptr);
return false;
}
}
if (dynDict != nullptr) {
if (dynDict->MethodExists(ls, "set" + key)) {
cse.back()->Push(
gc, dynDict->CallMethod(ls, "set" + key, {value}));
} else {
dynDict->SetField(ls, key, value);
cse.back()->Push(gc, value);
}
return false;
}
if (dict != nullptr) {
gc->BarrierBegin();
TObject fn = dict->GetValue("set" + key);
gc->BarrierEnd();
if (std::holds_alternative<THeapObjectHolder>(fn) &&
dynamic_cast<TCallable *>(
std::get<THeapObjectHolder>(fn).obj) != nullptr) {
return InvokeTwo(ls, fn, dict, value);
} else {
gc->BarrierBegin();
dict->SetValue(key, value);
stk->Push(gc, value);
gc->BarrierEnd();
return false;
}
}
}
stk->Push(gc, Undefined());
}
return false;
}
} // namespace Tesses::CrossLang

200
src/vm/bc/sub.cpp
View File

@@ -2,120 +2,112 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool InterperterThread::Sub(std::shared_ptr<GC> gc)
{
std::vector<CallStackEntry*>& cse=this->call_stack_entries;
GCList ls(gc);
auto right = cse.back()->Pop(ls);
auto left = cse.back()->Pop(ls);
bool InterperterThread::Sub(std::shared_ptr<GC> gc) {
std::vector<CallStackEntry *> &cse = this->call_stack_entries;
GCList ls(gc);
auto right = cse.back()->Pop(ls);
auto left = cse.back()->Pop(ls);
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc,std::get<int64_t>(left) - std::get<int64_t>(right));
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
cse.back()->Push(gc,std::get<double>(left) - std::get<double>(right));
}
else if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc,std::get<double>(left) - std::get<int64_t>(right));
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
cse.back()->Push(gc,std::get<int64_t>(left) - std::get<double>(right));
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
{
cse.back()->Push(gc, (int64_t)(std::get<char>(left) - std::get<char>(right)));
}
else if(std::holds_alternative<char>(left) && std::holds_alternative<int64_t>(right))
{
cse.back()->Push(gc, (int64_t)(std::get<char>(left) - std::get<int64_t>(right)));
}
else if(std::holds_alternative<int64_t>(left) && std::holds_alternative<char>(right))
{
cse.back()->Push(gc, (int64_t)(std::get<int64_t>(left) - std::get<char>(right)));
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right))
{
auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) - (*r)));
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) && std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right))
{
auto& l = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto& r = std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(gc,std::make_shared<Tesses::Framework::Date::DateTime>((*l) - (*r)));
}
else if(std::holds_alternative<THeapObjectHolder>(left))
{
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary*>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary*>(obj);
if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(gc,
std::get<int64_t>(left) - std::get<int64_t>(right));
}
auto natObj = dynamic_cast<TNativeObject*>(obj);
auto cls = dynamic_cast<TClassObject*>(obj);
if(cls != nullptr)
{
gc->BarrierBegin();
auto obj=cls->GetValue(cse.back()->callable->className,"operator-");
gc->BarrierEnd();
TClosure* clos;
TCallable* callable;
if(GetObjectHeap(obj,clos))
{
this->AddCallStackEntry(ls,clos,{right});
return true;
}
else if(GetObjectHeap(obj,callable))
{
cse.back()->Push(gc,callable->Call(ls,{right}));
return false;
}
cse.back()->Push(gc,Undefined());
return false;
}
else if(natObj != nullptr)
{
cse.back()->Push(gc, natObj->CallMethod(ls,"operator-",{right}));
else if (std::holds_alternative<double>(left) &&
std::holds_alternative<double>(right)) {
cse.back()->Push(gc, std::get<double>(left) - std::get<double>(right));
} else if (std::holds_alternative<double>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(gc, std::get<double>(left) - std::get<int64_t>(right));
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<double>(right)) {
cse.back()->Push(gc, std::get<int64_t>(left) - std::get<double>(right));
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<char>(right)) {
cse.back()->Push(
gc, (int64_t)(std::get<char>(left) - std::get<char>(right)));
} else if (std::holds_alternative<char>(left) &&
std::holds_alternative<int64_t>(right)) {
cse.back()->Push(
gc, (int64_t)(std::get<char>(left) - std::get<int64_t>(right)));
} else if (std::holds_alternative<int64_t>(left) &&
std::holds_alternative<char>(right)) {
cse.back()->Push(
gc, (int64_t)(std::get<int64_t>(left) - std::get<char>(right)));
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(right)) {
auto &l =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto &r =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(right);
cse.back()->Push(
gc,
std::make_shared<Tesses::Framework::Date::TimeSpan>((*l) - (*r)));
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(left) &&
std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right)) {
auto &l =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(left);
auto &r =
std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(right);
cse.back()->Push(
gc,
std::make_shared<Tesses::Framework::Date::DateTime>((*l) - (*r)));
} else if (std::holds_alternative<THeapObjectHolder>(left)) {
auto obj = std::get<THeapObjectHolder>(left).obj;
auto dict = dynamic_cast<TDictionary *>(obj);
auto dynDict = dynamic_cast<TDynamicDictionary *>(obj);
auto natObj = dynamic_cast<TNativeObject *>(obj);
auto cls = dynamic_cast<TClassObject *>(obj);
if (cls != nullptr) {
gc->BarrierBegin();
auto obj =
cls->GetValue(cse.back()->callable->className, "operator-");
gc->BarrierEnd();
TClosure *clos;
TCallable *callable;
if (GetObjectHeap(obj, clos)) {
this->AddCallStackEntry(ls, clos, {right});
return true;
} else if (GetObjectHeap(obj, callable)) {
cse.back()->Push(gc, callable->Call(ls, {right}));
return false;
}
else if(dict != nullptr)
{
gc->BarrierBegin();
TObject fn = dict->GetValue("operator-");
gc->BarrierEnd();
return InvokeTwo(ls,fn,left,right);
}
else if(dynDict != nullptr)
{
cse.back()->Push(gc,dynDict->CallMethod(ls,"operator-",{right}));
return false;
}
else
{
cse.back()->Push(gc,Undefined());
}
}
else
{
cse.back()->Push(gc, Undefined());
return false;
} else if (natObj != nullptr) {
cse.back()->Push(gc, natObj->CallMethod(ls, "operator-", {right}));
return false;
} else if (dict != nullptr) {
gc->BarrierBegin();
TObject fn = dict->GetValue("operator-");
gc->BarrierEnd();
return InvokeTwo(ls, fn, left, right);
} else if (dynDict != nullptr) {
cse.back()->Push(gc, dynDict->CallMethod(ls, "operator-", {right}));
return false;
} else {
cse.back()->Push(gc, Undefined());
}
return false;
} else {
cse.back()->Push(gc, Undefined());
}
}
return false;
}
} // namespace Tesses::CrossLang

167
src/vm/bc/tobool.cpp
View File

@@ -2,105 +2,84 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
bool ToBool(TObject obj)
{
if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(obj))
{
return true;
}
if(std::holds_alternative<TVMVersion>(obj))
{
auto v = std::get<TVMVersion>(obj);
return v.AsLong() != 0;
}
if(std::holds_alternative<std::string>(obj))
{
return !std::get<std::string>(obj).empty();
}
else if(std::holds_alternative<int64_t>(obj))
{
return std::get<int64_t>(obj) != 0;
}
else if(std::holds_alternative<double>(obj))
{
return std::get<double>(obj);
}
else if(std::holds_alternative<bool>(obj))
{
return std::get<bool>(obj);
}
else if(std::holds_alternative<char>(obj))
{
return std::get<char>(obj) != 0;
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj))
{
auto& dt = std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj);
return !(dt->Year() == 1970 && dt->Month() == 1 && dt->Day() == 1 && dt->Hour() == 0 && dt->Minute() == 0 && dt->Second() == 0 && !dt->IsLocal());
}
else if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj))
{
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj)->TotalSeconds() != 0;
}
else if(std::holds_alternative<Tesses::Framework::Uuid>(obj))
{
auto& uuid = std::get<Tesses::Framework::Uuid>(obj);
return !uuid.IsEmpty();
}
else if(std::holds_alternative<THeapObjectHolder>(obj))
{
auto o = std::get<THeapObjectHolder>(obj).obj;
auto ls = dynamic_cast<TList*>(o);
auto aarray = dynamic_cast<TAssociativeArray*>(o);
auto dict = dynamic_cast<TDictionary*>(o);
auto ba = dynamic_cast<TByteArray*>(o);
auto nat = dynamic_cast<TNative*>(o);
auto thrd = dynamic_cast<ThreadHandle*>(o);
auto natObj = dynamic_cast<TNativeObject*>(o);
auto any = dynamic_cast<TAny*>(o);
auto cls = dynamic_cast<TClassObject*>(o);
if(cls!=nullptr) return true;
if(natObj != nullptr) return natObj->ToBool();
if(any != nullptr) return any->any.has_value();
if(ls != nullptr)
{
return ls->Count() != 0;
}
if(aarray != nullptr)
{
return aarray->Count() != 0;
}
else if(dict != nullptr)
{
return !dict->items.empty();
}
else if(ba != nullptr)
{
return !ba->data.empty();
}
else if(nat != nullptr)
{
return !nat->GetDestroyed();
}
else if(thrd != nullptr)
{
return !thrd->hasReturned;
}
return true;
}
return false;
bool ToBool(TObject obj) {
if (std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(obj)) {
return true;
}
}
if (std::holds_alternative<TVMVersion>(obj)) {
auto v = std::get<TVMVersion>(obj);
return v.AsLong() != 0;
}
if (std::holds_alternative<std::string>(obj)) {
return !std::get<std::string>(obj).empty();
} else if (std::holds_alternative<int64_t>(obj)) {
return std::get<int64_t>(obj) != 0;
} else if (std::holds_alternative<double>(obj)) {
return std::get<double>(obj);
} else if (std::holds_alternative<bool>(obj)) {
return std::get<bool>(obj);
} else if (std::holds_alternative<char>(obj)) {
return std::get<char>(obj) != 0;
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj)) {
auto &dt =
std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(obj);
return !(dt->Year() == 1970 && dt->Month() == 1 && dt->Day() == 1 &&
dt->Hour() == 0 && dt->Minute() == 0 && dt->Second() == 0 &&
!dt->IsLocal());
} else if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj)) {
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(obj)
->TotalSeconds() != 0;
} else if (std::holds_alternative<Tesses::Framework::Uuid>(obj)) {
auto &uuid = std::get<Tesses::Framework::Uuid>(obj);
return !uuid.IsEmpty();
} else if (std::holds_alternative<THeapObjectHolder>(obj)) {
auto o = std::get<THeapObjectHolder>(obj).obj;
auto ls = dynamic_cast<TList *>(o);
auto aarray = dynamic_cast<TAssociativeArray *>(o);
auto dict = dynamic_cast<TDictionary *>(o);
auto ba = dynamic_cast<TByteArray *>(o);
auto nat = dynamic_cast<TNative *>(o);
auto thrd = dynamic_cast<ThreadHandle *>(o);
auto natObj = dynamic_cast<TNativeObject *>(o);
auto any = dynamic_cast<TAny *>(o);
auto cls = dynamic_cast<TClassObject *>(o);
if (cls != nullptr)
return true;
if (natObj != nullptr)
return natObj->ToBool();
if (any != nullptr)
return any->any.has_value();
if (ls != nullptr) {
return ls->Count() != 0;
}
if (aarray != nullptr) {
return aarray->Count() != 0;
} else if (dict != nullptr) {
return !dict->items.empty();
} else if (ba != nullptr) {
return !ba->data.empty();
} else if (nat != nullptr) {
return !nat->GetDestroyed();
} else if (thrd != nullptr) {
return !thrd->hasReturned;
}
return true;
}
return false;
}
} // namespace Tesses::CrossLang

226
src/vm/bc/tostring.cpp
View File

@@ -2,132 +2,114 @@
#include "TessesFramework/Serialization/BitConverter.hpp"
#include "TessesFramework/Streams/ByteReader.hpp"
#include "TessesFramework/Uuid.hpp"
#include <cmath>
#include <cstddef>
#include <cstring>
#include <exception>
#include <iostream>
#include <cmath>
#include <cstring>
#include <sstream>
#include <variant>
namespace Tesses::CrossLang {
std::string ToString(std::shared_ptr<GC> gc, TObject o)
{
if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(o))
{
return std::get<Tesses::Framework::Filesystem::VFSPath>(o).ToString();
}
if(std::holds_alternative<std::string>(o))
{
return std::get<std::string>(o);
}
if(std::holds_alternative<TVMVersion>(o))
{
return std::get<TVMVersion>(o).ToString();
}
if(std::holds_alternative<int64_t>(o))
{
return std::to_string(std::get<int64_t>(o));
}
if(std::holds_alternative<double>(o))
{
return std::to_string(std::get<double>(o));
}
if(std::holds_alternative<char>(o))
{
return std::string{std::get<char>(o)};
}
if(std::holds_alternative<std::nullptr_t>(o))
{
return "null";
}
if(std::holds_alternative<Undefined>(o))
{
return "undefined";
}
if(std::holds_alternative<bool>(o))
{
return std::get<bool>(o) ? "true" : "false";
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::DateTime>>(o))
{
return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(o)->ToString();
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o))
{
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o)->ToString(false);
}
if(std::holds_alternative<Tesses::Framework::Uuid>(o))
{
return std::get<Tesses::Framework::Uuid>(o).ToString(Framework::UuidStringifyConfig::LowercaseNoCurly);
}
if(std::holds_alternative<THeapObjectHolder>(o))
{
auto obj = std::get<THeapObjectHolder>(o).obj;
auto dict = dynamic_cast<TDictionary*>(obj);
auto list = dynamic_cast<TList*>(obj);
auto bArray = dynamic_cast<TByteArray*>(obj);
auto natObj = dynamic_cast<TNativeObject*>(obj);
auto cls = dynamic_cast<TClassObject*>(obj);
auto aArray = dynamic_cast<TAssociativeArray*>(obj);
if(aArray != nullptr)
{
std::string str={};
gc->BarrierBegin();
bool first=true;
for(auto item : aArray->items)
{
if(!first) str.push_back('\n');
first=false;
str.push_back('[');
str.append(Json_Encode(item.first));
str.append("] = ");
str.append(Json_Encode(item.second));
str.append(";");
}
gc->BarrierEnd();
return str;
}
if(cls != nullptr)
{
auto res = cls->GetValue("","ToString");
TCallable* call;
GCList ls(gc);
if(GetObjectHeap(res,call)) return ToString(gc, call->Call(ls,{}));
return cls->TypeName();
}
if(natObj != nullptr)
{
GCList ls(gc);
TObject o=natObj->CallMethod(ls,"ToString",{});
return ToString(gc, o);
}
if(dict != nullptr)
{
GCList ls(gc);
if(dict->MethodExists(ls,"ToString"))
return ToString(gc,dict->CallMethod(ls,"ToString",{}));
else
{
return Json_Encode(dict);
}
}
else if(bArray != nullptr)
{
return std::string(bArray->data.begin(),bArray->data.end());
}
else if(list != nullptr)
{
return Json_Encode(list);
}
}
return "";
std::string ToString(std::shared_ptr<GC> gc, TObject o) {
if (std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(o)) {
return std::get<Tesses::Framework::Filesystem::VFSPath>(o).ToString();
}
}
if (std::holds_alternative<std::string>(o)) {
return std::get<std::string>(o);
}
if (std::holds_alternative<TVMVersion>(o)) {
return std::get<TVMVersion>(o).ToString();
}
if (std::holds_alternative<int64_t>(o)) {
return std::to_string(std::get<int64_t>(o));
}
if (std::holds_alternative<double>(o)) {
return std::to_string(std::get<double>(o));
}
if (std::holds_alternative<char>(o)) {
return std::string{std::get<char>(o)};
}
if (std::holds_alternative<std::nullptr_t>(o)) {
return "null";
}
if (std::holds_alternative<Undefined>(o)) {
return "undefined";
}
if (std::holds_alternative<bool>(o)) {
return std::get<bool>(o) ? "true" : "false";
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::DateTime>>(o)) {
return std::get<std::shared_ptr<Tesses::Framework::Date::DateTime>>(o)
->ToString();
}
if (std::holds_alternative<
std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o)) {
return std::get<std::shared_ptr<Tesses::Framework::Date::TimeSpan>>(o)
->ToString(false);
}
if (std::holds_alternative<Tesses::Framework::Uuid>(o)) {
return std::get<Tesses::Framework::Uuid>(o).ToString(
Framework::UuidStringifyConfig::LowercaseNoCurly);
}
if (std::holds_alternative<THeapObjectHolder>(o)) {
auto obj = std::get<THeapObjectHolder>(o).obj;
auto dict = dynamic_cast<TDictionary *>(obj);
auto list = dynamic_cast<TList *>(obj);
auto bArray = dynamic_cast<TByteArray *>(obj);
auto natObj = dynamic_cast<TNativeObject *>(obj);
auto cls = dynamic_cast<TClassObject *>(obj);
auto aArray = dynamic_cast<TAssociativeArray *>(obj);
if (aArray != nullptr) {
std::string str = {};
gc->BarrierBegin();
bool first = true;
for (auto item : aArray->items) {
if (!first)
str.push_back('\n');
first = false;
str.push_back('[');
str.append(Json_Encode(item.first));
str.append("] = ");
str.append(Json_Encode(item.second));
str.append(";");
}
gc->BarrierEnd();
return str;
}
if (cls != nullptr) {
auto res = cls->GetValue("", "ToString");
TCallable *call;
GCList ls(gc);
if (GetObjectHeap(res, call))
return ToString(gc, call->Call(ls, {}));
return cls->TypeName();
}
if (natObj != nullptr) {
GCList ls(gc);
TObject o = natObj->CallMethod(ls, "ToString", {});
return ToString(gc, o);
}
if (dict != nullptr) {
GCList ls(gc);
if (dict->MethodExists(ls, "ToString"))
return ToString(gc, dict->CallMethod(ls, "ToString", {}));
else {
return Json_Encode(dict);
}
} else if (bArray != nullptr) {
return std::string(bArray->data.begin(), bArray->data.end());
} else if (list != nullptr) {
return Json_Encode(list);
}
}
return "";
}
} // namespace Tesses::CrossLang