tesses50/crosslang
1
0
Fork 0
mirror of https://onedev.site.tesses.net/crosslang synced 2026-02-08 17:15:45 +00:00
Code Issues Packages Projects Releases Wiki Activity

use shared ptrs for stream, vfs and ihttpserver and add progress

Browse Source
This commit is contained in:
Mike Nolan
2025-09-29 03:03:46 -05:00
parent 91622089f7
commit b92db28bba
31 changed files with 1394 additions and 1493 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
src/runtime_methods/console.cpp
View File

@@ -8,6 +8,7 @@
#ifdef CROSSLANG_ENABLE_TERMIOS
#include <termios.h>
#include <sys/ioctl.h>
#endif
namespace Tesses::CrossLang {
#ifdef CROSSLANG_ENABLE_TERMIOS
@@ -182,16 +183,16 @@ namespace Tesses::CrossLang {
}
TObject Console_getIn(GCList& ls, std::vector<TObject> args)
{
return TStreamHeapObject::Create(ls, new Tesses::Framework::Streams::FileStream(stdin,false,"r",false));
return std::make_shared<Tesses::Framework::Streams::FileStream>(stdin,false,"r",false);
}
TObject Console_getOut(GCList& ls, std::vector<TObject> args)
{
return TStreamHeapObject::Create(ls, new Tesses::Framework::Streams::FileStream(stdout,false,"w",false));
return std::make_shared<Tesses::Framework::Streams::FileStream>(stdout,false,"w",false);
}
TObject Console_getError(GCList& ls, std::vector<TObject> args)
{
return TStreamHeapObject::Create(ls, new Tesses::Framework::Streams::FileStream(stderr,false,"w",false));
return std::make_shared<Tesses::Framework::Streams::FileStream>(stderr,false,"w",false);
}
TObject Console_Clear(GCList& ls, std::vector<TObject> args)
{
@@ -203,6 +204,81 @@ namespace Tesses::CrossLang {
#endif
return Undefined();
}
static void con_sz(int& w, int& h)
{
w = 0;
h = 0;
#if defined(_WIN32)
#elif defined(CROSSLANG_ENABLE_TERMIOS)
if(!isatty(STDOUT_FILENO))
return;
struct winsize ws;
if(ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) == 0)
{
w = ws.ws_col;
h = ws.ws_row;
}
#endif
}
TObject Console_ProgressBar(GCList& ls, std::vector<TObject> args)
{
//[=== ] 50%
bool showBar = true;
#if defined(CROSSLANG_ENABLE_TERMIOS)
if(!isatty(STDOUT_FILENO)) showBar=false;
#endif
int64_t progress = 0;
double pdbl = 0;
GetArgument(args,0,pdbl);
if(GetArgument(args,0,progress)) pdbl = progress / 100.0;
if(pdbl < 0) pdbl=0;
if(pdbl > 1) pdbl=1;
std::cout << "\r";
if(showBar)
{
int w,h;
con_sz(w,h);
int totalBlocks = w - 10;
if(totalBlocks > 0)
{
std::cout << "[\033[0;32m";
int i;
int off = pdbl * totalBlocks;
for(int i = 0; i < totalBlocks; i++)
{
if(i < off)
std::cout << "=";
else
std::cout << " ";
}
std::cout << "\033[0m] ";
}
}
std::cout << std::setw(3) << progress << "%" << std::flush;
return Undefined();
}
TObject Console_getSize(GCList& ls, std::vector<TObject> args)
{
#if defined(CROSSLANG_ENABLE_TERMIOS)
if(!isatty(STDOUT_FILENO)) return nullptr;
#endif
int w, h;
con_sz(w,h);
TDictionary* dict = TDictionary::Create(ls,{
TDItem("Width", (int64_t)w),
TDItem("Height",(int64_t)h)
});
return dict;
}
void TStd::RegisterConsole(GC* gc,TRootEnvironment* env)
{
env->permissions.canRegisterConsole=true;
@@ -234,11 +310,13 @@ namespace Tesses::CrossLang {
dict->DeclareFunction(gc,"WriteLine","Write text \"text\" to stdout with new line",{"$text"},Console_WriteLine);
dict->DeclareFunction(gc,"Error", "Write text \"error\" to stderr",{"error"},Console_Error);
dict->DeclareFunction(gc,"ErrorLine","Write text \"error\" to stderr",{"$error"},Console_ErrorLine);
dict->DeclareFunction(gc,"ProgressBar","Draw progressbar", {}, Console_ProgressBar);
if(env->permissions.canRegisterEverything)
dict->DeclareFunction(gc,"Fatal","Stop the program with an optional error message",{"$text"},Console_Fatal);
dict->DeclareFunction(gc,"getIn","Get stdin Stream",{},Console_getIn);
dict->DeclareFunction(gc,"getOut","Get stdout Stream",{},Console_getOut);
dict->DeclareFunction(gc,"getError", "Get stderr Stream",{},Console_getError);
dict->DeclareFunction(gc, "getSize", "Get console size",{},Console_getSize);
gc->BarrierBegin();
env->DeclareVariable("Console", dict);
gc->BarrierEnd();

18
src/runtime_methods/crypto.cpp
View File

@@ -113,11 +113,11 @@ namespace Tesses::CrossLang
dict->DeclareFunction(gc, "Base64Decode","Base64 decode",{"str"},Crypto_Base64Decode);
dict->DeclareFunction(gc, "Sha1", "Hash with sha1 algorithm (please don't use sha1 unless you need to)",{"strm"}, [](GCList& ls, std::vector<TObject> args)->TObject {
TByteArray* baSrc;
TStreamHeapObject* sho;
std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
if(GetArgumentHeap(args, 0, sho))
if(GetArgument(args, 0, sho))
{
auto bytes = Sha1::ComputeHash(sho->stream);
auto bytes = Sha1::ComputeHash(sho);
auto ba = TByteArray::Create(ls);
ba->data = bytes;
return ba;
@@ -133,13 +133,13 @@ namespace Tesses::CrossLang
});
dict->DeclareFunction(gc, "Sha256", "Hash with sha256 algorithm",{"strm","$is224"}, [](GCList& ls, std::vector<TObject> args)->TObject {
TByteArray* baSrc;
TStreamHeapObject* sho;
std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
bool is224=false;
GetArgument(args,1,is224);
if(GetArgumentHeap(args, 0, sho))
if(GetArgument(args, 0, sho))
{
auto bytes = Sha256::ComputeHash(sho->stream,is224);
auto bytes = Sha256::ComputeHash(sho,is224);
auto ba = TByteArray::Create(ls);
ba->data = bytes;
return ba;
@@ -155,13 +155,13 @@ namespace Tesses::CrossLang
});
dict->DeclareFunction(gc, "Sha512", "Hash with sha512 algorithm",{"strm","$is384"}, [](GCList& ls, std::vector<TObject> args)->TObject {
TByteArray* baSrc;
TStreamHeapObject* sho;
std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
bool is384=false;
GetArgument(args,1,is384);
if(GetArgumentHeap(args, 0, sho))
if(GetArgument(args, 0, sho))
{
auto bytes = Sha512::ComputeHash(sho->stream,is384);
auto bytes = Sha512::ComputeHash(sho,is384);
auto ba = TByteArray::Create(ls);
ba->data = bytes;
return ba;

54
src/runtime_methods/helpers.cpp Normal file
View File

@@ -0,0 +1,54 @@
#include "CrossLang.hpp"
namespace Tesses::CrossLang {
static TObject Helpers_CopyToProgress(GCList& ls, std::vector<TObject> args)
{
std::shared_ptr<Tesses::Framework::Streams::Stream> src;
std::shared_ptr<Tesses::Framework::Streams::Stream> dest;
TCallable* callable;
if(GetArgument(args,0,src) && GetArgument(args,1,dest) && GetArgumentHeap(args,2,callable))
{
auto len = src->GetLength();
callable->Call(ls,{0.0});
if(len > 0)
{
std::shared_ptr<uint8_t> buff=std::make_shared<uint8_t>(1024);
int64_t pos=0;
int curPercent=0;
int lastPercent=0;
size_t read = 0;
do {
read = src->ReadBlock(buff.get(),1024);
dest->WriteBlock(buff.get(),read);
if(read == 0) break;
pos += (int64_t)read;
double percent = (double)(pos / len);
percent *= 10000;
curPercent = (int)percent;
if(curPercent > lastPercent)
{
lastPercent = curPercent;
callable->Call(ls,{curPercent/10000.0});
}
} while(read != 0);
}
else {
src->CopyTo(dest);
}
callable->Call(ls,{1.0});
}
return Undefined();
}
void TStd::RegisterHelpers(GC* gc, TRootEnvironment* env)
{
auto helpers=env->EnsureDictionary(gc,"Helpers");
helpers->DeclareFunction(gc,"CopyToProgress","Copy Stream to another (but with progress event)",{"src","dest","progressCB"},Helpers_CopyToProgress);
}
}

60
src/runtime_methods/io.cpp
View File

@@ -23,29 +23,33 @@ namespace Tesses::CrossLang
}
static TObject FS_CreateArchive(GCList& ls, std::vector<TObject> args)
{
TVFSHeapObject* vfs;
TStreamHeapObject* strm;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
std::string name;
std::string version;
std::string info;
std::string icon="";
TVMVersion version2;
if(GetArgumentHeap(args,0,vfs) && GetArgumentHeap(args,1,strm) && GetArgument(args,2,name) && GetArgument(args,4,info) && ((GetArgument(args,3,version) && TVMVersion::TryParse(version,version2)) || GetArgument(args,3,version2)))
if(GetArgument(args,0,vfs) && GetArgument(args,1,strm) && GetArgument(args,2,name) && GetArgument(args,4,info) && ((GetArgument(args,3,version) && TVMVersion::TryParse(version,version2)) || GetArgument(args,3,version2)))
{
GetArgument(args,5,icon);
CrossArchiveCreate(vfs->vfs,strm->stream,name,version2,info,icon);
CrossArchiveCreate(vfs,strm,name,version2,info,icon);
}
return nullptr;
}
static TObject FS_ExtractArchive(GCList& ls, std::vector<TObject> args)
{
TVFSHeapObject* vfs;
TStreamHeapObject* strm;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgumentHeap(args,0,strm) && GetArgumentHeap(args,1,vfs))
if(GetArgument(args,0,strm) && GetArgument(args,1,vfs))
{
auto res = CrossArchiveExtract(strm->stream,vfs->vfs);
auto res = CrossArchiveExtract(strm,vfs);
TDictionary* dict = TDictionary::Create(ls);
ls.GetGC()->BarrierBegin();
@@ -62,12 +66,13 @@ namespace Tesses::CrossLang
{
Tesses::Framework::Filesystem::VFSPath path;
TVFSHeapObject* vfs;
if(GetArgumentHeap(args,0,vfs) && GetArgumentAsPath(args,1,path))
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path))
{
auto txtFile = vfs->vfs->OpenFile(path,"rb");
auto txtFile = vfs->OpenFile(path,"rb");
if(txtFile == nullptr) return "";
Tesses::Framework::TextStreams::StreamReader reader(txtFile,true);
Tesses::Framework::TextStreams::StreamReader reader(txtFile);
return reader.ReadToEnd();
}
return "";
@@ -75,10 +80,11 @@ namespace Tesses::CrossLang
static TObject FS_ReadAllBytes(GCList& ls, std::vector<TObject> args)
{
Tesses::Framework::Filesystem::VFSPath path;
TVFSHeapObject* vfs;
if(GetArgumentHeap(args,0,vfs) && GetArgumentAsPath(args,1,path))
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path))
{
auto txtFile = vfs->vfs->OpenFile(path,"rb");
auto txtFile = vfs->OpenFile(path,"rb");
if(txtFile == nullptr) return nullptr;
auto res = TByteArray::Create(ls);
std::array<uint8_t,1024> data;
@@ -87,7 +93,7 @@ namespace Tesses::CrossLang
read = txtFile->ReadBlock(data.data(),data.size());
res->data.insert(res->data.end(),data.begin(),data.begin()+read);
} while(read != 0);
delete txtFile;
return res;
}
return nullptr;
@@ -97,15 +103,15 @@ namespace Tesses::CrossLang
static TObject FS_WriteAllText(GCList& ls, std::vector<TObject> args)
{
Tesses::Framework::Filesystem::VFSPath path;
TVFSHeapObject* vfs;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
std::string content;
if(GetArgumentHeap(args,0,vfs) && GetArgumentAsPath(args,1,path) && GetArgument(args,2,content))
if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path) && GetArgument(args,2,content))
{
auto txtFile = vfs->vfs->OpenFile(path,"wb");
auto txtFile = vfs->OpenFile(path,"wb");
if(txtFile == nullptr) return nullptr;
Tesses::Framework::TextStreams::StreamWriter writer(txtFile,true);
Tesses::Framework::TextStreams::StreamWriter writer(txtFile);
writer.Write(content);
}
return nullptr;
@@ -114,15 +120,15 @@ namespace Tesses::CrossLang
{
Tesses::Framework::Filesystem::VFSPath path;
TVFSHeapObject* vfs;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
TByteArray* bArray;
if(GetArgumentHeap(args,0,vfs) && GetArgumentAsPath(args,1,path) && GetArgumentHeap(args,2,bArray))
if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path) && GetArgumentHeap(args,2,bArray))
{
auto txtFile = vfs->vfs->OpenFile(path,"wb");
auto txtFile = vfs->OpenFile(path,"wb");
if(txtFile == nullptr) return nullptr;
txtFile->WriteBlock(bArray->data.data(),bArray->data.size());
delete txtFile;
}
return nullptr;
}
@@ -150,9 +156,9 @@ namespace Tesses::CrossLang
gc->BarrierBegin();
if(enableLocalFilesystem)
{
TVFSHeapObject* vfs = TVFSHeapObject::Create(ls, new Tesses::Framework::Filesystem::LocalFilesystem());
dict->SetValue("Local", vfs);
dict->SetValue("Local", Tesses::Framework::Filesystem::LocalFS);
dict->DeclareFunction(gc, "MakeFull", "Make absolute path from relative path",{"path"},FS_MakeFull);
dict->DeclareFunction(gc,"getCurrentPath","Get current path",{},FS_getCurrentPath);
dict->DeclareFunction(gc,"setCurrentPath","Set the current path",{"path"},FS_setCurrentPath);

269
src/runtime_methods/net.cpp
View File

@@ -14,64 +14,32 @@ using namespace Tesses::Framework::Http;
using namespace Tesses::Framework::Mail;
namespace Tesses::CrossLang
{
static SMTPBody* TObjectToSMTPBody(GCList& ls,std::string mimeType, TObject obj)
static std::shared_ptr<SMTPBody> TObjectToSMTPBody(GCList& ls,std::string mimeType, TObject obj)
{
SMTPBody* body = nullptr;
std::shared_ptr<SMTPBody> body;
std::string text;
TByteArray* ba;
TStreamHeapObject* sho;
std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
if(GetObject(obj,text))
{
body = new SMTPStringBody(text,mimeType);
body = std::make_shared<SMTPStringBody>(text,mimeType);
}
else if(GetObjectHeap(obj,ba)) {
MemoryStream* ms = new MemoryStream(true);
std::shared_ptr<MemoryStream> ms = std::make_shared<MemoryStream>(true);
ms->WriteBlock(ba->data.data(), ba->data.size());
ms->Seek(0L, SeekOrigin::Begin);
body = new SMTPStreamBody(mimeType,ms,true);
body = std::make_shared<SMTPStreamBody>(mimeType,ms);
}
else if(GetObjectHeap(obj,sho))
else if(GetObject(obj,sho))
{
ls.Add(sho);
body = new SMTPStreamBody(mimeType,sho->stream,false);
body = std::make_shared<SMTPStreamBody>(mimeType,sho);
}
return body;
}
TServerHeapObject* TServerHeapObject::Create(GCList& ls, Tesses::Framework::Http::IHttpServer* svr)
{
TServerHeapObject* ho = new TServerHeapObject();
ls.Add(ho);
auto gc = ls.GetGC();
gc->Watch(ho);
ho->server = svr;
return ho;
}
TServerHeapObject* TServerHeapObject::Create(GCList* ls, Tesses::Framework::Http::IHttpServer* svr)
{
TServerHeapObject* ho = new TServerHeapObject();
ls->Add(ho);
auto gc = ls->GetGC();
gc->Watch(ho);
ho->server = svr;
return ho;
}
void TServerHeapObject::Close()
{
if(this->server != nullptr)
{
delete this->server;
this->server = nullptr;
}
}
TServerHeapObject::~TServerHeapObject()
{
if(this->server != nullptr)
{
delete this->server;
}
}
class TNativeObjectThatReturnsHttpDictionary : public TNativeObject {
public:
virtual bool IsAvailable()=0;
@@ -293,26 +261,31 @@ namespace Tesses::CrossLang
else if(key == "getQueryParams") return TNativeObject::Create<THttpDictionary>(ls, &ctx->queryParams,this);
else if(key == "getRequestHeaders") return TNativeObject::Create<THttpDictionary>(ls, &ctx->requestHeaders,this);
else if(key == "getResponseHeaders") return TNativeObject::Create<THttpDictionary>(ls, &ctx->responseHeaders,this);
else if(key == "GetStream") return TStreamHeapObject::Create(ls, &ctx->GetStream());
else if(key == "OpenRequestStream") return TStreamHeapObject::Create(ls, ctx->OpenRequestStream());
else if(key == "OpenResponseStream") return TStreamHeapObject::Create(ls, ctx->OpenResponseStream());
else if(key == "GetStream") return ctx->GetStream();
else if(key == "OpenRequestStream") return ctx->OpenRequestStream();
else if(key == "OpenResponseStream") return ctx->OpenResponseStream();
else if(key == "ParseFormData")
{
TCallable* callable;
TVFSHeapObject* vfsHeapObject;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgumentHeap(args, 0, callable))
{
ctx->ParseFormData([callable,&ls](std::string a,std::string b, std::string c)->Tesses::Framework::Streams::Stream*{
ctx->ParseFormData([callable,&ls](std::string a,std::string b, std::string c)->std::shared_ptr<Tesses::Framework::Streams::Stream> {
auto res = callable->Call(ls,{a,b,c});
return new Tesses::CrossLang::TObjectStream(ls.GetGC(),res);
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetObject(res,strm))
{
return strm;
}
return nullptr;
});
}
else if(GetArgumentHeap(args,0,vfsHeapObject))
else if(GetArgument(args,0,vfs))
{
int i = 1;
std::vector<TObject> response;
ctx->ParseFormData([vfsHeapObject,&response,&ls,&i](std::string mime,std::string filename, std::string name)->Tesses::Framework::Streams::Stream* {
ctx->ParseFormData([vfs,&response,&ls,&i](std::string mime,std::string filename, std::string name)->std::shared_ptr<Tesses::Framework::Streams::Stream> {
std::string realFileName = "/" + std::to_string(i) + ".bin";
i++;
response.push_back(TDictionary::Create(ls,{
@@ -322,7 +295,7 @@ namespace Tesses::CrossLang
TDItem("Name", name)
}));
auto strm = vfsHeapObject->vfs->OpenFile(realFileName,"wb");
auto strm = vfs->OpenFile(realFileName,"wb");
return strm;
@@ -334,10 +307,10 @@ namespace Tesses::CrossLang
else if(key == "getNeedToParseFormData") return ctx->NeedToParseFormData();
else if(key == "ReadString") return ctx->ReadString();
else if(key == "ReadStream") {
Tesses::CrossLang::TStreamHeapObject* strm;
if(GetArgumentHeap(args,0,strm))
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgument(args,0,strm))
{
ctx->ReadStream(strm->stream);
ctx->ReadStream(strm);
}
}
else if(key == "ReadJson")
@@ -397,9 +370,9 @@ namespace Tesses::CrossLang
}
else if(key == "SendStream")
{
TStreamHeapObject* strmHeapObj;
if(GetArgumentHeap(args,0,strmHeapObj))
ctx->SendStream(strmHeapObj->stream);
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgument(args,0,strm))
ctx->SendStream(strm);
}
else if(key == "SendBytes")
@@ -552,12 +525,12 @@ namespace Tesses::CrossLang
req->CallMethod(ls,"HandleHeaders",{res});
dummy->Close();
}
void Write(Tesses::Framework::Streams::Stream* strm)
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{
GCList ls(gc);
auto res=TStreamHeapObject::Create(ls,strm);
req->CallMethod(ls,"Write",{res});
res->stream=nullptr;
req->CallMethod(ls,"Write",{strm});
}
~TDictionaryHttpRequestBody()
@@ -571,7 +544,6 @@ namespace Tesses::CrossLang
{
TCallable* callable;
TDictionary* dict;
TServerHeapObject* server;
TClassObject* clsObj;
if(GetObjectHeap<TCallable*>(this->obj,callable))
{
@@ -620,10 +592,6 @@ namespace Tesses::CrossLang
}
}
else if(GetObjectHeap<TServerHeapObject*>(this->obj,server))
{
return server->server->Handle(ctx);
}
return false;
}
@@ -678,7 +646,7 @@ namespace Tesses::CrossLang
bool datagram;
if(GetArgument(args,0,ipv6) && GetArgument(args,1,datagram))
{
return TStreamHeapObject::Create(ls,new NetworkStream(ipv6,datagram));
return std::make_shared<NetworkStream>(ipv6,datagram);
}
return nullptr;
}
@@ -686,13 +654,13 @@ namespace Tesses::CrossLang
{
HttpServer* server;
public:
HttpServerNativeObject(uint16_t port, TObjectHttpServer* httpServer,bool printIps)
HttpServerNativeObject(uint16_t port, std::shared_ptr<IHttpServer> httpServer,bool printIps)
{
server=new HttpServer(port,httpServer,true,printIps);
server=new HttpServer(port,httpServer,printIps);
}
HttpServerNativeObject(std::string unixPath, TObjectHttpServer* httpServer)
HttpServerNativeObject(std::string unixPath, std::shared_ptr<IHttpServer> httpServer)
{
server=new HttpServer(unixPath,httpServer,true);
server=new HttpServer(unixPath,httpServer);
}
std::string TypeName()
{
@@ -722,15 +690,25 @@ namespace Tesses::CrossLang
{
bool printIPs=true;
GetArgument(args,2,printIPs);
TObjectHttpServer* httpServer = new TObjectHttpServer(ls.GetGC(),args[0]);
uint16_t p = (uint16_t)port;
return TNativeObject::Create<HttpServerNativeObject>(ls,port,httpServer,printIPs);
std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
if(httpSvr) {
uint16_t p = (uint16_t)port;
return TNativeObject::Create<HttpServerNativeObject>(ls,port,httpSvr,printIPs);
}
}
if(GetArgument(args,1,pathStr) && env->permissions.canRegisterLocalFS)
{
TObjectHttpServer* httpServer = new TObjectHttpServer(ls.GetGC(),args[0]);
std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
if(httpSvr) {
return TNativeObject::Create<HttpServerNativeObject>(ls,pathStr,httpSvr);
}
return TNativeObject::Create<HttpServerNativeObject>(ls,pathStr,httpServer);
}
return nullptr;
@@ -740,27 +718,31 @@ namespace Tesses::CrossLang
int64_t port;
if(GetArgument(args,1,port))
{
TObjectHttpServer httpServer(ls.GetGC(),args[0]);
uint16_t p = (uint16_t)port;
HttpServer server(p,httpServer);
server.StartAccepting();
Tesses::Framework::TF_RunEventLoop();
std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
if(httpSvr) {
uint16_t p = (uint16_t)port;
HttpServer server(p,httpSvr);
server.StartAccepting();
Tesses::Framework::TF_RunEventLoop();
}
}
return nullptr;
}
static TObject Net_Http_ListenOnUnusedPort(GCList& ls, std::vector<TObject> args)
{
if(args.size() > 0)
{
TObjectHttpServer httpServer(ls.GetGC(),args[0]);
uint16_t port=0;
HttpServer server(port,httpServer, false);
std::cout << "Port: " << server.GetPort() << std::endl;
server.StartAccepting();
Tesses::Framework::TF_RunEventLoop();
if(args.empty()) return nullptr;
std::shared_ptr<IHttpServer> httpSvr=ToHttpServer(ls.GetGC(),args.front());
if(httpSvr) {
uint16_t p = 0;
HttpServer server(p,httpSvr);
std::cout << "Port: " << server.GetPort() << std::endl;
server.StartAccepting();
Tesses::Framework::TF_RunEventLoop();
}
return nullptr;
}
static TObject Net_Http_MimeType(GCList& ls, std::vector<TObject> args)
@@ -840,10 +822,10 @@ namespace Tesses::CrossLang
else if(key == "CopyToStream")
{
TStreamHeapObject* strm;
if(GetArgumentHeap(args,0,strm))
std::shared_ptr<Stream> strm;
if(GetArgument(args,0,strm))
{
response->CopyToStream(strm->stream);
response->CopyToStream(strm);
}
}
else if(key == "ReadAsString")
@@ -856,10 +838,9 @@ namespace Tesses::CrossLang
}
else if(key == "ReadAsStream")
{
auto strm = TStreamHeapObject::Create(ls, response->ReadAsStream());
strm->watch.push_back(this);
return strm;
return response->ReadAsStream();
}
else if(key == "getStatusCode")
{
@@ -1018,9 +999,9 @@ namespace Tesses::CrossLang
ls.GetGC()->BarrierBegin();
auto server = dict->GetValue("server");
TDictionary* dict2;
Tesses::Framework::Streams::Stream* strm=nullptr;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
bool ownsStream=true;
TStreamHeapObject* objStrm;
std::shared_ptr<Stream> objStrm;
if(GetObjectHeap(server,dict2))
{
auto tlsO = dict2->GetValue("tls");
@@ -1034,19 +1015,19 @@ namespace Tesses::CrossLang
if(!GetObject(portO, port)) port = tls ? 465 : 25;
GetObject(hostO,host);
strm = new NetworkStream(host,(uint16_t)port,false,false,false);
strm = std::make_shared<NetworkStream>(host,(uint16_t)port,false,false,false);
if(tls)
{
strm = new Framework::Crypto::ClientTLSStream(strm,true,true,host);
strm = std::make_shared<Framework::Crypto::ClientTLSStream>(strm,true,host);
}
}
else if (GetObjectHeap(server, objStrm)) {
else if (GetObject(server, objStrm)) {
ownsStream=false;
strm = objStrm->stream;
strm = objStrm;
}
Tesses::Framework::Mail::SMTPClient client(strm,ownsStream);
Tesses::Framework::Mail::SMTPClient client(strm);
auto o = dict->GetValue("domain");
GetObject(o,client.domain);
@@ -1097,7 +1078,7 @@ namespace Tesses::CrossLang
GetObject(o,type);
o = dict2->GetValue("data");
client.attachments.push_back(std::pair<std::string,SMTPBody*>(name,TObjectToSMTPBody(ls, type, o)));
client.attachments.push_back(std::pair<std::string,std::shared_ptr<SMTPBody>>(name,TObjectToSMTPBody(ls, type, o)));
}
}
}
@@ -1139,7 +1120,7 @@ namespace Tesses::CrossLang
hdict.AddValue(key,value);
}
}
CallbackWebSocketConnection conn([dict,&ls](std::function<void(WebSocketMessage&)> sendMessage,std::function<void()> ping,std::function<void()> close)->void{
auto conn = std::make_shared<CallbackWebSocketConnection>([dict,&ls](std::function<void(WebSocketMessage&)> sendMessage,std::function<void()> ping,std::function<void()> close)->void{
GCList ls2(ls.GetGC());
dict->CallMethod(ls2,"Open",{
TExternalMethod::Create(ls2,"Send a message",{"messageTextOrByteArray"},[sendMessage](GCList& ls,std::vector<TObject> args)->TObject{
@@ -1225,7 +1206,7 @@ namespace Tesses::CrossLang
}
}
CallbackWebSocketConnection conn([co,&ls](std::function<void(WebSocketMessage&)> sendMessage,std::function<void()> ping,std::function<void()> close)->void{
auto conn = std::make_shared<CallbackWebSocketConnection>([co,&ls](std::function<void(WebSocketMessage&)> sendMessage,std::function<void()> ping,std::function<void()> close)->void{
GCList ls2(ls.GetGC());
co->CallMethod(ls2,"","Open",{
TExternalMethod::Create(ls2,"Send a message",{"messageTextOrByteArray"},[sendMessage](GCList& ls,std::vector<TObject> args)->TObject{
@@ -1298,33 +1279,55 @@ namespace Tesses::CrossLang
static TObject Net_Http_DownloadToStream(GCList& ls, std::vector<TObject> args)
{
std::string url;
TStreamHeapObject* strm;
if(GetArgument(args,0,url) && GetArgumentHeap(args,1,strm))
std::shared_ptr<Stream> strm;
if(GetArgument(args,0,url) && GetArgument(args,1,strm))
{
DownloadToStreamSimple(url,strm->stream);
DownloadToStreamSimple(url,strm);
}
return nullptr;
}
static TObject Net_Http_DownloadToFile(GCList& ls, std::vector<TObject> args)
{
std::string url;
TVFSHeapObject* vfs;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
Tesses::Framework::Filesystem::VFSPath path;
if(GetArgument(args,0,url) && GetArgumentHeap(args,1,vfs) && GetArgumentAsPath(args,2, path))
if(GetArgument(args,0,url) && GetArgument(args,1,vfs) && GetArgumentAsPath(args,2, path))
{
DownloadToFileSimple(url,vfs->vfs,path);
DownloadToFileSimple(url,vfs,path);
}
return nullptr;
}
bool TServerHeapObject::Handle(std::vector<TObject> args)
bool IHttpServer_Handle(std::shared_ptr<IHttpServer> svr,std::vector<TObject>& args)
{
TServerContext* ctx;
if(this->server != nullptr && GetArgumentHeap(args,0,ctx) && ctx->IsAvailable())
if(GetArgumentHeap(args,0,ctx))
{
return this->server->Handle(*ctx->GetContext());
return svr->Handle(*ctx->GetContext());
}
return false;
}
std::shared_ptr<IHttpServer> ToHttpServer(GC* gc, TObject obj)
{
if(std::holds_alternative<std::shared_ptr<IHttpServer>>(obj)) return std::get<std::shared_ptr<IHttpServer>>(obj);
TDictionary* dict;
TClassObject* clo;
TCallable* call;
if(GetObjectHeap(obj,dict))
{
return std::make_shared<TObjectHttpServer>(gc,dict);
}
else if(GetObjectHeap(obj,clo))
{
return std::make_shared<TObjectHttpServer>(gc,clo);
}
else if(GetObjectHeap(obj,call))
{
return std::make_shared<TObjectHttpServer>(gc,call);
}
return nullptr;
}
void TStd::RegisterNet(GC* gc, TRootEnvironment* env)
{
@@ -1345,10 +1348,12 @@ namespace Tesses::CrossLang
//http->DeclareFunction(gc, "ProcessServer","Process HTTP server connection",{"networkstream","server","ip","port","encrypted"},, Net_ProcessServer);
http->DeclareFunction(gc, "StreamHttpRequestBody","Create a stream request body",{"stream","mimeType"},[](GCList& ls, std::vector<TObject> args)->TObject {
std::shared_ptr<Stream> strm;
std::string mimeType;
if(GetArgument(args, 1, mimeType))
if(GetArgument(args,0,strm) && GetArgument(args, 1, mimeType))
{
return TNativeObject::Create<THttpRequestBody>(ls, new StreamHttpRequestBody(new TObjectStream(ls.GetGC(),args[0]), true, mimeType));
return TNativeObject::Create<THttpRequestBody>(ls, new StreamHttpRequestBody(strm, mimeType));
}
return nullptr;
});
@@ -1382,24 +1387,36 @@ namespace Tesses::CrossLang
http->DeclareFunction(gc, "ListenSimpleWithLoop", "Listen (creates application loop)", {"server","port"},Net_Http_ListenSimpleWithLoop);
http->DeclareFunction(gc, "ListenOnUnusedPort","Listen on unused localhost port and print Port: theport",{"server"},Net_Http_ListenOnUnusedPort);
//FileServer svr()
http->DeclareFunction(gc, "FileServer","Create a file server",{"path","allowlisting","spa"}, [](GCList& ls, std::vector<TObject> args)->TObject{
http->DeclareFunction(gc, "FileServer","Create a file server",{"vfs","allowlisting","spa"}, [](GCList& ls, std::vector<TObject> args)->TObject{
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
bool allowlisting;
bool spa;
if(GetArgument(args,1,allowlisting) && GetArgument(args,2,spa))
if(GetArgument(args,0,vfs) && GetArgument(args,1,allowlisting) && GetArgument(args,2,spa))
{
auto fserver = new FileServer(new TObjectVFS(ls.GetGC(),args[0]),true,allowlisting,spa);
return TServerHeapObject::Create(ls,fserver);
return std::make_shared<FileServer>(vfs,allowlisting,spa);
}
return nullptr;
});
http->DeclareFunction(gc, "MountableServer","Create a server you can mount to, must mount parents before child",{"root"}, [](GCList& ls, std::vector<TObject> args)->TObject{
if(args.size() > 0)
TDictionary* dict;
TClassObject* cls;
std::shared_ptr<Tesses::Framework::Http::IHttpServer> mySvr;
if(GetArgumentHeap(args,0,dict))
{
auto svr = new TObjectHttpServer(ls.GetGC(), args[0]);
auto svr2 = new MountableServer(svr,true);
auto svr = std::make_shared<TObjectHttpServer>(ls.GetGC(), dict);
return std::make_shared<MountableServer>(svr);
return TServerHeapObject::Create(ls,svr2);
}
else if(GetArgumentHeap(args,0,cls))
{
auto svr = std::make_shared<TObjectHttpServer>(ls.GetGC(), cls);
return std::make_shared<MountableServer>(svr);
}
else if(GetArgument(args,0,mySvr))
{
return std::make_shared<MountableServer>(mySvr);
}
return nullptr;
});

6
src/runtime_methods/process.cpp
View File

@@ -171,15 +171,15 @@ namespace Tesses::CrossLang
}
if(key == "getStandardInput")
{
return TStreamHeapObject::Create(ls,process.GetStdinStream());
return process.GetStdinStream();
}
if(key == "getStandardOutput")
{
return TStreamHeapObject::Create(ls,process.GetStdoutStream());
return process.GetStdoutStream();
}
if(key == "getStandardError")
{
return TStreamHeapObject::Create(ls,process.GetStderrStream());
return process.GetStderrStream();
}
return Undefined();
}

132
src/runtime_methods/std.cpp
View File

@@ -844,14 +844,14 @@ namespace Tesses::CrossLang
static TObject TypeIsStream(GCList& ls, std::vector<TObject> args)
{
if(args.empty()) return nullptr;
TStreamHeapObject* strm;
return GetArgumentHeap(args,0,strm);
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
return GetArgument(args,0,strm);
}
static TObject TypeIsVFS(GCList& ls, std::vector<TObject> args)
{
if(args.empty()) return nullptr;
TVFSHeapObject* vfs;
return GetArgumentHeap(args,0,vfs);
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
return GetArgument(args,0,vfs);
}
static TObject TypeIsDateTime(GCList& ls, std::vector<TObject> args)
@@ -862,23 +862,23 @@ namespace Tesses::CrossLang
}
static TObject New_SubdirFilesystem(GCList& ls, std::vector<TObject> args)
{
TVFSHeapObject* vfsho;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
Tesses::Framework::Filesystem::VFSPath path;
if(GetArgumentHeap(args,0,vfsho) && GetArgumentAsPath(args,1,path))
if(GetArgument(args,0,vfs) && GetArgumentAsPath(args,1,path))
{
return TVFSHeapObject::Create(ls,new Tesses::Framework::Filesystem::SubdirFilesystem(new TObjectVFS(ls.GetGC(),vfsho),path,true));
return std::make_shared<Tesses::Framework::Filesystem::SubdirFilesystem>(vfs,path);
}
return nullptr;
}
static TObject New_MountableFilesystem(GCList& ls, std::vector<TObject> args)
{
TVFSHeapObject* vfsho;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgumentHeap(args,0,vfsho))
if(GetArgument(args,0,vfs))
{
return TVFSHeapObject::Create(ls,new Tesses::Framework::Filesystem::MountableFilesystem(new TObjectVFS(ls.GetGC(),vfsho),true));
return std::make_shared<Tesses::Framework::Filesystem::MountableFilesystem>(vfs);
}
return nullptr;
}
@@ -887,13 +887,13 @@ namespace Tesses::CrossLang
bool writable;
if(GetArgument(args,0,writable))
{
return TStreamHeapObject::Create(ls,new Tesses::Framework::Streams::MemoryStream(writable));
return std::make_shared<Tesses::Framework::Streams::MemoryStream>(writable);
}
return nullptr;
}
static TObject New_MemoryFilesystem(GCList& ls, std::vector<TObject> args)
{
return TVFSHeapObject::Create(ls, new Tesses::Framework::Filesystem::MemoryFilesystem());
return std::make_shared<Tesses::Framework::Filesystem::MemoryFilesystem>();
}
static TObject New_Filesystem(GCList& ls, std::vector<TObject> args)
@@ -901,7 +901,7 @@ namespace Tesses::CrossLang
TDictionary* dict;
if(GetArgumentHeap(args,0,dict))
{
return TVFSHeapObject::Create(ls, new TObjectVFS(ls.GetGC(),dict));
return std::make_shared<TObjectVFS>(ls.GetGC(),dict);
}
return nullptr;
}
@@ -910,7 +910,7 @@ namespace Tesses::CrossLang
TDictionary* dict;
if(GetArgumentHeap(args,0,dict))
{
return TStreamHeapObject::Create(ls, new TObjectStream(ls.GetGC(),dict));
return std::make_shared<TObjectStream>(ls.GetGC(), dict);
}
return nullptr;
}
@@ -960,6 +960,62 @@ namespace Tesses::CrossLang
if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(_obj)) return "Path";
if(std::holds_alternative<TDateTime>(_obj)) return "DateTime";
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Streams::Stream>>(_obj))
{
auto strm = std::get<std::shared_ptr<Tesses::Framework::Streams::Stream>>(_obj);
if(strm != nullptr)
{
auto netStrm = std::dynamic_pointer_cast<Tesses::Framework::Streams::NetworkStream>(strm);
if(netStrm != nullptr)
{
return "NetworkStream";
}
}
return "Stream";
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(_obj))
{
auto svr = std::get<std::shared_ptr<Tesses::Framework::Http::IHttpServer>>(_obj);
if(svr != nullptr)
{
auto fileServer = std::dynamic_pointer_cast<Tesses::Framework::Http::FileServer>(svr);
auto mountableServer = std::dynamic_pointer_cast<Tesses::Framework::Http::MountableServer>(svr);
if(fileServer != nullptr)
{
return "FileServer";
}
if(mountableServer != nullptr)
{
return "MountableServer";
}
}
return "HttpServer";
}
if(std::holds_alternative<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(_obj))
{
auto vfs = std::get<std::shared_ptr<Tesses::Framework::Filesystem::VFS>>(_obj);
if(vfs != nullptr)
{
auto localVFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::LocalFilesystem>(vfs);
auto mountableVFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::MountableFilesystem>(vfs);
auto subFS = std::dynamic_pointer_cast<Tesses::Framework::Filesystem::SubdirFilesystem>(vfs);
if(localVFS != nullptr) return "LocalFilesystem";
if(subFS != nullptr) return "SubdirFilesystem";
if(mountableVFS != nullptr) return "MountableFilesystem";
}
return "VFS";
}
if(std::holds_alternative<THeapObjectHolder>(_obj))
{
auto obj = std::get<THeapObjectHolder>(_obj).obj;
@@ -974,9 +1030,7 @@ namespace Tesses::CrossLang
auto byteArray = dynamic_cast<TByteArray*>(obj);
auto native = dynamic_cast<TNative*>(obj);
auto any = dynamic_cast<TAny*>(obj);
auto vfs = dynamic_cast<TVFSHeapObject*>(obj);
auto strm = dynamic_cast<TStreamHeapObject*>(obj);
auto svr = dynamic_cast<TServerHeapObject*>(obj);
auto cse = dynamic_cast<CallStackEntry*>(obj);
auto rootEnv = dynamic_cast<TRootEnvironment*>(obj);
auto subEnv = dynamic_cast<TSubEnvironment*>(obj);
@@ -995,46 +1049,7 @@ namespace Tesses::CrossLang
if(dynList != nullptr) return "DynamicList";
if(aarray != nullptr) return "AssociativeArray";
if(natObj != nullptr) return natObj->TypeName();
if(strm != nullptr)
{
auto netStrm = dynamic_cast<Tesses::Framework::Streams::NetworkStream*>(strm->stream);
if(netStrm != nullptr)
{
return "NetworkStream";
}
return "Stream";
}
if(svr != nullptr)
{
auto fileServer = dynamic_cast<Tesses::Framework::Http::FileServer*>(svr->server);
auto mountableServer = dynamic_cast<Tesses::Framework::Http::MountableServer*>(svr->server);
if(fileServer != nullptr)
{
return "FileServer";
}
if(mountableServer != nullptr)
{
return "MountableServer";
}
return "HttpServer";
}
if(vfs != nullptr)
{
auto localVFS = dynamic_cast<Tesses::Framework::Filesystem::LocalFilesystem*>(vfs->vfs);
auto mountableVFS = dynamic_cast<Tesses::Framework::Filesystem::MountableFilesystem*>(vfs->vfs);
auto subFS = dynamic_cast<Tesses::Framework::Filesystem::SubdirFilesystem*>(vfs->vfs);
if(localVFS != nullptr) return "LocalFilesystem";
if(subFS != nullptr) return "SubdirFilesystem";
if(mountableVFS != nullptr) return "MountableFilesystem";
return "VFS";
}
if(dict != nullptr) return "Dictionary";
if(list != nullptr) return "List";
if(argWrapper != nullptr) return "ArgWrapper";
@@ -1221,6 +1236,7 @@ namespace Tesses::CrossLang
gc->BarrierBegin();
env->permissions.canRegisterRoot=true;
RegisterHelpers(gc,env);
auto date =env->EnsureDictionary(gc,"DateTime");
date->DeclareFunction(gc, "Sleep","Sleep for a specified amount of milliseconds (multiply seconds by 1000 to get milliseconds)", {"ms"},DateTime_Sleep);
@@ -1258,8 +1274,8 @@ namespace Tesses::CrossLang
newTypes->DeclareFunction(gc, "MountableFilesystem","Create a mountable filesystem",{"root"}, New_MountableFilesystem);
newTypes->DeclareFunction(gc, "SubdirFilesystem","Create a subdir filesystem",{"fs","subdir"}, New_SubdirFilesystem);
newTypes->DeclareFunction(gc, "MemoryStream","Create a memory stream",{"writable"}, New_MemoryStream);
newTypes->DeclareFunction(gc, "Stream","Create stream", {"strm"},New_Stream);
newTypes->DeclareFunction(gc, "Filesystem","Create filesystem", {"fs"},New_Filesystem);
newTypes->DeclareFunction(gc, "Stream","Create stream", {"strm"},New_Stream);
newTypes->DeclareFunction(gc, "MemoryFilesystem","Create in memory filesystem", {},New_MemoryFilesystem);

38
src/runtime_methods/vm.cpp
View File

@@ -232,7 +232,7 @@ namespace Tesses::CrossLang
std::vector<std::pair<std::string,TVMVersion>> tools;
std::string info;
std::string icon;
TVFSHeapObject* vfsHO =nullptr;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
ls.GetGC()->BarrierBegin();
TObject _name = dict->GetValue("Name");
@@ -252,7 +252,7 @@ namespace Tesses::CrossLang
GetObject<std::string>(_name,name);
GetObject<std::string>(_info,info);
GetObject<std::string>(_icon,icon);
GetObjectHeap(_resourceFileSystem, vfsHO);
GetObject(_resourceFileSystem, vfs);
GetObjectHeap(_comptime,comptimeEnv);
std::string v2;
if(GetObject<std::string>(_version,v2))
@@ -362,10 +362,10 @@ namespace Tesses::CrossLang
gen.version = version;
gen.icon = icon;
std::string outpath;
TStreamHeapObject* stream;
if(GetObjectHeap<TStreamHeapObject*>(_out, stream))
std::shared_ptr<Tesses::Framework::Streams::Stream> stream;
if(GetObject(_out, stream))
{
gen.Save(vfsHO != nullptr ? vfsHO->vfs : nullptr, stream->stream);
gen.Save(vfs, stream);
}
@@ -403,11 +403,11 @@ namespace Tesses::CrossLang
}
});
dict->DeclareFunction(gc, "LoadExecutable", "Load a crossvm executable",{"stream"},[](GCList& ls,std::vector<TObject> args)->TObject{
TStreamHeapObject* strm;
if(GetArgumentHeap(args,0,strm))
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgument(args,0,strm))
{
TFile* f =TFile::Create(ls);
f->Load(ls.GetGC(),strm->stream);
f->Load(ls.GetGC(),strm);
return f;
}
return nullptr;
@@ -431,30 +431,30 @@ namespace Tesses::CrossLang
return Undefined();
});
dict->DeclareFunction(gc, "Merge", "Merge crvm files", {"srcVFS","sourcePath","destVFS"},[](GCList& ls, std::vector<TObject> args)->TObject {
TVFSHeapObject* srcVFS;
TVFSHeapObject* destVFS;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcVFS;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> destVFS;
Tesses::Framework::Filesystem::VFSPath sourcePath;
if(GetArgumentHeap(args,0, srcVFS) && GetArgumentAsPath(args,1,sourcePath) && GetArgumentHeap(args,2,destVFS))
return Merge(srcVFS->vfs, sourcePath, destVFS->vfs);
if(GetArgument(args,0, srcVFS) && GetArgumentAsPath(args,1,sourcePath) && GetArgument(args,2,destVFS))
return Merge(srcVFS, sourcePath, destVFS);
return Undefined();
});
dict->DeclareFunction(gc, "Disassemble","Disassemble crvm file",{"strm","vfs","$generateJSON","$extractResources"},[](GCList& ls, std::vector<TObject> args)->TObject {
TStreamHeapObject* strm;
TVFSHeapObject* vfs;
std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
bool generateJSON=true;
bool extractResources=true;
if(GetArgumentHeap(args,0,strm) && GetArgumentHeap(args,1, vfs))
if(GetArgument(args,0,strm) && GetArgument(args,1, vfs))
{
GetArgument(args,2,generateJSON);
GetArgument(args,3,extractResources);
Disassemble(strm->stream,vfs->vfs, generateJSON, extractResources);
Disassemble(strm,vfs, generateJSON, extractResources);
}
return Undefined();
});
dict->DeclareFunction(gc, "Assemble", "Assemble crvm file",{"vfs"},[](GCList& ls, std::vector<TObject> args)->TObject {
TVFSHeapObject* vfs;
if(GetArgumentHeap(args,0, vfs))
return Assemble(vfs->vfs);
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgument(args,0, vfs))
return Assemble(vfs);
return Undefined();
});