tesses50/crosslang
1
0
Fork 0
mirror of https://onedev.site.tesses.net/crosslang synced 2026-04-18 15:57:04 +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

10
Packaging/CPKG/ConsoleOrServer/main.cpp
View File

@@ -4,8 +4,7 @@ using namespace Tesses::CrossLang;
int main(int argc, char** argv) int main(int argc, char** argv)
{ {
std::string name = argv[0]; std::string name = argv[0];
Tesses::Framework::Filesystem::LocalFilesystem fs; Tesses::Framework::Filesystem::VFSPath exePath=Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(name);
Tesses::Framework::Filesystem::VFSPath exePath=fs.SystemToVFSPath(name);
exePath.MakeAbsolute(); exePath.MakeAbsolute();
exePath.ChangeExtension(".crvm"); exePath.ChangeExtension(".crvm");
@@ -18,7 +17,7 @@ int main(int argc, char** argv)
TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls)); TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
TStd::RegisterStd(&gc,env); TStd::RegisterStd(&gc,env);
env->LoadFileWithDependencies(&gc, &fs, exePath); env->LoadFileWithDependencies(&gc, Tesses::Framework::Filesystem::LocalFS, exePath);
@@ -41,8 +40,9 @@ int main(int argc, char** argv)
} }
auto res = env->CallFunction(ls, "WebAppMain", {args2}); auto res = env->CallFunction(ls, "WebAppMain", {args2});
TObjectHttpServer http(&gc, res); auto svr2 = Tesses::CrossLang::ToHttpServer(&gc,res);
Tesses::Framework::Http::HttpServer svr(port,http,false); if(svr2 == nullptr) return 1;
Tesses::Framework::Http::HttpServer svr(port,svr2);
svr.StartAccepting(); svr.StartAccepting();
TF_RunEventLoop(); TF_RunEventLoop();
TF_Quit(); TF_Quit();

110
include/CrossLang.hpp
View File

@@ -489,7 +489,7 @@ namespace Tesses::CrossLang {
* @param info the crvm info * @param info the crvm info
* @param icon the crvm icon * @param icon the crvm icon
*/ */
void CrossArchiveCreate(Tesses::Framework::Filesystem::VFS* vfs,Tesses::Framework::Streams::Stream* strm,std::string name,TVMVersion version,std::string info, std::string icon=""); void CrossArchiveCreate(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs,std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::string name,TVMVersion version,std::string info, std::string icon="");
/** /**
* @brief * @brief
* *
@@ -497,7 +497,7 @@ namespace Tesses::CrossLang {
* @param vfs vfs to extract to (as root) * @param vfs vfs to extract to (as root)
* @return std::pair<std::pair<std::string,TVMVersion>,std::string> ((name, version),info) * @return std::pair<std::pair<std::string,TVMVersion>,std::string> ((name, version),info)
*/ */
std::pair<std::pair<std::string,TVMVersion>,std::string> CrossArchiveExtract(Tesses::Framework::Streams::Stream* strm,Tesses::Framework::Filesystem::VFS* vfs); std::pair<std::pair<std::string,TVMVersion>,std::string> CrossArchiveExtract(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs);
@@ -800,7 +800,7 @@ class CharInstruction : public ByteCodeInstruction {
void Write(std::vector<uint8_t>& data); void Write(std::vector<uint8_t>& data);
}; };
using SyntaxNode = std::variant<int64_t, double, std::string, char, bool, std::nullptr_t, Undefined,std::vector<uint8_t>, AdvancedSyntaxNode>; using SyntaxNode = std::variant<int64_t, double, std::string, char, bool, std::nullptr_t, Undefined,std::vector<uint8_t>, AdvancedSyntaxNode,std::shared_ptr<Tesses::Framework::Streams::Stream>,std::shared_ptr<Tesses::Framework::Filesystem::VFSPath>>;
@@ -821,21 +821,21 @@ struct CodeGenClass {
class ResourceBase { class ResourceBase {
public: public:
virtual uint32_t GetLength(Tesses::Framework::Filesystem::VFS* embedFS)=0; virtual uint32_t GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS)=0;
virtual void Write(Tesses::Framework::Streams::Stream* output)=0; virtual void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output)=0;
virtual ~ResourceBase(); virtual ~ResourceBase();
virtual bool IsEqual(ResourceBase* base); virtual bool IsEqual(ResourceBase* base);
}; };
class ResourceFile : public ResourceBase class ResourceFile : public ResourceBase
{ {
Tesses::Framework::Streams::Stream* strm=nullptr; std::shared_ptr<Tesses::Framework::Streams::Stream> strm=nullptr;
public: public:
ResourceFile(); ResourceFile();
ResourceFile(std::string file); ResourceFile(std::string file);
std::string file; std::string file;
uint32_t GetLength(Tesses::Framework::Filesystem::VFS* embedFS); uint32_t GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS);
void Write(Tesses::Framework::Streams::Stream* output); void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output);
bool IsEqual(ResourceBase* base); bool IsEqual(ResourceBase* base);
~ResourceFile(); ~ResourceFile();
}; };
@@ -844,8 +844,8 @@ class ResourceByteArray : public ResourceBase
{ {
public: public:
std::vector<uint8_t> data; std::vector<uint8_t> data;
uint32_t GetLength(Tesses::Framework::Filesystem::VFS* embedFS); uint32_t GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS);
void Write(Tesses::Framework::Streams::Stream* output); void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output);
}; };
@@ -878,7 +878,7 @@ class CodeGen {
std::string info; std::string info;
std::string icon; std::string icon;
void GenRoot(SyntaxNode n); void GenRoot(SyntaxNode n);
void Save(Tesses::Framework::Filesystem::VFS* embedFS,Tesses::Framework::Streams::Stream* output); void Save(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS,std::shared_ptr<Tesses::Framework::Streams::Stream> output);
~CodeGen(); ~CodeGen();
}; };
/** /**
@@ -1395,7 +1395,7 @@ class TContinue {
* *
*/ */
using TObject = std::variant<int64_t,double,char,bool,std::string,std::regex,Tesses::Framework::Filesystem::VFSPath,std::nullptr_t,Undefined,MethodInvoker,THeapObjectHolder,TVMVersion,TDateTime,TBreak,TContinue>; using TObject = std::variant<int64_t,double,char,bool,std::string,std::regex,Tesses::Framework::Filesystem::VFSPath,std::nullptr_t,Undefined,MethodInvoker,THeapObjectHolder,TVMVersion,TDateTime,TBreak,TContinue,std::shared_ptr<Tesses::Framework::Streams::Stream>,std::shared_ptr<Tesses::Framework::Filesystem::VFS>,std::shared_ptr<Tesses::Framework::Http::IHttpServer>,std::shared_ptr<Tesses::Framework::Http::HttpRequestBody>,std::shared_ptr<Tesses::Framework::TextStreams::TextReader>,std::shared_ptr<Tesses::Framework::TextStreams::TextWriter>>;
class TRootEnvironment; class TRootEnvironment;
class GC; class GC;
@@ -1533,13 +1533,13 @@ class GC {
std::string info; std::string info;
int32_t icon; int32_t icon;
void Load(GC* gc, Tesses::Framework::Streams::Stream* strm); void Load(GC* gc, std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void Skip(Tesses::Framework::Streams::Stream* strm,size_t len); void Skip(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,size_t len);
void Ensure(Tesses::Framework::Streams::Stream* strm,uint8_t* buffer, size_t len); void Ensure(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint8_t* buffer, size_t len);
uint32_t EnsureInt(Tesses::Framework::Streams::Stream* strm); uint32_t EnsureInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string EnsureString(Tesses::Framework::Streams::Stream* strm); std::string EnsureString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string GetString(Tesses::Framework::Streams::Stream* strm); std::string GetString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void Mark(); void Mark();
void EnsureCanRunInCrossLang(); void EnsureCanRunInCrossLang();
@@ -1781,7 +1781,7 @@ class GC {
TDictionary* dict; TDictionary* dict;
TCallable* error=nullptr; TCallable* error=nullptr;
void LoadDependency(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, std::pair<std::string,TVMVersion> dep); void LoadDependency(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep);
public: public:
EnvironmentPermissions permissions; EnvironmentPermissions permissions;
@@ -1790,8 +1790,8 @@ class GC {
bool TryFindClass(std::vector<std::string>& name, size_t& index); bool TryFindClass(std::vector<std::string>& name, size_t& index);
void LoadFileWithDependencies(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, TFile* f); void LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* f);
void LoadFileWithDependencies(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Filesystem::VFSPath path); void LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path);
TDictionary* GetDictionary(); TDictionary* GetDictionary();
static TRootEnvironment* Create(GCList* gc,TDictionary* dict); static TRootEnvironment* Create(GCList* gc,TDictionary* dict);
@@ -1815,6 +1815,8 @@ class GC {
void Mark(); void Mark();
}; };
class TStd { class TStd {
private:
static void RegisterHelpers(GC* gc, TRootEnvironment* env);
public: public:
static void RegisterStd(GC* gc, TRootEnvironment* env); static void RegisterStd(GC* gc, TRootEnvironment* env);
static void RegisterConsole(GC* gc,TRootEnvironment* env); static void RegisterConsole(GC* gc,TRootEnvironment* env);
@@ -1990,69 +1992,14 @@ class GC {
}; };
class TStreamHeapObject : public THeapObject
{
public:
Tesses::Framework::Streams::Stream* stream;
std::vector<TObject> watch;
static TStreamHeapObject* Create(GCList& ls, Tesses::Framework::Streams::Stream* strm);
static TStreamHeapObject* Create(GCList* ls, Tesses::Framework::Streams::Stream* strm);
~TStreamHeapObject();
void Close();
void Mark()
{
if(this->marked) return;
this->marked=true;
for(auto item : watch)
GC::Mark(item);
}
};
class TVFSHeapObject : public THeapObject
{
public:
Tesses::Framework::Filesystem::VFS* vfs;
std::vector<TObject> watch;
static TVFSHeapObject* Create(GCList& ls, Tesses::Framework::Filesystem::VFS* vfs);
static TVFSHeapObject* Create(GCList* ls, Tesses::Framework::Filesystem::VFS* vfs);
~TVFSHeapObject();
void Close();
void Mark()
{
if(this->marked) return;
this->marked=true;
for(auto item : watch)
GC::Mark(item);
}
};
class TServerHeapObject : public THeapObject
{
public:
Tesses::Framework::Http::IHttpServer* server;
std::vector<TObject> watch;
static TServerHeapObject* Create(GCList& ls, Tesses::Framework::Http::IHttpServer* vfs);
static TServerHeapObject* Create(GCList* ls, Tesses::Framework::Http::IHttpServer* vfs);
~TServerHeapObject();
void Close();
bool Handle(std::vector<TObject> args);
void Mark()
{
if(this->marked) return;
this->marked=true;
for(auto item : watch)
GC::Mark(item);
}
};
class TObjectVFS : public Tesses::Framework::Filesystem::VFS class TObjectVFS : public Tesses::Framework::Filesystem::VFS
{ {
public: public:
TObject obj; TObject obj;
GCList* ls; GCList* ls;
TObjectVFS(GC* gc, TObject obj); TObjectVFS(GC* gc, TObject obj);
Tesses::Framework::Streams::Stream* OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode); std::shared_ptr<Tesses::Framework::Streams::Stream> OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode);
void CreateDirectory(Tesses::Framework::Filesystem::VFSPath path); void CreateDirectory(Tesses::Framework::Filesystem::VFSPath path);
void DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path); void DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path);
bool RegularFileExists(Tesses::Framework::Filesystem::VFSPath path); bool RegularFileExists(Tesses::Framework::Filesystem::VFSPath path);
@@ -2554,7 +2501,10 @@ class GC {
extern Tesses::Framework::Filesystem::VFSPath CrossLangConfigPath; extern Tesses::Framework::Filesystem::VFSPath CrossLangConfigPath;
Tesses::Framework::Filesystem::VFSPath Assemble(Tesses::Framework::Filesystem::VFS* vfs); Tesses::Framework::Filesystem::VFSPath Assemble(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs);
void Disassemble(Tesses::Framework::Streams::Stream* src,Tesses::Framework::Filesystem::VFS* vfs, bool generateJSON=true,bool extractResources=true); void Disassemble(std::shared_ptr<Tesses::Framework::Streams::Stream> src,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, bool generateJSON=true,bool extractResources=true);
Tesses::Framework::Filesystem::VFSPath Merge(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourcePath, Tesses::Framework::Filesystem::VFS* destFS); Tesses::Framework::Filesystem::VFSPath Merge(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourcePath, std::shared_ptr<Tesses::Framework::Filesystem::VFS> destFS);
std::shared_ptr<Tesses::Framework::Http::IHttpServer> ToHttpServer(GC* gc,TObject obj);
}; };

32
src/archive.cpp
View File

@@ -3,7 +3,7 @@
namespace Tesses::CrossLang namespace Tesses::CrossLang
{ {
void CrossArchiveCreate(Tesses::Framework::Filesystem::VFS* vfs,Tesses::Framework::Streams::Stream* strm,std::string name, TVMVersion version, std::string info, std::string icon) void CrossArchiveCreate(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs,std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::string name, TVMVersion version, std::string info, std::string icon)
{ {
std::vector<std::string> ignored_files; std::vector<std::string> ignored_files;
std::string file = "/.crossarchiveignore"; std::string file = "/.crossarchiveignore";
@@ -12,7 +12,7 @@ namespace Tesses::CrossLang
auto strm = vfs->OpenFile(file,"rb"); auto strm = vfs->OpenFile(file,"rb");
if(strm != nullptr) if(strm != nullptr)
{ {
Tesses::Framework::TextStreams::StreamReader reader(strm,true); Tesses::Framework::TextStreams::StreamReader reader(strm);
std::string ignores; std::string ignores;
while(reader.ReadLine(ignores)) while(reader.ReadLine(ignores))
{ {
@@ -53,12 +53,12 @@ namespace Tesses::CrossLang
CALLMETHOD, CALLMETHOD,
RET RET
}; };
auto writeInt = [](Tesses::Framework::Streams::Stream* strm,uint32_t number)->void{ auto writeInt = [](std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint32_t number)->void{
uint8_t buff[4]; uint8_t buff[4];
BitConverter::FromUint32BE(buff[0],number); BitConverter::FromUint32BE(buff[0],number);
strm->WriteBlock(buff,4); strm->WriteBlock(buff,4);
}; };
auto writeStr = [&writeInt](Tesses::Framework::Streams::Stream* strm,std::string text)->void { auto writeStr = [&writeInt](std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::string text)->void {
writeInt(strm,(uint32_t)text.size()); writeInt(strm,(uint32_t)text.size());
strm->WriteBlock((const uint8_t*)text.c_str(),text.size()); strm->WriteBlock((const uint8_t*)text.c_str(),text.size());
}; };
@@ -90,14 +90,14 @@ namespace Tesses::CrossLang
strs.push_back(str); strs.push_back(str);
return index; return index;
}; };
Tesses::Framework::Streams::MemoryStream ms(true); auto ms = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
std::function<void(Tesses::Framework::Filesystem::VFSPath)> walkFS = [&ignored_files,vfs,&ensureString,&ensureResource,&ms,&walkFS,&writeInt](Tesses::Framework::Filesystem::VFSPath path)->void { std::function<void(Tesses::Framework::Filesystem::VFSPath)> walkFS = [&ignored_files,vfs,&ensureString,&ensureResource,&ms,&walkFS,&writeInt](Tesses::Framework::Filesystem::VFSPath path)->void {
if(vfs->DirectoryExists(path)) if(vfs->DirectoryExists(path))
{ {
ms.WriteByte(1); ms->WriteByte(1);
std::vector<std::string> paths; std::vector<std::string> paths;
for(auto item : vfs->EnumeratePaths(path)) for(auto item : vfs->EnumeratePaths(path))
{ {
@@ -110,17 +110,17 @@ namespace Tesses::CrossLang
if(vfs->DirectoryExists(item) || vfs->RegularFileExists(item)) if(vfs->DirectoryExists(item) || vfs->RegularFileExists(item))
paths.push_back(item.GetFileName()); paths.push_back(item.GetFileName());
} }
writeInt(&ms,(uint32_t)paths.size()); writeInt(ms,(uint32_t)paths.size());
for(auto item : paths) for(auto item : paths)
{ {
writeInt(&ms,ensureString(item)); writeInt(ms,ensureString(item));
walkFS(path / item); walkFS(path / item);
} }
} }
else if(vfs->RegularFileExists(path)) else if(vfs->RegularFileExists(path))
{ {
ms.WriteByte(0); ms->WriteByte(0);
writeInt(&ms,ensureResource(path.ToString())); writeInt(ms,ensureResource(path.ToString()));
} }
}; };
@@ -166,14 +166,14 @@ namespace Tesses::CrossLang
auto strm2 = vfs->OpenFile(res,"rb"); auto strm2 = vfs->OpenFile(res,"rb");
writeInt(strm,(uint32_t)strm2->GetLength()); writeInt(strm,(uint32_t)strm2->GetLength());
strm2->CopyTo(strm); strm2->CopyTo(strm);
delete strm2;
} }
strm->WriteBlock((const uint8_t*)"ARCV",4); strm->WriteBlock((const uint8_t*)"ARCV",4);
writeInt(strm,(uint32_t)ms.GetLength()); writeInt(strm,(uint32_t)ms->GetLength());
ms.Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin); ms->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
ms.CopyTo(strm); ms->CopyTo(strm);
} }
std::pair<std::pair<std::string,TVMVersion>,std::string> CrossArchiveExtract(Tesses::Framework::Streams::Stream* strm,Tesses::Framework::Filesystem::VFS* vfs) std::pair<std::pair<std::string,TVMVersion>,std::string> CrossArchiveExtract(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs)
{ {
auto ensure = [strm](uint8_t* buffer,size_t count)->void{ auto ensure = [strm](uint8_t* buffer,size_t count)->void{
@@ -252,7 +252,7 @@ namespace Tesses::CrossLang
strm2->WriteBlock(buff,read); strm2->WriteBlock(buff,read);
offset+=read; offset+=read;
} while(read > 0); } while(read > 0);
delete strm2;
resource_id++; resource_id++;
} }

31
src/assembler/asm.cpp
View File

@@ -723,22 +723,22 @@ namespace Tesses::CrossLang {
class CodeGen2 { class CodeGen2 {
public: public:
void Write(Tesses::Framework::Streams::Stream* strm, uint8_t* buffer, size_t len) void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, uint8_t* buffer, size_t len)
{ {
strm->WriteBlock(buffer,len); strm->WriteBlock(buffer,len);
} }
void WriteInt(Tesses::Framework::Streams::Stream* strm,uint32_t v) void WriteInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint32_t v)
{ {
uint8_t buffer[4]; uint8_t buffer[4];
BitConverter::FromUint32BE(buffer[0],v); BitConverter::FromUint32BE(buffer[0],v);
Write(strm,buffer,4); Write(strm,buffer,4);
} }
void WriteString(Tesses::Framework::Streams::Stream* strm,std::string v) void WriteString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::string v)
{ {
WriteInt(strm,(uint32_t)v.size()); WriteInt(strm,(uint32_t)v.size());
Write(strm,(uint8_t*)v.data(),v.size()); Write(strm,(uint8_t*)v.data(),v.size());
} }
void Save(Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Streams::Stream* stream) void Save(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
TVMVersion runtime_version(TVM_MAJOR,TVM_MINOR,TVM_PATCH,TVM_BUILD,TVM_VERSIONSTAGE); TVMVersion runtime_version(TVM_MAJOR,TVM_MINOR,TVM_PATCH,TVM_BUILD,TVM_VERSIONSTAGE);
@@ -941,7 +941,6 @@ namespace Tesses::CrossLang {
strm->CopyTo(stream); strm->CopyTo(stream);
} }
delete strm;
} }
if(!this->icon.empty()) if(!this->icon.empty())
{ {
@@ -1085,7 +1084,7 @@ namespace Tesses::CrossLang {
Tesses::Framework::Filesystem::VFSPath Assemble(Tesses::Framework::Filesystem::VFS* vfs) Tesses::Framework::Filesystem::VFSPath Assemble(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs)
{ {
using namespace Tesses::Framework::Filesystem; using namespace Tesses::Framework::Filesystem;
using namespace Tesses::Framework::TextStreams; using namespace Tesses::Framework::TextStreams;
@@ -1104,7 +1103,7 @@ namespace Tesses::CrossLang {
else { else {
if(item.GetExtension() == ".tcasm") if(item.GetExtension() == ".tcasm")
{ {
StreamReader reader(vfs->OpenFile(item,"rb"),true); StreamReader reader(vfs->OpenFile(item,"rb"));
std::stringstream strm(reader.ReadToEnd(),std::ios_base::binary | std::ios_base::in); std::stringstream strm(reader.ReadToEnd(),std::ios_base::binary | std::ios_base::in);
Lex(item.ToString(), strm, tokens); Lex(item.ToString(), strm, tokens);
@@ -1124,7 +1123,7 @@ namespace Tesses::CrossLang {
auto confFile = VFSPath() / "crossapp.json"; auto confFile = VFSPath() / "crossapp.json";
if(vfs->FileExists(confFile)) if(vfs->FileExists(confFile))
{ {
Tesses::Framework::TextStreams::StreamReader reader(vfs->OpenFile(confFile,"rb"),true); Tesses::Framework::TextStreams::StreamReader reader(vfs->OpenFile(confFile,"rb"));
auto jobj = Json::Decode(reader.ReadToEnd()); auto jobj = Json::Decode(reader.ReadToEnd());
JObject main; JObject main;
if(TryGetJToken(jobj,main)) if(TryGetJToken(jobj,main))
@@ -1249,14 +1248,14 @@ namespace Tesses::CrossLang {
vfs->CreateDirectory(VFSPath() / "bin"); vfs->CreateDirectory(VFSPath() / "bin");
vfs->CreateDirectory(VFSPath() / "sections"); vfs->CreateDirectory(VFSPath() / "sections");
SubdirFilesystem sectionsdir(vfs,VFSPath() / "sections",false); auto sectionsdir = std::make_shared<SubdirFilesystem>(vfs,VFSPath() / "sections");
SubdirFilesystem resdir(vfs,VFSPath() / "res",false); auto resdir = std::make_shared<SubdirFilesystem>(vfs,VFSPath() / "res");
for(auto file : sectionsdir.EnumeratePaths(VFSPath())) for(auto file : sectionsdir->EnumeratePaths(VFSPath()))
{ {
if(file.GetExtension() == ".tsec" && sectionsdir.FileExists(file)) if(file.GetExtension() == ".tsec" && sectionsdir->FileExists(file))
{ {
auto strm0 = sectionsdir.OpenFile(file,"rb"); auto strm0 = sectionsdir->OpenFile(file,"rb");
int64_t len = strm0->GetLength(); int64_t len = strm0->GetLength();
if(len > 4) if(len > 4)
{ {
@@ -1269,15 +1268,15 @@ namespace Tesses::CrossLang {
strm0->ReadBlock(cg2.sections[off].second.data(), cg2.sections[off].second.size()); strm0->ReadBlock(cg2.sections[off].second.data(), cg2.sections[off].second.size());
} }
delete strm0;
} }
} }
auto strm = vfs->OpenFile(VFSPath() / "bin" / cg2.name + "-" + cg2.version.ToString() + ".crvm","wb"); auto strm = vfs->OpenFile(VFSPath() / "bin" / cg2.name + "-" + cg2.version.ToString() + ".crvm","wb");
cg2.Save(&resdir, strm); cg2.Save(resdir, strm);
delete strm;
return VFSPath() / "bin" / cg2.name + "-" + cg2.version.ToString() + ".crvm"; return VFSPath() / "bin" / cg2.name + "-" + cg2.version.ToString() + ".crvm";

14
src/assembler/disasm.cpp
View File

@@ -2,7 +2,7 @@
namespace Tesses::CrossLang { namespace Tesses::CrossLang {
class CrossLangFileReader { class CrossLangFileReader {
Tesses::Framework::Streams::Stream* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
void Ensure(uint8_t* buffer, size_t len) void Ensure(uint8_t* buffer, size_t len)
{ {
@@ -34,7 +34,7 @@ namespace Tesses::CrossLang {
} }
public: public:
CrossLangFileReader(Tesses::Framework::Streams::Stream* strm) CrossLangFileReader(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{ {
this->strm = strm; this->strm = strm;
@@ -639,7 +639,7 @@ namespace Tesses::CrossLang {
void Disassemble(Tesses::Framework::Streams::Stream* src,Tesses::Framework::Filesystem::VFS* vfs, bool generateJSON,bool extractResources) void Disassemble(std::shared_ptr<Tesses::Framework::Streams::Stream> src,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, bool generateJSON,bool extractResources)
{ {
using namespace Tesses::Framework::Filesystem; using namespace Tesses::Framework::Filesystem;
CrossLangFileReader file(src); CrossLangFileReader file(src);
@@ -653,7 +653,7 @@ namespace Tesses::CrossLang {
auto path2 = path / file.name + "-" + file.version.ToString()+"_"+ std::to_string((uint32_t)i) + ".bin"; auto path2 = path / file.name + "-" + file.version.ToString()+"_"+ std::to_string((uint32_t)i) + ".bin";
auto strm = vfs->OpenFile(path2,"wb"); auto strm = vfs->OpenFile(path2,"wb");
strm->WriteBlock(file.resources[i].data(),file.resources[i].size()); strm->WriteBlock(file.resources[i].data(),file.resources[i].size());
delete strm;
} }
std::string secdir = "sections"; std::string secdir = "sections";
@@ -670,7 +670,7 @@ namespace Tesses::CrossLang {
auto strm = vfs->OpenFile(path2,"wb"); auto strm = vfs->OpenFile(path2,"wb");
strm->WriteBlock((const uint8_t*)file.sections[i].first.data(), 4); strm->WriteBlock((const uint8_t*)file.sections[i].first.data(), 4);
strm->WriteBlock(file.sections[i].second.data(),file.sections[i].second.size()); strm->WriteBlock(file.sections[i].second.data(),file.sections[i].second.size());
delete strm;
} }
} }
@@ -812,7 +812,7 @@ namespace Tesses::CrossLang {
std::string srcdirs = "src"; std::string srcdirs = "src";
VFSPath srcdir=srcdirs; VFSPath srcdir=srcdirs;
vfs->CreateDirectory(srcdir); vfs->CreateDirectory(srcdir);
Tesses::Framework::TextStreams::StreamWriter writer(vfs->OpenFile(srcdir / file.name + "-" + file.version.ToString() + ".tcasm","wb"),true); Tesses::Framework::TextStreams::StreamWriter writer(vfs->OpenFile(srcdir / file.name + "-" + file.version.ToString() + ".tcasm","wb"));
writer.Write(srcFile); writer.Write(srcFile);
if(generateJSON) if(generateJSON)
@@ -889,7 +889,7 @@ namespace Tesses::CrossLang {
} }
Tesses::Framework::TextStreams::StreamWriter json_writer(vfs->OpenFile(VFSPath() / "crossapp.json","wb" ),true); Tesses::Framework::TextStreams::StreamWriter json_writer(vfs->OpenFile(VFSPath() / "crossapp.json","wb" ));
json_writer.WriteLine(Json::Encode(json_data,true)); json_writer.WriteLine(Json::Encode(json_data,true));
} }

20
src/assembler/merge.cpp
View File

@@ -1,9 +1,9 @@
#include "CrossLang.hpp" #include "CrossLang.hpp"
using namespace Tesses::Framework::Serialization::Json; using namespace Tesses::Framework::Serialization::Json;
namespace Tesses::CrossLang { namespace Tesses::CrossLang {
static void LoadDependency(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir, std::pair<std::string,TVMVersion> dep, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools); static void LoadDependency(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir, std::pair<std::string,TVMVersion> dep, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools);
static void LoadDependencies(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,TFile* file, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools); static void LoadDependencies(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,TFile* file, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools);
static void LoadDependency(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir, std::pair<std::string,TVMVersion> dep, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools) static void LoadDependency(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir, std::pair<std::string,TVMVersion> dep, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools)
{ {
for(auto index = files.begin(); index != files.end(); index++) for(auto index = files.begin(); index != files.end(); index++)
{ {
@@ -23,17 +23,17 @@ namespace Tesses::CrossLang {
if(srcFS->RegularFileExists(filename)) if(srcFS->RegularFileExists(filename))
{ {
Tesses::Framework::Streams::Stream* file = srcFS->OpenFile(filename,"rb"); auto file = srcFS->OpenFile(filename,"rb");
TFile f; TFile f;
f.Load(nullptr, file); f.Load(nullptr, file);
delete file;
LoadDependencies(srcFS,sourceDir,&f,files,tools); LoadDependencies(srcFS,sourceDir,&f,files,tools);
} }
else throw VMException("Could not open file: \"" + name + "\"."); else throw VMException("Could not open file: \"" + name + "\".");
} }
static void LoadDependencies(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,TFile* file, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools) static void LoadDependencies(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,TFile* file, std::vector<std::pair<std::string, TVMVersion>>& files, std::vector<std::pair<std::string, TVMVersion>>& tools)
{ {
files.push_back(std::pair<std::string,TVMVersion>(file->name,file->version)); files.push_back(std::pair<std::string,TVMVersion>(file->name,file->version));
for(auto item : file->tools) for(auto item : file->tools)
@@ -58,7 +58,7 @@ namespace Tesses::CrossLang {
LoadDependency(srcFS,sourceDir,item,files,tools); LoadDependency(srcFS,sourceDir,item,files,tools);
} }
} }
static void EnumerateCRVM(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,std::string filename, std::vector<std::pair<std::string, TVMVersion>>& files, Tesses::Framework::Filesystem::VFS* destFS) static void EnumerateCRVM(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourceDir,std::string filename, std::vector<std::pair<std::string, TVMVersion>>& files, std::shared_ptr<Tesses::Framework::Filesystem::VFS> destFS)
{ {
@@ -66,14 +66,12 @@ namespace Tesses::CrossLang {
auto strm = srcFS->OpenFile(sourceDir / filename,"rb"); auto strm = srcFS->OpenFile(sourceDir / filename,"rb");
if(strm->EndOfStream()) { if(strm->EndOfStream()) {
delete strm;
throw std::runtime_error("File does not exist: " + (sourceDir / filename).ToString() ); throw std::runtime_error("File does not exist: " + (sourceDir / filename).ToString() );
} }
file.Load(nullptr,strm); file.Load(nullptr,strm);
delete strm;
std::vector<std::pair<std::string, TVMVersion>> tools; std::vector<std::pair<std::string, TVMVersion>> tools;
LoadDependencies(srcFS,sourceDir,&file,files,tools); LoadDependencies(srcFS,sourceDir,&file,files,tools);
@@ -135,10 +133,10 @@ namespace Tesses::CrossLang {
} }
Tesses::Framework::TextStreams::StreamWriter json_writer(destFS->OpenFile(Tesses::Framework::Filesystem::VFSPath() / "crossapp.json","wb" ),true); Tesses::Framework::TextStreams::StreamWriter json_writer(destFS->OpenFile(Tesses::Framework::Filesystem::VFSPath() / "crossapp.json","wb" ));
json_writer.WriteLine(Json::Encode(json_data,true)); json_writer.WriteLine(Json::Encode(json_data,true));
} }
Tesses::Framework::Filesystem::VFSPath Merge(Tesses::Framework::Filesystem::VFS* srcFS, Tesses::Framework::Filesystem::VFSPath sourcePath, Tesses::Framework::Filesystem::VFS* destFS) Tesses::Framework::Filesystem::VFSPath Merge(std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcFS, Tesses::Framework::Filesystem::VFSPath sourcePath, std::shared_ptr<Tesses::Framework::Filesystem::VFS> destFS)
{ {
std::vector<std::pair<std::string, TVMVersion>> files; std::vector<std::pair<std::string, TVMVersion>> files;

17
src/compiler/codegen.cpp
View File

@@ -7,17 +7,17 @@
namespace Tesses::CrossLang namespace Tesses::CrossLang
{ {
void Write(Tesses::Framework::Streams::Stream* strm, uint8_t* buffer, size_t len) void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm, uint8_t* buffer, size_t len)
{ {
strm->WriteBlock(buffer,len); strm->WriteBlock(buffer,len);
} }
void WriteInt(Tesses::Framework::Streams::Stream* strm,uint32_t v) void WriteInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,uint32_t v)
{ {
uint8_t buffer[4]; uint8_t buffer[4];
BitConverter::FromUint32BE(buffer[0],v); BitConverter::FromUint32BE(buffer[0],v);
Write(strm,buffer,4); Write(strm,buffer,4);
} }
void WriteString(Tesses::Framework::Streams::Stream* strm,std::string v) void WriteString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,std::string v)
{ {
WriteInt(strm,(uint32_t)v.size()); WriteInt(strm,(uint32_t)v.size());
Write(strm,(uint8_t*)v.data(),v.size()); Write(strm,(uint8_t*)v.data(),v.size());
@@ -34,7 +34,7 @@ namespace Tesses::CrossLang
} }
void CodeGen::Save(Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Streams::Stream* stream) void CodeGen::Save(std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
TVMVersion runtime_version(TVM_MAJOR,TVM_MINOR,TVM_PATCH,TVM_BUILD,TVM_VERSIONSTAGE); TVMVersion runtime_version(TVM_MAJOR,TVM_MINOR,TVM_PATCH,TVM_BUILD,TVM_VERSIONSTAGE);
uint8_t buffer[18]; uint8_t buffer[18];
@@ -1765,10 +1765,9 @@ namespace Tesses::CrossLang
} }
ResourceFile::~ResourceFile() ResourceFile::~ResourceFile()
{ {
delete this->strm;
} }
uint32_t ResourceFile::GetLength(Tesses::Framework::Filesystem::VFS* embedFS) uint32_t ResourceFile::GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS)
{ {
if(embedFS == nullptr) return 0; if(embedFS == nullptr) return 0;
if(strm != nullptr) return strm->GetLength(); if(strm != nullptr) return strm->GetLength();
@@ -1783,17 +1782,17 @@ namespace Tesses::CrossLang
if(res != nullptr) return this->file == res->file; if(res != nullptr) return this->file == res->file;
return ResourceBase::IsEqual(base); return ResourceBase::IsEqual(base);
} }
void ResourceFile::Write(Tesses::Framework::Streams::Stream* output) void ResourceFile::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output)
{ {
if(this->strm != nullptr) if(this->strm != nullptr)
this->strm->CopyTo(output); this->strm->CopyTo(output);
} }
uint32_t ResourceByteArray::GetLength(Tesses::Framework::Filesystem::VFS* embedFS) uint32_t ResourceByteArray::GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS)
{ {
return (uint32_t)this->data.size(); return (uint32_t)this->data.size();
} }
void ResourceByteArray::Write(Tesses::Framework::Streams::Stream* output) void ResourceByteArray::Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output)
{ {
output->WriteBlock(this->data.data(),this->data.size()); output->WriteBlock(this->data.data(),this->data.size());
} }

8
src/compiler/parser.cpp
View File

@@ -718,14 +718,14 @@ namespace Tesses::CrossLang
CodeGen gen; CodeGen gen;
gen.GenRoot(n); gen.GenRoot(n);
Tesses::Framework::Streams::MemoryStream ms(true); auto ms = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
gen.Save(nullptr,&ms); gen.Save(nullptr,ms);
ms.Seek(0, Tesses::Framework::Streams::SeekOrigin::Begin); ms->Seek(0, Tesses::Framework::Streams::SeekOrigin::Begin);
TFile* f = TFile::Create(ls); TFile* f = TFile::Create(ls);
f->Load(gc,&ms); f->Load(gc,ms);
node = TObject2SyntaxNode(env->LoadFile(gc,f)); node = TObject2SyntaxNode(env->LoadFile(gc,f));
} }

11
src/crossarchivecreate.cpp
View File

@@ -74,10 +74,9 @@ int main(int argc, char** argv)
if(args.size() < 2) Help(argv[0]); if(args.size() < 2) Help(argv[0]);
LocalFilesystem fs; auto path = Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(args[0]);
auto path = fs.SystemToVFSPath(args[0]); Tesses::Framework::Filesystem::LocalFS->CreateDirectory(path);
fs.CreateDirectory(path); auto sdfs = std::make_shared<SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,path);
SubdirFilesystem sdfs(&fs,path,false);
FILE* f = fopen(args[1].c_str(),"wb"); FILE* f = fopen(args[1].c_str(),"wb");
if(f == NULL) if(f == NULL)
@@ -86,8 +85,8 @@ int main(int argc, char** argv)
return 1; return 1;
} }
FileStream strm(f,true,"wb",true); auto strm = std::make_shared<FileStream>(f,true,"wb",true);
CrossArchiveCreate(&sdfs,&strm,name,version,info,icon); CrossArchiveCreate(sdfs,strm,name,version,info,icon);
return 0; return 0;
} }

7
src/crossarchiveextract.cpp
View File

@@ -12,8 +12,7 @@ int main(int argc, char** argv)
return 1; return 1;
} }
LocalFilesystem fs; auto sdfs= std::make_shared<SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,std::string(argv[2]));
SubdirFilesystem sdfs(&fs,std::string(argv[2]),false);
FILE* f = fopen(argv[1],"rb"); FILE* f = fopen(argv[1],"rb");
if(f == NULL) if(f == NULL)
@@ -22,9 +21,9 @@ int main(int argc, char** argv)
return 1; return 1;
} }
FileStream strm(f,true,"rb",true); auto strm = std::make_shared<FileStream>(f,true,"rb",true);
auto res = CrossArchiveExtract(&strm,&sdfs); auto res = CrossArchiveExtract(strm,sdfs);
std::cout << "Crvm Name: " << res.first.first << std::endl; std::cout << "Crvm Name: " << res.first.first << std::endl;
std::cout << "Crvm Version: " << res.first.second.ToString() << std::endl; std::cout << "Crvm Version: " << res.first.second.ToString() << std::endl;

4
src/crossasmcli.cpp
View File

@@ -12,8 +12,8 @@ int main(int argc, char** argv)
return 0; return 0;
} }
auto curdir = VFSPath::GetAbsoluteCurrentDirectory(); auto curdir = VFSPath::GetAbsoluteCurrentDirectory();
SubdirFilesystem sdfs(&LocalFS,curdir,false); auto sdfs=std::make_shared<SubdirFilesystem>(LocalFS,curdir);
auto path = Assemble(&sdfs); auto path = Assemble(sdfs);
path.relative = true; path.relative = true;
std::cout << "Output: " << (curdir / path).ToString() << std::endl; std::cout << "Output: " << (curdir / path).ToString() << std::endl;

10
src/crossdisasmcli.cpp
View File

@@ -44,7 +44,7 @@ int main(int argc, char** argv)
} }
else if(curPos == 1) else if(curPos == 1)
{ {
path = LocalFS.SystemToVFSPath(argv[i]); path = LocalFS->SystemToVFSPath(argv[i]);
} }
} }
} }
@@ -52,10 +52,10 @@ int main(int argc, char** argv)
{ {
help(argv[0]); help(argv[0]);
} }
auto strm = LocalFS.OpenFile(file,"rb"); auto strm = LocalFS->OpenFile(file,"rb");
SubdirFilesystem sdir(&LocalFS,path,false); auto sdir = std::make_shared<SubdirFilesystem>(LocalFS,path);
if(strm->CanRead()) if(strm->CanRead())
Disassemble(strm, &sdir,json,resources); Disassemble(strm, sdir,json,resources);
delete strm;
return 0; return 0;
} }

29
src/crosslang.cpp
View File

@@ -6,7 +6,7 @@ using namespace Tesses::Framework;
using namespace Tesses::CrossLang; using namespace Tesses::CrossLang;
using namespace Tesses::Framework::Http; using namespace Tesses::Framework::Http;
bool Download(Tesses::Framework::Filesystem::VFSPath filename,Tesses::Framework::Filesystem::VFS* vfs) bool Download(Tesses::Framework::Filesystem::VFSPath filename,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs)
{ {
while(true) while(true)
{ {
@@ -23,7 +23,7 @@ bool Download(Tesses::Framework::Filesystem::VFSPath filename,Tesses::Framework:
{ {
auto strm = resp.ReadAsStream(); auto strm = resp.ReadAsStream();
CrossArchiveExtract(strm, vfs); CrossArchiveExtract(strm, vfs);
delete strm;
return true; return true;
} }
else else
@@ -56,14 +56,13 @@ int main(int argc, char** argv)
Tesses::Framework::Filesystem::VFSPath filename = dir / "Shell" / "Shell.crvm"; Tesses::Framework::Filesystem::VFSPath filename = dir / "Shell" / "Shell.crvm";
Tesses::Framework::Filesystem::LocalFilesystem fs;
auto p = Tesses::Framework::Platform::Environment::GetRealExecutablePath(fs.SystemToVFSPath(argv[0])).GetParent().GetParent() / "share" / "Tesses" / "CrossLang" / "Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm"; auto p = Tesses::Framework::Platform::Environment::GetRealExecutablePath(Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(argv[0])).GetParent().GetParent() / "share" / "Tesses" / "CrossLang" / "Tesses.CrossLang.ShellPackage-1.0.0.0-prod.crvm";
if(argc > 1 && strcmp(argv[1],"update-shell") == 0) if(argc > 1 && strcmp(argv[1],"update-shell") == 0)
{ {
Tesses::Framework::Filesystem::SubdirFilesystem subdir(&fs,dir,false); auto subdir = std::make_shared<Tesses::Framework::Filesystem::SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,dir);
HttpRequest req; HttpRequest req;
req.url = "https://downloads.tesses.net/ShellPackage.crvm"; req.url = "https://downloads.tesses.net/ShellPackage.crvm";
req.method = "GET"; req.method = "GET";
@@ -71,8 +70,8 @@ int main(int argc, char** argv)
if(resp.statusCode == StatusCode::OK) if(resp.statusCode == StatusCode::OK)
{ {
auto strm = resp.ReadAsStream(); auto strm = resp.ReadAsStream();
CrossArchiveExtract(strm, &subdir); CrossArchiveExtract(strm, subdir);
delete strm;
return 0; return 0;
} }
else else
@@ -83,17 +82,17 @@ int main(int argc, char** argv)
return 0; return 0;
} }
if(!fs.RegularFileExists(filename)) if(!Tesses::Framework::Filesystem::LocalFS->RegularFileExists(filename))
{ {
Tesses::Framework::Filesystem::SubdirFilesystem subdir(&fs,dir,false); auto subdir = std::make_shared<Tesses::Framework::Filesystem::SubdirFilesystem>(Tesses::Framework::Filesystem::LocalFS,dir);
if(fs.RegularFileExists(p)) if(Tesses::Framework::Filesystem::LocalFS->RegularFileExists(p))
{ {
std::cout << "Installing " << p.ToString() << " -> " << dir.ToString() << std::endl; std::cout << "Installing " << p.ToString() << " -> " << dir.ToString() << std::endl;
auto strm = fs.OpenFile(p,"rb"); auto strm = Tesses::Framework::Filesystem::LocalFS->OpenFile(p,"rb");
if(strm != nullptr) if(strm != nullptr)
{ {
CrossArchiveExtract(strm, &subdir); CrossArchiveExtract(strm, subdir);
delete strm;
} }
else else
{ {
@@ -102,7 +101,7 @@ int main(int argc, char** argv)
} }
else else
{ {
if(!Download(filename,&subdir)) return 1; if(!Download(filename,subdir)) return 1;
return 0; return 0;
} }
} }
@@ -118,7 +117,7 @@ int main(int argc, char** argv)
TStd::RegisterStd(&gc,env); TStd::RegisterStd(&gc,env);
env->LoadFileWithDependencies(&gc, &fs, filename); env->LoadFileWithDependencies(&gc, Tesses::Framework::Filesystem::LocalFS, filename);
TList* args = TList::Create(ls); TList* args = TList::Create(ls);

9
src/crosslangcompiler.cpp
View File

@@ -238,7 +238,7 @@ int main(int argc, char** argv)
TStd::RegisterIO(gc,env,false); TStd::RegisterIO(gc,env,false);
env->permissions.locked=true; env->permissions.locked=true;
auto fs = env->EnsureDictionary(gc,"FS"); auto fs = env->EnsureDictionary(gc,"FS");
fs->SetValue("Local",TVFSHeapObject::Create(ls, new SubdirFilesystem(new Tesses::Framework::Filesystem::LocalFilesystem(),Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory(),true))); fs->SetValue("Local", std::make_shared<SubdirFilesystem>(LocalFS,Tesses::Framework::Filesystem::VFSPath::GetAbsoluteCurrentDirectory()));
} }
else if(comptime == "full") else if(comptime == "full")
{ {
@@ -267,12 +267,11 @@ int main(int argc, char** argv)
std::filesystem::create_directory(outputDir); std::filesystem::create_directory(outputDir);
{ {
Tesses::Framework::Streams::FileStream strm(outputDir / (name + "-" + version.ToString() + ".crvm"),"wb"); auto strm = std::make_shared<Tesses::Framework::Streams::FileStream>(outputDir / (name + "-" + version.ToString() + ".crvm"),"wb");
LocalFilesystem fs; auto sfs = std::make_shared<SubdirFilesystem>(LocalFS,LocalFS->SystemToVFSPath(resourceDir.string()));
SubdirFilesystem sfs(&fs,fs.SystemToVFSPath(resourceDir.string()),false);
gen.Save(&sfs,&strm); gen.Save(sfs,strm);
} }
if(gc != nullptr) if(gc != nullptr)
{ {

29
src/crosslanginterperter.cpp
View File

@@ -26,22 +26,23 @@ int main(int argc, char** argv)
CodeGen gen; CodeGen gen;
gen.GenRoot(parser.ParseRoot()); gen.GenRoot(parser.ParseRoot());
std::vector<uint8_t> data; std::vector<uint8_t> data;
LocalFilesystem fs; {
SubdirFilesystem sfs(&fs,VFSPath("."),false); auto sfs = std::make_shared<SubdirFilesystem>(LocalFS,VFSPath("."));
Tesses::Framework::Streams::MemoryStream strm2(true); auto strm2 = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
gen.Save(&sfs,&strm2); gen.Save(sfs,strm2);
{ {
TFile* file = TFile::Create(ls); TFile* file = TFile::Create(ls);
strm2.Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin); strm2->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
file->Load(&gc,&strm2); file->Load(&gc,strm2);
env->LoadFile(&gc, file); env->LoadFile(&gc, file);
}
} }
TList* args = TList::Create(ls); TList* args = TList::Create(ls);
@@ -64,7 +65,7 @@ int main(int argc, char** argv)
std::string source; std::string source;
std::getline(std::cin,source); std::getline(std::cin,source);
Tesses::Framework::Streams::MemoryStream strm2(true); auto strm2 = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
if(source.find("loadfile ") == 0) if(source.find("loadfile ") == 0)
{ {
@@ -79,10 +80,9 @@ int main(int argc, char** argv)
CodeGen gen; CodeGen gen;
gen.GenRoot(parser.ParseRoot()); gen.GenRoot(parser.ParseRoot());
LocalFilesystem fs; auto sfs = std::make_shared<SubdirFilesystem>(LocalFS,VFSPath("."));
SubdirFilesystem sfs(&fs,VFSPath("."),false);
gen.Save(&sfs, &strm2); gen.Save(sfs, strm2);
} }
else if(source == "exit") else if(source == "exit")
@@ -100,18 +100,17 @@ int main(int argc, char** argv)
CodeGen gen; CodeGen gen;
gen.GenRoot(parser.ParseRoot()); gen.GenRoot(parser.ParseRoot());
LocalFilesystem fs; auto sfs = std::make_shared<SubdirFilesystem>(LocalFS,VFSPath("."));
SubdirFilesystem sfs(&fs,VFSPath("."),false);
gen.Save(&sfs,&strm2); gen.Save(sfs,strm2);
} }
{ {
TFile* file = TFile::Create(ls); TFile* file = TFile::Create(ls);
strm2.Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin); strm2->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
file->Load(&gc,&strm2); file->Load(&gc,strm2);
env->LoadFile(&gc, file); env->LoadFile(&gc, file);

4
src/crosslangvm.cpp
View File

@@ -14,9 +14,9 @@ int main(int argc, char** argv)
gc.Start(); gc.Start();
GCList ls(gc); GCList ls(gc);
TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls)); TRootEnvironment* env = TRootEnvironment::Create(ls, TDictionary::Create(ls));
Tesses::Framework::Filesystem::LocalFilesystem fs;
TStd::RegisterStd(&gc,env); TStd::RegisterStd(&gc,env);
env->LoadFileWithDependencies(&gc, &fs, fs.SystemToVFSPath(argv[1])); env->LoadFileWithDependencies(&gc, Tesses::Framework::Filesystem::LocalFS, Tesses::Framework::Filesystem::LocalFS->SystemToVFSPath(argv[1]));
TList* args = TList::Create(ls); TList* args = TList::Create(ls);
for(int arg=1;arg<argc;arg++) for(int arg=1;arg<argc;arg++)

10
src/crossmergecli.cpp
View File

@@ -28,15 +28,15 @@ int main(int argc, char** argv)
destF.MakeAbsolute(); destF.MakeAbsolute();
SubdirFilesystem sdir(&LocalFS,srcF.GetParent(),false); auto sdir = std::make_shared<SubdirFilesystem>(LocalFS,srcF.GetParent());
SubdirFilesystem ddir(&LocalFS,destF+"_tmp",false); auto ddir = std::make_shared<SubdirFilesystem>(LocalFS,destF+"_tmp");
auto outpath = Merge(&sdir,"/"+srcF.GetFileName(), &ddir); auto outpath = Merge(sdir,"/"+srcF.GetFileName(), ddir);
outpath.relative=true; outpath.relative=true;
outpath = (destF+"_tmp") / outpath; outpath = (destF+"_tmp") / outpath;
LocalFS.MoveFile(outpath,destF); LocalFS->MoveFile(outpath,destF);
LocalFS.DeleteDirectoryRecurse(destF+"_tmp"); LocalFS->DeleteDirectoryRecurse(destF+"_tmp");
return 0; return 0;

19
src/crossthumbnailer.cpp
View File

@@ -19,26 +19,24 @@ int main(int argc,char** argv)
std::string crvm = argv[1]; std::string crvm = argv[1];
std::string png = argv[2]; std::string png = argv[2];
Tesses::Framework::Filesystem::LocalFilesystem lfs;
if(lfs.FileExists(crvm)) if(Tesses::Framework::Filesystem::LocalFS->FileExists(crvm))
{ {
Tesses::CrossLang::TFile file; Tesses::CrossLang::TFile file;
auto f = lfs.OpenFile(crvm, "rb"); auto f = Tesses::Framework::Filesystem::LocalFS->OpenFile(crvm, "rb");
file.Load(nullptr,f); file.Load(nullptr,f);
delete f;
if(file.icon >= 0 && file.icon < file.resources.size()) if(file.icon >= 0 && file.icon < file.resources.size())
{ {
auto f2 = lfs.OpenFile(png, "wb"); auto f2 = Tesses::Framework::Filesystem::LocalFS->OpenFile(png, "wb");
if(f2 != nullptr) if(f2 != nullptr)
{ {
auto& icon = file.resources[file.icon]; auto& icon = file.resources[file.icon];
f2->WriteBlock(icon.data(),icon.size()); f2->WriteBlock(icon.data(),icon.size());
delete f2;
} }
return 0; return 0;
@@ -46,16 +44,15 @@ int main(int argc,char** argv)
} }
if(lfs.FileExists(emptyThumb)) if(Tesses::Framework::Filesystem::LocalFS->FileExists(emptyThumb))
{ {
auto src = lfs.OpenFile(emptyThumb,"rb"); auto src = Tesses::Framework::Filesystem::LocalFS->OpenFile(emptyThumb,"rb");
auto dest = lfs.OpenFile(png,"wb"); auto dest = Tesses::Framework::Filesystem::LocalFS->OpenFile(png,"wb");
if(src != nullptr && dest != nullptr) if(src != nullptr && dest != nullptr)
{ {
src->CopyTo(dest); src->CopyTo(dest);
} }
delete src;
delete dest;
} }
return 0; return 0;
} }

84
src/runtime_methods/console.cpp
View File

@@ -8,6 +8,7 @@
#ifdef CROSSLANG_ENABLE_TERMIOS #ifdef CROSSLANG_ENABLE_TERMIOS
#include <termios.h> #include <termios.h>
#include <sys/ioctl.h>
#endif #endif
namespace Tesses::CrossLang { namespace Tesses::CrossLang {
#ifdef CROSSLANG_ENABLE_TERMIOS #ifdef CROSSLANG_ENABLE_TERMIOS
@@ -182,16 +183,16 @@ namespace Tesses::CrossLang {
} }
TObject Console_getIn(GCList& ls, std::vector<TObject> args) 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) 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) 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) TObject Console_Clear(GCList& ls, std::vector<TObject> args)
{ {
@@ -203,6 +204,81 @@ namespace Tesses::CrossLang {
#endif #endif
return Undefined(); 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) void TStd::RegisterConsole(GC* gc,TRootEnvironment* env)
{ {
env->permissions.canRegisterConsole=true; 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,"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,"Error", "Write text \"error\" to stderr",{"error"},Console_Error);
dict->DeclareFunction(gc,"ErrorLine","Write text \"error\" to stderr",{"$error"},Console_ErrorLine); dict->DeclareFunction(gc,"ErrorLine","Write text \"error\" to stderr",{"$error"},Console_ErrorLine);
dict->DeclareFunction(gc,"ProgressBar","Draw progressbar", {}, Console_ProgressBar);
if(env->permissions.canRegisterEverything) if(env->permissions.canRegisterEverything)
dict->DeclareFunction(gc,"Fatal","Stop the program with an optional error message",{"$text"},Console_Fatal); 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,"getIn","Get stdin Stream",{},Console_getIn);
dict->DeclareFunction(gc,"getOut","Get stdout Stream",{},Console_getOut); dict->DeclareFunction(gc,"getOut","Get stdout Stream",{},Console_getOut);
dict->DeclareFunction(gc,"getError", "Get stderr Stream",{},Console_getError); dict->DeclareFunction(gc,"getError", "Get stderr Stream",{},Console_getError);
dict->DeclareFunction(gc, "getSize", "Get console size",{},Console_getSize);
gc->BarrierBegin(); gc->BarrierBegin();
env->DeclareVariable("Console", dict); env->DeclareVariable("Console", dict);
gc->BarrierEnd(); 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, "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 { 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; 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); auto ba = TByteArray::Create(ls);
ba->data = bytes; ba->data = bytes;
return ba; 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 { dict->DeclareFunction(gc, "Sha256", "Hash with sha256 algorithm",{"strm","$is224"}, [](GCList& ls, std::vector<TObject> args)->TObject {
TByteArray* baSrc; TByteArray* baSrc;
TStreamHeapObject* sho; std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
bool is224=false; bool is224=false;
GetArgument(args,1,is224); 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); auto ba = TByteArray::Create(ls);
ba->data = bytes; ba->data = bytes;
return ba; 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 { dict->DeclareFunction(gc, "Sha512", "Hash with sha512 algorithm",{"strm","$is384"}, [](GCList& ls, std::vector<TObject> args)->TObject {
TByteArray* baSrc; TByteArray* baSrc;
TStreamHeapObject* sho; std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
bool is384=false; bool is384=false;
GetArgument(args,1,is384); 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); auto ba = TByteArray::Create(ls);
ba->data = bytes; ba->data = bytes;
return ba; 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);
}
}

58
src/runtime_methods/io.cpp
View File

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

253
src/runtime_methods/net.cpp
View File

@@ -14,64 +14,32 @@ using namespace Tesses::Framework::Http;
using namespace Tesses::Framework::Mail; using namespace Tesses::Framework::Mail;
namespace Tesses::CrossLang 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; std::string text;
TByteArray* ba; TByteArray* ba;
TStreamHeapObject* sho; std::shared_ptr<Tesses::Framework::Streams::Stream> sho;
if(GetObject(obj,text)) if(GetObject(obj,text))
{ {
body = new SMTPStringBody(text,mimeType); body = std::make_shared<SMTPStringBody>(text,mimeType);
} }
else if(GetObjectHeap(obj,ba)) { 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->WriteBlock(ba->data.data(), ba->data.size());
ms->Seek(0L, SeekOrigin::Begin); 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); ls.Add(sho);
body = new SMTPStreamBody(mimeType,sho->stream,false); body = std::make_shared<SMTPStreamBody>(mimeType,sho);
} }
return body; 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 { class TNativeObjectThatReturnsHttpDictionary : public TNativeObject {
public: public:
virtual bool IsAvailable()=0; 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 == "getQueryParams") return TNativeObject::Create<THttpDictionary>(ls, &ctx->queryParams,this);
else if(key == "getRequestHeaders") return TNativeObject::Create<THttpDictionary>(ls, &ctx->requestHeaders,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 == "getResponseHeaders") return TNativeObject::Create<THttpDictionary>(ls, &ctx->responseHeaders,this);
else if(key == "GetStream") return TStreamHeapObject::Create(ls, &ctx->GetStream()); else if(key == "GetStream") return ctx->GetStream();
else if(key == "OpenRequestStream") return TStreamHeapObject::Create(ls, ctx->OpenRequestStream()); else if(key == "OpenRequestStream") return ctx->OpenRequestStream();
else if(key == "OpenResponseStream") return TStreamHeapObject::Create(ls, ctx->OpenResponseStream()); else if(key == "OpenResponseStream") return ctx->OpenResponseStream();
else if(key == "ParseFormData") else if(key == "ParseFormData")
{ {
TCallable* callable; TCallable* callable;
TVFSHeapObject* vfsHeapObject; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgumentHeap(args, 0, callable)) 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}); 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; int i = 1;
std::vector<TObject> response; 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"; std::string realFileName = "/" + std::to_string(i) + ".bin";
i++; i++;
response.push_back(TDictionary::Create(ls,{ response.push_back(TDictionary::Create(ls,{
@@ -322,7 +295,7 @@ namespace Tesses::CrossLang
TDItem("Name", name) TDItem("Name", name)
})); }));
auto strm = vfsHeapObject->vfs->OpenFile(realFileName,"wb"); auto strm = vfs->OpenFile(realFileName,"wb");
return strm; return strm;
@@ -334,10 +307,10 @@ namespace Tesses::CrossLang
else if(key == "getNeedToParseFormData") return ctx->NeedToParseFormData(); else if(key == "getNeedToParseFormData") return ctx->NeedToParseFormData();
else if(key == "ReadString") return ctx->ReadString(); else if(key == "ReadString") return ctx->ReadString();
else if(key == "ReadStream") { else if(key == "ReadStream") {
Tesses::CrossLang::TStreamHeapObject* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgumentHeap(args,0,strm)) if(GetArgument(args,0,strm))
{ {
ctx->ReadStream(strm->stream); ctx->ReadStream(strm);
} }
} }
else if(key == "ReadJson") else if(key == "ReadJson")
@@ -397,9 +370,9 @@ namespace Tesses::CrossLang
} }
else if(key == "SendStream") else if(key == "SendStream")
{ {
TStreamHeapObject* strmHeapObj; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgumentHeap(args,0,strmHeapObj)) if(GetArgument(args,0,strm))
ctx->SendStream(strmHeapObj->stream); ctx->SendStream(strm);
} }
else if(key == "SendBytes") else if(key == "SendBytes")
@@ -552,12 +525,12 @@ namespace Tesses::CrossLang
req->CallMethod(ls,"HandleHeaders",{res}); req->CallMethod(ls,"HandleHeaders",{res});
dummy->Close(); dummy->Close();
} }
void Write(Tesses::Framework::Streams::Stream* strm) void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> strm)
{ {
GCList ls(gc); GCList ls(gc);
auto res=TStreamHeapObject::Create(ls,strm);
req->CallMethod(ls,"Write",{res}); req->CallMethod(ls,"Write",{strm});
res->stream=nullptr;
} }
~TDictionaryHttpRequestBody() ~TDictionaryHttpRequestBody()
@@ -571,7 +544,6 @@ namespace Tesses::CrossLang
{ {
TCallable* callable; TCallable* callable;
TDictionary* dict; TDictionary* dict;
TServerHeapObject* server;
TClassObject* clsObj; TClassObject* clsObj;
if(GetObjectHeap<TCallable*>(this->obj,callable)) 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; return false;
} }
@@ -678,7 +646,7 @@ namespace Tesses::CrossLang
bool datagram; bool datagram;
if(GetArgument(args,0,ipv6) && GetArgument(args,1,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; return nullptr;
} }
@@ -686,13 +654,13 @@ namespace Tesses::CrossLang
{ {
HttpServer* server; HttpServer* server;
public: 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() std::string TypeName()
{ {
@@ -722,15 +690,25 @@ namespace Tesses::CrossLang
{ {
bool printIPs=true; bool printIPs=true;
GetArgument(args,2,printIPs); GetArgument(args,2,printIPs);
TObjectHttpServer* httpServer = new TObjectHttpServer(ls.GetGC(),args[0]);
std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
if(httpSvr) {
uint16_t p = (uint16_t)port; uint16_t p = (uint16_t)port;
return TNativeObject::Create<HttpServerNativeObject>(ls,port,httpServer,printIPs); return TNativeObject::Create<HttpServerNativeObject>(ls,port,httpSvr,printIPs);
} }
}
if(GetArgument(args,1,pathStr) && env->permissions.canRegisterLocalFS) 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; return nullptr;
@@ -740,27 +718,31 @@ namespace Tesses::CrossLang
int64_t port; int64_t port;
if(GetArgument(args,1,port)) if(GetArgument(args,1,port))
{ {
TObjectHttpServer httpServer(ls.GetGC(),args[0]); std::shared_ptr<IHttpServer> httpSvr = ToHttpServer(ls.GetGC(),args[0]);
if(httpSvr) {
uint16_t p = (uint16_t)port; uint16_t p = (uint16_t)port;
HttpServer server(p,httpServer); HttpServer server(p,httpSvr);
server.StartAccepting(); server.StartAccepting();
Tesses::Framework::TF_RunEventLoop(); Tesses::Framework::TF_RunEventLoop();
} }
}
return nullptr; return nullptr;
} }
static TObject Net_Http_ListenOnUnusedPort(GCList& ls, std::vector<TObject> args) static TObject Net_Http_ListenOnUnusedPort(GCList& ls, std::vector<TObject> args)
{ {
if(args.size() > 0) if(args.empty()) return nullptr;
{ std::shared_ptr<IHttpServer> httpSvr=ToHttpServer(ls.GetGC(),args.front());
TObjectHttpServer httpServer(ls.GetGC(),args[0]); if(httpSvr) {
uint16_t p = 0;
HttpServer server(p,httpSvr);
uint16_t port=0;
HttpServer server(port,httpServer, false);
std::cout << "Port: " << server.GetPort() << std::endl; std::cout << "Port: " << server.GetPort() << std::endl;
server.StartAccepting(); server.StartAccepting();
Tesses::Framework::TF_RunEventLoop(); Tesses::Framework::TF_RunEventLoop();
} }
return nullptr; return nullptr;
} }
static TObject Net_Http_MimeType(GCList& ls, std::vector<TObject> args) static TObject Net_Http_MimeType(GCList& ls, std::vector<TObject> args)
@@ -840,10 +822,10 @@ namespace Tesses::CrossLang
else if(key == "CopyToStream") else if(key == "CopyToStream")
{ {
TStreamHeapObject* strm; std::shared_ptr<Stream> strm;
if(GetArgumentHeap(args,0,strm)) if(GetArgument(args,0,strm))
{ {
response->CopyToStream(strm->stream); response->CopyToStream(strm);
} }
} }
else if(key == "ReadAsString") else if(key == "ReadAsString")
@@ -856,10 +838,9 @@ namespace Tesses::CrossLang
} }
else if(key == "ReadAsStream") 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") else if(key == "getStatusCode")
{ {
@@ -1018,9 +999,9 @@ namespace Tesses::CrossLang
ls.GetGC()->BarrierBegin(); ls.GetGC()->BarrierBegin();
auto server = dict->GetValue("server"); auto server = dict->GetValue("server");
TDictionary* dict2; TDictionary* dict2;
Tesses::Framework::Streams::Stream* strm=nullptr; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
bool ownsStream=true; bool ownsStream=true;
TStreamHeapObject* objStrm; std::shared_ptr<Stream> objStrm;
if(GetObjectHeap(server,dict2)) if(GetObjectHeap(server,dict2))
{ {
auto tlsO = dict2->GetValue("tls"); auto tlsO = dict2->GetValue("tls");
@@ -1034,19 +1015,19 @@ namespace Tesses::CrossLang
if(!GetObject(portO, port)) port = tls ? 465 : 25; if(!GetObject(portO, port)) port = tls ? 465 : 25;
GetObject(hostO,host); 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) 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; 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"); auto o = dict->GetValue("domain");
GetObject(o,client.domain); GetObject(o,client.domain);
@@ -1097,7 +1078,7 @@ namespace Tesses::CrossLang
GetObject(o,type); GetObject(o,type);
o = dict2->GetValue("data"); 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); 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()); GCList ls2(ls.GetGC());
dict->CallMethod(ls2,"Open",{ dict->CallMethod(ls2,"Open",{
TExternalMethod::Create(ls2,"Send a message",{"messageTextOrByteArray"},[sendMessage](GCList& ls,std::vector<TObject> args)->TObject{ 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()); GCList ls2(ls.GetGC());
co->CallMethod(ls2,"","Open",{ co->CallMethod(ls2,"","Open",{
TExternalMethod::Create(ls2,"Send a message",{"messageTextOrByteArray"},[sendMessage](GCList& ls,std::vector<TObject> args)->TObject{ 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) static TObject Net_Http_DownloadToStream(GCList& ls, std::vector<TObject> args)
{ {
std::string url; std::string url;
TStreamHeapObject* strm; std::shared_ptr<Stream> strm;
if(GetArgument(args,0,url) && GetArgumentHeap(args,1,strm)) if(GetArgument(args,0,url) && GetArgument(args,1,strm))
{ {
DownloadToStreamSimple(url,strm->stream); DownloadToStreamSimple(url,strm);
} }
return nullptr; return nullptr;
} }
static TObject Net_Http_DownloadToFile(GCList& ls, std::vector<TObject> args) static TObject Net_Http_DownloadToFile(GCList& ls, std::vector<TObject> args)
{ {
std::string url; std::string url;
TVFSHeapObject* vfs; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
Tesses::Framework::Filesystem::VFSPath path; 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; return nullptr;
} }
bool TServerHeapObject::Handle(std::vector<TObject> args) bool IHttpServer_Handle(std::shared_ptr<IHttpServer> svr,std::vector<TObject>& args)
{ {
TServerContext* ctx; 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; 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) 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, "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 { 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; 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; 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, "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); http->DeclareFunction(gc, "ListenOnUnusedPort","Listen on unused localhost port and print Port: theport",{"server"},Net_Http_ListenOnUnusedPort);
//FileServer svr() //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 allowlisting;
bool spa; 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 std::make_shared<FileServer>(vfs,allowlisting,spa);
return TServerHeapObject::Create(ls,fserver);
} }
return nullptr; 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{ 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 svr = std::make_shared<TObjectHttpServer>(ls.GetGC(), dict);
auto svr2 = new MountableServer(svr,true); 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; return nullptr;
}); });

6
src/runtime_methods/process.cpp
View File

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

130
src/runtime_methods/std.cpp
View File

@@ -844,14 +844,14 @@ namespace Tesses::CrossLang
static TObject TypeIsStream(GCList& ls, std::vector<TObject> args) static TObject TypeIsStream(GCList& ls, std::vector<TObject> args)
{ {
if(args.empty()) return nullptr; if(args.empty()) return nullptr;
TStreamHeapObject* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
return GetArgumentHeap(args,0,strm); return GetArgument(args,0,strm);
} }
static TObject TypeIsVFS(GCList& ls, std::vector<TObject> args) static TObject TypeIsVFS(GCList& ls, std::vector<TObject> args)
{ {
if(args.empty()) return nullptr; if(args.empty()) return nullptr;
TVFSHeapObject* vfs; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
return GetArgumentHeap(args,0,vfs); return GetArgument(args,0,vfs);
} }
static TObject TypeIsDateTime(GCList& ls, std::vector<TObject> args) 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) 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; 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; return nullptr;
} }
static TObject New_MountableFilesystem(GCList& ls, std::vector<TObject> args) 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; return nullptr;
} }
@@ -887,13 +887,13 @@ namespace Tesses::CrossLang
bool writable; bool writable;
if(GetArgument(args,0,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; return nullptr;
} }
static TObject New_MemoryFilesystem(GCList& ls, std::vector<TObject> args) 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) static TObject New_Filesystem(GCList& ls, std::vector<TObject> args)
@@ -901,7 +901,7 @@ namespace Tesses::CrossLang
TDictionary* dict; TDictionary* dict;
if(GetArgumentHeap(args,0,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; return nullptr;
} }
@@ -910,7 +910,7 @@ namespace Tesses::CrossLang
TDictionary* dict; TDictionary* dict;
if(GetArgumentHeap(args,0,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; return nullptr;
} }
@@ -960,6 +960,62 @@ namespace Tesses::CrossLang
if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(_obj)) return "Path"; if(std::holds_alternative<Tesses::Framework::Filesystem::VFSPath>(_obj)) return "Path";
if(std::holds_alternative<TDateTime>(_obj)) return "DateTime"; 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)) if(std::holds_alternative<THeapObjectHolder>(_obj))
{ {
auto obj = std::get<THeapObjectHolder>(_obj).obj; auto obj = std::get<THeapObjectHolder>(_obj).obj;
@@ -974,9 +1030,7 @@ namespace Tesses::CrossLang
auto byteArray = dynamic_cast<TByteArray*>(obj); auto byteArray = dynamic_cast<TByteArray*>(obj);
auto native = dynamic_cast<TNative*>(obj); auto native = dynamic_cast<TNative*>(obj);
auto any = dynamic_cast<TAny*>(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 cse = dynamic_cast<CallStackEntry*>(obj);
auto rootEnv = dynamic_cast<TRootEnvironment*>(obj); auto rootEnv = dynamic_cast<TRootEnvironment*>(obj);
auto subEnv = dynamic_cast<TSubEnvironment*>(obj); auto subEnv = dynamic_cast<TSubEnvironment*>(obj);
@@ -995,46 +1049,7 @@ namespace Tesses::CrossLang
if(dynList != nullptr) return "DynamicList"; if(dynList != nullptr) return "DynamicList";
if(aarray != nullptr) return "AssociativeArray"; if(aarray != nullptr) return "AssociativeArray";
if(natObj != nullptr) return natObj->TypeName(); 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(dict != nullptr) return "Dictionary";
if(list != nullptr) return "List"; if(list != nullptr) return "List";
if(argWrapper != nullptr) return "ArgWrapper"; if(argWrapper != nullptr) return "ArgWrapper";
@@ -1221,6 +1236,7 @@ namespace Tesses::CrossLang
gc->BarrierBegin(); gc->BarrierBegin();
env->permissions.canRegisterRoot=true; env->permissions.canRegisterRoot=true;
RegisterHelpers(gc,env);
auto date =env->EnsureDictionary(gc,"DateTime"); 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); 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, "MountableFilesystem","Create a mountable filesystem",{"root"}, New_MountableFilesystem);
newTypes->DeclareFunction(gc, "SubdirFilesystem","Create a subdir filesystem",{"fs","subdir"}, New_SubdirFilesystem); 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, "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, "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); 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::vector<std::pair<std::string,TVMVersion>> tools;
std::string info; std::string info;
std::string icon; std::string icon;
TVFSHeapObject* vfsHO =nullptr; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
ls.GetGC()->BarrierBegin(); ls.GetGC()->BarrierBegin();
TObject _name = dict->GetValue("Name"); TObject _name = dict->GetValue("Name");
@@ -252,7 +252,7 @@ namespace Tesses::CrossLang
GetObject<std::string>(_name,name); GetObject<std::string>(_name,name);
GetObject<std::string>(_info,info); GetObject<std::string>(_info,info);
GetObject<std::string>(_icon,icon); GetObject<std::string>(_icon,icon);
GetObjectHeap(_resourceFileSystem, vfsHO); GetObject(_resourceFileSystem, vfs);
GetObjectHeap(_comptime,comptimeEnv); GetObjectHeap(_comptime,comptimeEnv);
std::string v2; std::string v2;
if(GetObject<std::string>(_version,v2)) if(GetObject<std::string>(_version,v2))
@@ -362,10 +362,10 @@ namespace Tesses::CrossLang
gen.version = version; gen.version = version;
gen.icon = icon; gen.icon = icon;
std::string outpath; std::string outpath;
TStreamHeapObject* stream; std::shared_ptr<Tesses::Framework::Streams::Stream> stream;
if(GetObjectHeap<TStreamHeapObject*>(_out, 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{ dict->DeclareFunction(gc, "LoadExecutable", "Load a crossvm executable",{"stream"},[](GCList& ls,std::vector<TObject> args)->TObject{
TStreamHeapObject* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetArgumentHeap(args,0,strm)) if(GetArgument(args,0,strm))
{ {
TFile* f =TFile::Create(ls); TFile* f =TFile::Create(ls);
f->Load(ls.GetGC(),strm->stream); f->Load(ls.GetGC(),strm);
return f; return f;
} }
return nullptr; return nullptr;
@@ -431,30 +431,30 @@ namespace Tesses::CrossLang
return Undefined(); return Undefined();
}); });
dict->DeclareFunction(gc, "Merge", "Merge crvm files", {"srcVFS","sourcePath","destVFS"},[](GCList& ls, std::vector<TObject> args)->TObject { dict->DeclareFunction(gc, "Merge", "Merge crvm files", {"srcVFS","sourcePath","destVFS"},[](GCList& ls, std::vector<TObject> args)->TObject {
TVFSHeapObject* srcVFS; std::shared_ptr<Tesses::Framework::Filesystem::VFS> srcVFS;
TVFSHeapObject* destVFS; std::shared_ptr<Tesses::Framework::Filesystem::VFS> destVFS;
Tesses::Framework::Filesystem::VFSPath sourcePath; Tesses::Framework::Filesystem::VFSPath sourcePath;
if(GetArgumentHeap(args,0, srcVFS) && GetArgumentAsPath(args,1,sourcePath) && GetArgumentHeap(args,2,destVFS)) if(GetArgument(args,0, srcVFS) && GetArgumentAsPath(args,1,sourcePath) && GetArgument(args,2,destVFS))
return Merge(srcVFS->vfs, sourcePath, destVFS->vfs); return Merge(srcVFS, sourcePath, destVFS);
return Undefined(); return Undefined();
}); });
dict->DeclareFunction(gc, "Disassemble","Disassemble crvm file",{"strm","vfs","$generateJSON","$extractResources"},[](GCList& ls, std::vector<TObject> args)->TObject { dict->DeclareFunction(gc, "Disassemble","Disassemble crvm file",{"strm","vfs","$generateJSON","$extractResources"},[](GCList& ls, std::vector<TObject> args)->TObject {
TStreamHeapObject* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
TVFSHeapObject* vfs; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
bool generateJSON=true; bool generateJSON=true;
bool extractResources=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,2,generateJSON);
GetArgument(args,3,extractResources); GetArgument(args,3,extractResources);
Disassemble(strm->stream,vfs->vfs, generateJSON, extractResources); Disassemble(strm,vfs, generateJSON, extractResources);
} }
return Undefined(); return Undefined();
}); });
dict->DeclareFunction(gc, "Assemble", "Assemble crvm file",{"vfs"},[](GCList& ls, std::vector<TObject> args)->TObject { dict->DeclareFunction(gc, "Assemble", "Assemble crvm file",{"vfs"},[](GCList& ls, std::vector<TObject> args)->TObject {
TVFSHeapObject* vfs; std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs;
if(GetArgumentHeap(args,0, vfs)) if(GetArgument(args,0, vfs))
return Assemble(vfs->vfs); return Assemble(vfs);
return Undefined(); return Undefined();
}); });

26
src/types/rootenvironment.cpp
View File

@@ -65,7 +65,7 @@ namespace Tesses::CrossLang {
return value; return value;
} }
void TRootEnvironment::LoadDependency(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, std::pair<std::string,TVMVersion> dep) void TRootEnvironment::LoadDependency(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, std::pair<std::string,TVMVersion> dep)
{ {
for(auto item : this->dependencies) for(auto item : this->dependencies)
if(item.first == dep.first && item.second.CompareTo(dep.second) >= 0) return; if(item.first == dep.first && item.second.CompareTo(dep.second) >= 0) return;
@@ -78,11 +78,11 @@ namespace Tesses::CrossLang {
if(vfs->RegularFileExists(filename)) if(vfs->RegularFileExists(filename))
{ {
Tesses::Framework::Streams::Stream* file = vfs->OpenFile(filename,"rb"); auto file = vfs->OpenFile(filename,"rb");
GCList ls(gc); GCList ls(gc);
TFile* f = TFile::Create(ls); TFile* f = TFile::Create(ls);
f->Load(gc, file); f->Load(gc, file);
delete file;
LoadFileWithDependencies(gc, vfs, f); LoadFileWithDependencies(gc, vfs, f);
} }
else throw VMException("Could not open file: \"" + name + "\"."); else throw VMException("Could not open file: \"" + name + "\".");
@@ -100,11 +100,11 @@ namespace Tesses::CrossLang {
SyntaxNode n = parser.ParseRoot(); SyntaxNode n = parser.ParseRoot();
CodeGen gen; CodeGen gen;
gen.GenRoot(n); gen.GenRoot(n);
Tesses::Framework::Streams::MemoryStream ms(true); auto ms = std::make_shared<Tesses::Framework::Streams::MemoryStream>(true);
gen.Save(nullptr, &ms); gen.Save(nullptr, ms);
ms.Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin); ms->Seek(0,Tesses::Framework::Streams::SeekOrigin::Begin);
TFile* f = TFile::Create(ls); TFile* f = TFile::Create(ls);
f->Load(ls.GetGC(),&ms); f->Load(ls.GetGC(),ms);
return this->LoadFile(ls.GetGC(), f); return this->LoadFile(ls.GetGC(), f);
} }
TDictionary* TEnvironment::EnsureDictionary(GC* gc, std::string key) TDictionary* TEnvironment::EnsureDictionary(GC* gc, std::string key)
@@ -241,7 +241,7 @@ namespace Tesses::CrossLang {
} }
return nullptr; return nullptr;
} }
void TRootEnvironment::LoadFileWithDependencies(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, TFile* file) void TRootEnvironment::LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile* file)
{ {
this->dependencies.push_back(std::pair<std::string,TVMVersion>(file->name,file->version)); this->dependencies.push_back(std::pair<std::string,TVMVersion>(file->name,file->version));
for(auto item : file->dependencies) for(auto item : file->dependencies)
@@ -251,19 +251,19 @@ namespace Tesses::CrossLang {
LoadFile(gc, file); LoadFile(gc, file);
} }
void TRootEnvironment::LoadFileWithDependencies(GC* gc,Tesses::Framework::Filesystem::VFS* vfs, Tesses::Framework::Filesystem::VFSPath path) void TRootEnvironment::LoadFileWithDependencies(GC* gc,std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, Tesses::Framework::Filesystem::VFSPath path)
{ {
if(vfs->RegularFileExists(path)) if(vfs->RegularFileExists(path))
{ {
Tesses::Framework::Streams::Stream* file=vfs->OpenFile(path,"rb"); auto file=vfs->OpenFile(path,"rb");
GCList ls(gc); GCList ls(gc);
TFile* f = TFile::Create(ls); TFile* f = TFile::Create(ls);
f->Load(gc, file); f->Load(gc, file);
delete file;
Tesses::Framework::Filesystem::SubdirFilesystem dir(vfs,path.GetParent(),false); auto dir = std::make_shared<Tesses::Framework::Filesystem::SubdirFilesystem>(vfs,path.GetParent());
LoadFileWithDependencies(gc,&dir,f); LoadFileWithDependencies(gc,dir,f);
} }
else throw VMException("Could not open file: \"" + path.GetFileName() + "\"."); else throw VMException("Could not open file: \"" + path.GetFileName() + "\".");

93
src/types/streamheapobject.cpp
View File

@@ -70,23 +70,18 @@ namespace Tesses::CrossLang
bool TObjectStream::EndOfStream() bool TObjectStream::EndOfStream()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getEndOfStream",{}); auto res = dict->CallMethod(*ls, "getEndOfStream",{});
bool r; bool r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->EndOfStream();
}
return false; return false;
} }
size_t TObjectStream::Read(uint8_t* buff, size_t sz) size_t TObjectStream::Read(uint8_t* buff, size_t sz)
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls2(this->ls->GetGC()); GCList ls2(this->ls->GetGC());
@@ -101,16 +96,11 @@ namespace Tesses::CrossLang
int64_t r; int64_t r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->Read(buff,sz);
}
return 0; return 0;
} }
size_t TObjectStream::Write(const uint8_t* buff, size_t sz) size_t TObjectStream::Write(const uint8_t* buff, size_t sz)
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls2(this->ls->GetGC()); GCList ls2(this->ls->GetGC());
@@ -123,124 +113,92 @@ namespace Tesses::CrossLang
int64_t r; int64_t r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->Write(buff,sz);
}
return 0; return 0;
} }
bool TObjectStream::CanRead() bool TObjectStream::CanRead()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getCanRead",{}); auto res = dict->CallMethod(*ls, "getCanRead",{});
bool r; bool r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->CanRead();
}
return false; return false;
} }
bool TObjectStream::CanWrite() bool TObjectStream::CanWrite()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getCanWrite",{}); auto res = dict->CallMethod(*ls, "getCanWrite",{});
bool r; bool r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->CanWrite();
}
return false; return false;
} }
bool TObjectStream::CanSeek() bool TObjectStream::CanSeek()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getCanSeek",{}); auto res = dict->CallMethod(*ls, "getCanSeek",{});
bool r; bool r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->CanSeek();
}
return false; return false;
} }
int64_t TObjectStream::GetPosition() int64_t TObjectStream::GetPosition()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getPosition",{}); auto res = dict->CallMethod(*ls, "getPosition",{});
int64_t r; int64_t r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->GetPosition();
}
return 0; return 0;
} }
int64_t TObjectStream::GetLength() int64_t TObjectStream::GetLength()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
auto res = dict->CallMethod(*ls, "getEndOfStream",{}); auto res = dict->CallMethod(*ls, "getEndOfStream",{});
bool r; bool r;
if(GetObject(res,r)) return r; if(GetObject(res,r)) return r;
} }
else if(GetObjectHeap(this->obj, strm))
{
return strm->stream->GetLength();
}
return Tesses::Framework::Streams::Stream::GetLength(); return Tesses::Framework::Streams::Stream::GetLength();
} }
void TObjectStream::Flush() void TObjectStream::Flush()
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
dict->CallMethod(*ls, "Flush",{}); dict->CallMethod(*ls, "Flush",{});
} }
else if(GetObjectHeap(this->obj, strm))
{
strm->stream->Flush();
}
} }
void TObjectStream::Seek(int64_t pos, Tesses::Framework::Streams::SeekOrigin whence) void TObjectStream::Seek(int64_t pos, Tesses::Framework::Streams::SeekOrigin whence)
{ {
TDictionary* dict; TDictionary* dict;
TStreamHeapObject* strm;
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
dict->CallMethod(*ls, "Seek",{pos,(int64_t)(whence == Tesses::Framework::Streams::SeekOrigin::Begin ? 0 : whence == Tesses::Framework::Streams::SeekOrigin::Current ? 1 : 2) }); dict->CallMethod(*ls, "Seek",{pos,(int64_t)(whence == Tesses::Framework::Streams::SeekOrigin::Begin ? 0 : whence == Tesses::Framework::Streams::SeekOrigin::Current ? 1 : 2) });
} }
else if(GetObjectHeap(this->obj, strm))
{
strm->stream->Seek(pos,whence);
}
} }
TObjectStream::~TObjectStream() TObjectStream::~TObjectStream()
{ {
@@ -248,37 +206,6 @@ namespace Tesses::CrossLang
} }
TStreamHeapObject* TStreamHeapObject::Create(GCList& ls, Tesses::Framework::Streams::Stream* strm)
{
TStreamHeapObject* heapObj = new TStreamHeapObject();
GC* _gc = ls.GetGC();
ls.Add(heapObj);
_gc->Watch(heapObj);
heapObj->stream = strm;
return heapObj;
}
TStreamHeapObject* TStreamHeapObject::Create(GCList* ls, Tesses::Framework::Streams::Stream* strm)
{
TStreamHeapObject* heapObj = new TStreamHeapObject();
GC* _gc = ls->GetGC();
ls->Add(heapObj);
_gc->Watch(heapObj);
heapObj->stream = strm;
return heapObj;
}
TStreamHeapObject::~TStreamHeapObject()
{
if(this->stream != nullptr)
{
delete this->stream;
}
}
void TStreamHeapObject::Close()
{
if(this->stream != nullptr)
{
delete this->stream;
this->stream = nullptr;
}
}
} }

186
src/types/vfsheapobject.cpp
View File

@@ -131,34 +131,26 @@ namespace Tesses::CrossLang {
} }
} }
Tesses::Framework::Streams::Stream* TObjectVFS::OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode) std::shared_ptr<Tesses::Framework::Streams::Stream> TObjectVFS::OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->OpenFile(path,mode);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
auto res = dict->CallMethod(ls, "OpenFile",{path,mode}); auto res = dict->CallMethod(ls, "OpenFile",{path,mode});
TStreamHeapObject* strm; std::shared_ptr<Tesses::Framework::Streams::Stream> strm;
if(GetObjectHeap(res,strm)) if(GetObject(res,strm))
{ {
return new TObjectStream(this->ls->GetGC(), strm); return strm;
} }
} }
return nullptr; return nullptr;
} }
void TObjectVFS::CreateDirectory(Tesses::Framework::Filesystem::VFSPath path) void TObjectVFS::CreateDirectory(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->CreateDirectory(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -169,12 +161,7 @@ namespace Tesses::CrossLang {
} }
void TObjectVFS::DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path) void TObjectVFS::DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->DeleteDirectory(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -185,12 +172,7 @@ namespace Tesses::CrossLang {
bool TObjectVFS::RegularFileExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::RegularFileExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->RegularFileExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -206,12 +188,8 @@ namespace Tesses::CrossLang {
bool TObjectVFS::SymlinkExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::SymlinkExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->SymlinkExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -226,12 +204,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::CharacterDeviceExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::CharacterDeviceExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->CharacterDeviceExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -246,12 +220,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::BlockDeviceExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::BlockDeviceExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->BlockDeviceExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -266,12 +236,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::SocketFileExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::SocketFileExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->SocketFileExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -286,12 +252,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::FIFOFileExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::FIFOFileExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->FIFOFileExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -306,12 +268,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::FileExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::FileExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->FileExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -326,12 +284,8 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::SpecialFileExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::SpecialFileExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->SpecialFileExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -346,12 +300,8 @@ namespace Tesses::CrossLang {
} }
void TObjectVFS::CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile) void TObjectVFS::CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath symlinkFile)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->CreateSymlink(existingFile,symlinkFile);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -361,12 +311,8 @@ namespace Tesses::CrossLang {
} }
void TObjectVFS::CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath newName) void TObjectVFS::CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile, Tesses::Framework::Filesystem::VFSPath newName)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->CreateHardlink(existingFile,newName);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -376,12 +322,7 @@ namespace Tesses::CrossLang {
} }
bool TObjectVFS::DirectoryExists(Tesses::Framework::Filesystem::VFSPath path) bool TObjectVFS::DirectoryExists(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->DirectoryExists(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -396,12 +337,8 @@ namespace Tesses::CrossLang {
} }
void TObjectVFS::DeleteFile(Tesses::Framework::Filesystem::VFSPath path) void TObjectVFS::DeleteFile(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->DeleteFile(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -411,12 +348,8 @@ namespace Tesses::CrossLang {
} }
void TObjectVFS::DeleteDirectoryRecurse(Tesses::Framework::Filesystem::VFSPath path) void TObjectVFS::DeleteDirectoryRecurse(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->DeleteDirectoryRecurse(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -426,12 +359,8 @@ namespace Tesses::CrossLang {
} }
Tesses::Framework::Filesystem::VFSPathEnumerator TObjectVFS::EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path) Tesses::Framework::Filesystem::VFSPathEnumerator TObjectVFS::EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->EnumeratePaths(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList* ls=new GCList(this->ls->GetGC()); GCList* ls=new GCList(this->ls->GetGC());
@@ -465,12 +394,8 @@ namespace Tesses::CrossLang {
void TObjectVFS::MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest) void TObjectVFS::MoveFile(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->MoveFile(src,dest);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -481,12 +406,8 @@ namespace Tesses::CrossLang {
void TObjectVFS::MoveDirectory(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest) void TObjectVFS::MoveDirectory(Tesses::Framework::Filesystem::VFSPath src, Tesses::Framework::Filesystem::VFSPath dest)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->MoveDirectory(src,dest);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -497,12 +418,7 @@ namespace Tesses::CrossLang {
Tesses::Framework::Filesystem::VFSPath TObjectVFS::ReadLink(Tesses::Framework::Filesystem::VFSPath path) Tesses::Framework::Filesystem::VFSPath TObjectVFS::ReadLink(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->ReadLink(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -518,12 +434,8 @@ namespace Tesses::CrossLang {
std::string TObjectVFS::VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path) std::string TObjectVFS::VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->VFSPathToSystem(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -538,12 +450,8 @@ namespace Tesses::CrossLang {
} }
Tesses::Framework::Filesystem::VFSPath TObjectVFS::SystemToVFSPath(std::string path) Tesses::Framework::Filesystem::VFSPath TObjectVFS::SystemToVFSPath(std::string path)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
return vfs->vfs->SystemToVFSPath(path);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -559,12 +467,7 @@ namespace Tesses::CrossLang {
void TObjectVFS::GetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime& lastWrite, Tesses::Framework::Date::DateTime& lastAccess) void TObjectVFS::GetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime& lastWrite, Tesses::Framework::Date::DateTime& lastAccess)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->GetDate(path,lastWrite,lastAccess);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -589,12 +492,8 @@ namespace Tesses::CrossLang {
void TObjectVFS::SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess) void TObjectVFS::SetDate(Tesses::Framework::Filesystem::VFSPath path, Tesses::Framework::Date::DateTime lastWrite, Tesses::Framework::Date::DateTime lastAccess)
{ {
TVFSHeapObject* vfs;
TDictionary* dict; TDictionary* dict;
if(GetObjectHeap(this->obj, vfs))
{
vfs->vfs->SetDate(path,lastWrite,lastAccess);
}
if(GetObjectHeap(this->obj, dict)) if(GetObjectHeap(this->obj, dict))
{ {
GCList ls(this->ls->GetGC()); GCList ls(this->ls->GetGC());
@@ -604,37 +503,14 @@ namespace Tesses::CrossLang {
} }
TObjectVFS::~TObjectVFS() TObjectVFS::~TObjectVFS()
{ {
TDictionary* dict;
if(GetObjectHeap(this->obj, dict))
{
GCList ls(this->ls->GetGC());
dict->CallMethod(ls,"Dispose",{});
}
delete this->ls; delete this->ls;
} }
TVFSHeapObject* TVFSHeapObject::Create(GCList& ls, Tesses::Framework::Filesystem::VFS* vfs)
{
TVFSHeapObject* heapObj = new TVFSHeapObject();
GC* _gc = ls.GetGC();
ls.Add(heapObj);
_gc->Watch(heapObj);
heapObj->vfs = vfs;
return heapObj;
}
TVFSHeapObject* TVFSHeapObject::Create(GCList* ls, Tesses::Framework::Filesystem::VFS* vfs)
{
TVFSHeapObject* heapObj = new TVFSHeapObject();
GC* _gc = ls->GetGC();
ls->Add(heapObj);
_gc->Watch(heapObj);
heapObj->vfs = vfs;
return heapObj;
}
TVFSHeapObject::~TVFSHeapObject()
{
if(this->vfs != nullptr)
delete this->vfs;
}
void TVFSHeapObject::Close()
{
if(this->vfs != nullptr)
{
delete this->vfs;
this->vfs = nullptr;
}
}
} }

12
src/vm/filereader.cpp
View File

@@ -57,7 +57,7 @@ namespace Tesses::CrossLang
item->Mark(); item->Mark();
} }
void TFile::Skip(Tesses::Framework::Streams::Stream* stream,size_t len) void TFile::Skip(std::shared_ptr<Tesses::Framework::Streams::Stream> stream,size_t len)
{ {
if(stream->CanSeek()) if(stream->CanSeek())
{ {
@@ -69,12 +69,12 @@ namespace Tesses::CrossLang
delete[] buffer; delete[] buffer;
} }
} }
void TFile::Ensure(Tesses::Framework::Streams::Stream* stream, uint8_t* buffer,size_t len) void TFile::Ensure(std::shared_ptr<Tesses::Framework::Streams::Stream> stream, uint8_t* buffer,size_t len)
{ {
size_t read = stream->ReadBlock(buffer, len); size_t read = stream->ReadBlock(buffer, len);
if(read < len) throw VMException("End of file, could not read " + std::to_string((int64_t)len) + " byte(s)., offset=" + std::to_string(stream->GetLength())); if(read < len) throw VMException("End of file, could not read " + std::to_string((int64_t)len) + " byte(s)., offset=" + std::to_string(stream->GetLength()));
} }
std::string TFile::EnsureString(Tesses::Framework::Streams::Stream* stream) std::string TFile::EnsureString(std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
auto len = EnsureInt(stream); auto len = EnsureInt(stream);
if(len == 0) return {}; if(len == 0) return {};
@@ -84,13 +84,13 @@ namespace Tesses::CrossLang
return str; return str;
} }
uint32_t TFile::EnsureInt(Tesses::Framework::Streams::Stream* stream) uint32_t TFile::EnsureInt(std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
uint8_t buffer[4]; uint8_t buffer[4];
Ensure(stream,buffer,4); Ensure(stream,buffer,4);
return BitConverter::ToUint32BE(buffer[0]); return BitConverter::ToUint32BE(buffer[0]);
} }
std::string TFile::GetString(Tesses::Framework::Streams::Stream* stream) std::string TFile::GetString(std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
uint32_t index=EnsureInt(stream); uint32_t index=EnsureInt(stream);
if(index >= this->strings.size()) throw VMException("String does not exist in TCrossVM file, expected string index: " + std::to_string(index) + ", total strings: " + std::to_string(this->strings.size())); if(index >= this->strings.size()) throw VMException("String does not exist in TCrossVM file, expected string index: " + std::to_string(index) + ", total strings: " + std::to_string(this->strings.size()));
@@ -118,7 +118,7 @@ namespace Tesses::CrossLang
throw VMException(errorMessage); throw VMException(errorMessage);
} }
void TFile::Load(GC* gc, Tesses::Framework::Streams::Stream* stream) void TFile::Load(GC* gc, std::shared_ptr<Tesses::Framework::Streams::Stream> stream)
{ {
uint8_t main_header[18]; uint8_t main_header[18];

1523
src/vm/vm.cpp
View File

File diff suppressed because it is too large Load Diff