tesses50/crosslang
1
0
Fork 0
mirror of https://git.tesses.org/tesses50/crosslang.git synced 2026-06-01 10:15:31 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
17e4ca9410c11751d6a0d4ef10d69b639410336b
crosslang/include/CrossLang.hpp

2645 lines
79 KiB
C++
Raw Blame History

#pragma once
#include <TessesFramework/TessesFramework.hpp>
#include <any>
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <functional>
#include <initializer_list>
#include <memory>
#include <regex>
#include <sstream>
#include <string>
#include <time.h>
#include <variant>
#include <vector>
#include "CrossLangVersion.h"
#include "TessesFramework/Streams/ByteReader.hpp"
#define CROSSLANG_BYTECODE_MAJOR 1
#define CROSSLANG_BYTECODE_MINOR 0
#define CROSSLANG_BYTECODE_PATCH 0
#define CROSSLANG_BYTECODE_BUILD 0 // SHOULD ALWAYS BE 0
#define CROSSLANG_BYTECODE_VERSIONSTAGE DevVersion
#if defined(_WIN32)
#undef Yield
#endif
/**
* @namespace Tesses::CrossLang
* @brief The CrossLang namespace
*
*/
namespace Tesses::CrossLang {
using BitConverter = Tesses::Framework::Serialization::BitConverter;
constexpr std::string_view VMName = "CrossLangVM";
constexpr std::string_view VMHowToGet = "https://crosslang.tesseslanguage.com/";
/**
* @brief Escape a crosslang string (for generating source code)
*
* @param text text to escape
* @param quote whether to surround with double quotes
* @return std::string the escaped string
*/
std::string EscapeString(std::string text, bool quote);
/**
* @brief Get the config folder used by crosslang
*
* @return Tesses::Framework::Filesystem::VFSPath the config folder for
* crosslang
*/
Tesses::Framework::Filesystem::VFSPath GetCrossLangConfigDir();
/**
* @brief Version stage
*
*/
enum TVMVersionStage : uint8_t {
DevVersion = 0,
AlphaVersion = 1,
BetaVersion = 2,
ProductionVersion = 3
};
/**
* @brief CrossLang version
*
*/
class TVMVersion {
uint8_t major;
uint8_t minor;
uint8_t patch;
uint16_t build;
public:
/**
* @brief Major
*
* @return uint8_t The major
*/
uint8_t Major() { return major; }
/**
* @brief Minor
*
* @return uint8_t The minor
*/
uint8_t Minor() { return minor; }
/**
* @brief Patch
*
* @return uint8_t The patch
*/
uint8_t Patch() { return patch; }
/**
* @brief Build
*
* @return uint16_t The build
*/
uint16_t Build() { return build >> 2; }
/**
* @brief Stage (dev, alpha, beta or prod)
*
* @return TVMVersionStage The stage
*/
TVMVersionStage VersionStage() { return (TVMVersionStage)(build & 3); }
/**
* @brief Set the Major
*
* @param major The major
*/
void SetMajor(uint8_t major) { this->major = major; }
/**
* @brief Set the Minor
*
* @param minor The minor
*/
void SetMinor(uint8_t minor) { this->minor = minor; }
/**
* @brief Set the Patch
*
* @param patch The patch
*/
void SetPatch(uint8_t patch) { this->patch = patch; }
/**
* @brief Set the Build
*
* @param build The build << 2 | (stage & 3)
*/
void SetBuild(uint16_t build) { this->build = build; }
/**
* @brief Set the Build (and stage)
*
* @param build
* @param version
*/
void SetBuild(uint16_t build, TVMVersionStage version) {
this->build = (build << 2) | version;
}
/**
* @brief Set the Version
*
* @param major The major
* @param minor The minor
* @param patch The patch
* @param build The build
* @param ver The stage
*/
void SetVersion(uint8_t major, uint8_t minor, uint8_t patch, uint16_t build,
TVMVersionStage ver) {
this->SetMajor(major);
this->SetMinor(minor);
this->SetPatch(patch);
this->SetBuild(build, ver);
}
/**
* @brief Set the Version
*
* @param major The major
* @param minor The minor
* @param patch The patch
* @param build The build << 2 | (stage & 3)
*/
void SetVersion(uint8_t major, uint8_t minor, uint8_t patch,
uint16_t build) {
this->SetMajor(major);
this->SetMinor(minor);
this->SetPatch(patch);
this->SetBuild(build);
}
/**
* @brief Set the Version
*
* @param major The major
* @param minor The minor
* @param patch The patch
* @param buildHigh The build (high 8 bits)
* @param buildLow The build (low 6 bits) << 2 | (stage & 3)
*/
void SetVersion(uint8_t major, uint8_t minor, uint8_t patch,
uint8_t buildHigh, uint8_t buildLow) {
this->SetVersion(major, minor, patch, buildHigh << 8 | buildLow);
}
/**
* @brief Set the Version
*
* @param versionData same order as SetVersion(uint8_t major, uint8_t minor,
* uint8_t patch, uint8_t buildHigh, uint8_t buildLow) but is a pointer to
* uint8_t version[5]
*/
void SetVersion(uint8_t *versionData) {
this->SetVersion(versionData[0], versionData[1], versionData[2],
versionData[3], versionData[4]);
}
/**
* @brief Set the version from long
*
* @param v version serialized as long
*/
void SetFromLong(uint64_t v) {
this->major = (uint8_t)((v >> 32) & 0xFF);
this->minor = (uint8_t)(v >> 24) & 0xFF;
this->patch = (uint8_t)(v >> 16) & 0xFF;
this->build = (uint16_t)(v & 0xFFFF);
}
/**
* @brief Encodes the version to bytes to be decoded by SetVersion(uint8_t*)
* or the constructor
*
* @param versionData an array that is 5 bytes long
*/
void ToArray(uint8_t *versionData) {
versionData[0] = major;
versionData[1] = minor;
versionData[2] = patch;
versionData[3] = build >> 8;
versionData[4] = build & 0xFF;
}
/**
* @brief Construct a new Version object
*
* @param major Major
* @param minor Minor
* @param patch Patch
* @param build Build
* @param version Stage (dev, alpha, beta, prod) see TVMVersionStage for
* actual names
*/
TVMVersion(uint8_t major, uint8_t minor, uint8_t patch, uint16_t build,
TVMVersionStage version) {
this->SetVersion(major, minor, patch, build, version);
}
/**
* @brief Construct a new Version object
*
* @param versionData same order as SetVersion(uint8_t major, uint8_t minor,
* uint8_t patch, uint8_t buildHigh, uint8_t buildLow) but is a pointer to
* uint8_t version[5]
*/
TVMVersion(uint8_t *versionData) { this->SetVersion(versionData); }
/**
* @brief Construct a new 1.0.0.0-dev Version object
*
*/
TVMVersion() {
this->major = 1;
this->minor = 0;
this->patch = 0;
this->SetBuild(0, TVMVersionStage::DevVersion);
}
/**
* @brief Construct a new Version object from a long
*
* @param v version serialized as long
*/
TVMVersion(uint64_t v) { this->SetFromLong(v); }
/**
* @brief Compares to another version
*
* @param version another version object
* @return int returns 1 if this is newer than other version, 0 if same, -1
* if this is older than other version
*/
int CompareTo(TVMVersion &version) {
if (this->major > version.major)
return 1;
if (this->major < version.major)
return -1;
if (this->minor > version.minor)
return 1;
if (this->minor < version.minor)
return -1;
if (this->patch > version.patch)
return 1;
if (this->patch < version.patch)
return -1;
if (this->build > version.build)
return 1;
if (this->build < version.build)
return -1;
return 0;
}
/**
* @brief Serializes to a long
*
* @return uint64_t serialized as a long
*/
uint64_t AsLong() {
uint64_t v = (uint64_t)major << 32;
v |= (uint64_t)minor << 24;
v |= (uint64_t)patch << 16;
v |= (uint64_t)build;
return v;
}
/**
* @brief Compares this to the runtime version (for Bytecode)
*
* @return int CompareTo(RuntimeVersion) where RuntimeVersion is the runtime
* version
*/
int CompareToRuntime() {
TVMVersion version(CROSSLANG_BYTECODE_MAJOR, CROSSLANG_BYTECODE_MINOR,
CROSSLANG_BYTECODE_PATCH, CROSSLANG_BYTECODE_BUILD,
CROSSLANG_BYTECODE_VERSIONSTAGE);
return CompareTo(version);
}
/**
* @brief Try to parse the version from a string
*
* @param versionStr the version string like 1.0.0.0-prod (or dev, alpha,
* beta)
* @param version a reference to a version
* @return true the parsing succeeded
* @return false the parsing failed
*/
static bool TryParse(std::string versionStr, TVMVersion &version) {
if (versionStr.empty())
return false;
size_t sep = versionStr.find_last_of('-');
std::string left = versionStr;
std::string right = "prod";
if (sep != std::string::npos) {
left = versionStr.substr(0, sep);
right = versionStr.substr(sep + 1);
}
if (left.empty())
return false;
TVMVersionStage stage;
if (right == "dev")
stage = TVMVersionStage::DevVersion;
else if (right == "alpha")
stage = TVMVersionStage::AlphaVersion;
else if (right == "beta")
stage = TVMVersionStage::BetaVersion;
else if (right == "prod")
stage = TVMVersionStage::ProductionVersion;
else
return false;
// 1 0.0.0
sep = left.find_first_of('.');
if (sep != std::string::npos) {
auto lStr = left.substr(0, sep);
right = left.substr(sep + 1);
left = lStr;
} else {
version.SetMajor((uint8_t)std::stoul(left));
version.SetBuild(0, stage);
return true;
}
version.SetMajor((uint8_t)std::stoul(left));
left = right;
sep = left.find_first_of('.');
if (sep != std::string::npos) {
auto lStr = left.substr(0, sep);
right = left.substr(sep + 1);
left = lStr;
} else {
version.SetMinor((uint8_t)std::stoul(left));
version.SetBuild(0, stage);
return true;
}
version.SetMinor((uint8_t)std::stoul(left));
left = right;
sep = left.find_first_of('.');
if (sep != std::string::npos) {
auto lStr = left.substr(0, sep);
right = left.substr(sep + 1);
left = lStr;
} else {
version.SetPatch((uint8_t)std::stoul(left));
version.SetBuild(0, stage);
return true;
}
version.SetPatch((uint8_t)std::stoul(left));
version.SetBuild((uint16_t)std::stoul(right), stage);
return true;
}
/**
* @brief Converts version to string
*
* @return std::string the version string like 1.0.0.0-prod (or dev, alpha,
* beta)
*/
std::string ToString() {
std::string str = {};
str.append(std::to_string((int)this->Major()));
str.push_back('.');
str.append(std::to_string((int)this->Minor()));
str.push_back('.');
str.append(std::to_string((int)this->Patch()));
str.push_back('.');
str.append(std::to_string((int)this->Build()));
if (this->VersionStage() == TVMVersionStage::DevVersion) {
str.append("-dev");
} else if (this->VersionStage() == TVMVersionStage::AlphaVersion) {
str.append("-alpha");
} else if (this->VersionStage() == TVMVersionStage::BetaVersion) {
str.append("-beta");
} else if (this->VersionStage() == TVMVersionStage::ProductionVersion) {
str.append("-prod");
}
return str;
}
};
/**
* @brief Create a crvm archive file
*
* @param vfs the filesystem used as root of the archive
* @param strm the output stream
* @param name the crvm name
* @param version the crvm version
* @param info the crvm info
* @param icon the crvm 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
*
* @param strm the input stream
* @param vfs vfs to extract to (as root)
* @return std::pair<std::pair<std::string,TVMVersion>,std::string> ((name,
* version),info)
*/
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);
/**
* @brief The token type for lexer
*
*/
typedef enum { Identifier, Symbol, String, Char, Documentation } LexTokenType;
/**
* @brief The line info for lextoken
*
*/
class LexTokenLineInfo {
public:
/**
* @brief line number
*
*/
int line;
/**
* @brief column number
*
*/
int column;
/**
* @brief byte offset in file
*
*/
int offset;
/**
* @brief filename
*
*/
std::string filename;
/**
* @brief Add a char
*
* @param c a char to add to line, column, offset
*/
void Add(int c);
/**
* @brief Subtract from column and offset
*
* @param c the number of chars
*/
void Subtract(size_t c);
};
/**
* @brief The lextoken for lexer
*
*/
class LexToken {
public:
/**
* @brief line information
*
*/
LexTokenLineInfo lineInfo;
/**
* @brief the token type
*
*/
LexTokenType type;
/**
* @brief the token text
*
*/
std::string text;
/**
* @brief any white space characters before this token
*
*/
std::string whiteSpaceCharsBefore;
};
/**
* @brief Start lexing the file
*
* @param filename the filename used for exception purposes
* @param strm the character stream
* @param tokens the tokens
* @return int 0 on success, line number on failure
*/
int Lex(std::string filename, std::istream &strm,
std::vector<LexToken> &tokens);
using Undefined = std::monostate;
class AdvancedSyntaxNode;
/**
* @brief Bytecode instruction enumeration
*
*/
typedef enum {
ADD,
SUB,
TIMES,
DIVIDE,
MODULO,
LEFTSHIFT,
RIGHTSHIFT,
BITWISEOR,
BITWISEAND,
BITWISENOT,
LESSTHAN,
GREATERTHAN,
LESSTHANEQ,
GREATERTHANEQ,
EQ,
NEQ,
NOT,
NEGATIVE,
XOR,
POP,
DUP,
NOP,
PUSHCLOSURE,
CREATEDICTIONARY,
CREATEARRAY,
APPENDLIST,
APPENDDICT,
PUSHRESOURCE,
PUSHLONG,
PUSHCHAR,
PUSHDOUBLE,
PUSHSTRING,
PUSHNULL,
PUSHUNDEFINED,
SCOPEBEGIN,
SCOPEEND,
SCOPEENDTIMES,
PUSHFALSE,
PUSHTRUE,
SETVARIABLE,
GETVARIABLE,
DECLAREVARIABLE,
SETFIELD,
GETFIELD,
CALLFUNCTION,
CALLMETHOD,
RET,
JMPC,
JMP,
JMPUNDEFINED,
DEFER,
TRYCATCH,
THROW,
PUSHSCOPELESSCLOSURE,
YIELD,
PUSHROOTPATH,
PUSHRELATIVEPATH,
BREAKPOINT,
PUSHBREAK,
PUSHCONTINUE,
JMPIFBREAK,
JMPIFCONTINUE,
JMPIFDEFINED,
DECLARECONSTVARIABLE,
LINEINFO,
PUSHRESOURCESTREAM,
PUSHRESOUURCEDIR,
PUSHPRIVATEXPRESSION
} Instruction;
/**
* @brief Base type for bytecode instruction
*
*/
class ByteCodeInstruction {
public:
/**
* @brief Size of instruction
*
* @return size_t the length of the instruction
*/
virtual size_t Size() = 0;
/**
* @brief Write the instruction to vector
*
* @param data the vector of uint8_t
*/
virtual void Write(std::vector<uint8_t> &data) = 0;
virtual ~ByteCodeInstruction() {}
};
/**
* @brief Basic bytecode instruction
*
*/
class SimpleInstruction : public ByteCodeInstruction {
public:
/**
* @brief The instruction
*
*/
Instruction instruction;
/**
* @brief Construct a new Simple Instruction object
*
* @param instr the instruction
*/
SimpleInstruction(Instruction instr);
/**
* @brief Size of instruction
*
* @return size_t 1, because simple instructions are just an instruction
*/
size_t Size();
/**
* @brief Write the opcode to the vector
*
* @param data the vector of uint8_t
*/
void Write(std::vector<uint8_t> &data);
};
class StringInstruction : public ByteCodeInstruction {
public:
uint32_t n;
StringInstruction(uint32_t n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class ScopeEndTimesInstruction : public ByteCodeInstruction {
public:
uint32_t n;
ScopeEndTimesInstruction(uint32_t n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class LabelInstruction : public ByteCodeInstruction {
public:
std::string label;
LabelInstruction(std::string lbl);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class LabelableInstruction : public ByteCodeInstruction {
public:
uint32_t n;
std::string label;
virtual size_t Size();
virtual void Write(std::vector<uint8_t> &data);
};
class JumpStyleInstruction : public LabelableInstruction {
public:
Instruction type;
JumpStyleInstruction(Instruction conditional, std::string label);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class EmbedInstruction : public ByteCodeInstruction {
public:
uint32_t n;
EmbedInstruction(uint32_t n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class EmbedStreamInstruction : public ByteCodeInstruction {
public:
uint32_t n;
EmbedStreamInstruction(uint32_t n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class ClosureInstruction : public ByteCodeInstruction {
public:
bool hasScope;
uint32_t n;
ClosureInstruction(uint32_t n, bool hasScope = true);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class DoubleInstruction : public ByteCodeInstruction {
public:
double n;
DoubleInstruction(double n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class LongInstruction : public ByteCodeInstruction {
public:
int64_t n;
LongInstruction(int64_t n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
class CharInstruction : public ByteCodeInstruction {
public:
char n;
CharInstruction(char n);
size_t Size();
void Write(std::vector<uint8_t> &data);
};
using SyntaxNode =
std::variant<Undefined, int64_t, double, std::string, char, bool,
std::nullptr_t, std::vector<uint8_t>, AdvancedSyntaxNode,
std::shared_ptr<Tesses::Framework::Streams::Stream>,
std::shared_ptr<Tesses::Framework::Filesystem::VFSPath>>;
struct CodeGenClassEntry {
uint8_t type;
uint32_t documentation;
uint32_t name;
std::vector<uint32_t> arguments;
uint32_t closure;
};
struct CodeGenClass {
uint32_t documentation;
std::vector<uint32_t> name;
std::vector<uint32_t> inherits;
std::vector<CodeGenClassEntry> entries;
};
class ResourceBase {
public:
virtual uint32_t
GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS) = 0;
virtual void
Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output) = 0;
virtual ~ResourceBase();
virtual bool IsEqual(ResourceBase *base);
};
class ResourceFile : public ResourceBase {
std::shared_ptr<Tesses::Framework::Streams::Stream> strm = nullptr;
public:
ResourceFile();
ResourceFile(std::string file);
std::string file;
uint32_t
GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output);
bool IsEqual(ResourceBase *base);
~ResourceFile();
};
class ResourceByteArray : public ResourceBase {
public:
std::vector<uint8_t> data;
uint32_t
GetLength(std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS);
void Write(std::shared_ptr<Tesses::Framework::Streams::Stream> output);
};
class CodeGen {
uint32_t id;
uint32_t NewId();
void GetFunctionArgs(std::vector<uint32_t> &args, SyntaxNode n);
void GetFunctionName(std::vector<uint32_t> &name, SyntaxNode n);
void GetFunctionArgs(std::vector<SyntaxNode> &args, SyntaxNode n);
SyntaxNode StringifyListOfVars(SyntaxNode n);
uint32_t GetString(std::string str);
uint32_t GetResource(std::shared_ptr<ResourceBase> resource);
std::vector<std::string> strs;
std::vector<std::shared_ptr<ResourceBase>> res;
std::vector<
std::pair<std::vector<uint32_t>, std::vector<ByteCodeInstruction *>>>
chunks;
std::vector<std::pair<std::vector<uint32_t>, uint32_t>> funcs;
std::vector<CodeGenClass> classes;
std::vector<std::vector<uint8_t>> meta;
SyntaxNode OptimizeNode(SyntaxNode n);
void WriteMetadataObject(std::vector<uint8_t> &bytes, SyntaxNode n);
void GenNode(std::vector<ByteCodeInstruction *> &instructions, SyntaxNode n,
int32_t scope, int32_t contscope, int32_t brkscope,
int32_t contI, int32_t brkI);
void GenPop(std::vector<ByteCodeInstruction *> &instrs, SyntaxNode n);
public:
std::shared_ptr<Tesses::Framework::Filesystem::VFS> embedFS;
std::vector<std::pair<std::string, TVMVersion>> dependencies;
std::vector<std::pair<std::string, TVMVersion>> tools;
TVMVersion version;
std::string name;
std::string info;
std::string icon;
void GenRoot(SyntaxNode n);
void Save(std::shared_ptr<Tesses::Framework::Streams::Stream> output);
~CodeGen();
};
/**
* @brief A html expression
*
*/
constexpr std::string_view HtmlRootExpression = "htmlRootExpression";
/**
* @brief an intrinsic function that embeds a resource from the filename based
* on the constant string argument
*
*/
constexpr std::string_view EmbedExpression = "embedExpression";
/**
* @brief an intrinsic function that embeds a resource as a stream from the
* filename based on the constant string argument
*
*/
constexpr std::string_view EmbedStreamExpression = "embedStreamExpression";
/**
* @brief an intrinsic function that embeds a resource directory from the
* directory name based on the constant string argument
*
*/
constexpr std::string_view EmbedDirectoryExpression =
"embedDirectoryExpression";
/**
* @brief Negative operator -EXPR
*
*/
constexpr std::string_view NegativeExpression = "negativeExpression";
/**
* @brief Not operator !EXPR
*
*/
constexpr std::string_view NotExpression = "notExpression";
/**
* @brief Bitwise not operator ~EXPR
*
*/
constexpr std::string_view BitwiseNotExpression = "bitwiseNotExpression";
/**
* @brief ++i
*
*/
constexpr std::string_view PrefixIncrementExpression =
"prefixIncrementExpression";
/**
* @brief --i
*
*/
constexpr std::string_view PrefixDecrementExpression =
"prefixDecrementExpression";
/**
* @brief i++
*
*/
constexpr std::string_view PostfixIncrementExpression =
"postfixIncrementExpression";
/**
* @brief i--
*
*/
constexpr std::string_view PostfixDecrementExpression =
"postfixDecrementExpression";
/**
* @brief Gets variable value
*
*/
constexpr std::string_view GetVariableExpression = "getVariableExpression";
/**
* @brief Get field or get property (EXPR.getNAME()) (unless it is wrapped in
* AssignExpression) which then it sets the field or calls EXPR.setNAME(VALUE)
*
*/
constexpr std::string_view GetFieldExpression = "getFieldExpression";
/**
* @brief Syntax sugar for EXPR.GetAt(index) (unless it is wrapped in
* AssignExpresion) which then it is EXPR.SetAt(index, VALUE)
*
*/
constexpr std::string_view GetArrayExpression = "getArrayExpression";
/**
* @brief Function Call myFn() or MyDict.Fn()
*
*/
constexpr std::string_view FunctionCallExpression = "functionCallExpression";
/**
* @brief Used for compound assignment like VAR += EXPR
*
*/
constexpr std::string_view CompoundAssignExpression =
"compoundAssignExpression";
/**
* @brief Assign something using =
*
*/
constexpr std::string_view AssignExpression = "assignExpression";
/**
* @brief A char litteral
*
*/
constexpr std::string_view CharExpression = "charExpression";
/**
* @brief The undefined literal
*
*/
constexpr std::string_view UndefinedExpression = "undefinedExpression";
/**
* @brief A list of nodes that does create a new scope
*
*/
constexpr std::string_view ScopeNode = "scopeNode";
/**
* @brief A list of nodes that doesn't create a new scope
*
*/
constexpr std::string_view NodeList = "nodeList";
/**
* @brief Array expresion [1,2,10]
*
*/
constexpr std::string_view ArrayExpression = "arrayExpression";
/**
* @brief Dictionary expression { a = 42, b = false}
*
*/
constexpr std::string_view DictionaryExpression = "dictionaryExpression";
/**
* @brief var v = 59;
*
*/
constexpr std::string_view DeclareExpression = "declareExpression";
/**
* @brief const v = 59;
*
*/
constexpr std::string_view ConstExpression = "constExpression";
/**
* @brief Closure expression (a,b)=> a * b
*
*/
constexpr std::string_view ClosureExpression = "closureExpression";
/**
* @brief Just like normal closures but doesn't create its own scope
*
*/
constexpr std::string_view ScopelessClosureExpression =
"scopelessClosureExpression";
/**
* @brief Ternary operator COND ? EXPR : EXPR
*
*/
constexpr std::string_view TernaryExpression = "ternaryExpression";
/**
* @brief If statement if(COND) {} else if(COND) {} else {}
*
*/
constexpr std::string_view IfStatement = "ifStatement";
/**
* @brief For statement for(var i = 0; i < 42; i++)
*
*/
constexpr std::string_view ForStatement = "forStatement";
/**
* @brief While statement while(COND)
*
*/
constexpr std::string_view WhileStatement = "whileStatement";
/**
* @brief using statement using(EXPR)
*
*/
constexpr std::string_view UsingStatement = "usingStatement";
/**
* @brief Do statement do(COND)
*
*/
constexpr std::string_view DoStatement = "doStatement";
/**
* @brief Each statement each(var item : EXPR)
*
*/
constexpr std::string_view EachStatement = "eachStatement";
/**
* @brief Return statement return EXPR;
*
*/
constexpr std::string_view ReturnStatement = "returnStatement";
/**
* @brief Break statement break;
*
*/
constexpr std::string_view BreakStatement = "breakStatement";
/**
* @brief Continue statement continue;
*
*/
constexpr std::string_view ContinueStatement = "continueStatement";
/**
* @brief Function statement func main(args)
*
*/
constexpr std::string_view FunctionStatement = "functionStatement";
/**
* @brief The documentation statement /^ Documentation ^/ func main(args) {}
*
*/
constexpr std::string_view DocumentationStatement = "documentationStatement";
/**
* @brief The comma expression EXPR, EXPR
*
*/
constexpr std::string_view CommaExpression = "commaExpression";
/**
* @brief The addition operator EXPR + EXPR
*
*/
constexpr std::string_view AddExpression = "addExpression";
/**
* @brief The subtraction operator EXPR - EXPR
*
*/
constexpr std::string_view SubExpression = "subtractExpression";
/**
* @brief The times operator EXPR * EXPR
*
*/
constexpr std::string_view TimesExpression = "timesExpression";
/**
* @brief The divsion operator EXPR / EXPR
*
*/
constexpr std::string_view DivideExpression = "divideExpression";
/**
* @brief The modulo operator (get remainder) EXPR % EXPR
*
*/
constexpr std::string_view ModExpression = "modExpression";
/**
* @brief The left shift operator EXPR << EXPR
*
*/
constexpr std::string_view LeftShiftExpression = "leftShiftExpression";
/**
* @brief The right shift operator EXPR >> EXPR
*
*/
constexpr std::string_view RightShiftExpression = "rightShiftExpression";
/**
* @brief The bitwise or expression EXPR | EXPR
*
*/
constexpr std::string_view BitwiseOrExpression = "bitwiseOrExpression";
/**
* @brief The bitwise and expression EXPR & EXPR
*
*/
constexpr std::string_view BitwiseAndExpression = "bitwiseAndExpression";
/**
* @brief The xor expression EXPR ^ EXPR
*
*/
constexpr std::string_view XOrExpression = "xOrExpression";
/**
* @brief The logical or expression EXPR || EXPR
*
*/
constexpr std::string_view LogicalOrExpression = "logicalOrExpression";
/**
* @brief The logical and expression EXPR && EXPR
*
*/
constexpr std::string_view LogicalAndExpression = "logicalAndExpression";
/**
* @brief The equals expression EXPR == EXPR
*
*/
constexpr std::string_view EqualsExpression = "equalsExpression";
/**
* @brief The not equals expression EXPR != EXPR
*
*/
constexpr std::string_view NotEqualsExpression = "notEqualsExpression";
/**
* @brief The less than expression EXPR < EXPR
*
*/
constexpr std::string_view LessThanExpression = "lessThanExpression";
/**
* @brief The greater than expression EXPR > EXPR
*
*/
constexpr std::string_view GreaterThanExpression = "greaterThanExpression";
/**
* @brief The less than equals expression EXPR <= EXPR
*
*/
constexpr std::string_view LessThanEqualsExpression =
"lessThanEqualsExpression";
/**
* @brief The greater than equals expression EXPR >= EXPR
*
*/
constexpr std::string_view GreaterThanEqualsExpression =
"greaterThanEqualsExpression";
/**
* @brief The parentheses expression (expression)
*
*/
constexpr std::string_view ParenthesesExpression = "parenthesesExpression";
/**
* @brief The throw statement
*
*/
constexpr std::string_view ThrowStatement = "throwStatement";
/**
* @brief The breakpoint statement
*/
constexpr std::string_view BreakpointStatement = "breakpointStatement";
/**
* @brief The try statement
*
*/
constexpr std::string_view TryStatement = "tryStatement";
/**
* @brief The defer statement
*
*/
constexpr std::string_view DeferStatement = "deferStatement";
/**
* @brief The defer statement
*
*/
constexpr std::string_view YieldStatement = "yieldStatement";
/**
* @brief The enumerable statement
*
*/
constexpr std::string_view EnumerableStatement = "enumerableStatement";
/**
* @brief The switch statement
*
*/
constexpr std::string_view SwitchStatement = "switchStatement";
/**
* @brief Case clause of switch statement
*
*/
constexpr std::string_view CaseStatement = "caseStatement";
/**
* @brief Default clause of switch statement
*
*/
constexpr std::string_view DefaultStatement = "defaultStatement";
/**
* @brief Class statement (not implemented)
*
*/
constexpr std::string_view ClassStatement = "classStatement";
/**
* @brief Method statement (in class statement)
*
*/
constexpr std::string_view MethodStatement = "methodStatement";
/**
* @brief Abstract method statement (in class statement)
*
*/
constexpr std::string_view AbstractMethodStatement = "abstractMethodStatement";
/**
* @brief Field statement (in class statement)
*
*/
constexpr std::string_view FieldStatement = "fieldStatement";
/**
* @brief Root path expression / "path" / "to" / "file" (fullfils the first /)
*
*/
constexpr std::string_view RootPathExpression = "rootPathExpression";
/**
* @brief The relative path expression ./ "path" / "to" / "subdir" (fullfills
* the ./)
*
*/
constexpr std::string_view RelativePathExpression = "relativePathExpression";
/**
* @brief await expression for async/await
*/
constexpr std::string_view AwaitExpression = "awaitExpression";
/**
* @brief ?? operator
*/
constexpr std::string_view NullCoalescingExpression =
"nullCoalescingExpression";
/**
* @brief For debugging (store line info and filename)
*/
constexpr std::string_view LineNode = "lineNode";
/**
* @brief For storing generic metadata
*/
constexpr std::string_view MetadataStatement = "MetadataStatement";
/**
* @brief For storing private data (isolated to specific crvm file)
*/
constexpr std::string_view GetPrivateExpression = "getPrivateExpression";
/**
* @brief Advanced AST node
*
*/
class AdvancedSyntaxNode {
public:
/**
* @brief The name of the advanced AST node
*
*/
std::string nodeName;
/**
* @brief The advanced syntax node is an expression
*
*/
bool isExpression;
/**
* @brief The subnodes of the abstract syntax node
*
*/
std::vector<SyntaxNode> nodes;
/**
* @brief Create abstract syntax node
*
* @param nodeName The name of the advanced AST node
* @param isExpression The advanced syntax node is an expression
* @param n The subnodes of the abstract syntax node
* @return AdvancedSyntaxNode The AST node
*/
static AdvancedSyntaxNode Create(std::string_view nodeName,
bool isExpression,
std::vector<SyntaxNode> n);
};
SyntaxNode Deserialize(std::string astData);
std::string Serialize(SyntaxNode node);
class GC;
class TRootEnvironment;
/**
* @brief Token Parser
*
*/
class Parser {
uint32_t id;
uint32_t NewId();
uint64_t i;
std::vector<LexToken> tokens;
LexToken tkn;
void EnsureSymbol(std::string txt);
bool IsIdentifier(std::string txt, bool pop = true);
bool IsAnyIdentifier(std::initializer_list<std::string> idents,
bool pop = true);
bool IsSymbol(std::string txt, bool pop = true);
bool IsAnySymbol(std::initializer_list<std::string> idents,
bool pop = true);
SyntaxNode ParseExpression();
SyntaxNode ParseTernary();
SyntaxNode ParseNode(bool isRoot = false);
SyntaxNode ParseAssignment();
SyntaxNode ParseXOr();
SyntaxNode ParseBOr();
SyntaxNode ParseLOr();
SyntaxNode ParseLAnd();
SyntaxNode ParseBAnd();
SyntaxNode ParseEq();
SyntaxNode ParseRel();
SyntaxNode ParseShift();
SyntaxNode ParseSum();
SyntaxNode ParseFactor();
SyntaxNode ParseValue();
SyntaxNode ParseUnary();
SyntaxNode ParseNullCoalescing();
void ParseHtml(std::vector<SyntaxNode> &nodes, std::string var);
std::shared_ptr<GC> gc;
TRootEnvironment *env;
int lastLine = -1;
std::string lastFile = "";
bool CanEmit(LexTokenLineInfo &token);
public:
bool debug = true;
/**
* @brief Construct a new Parser object
*
* @param tokens the tokens from lexer
*/
Parser(std::vector<LexToken> tokens);
Parser(std::vector<LexToken> tokens, std::shared_ptr<GC> gc,
TRootEnvironment *env);
/**
* @brief Turn tokens into abstract syntax tree
*
* @return SyntaxNode the abstract syntax tree
*/
SyntaxNode ParseRoot() { return ParseNode(true); }
};
class THeapObject;
class CallStackEntry;
class InterperterThread;
class THeapObject {
public:
bool marked;
virtual void Mark() { marked = true; }
virtual ~THeapObject() {}
};
class THeapObjectHolder {
public:
THeapObject *obj;
THeapObjectHolder(THeapObject *obj) { this->obj = obj; }
THeapObjectHolder() {}
};
// this is a dummy type with
class MethodInvoker {};
class TBreak {};
class TContinue {};
/**
* @brief A script object
*
*/
using TObject =
std::variant<int64_t, double, char, bool, std::string, std::regex,
Tesses::Framework::Filesystem::VFSPath, std::nullptr_t,
Undefined, MethodInvoker, THeapObjectHolder, TVMVersion,
std::shared_ptr<Tesses::Framework::Date::DateTime>,
std::shared_ptr<Tesses::Framework::Date::TimeSpan>, 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>,
std::shared_ptr<Tesses::Framework::Streams::ByteReader>,
std::shared_ptr<Tesses::Framework::Streams::ByteWriter>,
std::shared_ptr<Tesses::Framework::Http::ServerSentEvents>,
std::shared_ptr<Tesses::Framework::TF_Timer_Handle>,
Tesses::Framework::Uuid>;
class TRootEnvironment;
class GC : public std::enable_shared_from_this<GC> {
Tesses::Framework::Threading::Thread *thrd;
Tesses::Framework::Threading::Mutex *mtx;
volatile std::atomic<bool> running;
std::vector<THeapObject *> roots;
std::vector<THeapObject *> objects;
Tesses::Framework::Lazy<Tesses::Framework::Threading::ThreadPool *> *tpool;
std::vector<
std::function<void(std::shared_ptr<GC> gc, TRootEnvironment *env)>>
register_everything;
public:
Tesses::Framework::Threading::ThreadPool *GetPool();
bool UsingNullThreads();
GC();
void Start();
bool IsRunning();
void BarrierBegin();
void BarrierEnd();
void Collect();
void Watch(TObject obj);
void Unwatch(TObject obj);
void SetRoot(TObject obj);
void UnsetRoot(TObject obj);
static void Mark(TObject obj);
void RegisterEverythingCallback(
std::function<void(std::shared_ptr<GC> gc, TRootEnvironment *env)> cb);
void RegisterEverything(TRootEnvironment *env);
~GC();
};
std::string GetObjectTypeString(TObject obj);
std::string ToString(std::shared_ptr<GC> gc, TObject obj);
class GCList : public THeapObject {
std::vector<THeapObject *> items;
std::shared_ptr<GC> gc;
public:
GCList(std::shared_ptr<GC> gc);
std::shared_ptr<GC> GetGC();
void Add(TObject v);
void Remove(TObject v);
void Mark();
~GCList();
friend class GC;
};
class TFile;
class TFileChunk : public THeapObject {
public:
static TFileChunk *Create(GCList *gc);
static TFileChunk *Create(GCList &gc);
TFile *file;
std::vector<uint8_t> code;
std::vector<std::string> args;
std::optional<std::string> name;
void Mark();
};
class TByteArray : public THeapObject {
public:
std::vector<uint8_t> data;
static TByteArray *Create(GCList *gc);
static TByteArray *Create(GCList &gc);
};
enum class TClassModifier { Private, Protected, Public, Static };
class TClassEntry {
public:
TClassModifier modifier;
bool isFunction;
bool isAbstract;
std::vector<std::string> args;
std::string documentation;
std::string name;
uint32_t chunkId;
};
class TClass {
public:
std::string documentation;
std::vector<std::string> name;
std::vector<std::string> inherits;
std::vector<TClassEntry> entry;
};
class TClassObjectEntry {
public:
TClassModifier modifier;
bool canSet;
std::string name;
std::string owner;
TObject value;
};
class TDictionary;
class TFile : public THeapObject {
public:
static TFile *Create(GCList *gc);
static TFile *Create(GCList &gc);
std::vector<TFileChunk *> chunks;
std::vector<std::string> strings;
std::vector<std::pair<std::string, std::string>> vms;
std::vector<std::pair<std::vector<std::string>, uint32_t>> functions;
std::vector<std::pair<std::string, TVMVersion>> dependencies;
std::vector<std::pair<std::string, TVMVersion>> tools;
std::vector<std::pair<std::string, std::vector<uint8_t>>> sections;
std::vector<std::pair<std::string, std::vector<uint8_t>>> metadata;
std::vector<std::vector<uint8_t>> resources;
std::vector<TClass> classes;
std::string name;
TVMVersion version;
std::string info;
int32_t icon;
void Load(std::shared_ptr<GC> gc,
std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void Skip(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,
size_t len);
void Ensure(std::shared_ptr<Tesses::Framework::Streams::Stream> strm,
uint8_t *buffer, size_t len);
uint32_t
EnsureInt(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string
EnsureString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
std::string
GetString(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void Mark();
void EnsureCanRunInCrossLang();
TDictionary *MetadataDecode(GCList &ls, size_t index);
};
class TAssociativeArray : public THeapObject {
public:
std::vector<std::pair<TObject, TObject>> items;
static TAssociativeArray *Create(GCList &ls);
static TAssociativeArray *Create(GCList *ls);
void Set(std::shared_ptr<GC> gc, TObject key, TObject value);
TObject Get(std::shared_ptr<GC> gc, TObject key);
TObject GetKey(int64_t index);
TObject GetValue(int64_t index);
void SetKey(int64_t index, TObject key);
void SetValue(int64_t index, TObject value);
int64_t Count();
void Mark();
};
class TList : public THeapObject {
public:
std::vector<TObject> items;
static TList *Create(GCList *gc);
static TList *Create(GCList &gc);
template <typename Itterator>
static TList *Create(GCList *gc, Itterator begin, Itterator end) {
auto list = Create(gc);
gc->GetGC()->BarrierBegin();
for (Itterator i = begin; i != end; ++i) {
TObject item = *i;
list->Add(item);
}
gc->GetGC()->BarrierEnd();
return list;
}
template <typename Itterator>
static TList *Create(GCList &gc, Itterator begin, Itterator end) {
return Create(&gc, begin, end);
}
static TList *Create(GCList *gc, std::initializer_list<TObject> il) {
return Create(gc, il.begin(), il.end());
}
static TList *Create(GCList &gc, std::initializer_list<TObject> il) {
return Create(gc, il.begin(), il.end());
}
virtual int64_t Count();
virtual TObject Get(int64_t index);
virtual void Set(int64_t index, TObject value);
virtual void Insert(int64_t index, TObject value);
virtual void Add(TObject value);
virtual void RemoveAt(int64_t index);
virtual void Clear();
virtual void Mark();
};
using TDItem = std::pair<std::string, TObject>;
class TDictionary : public THeapObject {
public:
std::map<std::string, TObject> items;
static TDictionary *Create(GCList *gc);
static TDictionary *Create(GCList &gc);
template <typename Itterator>
static TDictionary *Create(GCList *gc, Itterator begin, Itterator end) {
auto dict = Create(gc);
gc->GetGC()->BarrierBegin();
for (Itterator i = begin; i != end; ++i) {
TDItem item = *i;
dict->SetValue(item.first, item.second);
}
gc->GetGC()->BarrierEnd();
return dict;
}
template <typename Itterator>
static TDictionary *Create(GCList &gc, Itterator begin, Itterator end) {
return Create(&gc, begin, end);
}
static TDictionary *Create(GCList *gc, std::initializer_list<TDItem> il) {
return Create(gc, il.begin(), il.end());
}
static TDictionary *Create(GCList &gc, std::initializer_list<TDItem> il) {
return Create(gc, il.begin(), il.end());
}
virtual bool HasValue(std::string key);
virtual bool MethodExists(GCList &ls, std::string key);
virtual TObject GetValue(std::string key);
virtual void SetValue(std::string key, TObject value);
virtual void Mark();
void DeclareFunction(
std::shared_ptr<GC> gc, std::string key, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb);
void DeclareFunction(
std::shared_ptr<GC> gc, std::string key, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb,
std::function<void()> destroy);
TObject CallMethod(GCList &ls, std::string key, std::vector<TObject> args);
TObject CallMethodWithFatalError(GCList &ls, std::string key,
std::vector<TObject> args);
};
class TRootEnvironment;
class TSubEnvironment;
class TCallable : public THeapObject {
public:
TObject tag;
std::string documentation;
virtual TObject Call(GCList &ls, std::vector<TObject> args) = 0;
TObject CallWithFatalError(GCList &ls, std::vector<TObject> args);
virtual void Mark();
Tesses::Framework::Http::ServerRequestHandler
ToRouteServerRequestHandler(std::shared_ptr<GC> gc);
};
void ThrowFatalError(std::exception &ex);
void ThrowConstError(std::string key);
class TEnvironment : public THeapObject {
std::vector<std::string> consts;
public:
std::vector<TCallable *> defers;
TObject LoadFile(std::shared_ptr<GC> gc, TFile *f);
TObject Eval(GCList &ls, std::string code);
virtual bool HasVariable(std::string key) = 0;
virtual bool HasVariableRecurse(std::string key) = 0;
virtual bool HasVariableOrFieldRecurse(std::string key,
bool setting = false) = 0;
virtual TObject GetVariable(std::string key) = 0;
virtual TObject GetVariable(GCList &ls, std::string key) = 0;
virtual TObject SetVariable(GCList &ls, std::string key, TObject v) = 0;
virtual void SetVariable(std::string key, TObject value) = 0;
TDictionary *EnsureDictionary(std::shared_ptr<GC> gc, std::string key);
virtual void DeclareVariable(std::string key, TObject value) = 0;
void DeclareConstVariable(std::string key, TObject value);
bool HasConstForDeclare(std::string key);
virtual bool HasConstForSet(std::string key);
void DeclareVariable(std::shared_ptr<GC> gc, std::vector<std::string> key,
TObject value);
virtual TRootEnvironment *GetRootEnvironment() = 0;
virtual TEnvironment *GetParentEnvironment() = 0;
virtual TSubEnvironment *GetSubEnvironment(TDictionary *dict);
TSubEnvironment *GetSubEnvironment(GCList *gc);
TSubEnvironment *GetSubEnvironment(GCList &gc);
void DeclareFunction(
std::shared_ptr<GC> gc, std::string key, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb);
void DeclareFunction(
std::shared_ptr<GC> gc, std::string key, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb,
std::function<void()> destroy);
TObject CallFunction(GCList &ls, std::string key,
std::vector<TObject> args);
TObject CallFunctionWithFatalError(GCList &ls, std::string key,
std::vector<TObject> args);
};
class TClassEnvironment;
class TClassObject : public THeapObject {
TClassObjectEntry *GetEntry(std::string classN, std::string key);
public:
TFile *file;
uint32_t classIndex;
TEnvironment *ogEnv;
TClassEnvironment *env;
std::string name;
std::vector<std::string> inherit_tree;
std::vector<TClassObjectEntry> entries;
static TClassObject *Create(GCList &ls, TFile *f, uint32_t classIndex,
TEnvironment *env, std::vector<TObject> args);
static TClassObject *Create(GCList *ls, TFile *f, uint32_t classIndex,
TEnvironment *env, std::vector<TObject> args);
TObject GetValue(std::string className, std::string name);
void SetValue(std::string className, std::string name, TObject value);
bool HasValue(std::string className, std::string name);
bool HasField(std::string className, std::string name);
bool HasMethod(std::string className, std::string name);
TObject CallMethod(GCList &ls, std::string className, std::string name,
std::vector<TObject> args);
std::string TypeName();
void Mark();
};
class TClassEnvironment : public TEnvironment {
TEnvironment *env;
TClassObject *clsObj;
public:
static TClassEnvironment *Create(GCList *gc, TEnvironment *env,
TClassObject *obj);
static TClassEnvironment *Create(GCList &gc, TEnvironment *env,
TClassObject *obj);
TClassEnvironment(TEnvironment *env, TClassObject *obj);
bool HasVariable(std::string key);
bool HasVariableRecurse(std::string key);
bool HasVariableOrFieldRecurse(std::string key, bool setting = false);
TObject GetVariable(std::string key);
void SetVariable(std::string key, TObject value);
TObject GetVariable(GCList &ls, std::string key);
TObject SetVariable(GCList &ls, std::string key, TObject v);
void DeclareVariable(std::string key, TObject value);
bool HasConstForSet(std::string key);
TRootEnvironment *GetRootEnvironment();
TEnvironment *GetParentEnvironment();
void Mark();
};
class EnvironmentPermissions {
public:
EnvironmentPermissions();
Tesses::Framework::Filesystem::VFSPath sqliteOffsetPath;
std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem> localfs;
bool canRegisterEverything;
bool canRegisterConsole;
bool canRegisterIO;
bool canRegisterNet;
bool canRegisterSqlite;
bool canRegisterVM;
bool canRegisterDictionary;
bool canRegisterJSON;
bool canRegisterCrypto;
bool canRegisterRoot;
bool canRegisterProcess;
bool canRegisterPath;
bool canRegisterOGC;
bool canRegisterEnv;
bool canRegisterClass;
bool sqlite3Scoped;
bool locked;
TDictionary *customConsole = nullptr;
};
class TRootEnvironment : public TEnvironment {
TDictionary *dict;
TCallable *error = nullptr;
std::map<uint64_t, TDictionary *> private_file_data;
void LoadDependency(std::shared_ptr<GC> gc,
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs,
std::pair<std::string, TVMVersion> dep);
public:
EnvironmentPermissions permissions;
std::vector<std::pair<std::string, TVMVersion>> dependencies;
std::vector<std::pair<TFile *, uint32_t>> classes;
TDictionary *GetPrivateFromFile(std::shared_ptr<GC> gc, TFile *file);
bool TryFindClass(std::vector<std::string> &name, size_t &index);
void LoadFileWithDependencies(
std::shared_ptr<GC> gc,
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs, TFile *f);
void LoadFileWithDependencies(
std::shared_ptr<GC> gc,
std::shared_ptr<Tesses::Framework::Filesystem::VFS> vfs,
Tesses::Framework::Filesystem::VFSPath path);
TDictionary *GetDictionary();
static TRootEnvironment *Create(GCList *gc, TDictionary *dict);
static TRootEnvironment *Create(GCList &gc, TDictionary *dict);
TRootEnvironment(TDictionary *dict);
bool HasVariable(std::string key);
bool HasVariableRecurse(std::string key);
bool HasVariableOrFieldRecurse(std::string key, bool setting = false);
TObject GetVariable(std::string key);
void SetVariable(std::string key, TObject value);
TObject GetVariable(GCList &ls, std::string key);
TObject SetVariable(GCList &ls, std::string key, TObject v);
void DeclareVariable(std::string key, TObject value);
TRootEnvironment *GetRootEnvironment();
TEnvironment *GetParentEnvironment();
void RegisterOnError(TCallable *callable);
bool HandleException(std::shared_ptr<GC> gc, TEnvironment *env,
TObject err);
bool HandleBreakpoint(std::shared_ptr<GC> gc, TEnvironment *env,
TObject err);
void Mark();
};
class TStd {
private:
static void RegisterHelpers(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterUuid(std::shared_ptr<GC> gc, TRootEnvironment *env);
public:
static void RegisterStd(
std::shared_ptr<GC> gc, TRootEnvironment *env,
std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem>
localfs);
static void RegisterStd(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterConsole(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterIO(
std::shared_ptr<GC> gc, TRootEnvironment *env,
std::shared_ptr<Tesses::Framework::Filesystem::RelativeFilesystem>
local);
static void RegisterIO(std::shared_ptr<GC> gc, TRootEnvironment *env,
bool enableLocalFS = true);
static void RegisterNet(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterSqlite(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterVM(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterDictionary(std::shared_ptr<GC> gc,
TRootEnvironment *env);
static void RegisterJson(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterCrypto(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterRoot(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterPath(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterOGC(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterEnv(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterProcess(std::shared_ptr<GC> gc, TRootEnvironment *env);
static void RegisterClass(std::shared_ptr<GC> gc, TRootEnvironment *env);
};
class TSubEnvironment : public TEnvironment {
TEnvironment *env;
TDictionary *dict;
public:
static TSubEnvironment *Create(GCList *gc, TEnvironment *env,
TDictionary *dict);
static TSubEnvironment *Create(GCList &gc, TEnvironment *env,
TDictionary *dict);
TSubEnvironment(TEnvironment *env, TDictionary *dict);
bool HasVariable(std::string key);
bool HasVariableRecurse(std::string key);
bool HasVariableOrFieldRecurse(std::string key, bool setting = false);
bool HasConstForSet(std::string key);
TObject GetVariable(std::string key);
void SetVariable(std::string key, TObject value);
TObject GetVariable(GCList &ls, std::string key);
TObject SetVariable(GCList &ls, std::string key, TObject v);
void DeclareVariable(std::string key, TObject value);
TRootEnvironment *GetRootEnvironment();
TEnvironment *GetParentEnvironment();
TDictionary *GetDictionary();
void Mark();
};
TDictionary *CreateThread(GCList &ls, TCallable *callable, bool detached);
class TArgWrapper : public TCallable {
public:
TCallable *callable;
static TArgWrapper *Create(GCList &ls, TCallable *callable);
static TArgWrapper *Create(GCList *ls, TCallable *callable);
TObject Call(GCList &ls, std::vector<TObject> args);
void Mark();
};
class TExternalMethod : public TCallable {
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb;
std::function<void()> destroy;
public:
std::vector<std::string> args;
std::vector<TObject> watch;
TExternalMethod(
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb,
std::string documentation, std::vector<std::string> argNames,
std::function<void()> destroy);
static TExternalMethod *
Create(GCList &ls, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb,
std::function<void()> destroy);
static TExternalMethod *
Create(GCList *ls, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb,
std::function<void()> destroy);
static TExternalMethod *
Create(GCList &ls, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb);
static TExternalMethod *
Create(GCList *ls, std::string documentation,
std::vector<std::string> argNames,
std::function<TObject(GCList &ls, std::vector<TObject> args)> cb);
TObject Call(GCList &ls, std::vector<TObject> args);
~TExternalMethod();
void Mark() {
if (this->marked)
return;
this->marked = true;
for (auto item : watch)
GC::Mark(item);
GC::Mark(this->tag);
}
};
class TEnumerator : public THeapObject {
public:
virtual bool MoveNext(std::shared_ptr<GC> ls) = 0;
virtual TObject GetCurrent(GCList &ls) = 0;
static TEnumerator *CreateFromObject(GCList &ls, TObject obj);
};
class TAssociativeArrayEnumerator : public TEnumerator {
int64_t index;
TAssociativeArray *ls;
public:
static TAssociativeArrayEnumerator *Create(GCList &ls,
TAssociativeArray *list);
static TAssociativeArrayEnumerator *Create(GCList *ls,
TAssociativeArray *list);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
};
class TCustomEnumerator : public TEnumerator {
public:
TDictionary *dict;
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
static TCustomEnumerator *Create(GCList &ls, TDictionary *dict);
static TCustomEnumerator *Create(GCList *ls, TDictionary *dict);
};
class TYieldEnumerator : public TEnumerator {
bool hasStarted;
TObject enumerator;
TObject current;
public:
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
static TYieldEnumerator *Create(GCList &ls, TObject v);
static TYieldEnumerator *Create(GCList *ls, TObject v);
};
class TStringEnumerator : public TEnumerator {
bool hasStarted;
size_t index;
std::string str;
public:
static TStringEnumerator *Create(GCList &ls, std::string str);
static TStringEnumerator *Create(GCList *ls, std::string str);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
};
class TListEnumerator : public TEnumerator {
int64_t index;
TList *ls;
public:
static TListEnumerator *Create(GCList &ls, TList *list);
static TListEnumerator *Create(GCList *ls, TList *list);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
};
class TDynamicList;
class TDynamicDictionary;
class TDynamicListEnumerator : public TEnumerator {
int64_t index;
TDynamicList *ls;
public:
static TDynamicListEnumerator *Create(GCList &ls, TDynamicList *list);
static TDynamicListEnumerator *Create(GCList *ls, TDynamicList *list);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
};
class TVFSPathEnumerator : public TEnumerator {
Tesses::Framework::Filesystem::VFSPathEnumerator enumerator;
public:
static TVFSPathEnumerator *
Create(GCList &ls, Tesses::Framework::Filesystem::VFSPathEnumerator list);
static TVFSPathEnumerator *
Create(GCList *ls, Tesses::Framework::Filesystem::VFSPathEnumerator list);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
};
class TObjectVFS : public Tesses::Framework::Filesystem::VFS {
public:
TObject obj;
GCList *ls;
TObjectVFS(std::shared_ptr<GC> gc, TObject obj);
std::shared_ptr<Tesses::Framework::Streams::Stream>
OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode);
Tesses::Framework::Filesystem::FIFOCreationResult
CreateFIFO(Tesses::Framework::Filesystem::VFSPath path);
void CreateDirectory(Tesses::Framework::Filesystem::VFSPath path);
void DeleteDirectory(Tesses::Framework::Filesystem::VFSPath path);
void CreateSymlink(Tesses::Framework::Filesystem::VFSPath existingFile,
Tesses::Framework::Filesystem::VFSPath symlinkFile);
void CreateHardlink(Tesses::Framework::Filesystem::VFSPath existingFile,
Tesses::Framework::Filesystem::VFSPath newName);
void DeleteFile(Tesses::Framework::Filesystem::VFSPath path);
void Lock(Tesses::Framework::Filesystem::VFSPath path);
void Unlock(Tesses::Framework::Filesystem::VFSPath path);
void DeleteDirectoryRecurse(Tesses::Framework::Filesystem::VFSPath path);
Tesses::Framework::Filesystem::VFSPathEnumerator
EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path);
void MoveFile(Tesses::Framework::Filesystem::VFSPath src,
Tesses::Framework::Filesystem::VFSPath dest);
void MoveDirectory(Tesses::Framework::Filesystem::VFSPath src,
Tesses::Framework::Filesystem::VFSPath dest);
Tesses::Framework::Filesystem::VFSPath
ReadLink(Tesses::Framework::Filesystem::VFSPath path);
std::string VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path);
Tesses::Framework::Filesystem::VFSPath SystemToVFSPath(std::string path);
void SetDate(Tesses::Framework::Filesystem::VFSPath path,
Tesses::Framework::Date::DateTime lastWrite,
Tesses::Framework::Date::DateTime lastAccess);
void Chmod(Tesses::Framework::Filesystem::VFSPath path, uint32_t mode);
void Chown(Tesses::Framework::Filesystem::VFSPath path, uint32_t uid,
uint32_t gid);
bool StatVFS(Tesses::Framework::Filesystem::VFSPath path,
Tesses::Framework::Filesystem::StatVFSData &data);
bool Stat(Tesses::Framework::Filesystem::VFSPath path,
Tesses::Framework::Filesystem::StatData &data);
void Close();
~TObjectVFS();
};
class TObjectStream : public Tesses::Framework::Streams::Stream {
int64_t _GetPosInternal();
public:
TObject obj;
GCList *ls;
TObjectStream(std::shared_ptr<GC> gc, TObject obj);
bool EndOfStream();
size_t Read(uint8_t *buff, size_t sz);
size_t Write(const uint8_t *buff, size_t sz);
bool CanRead();
bool CanWrite();
bool CanSeek();
int64_t GetPosition();
int64_t GetLength();
void Flush();
void Seek(int64_t pos, Tesses::Framework::Streams::SeekOrigin whence);
void Close();
~TObjectStream();
};
class TObjectHttpServer : public Tesses::Framework::Http::IHttpServer {
public:
TObject obj;
GCList *ls;
TObjectHttpServer(std::shared_ptr<GC> gc, TObject obj);
bool Handle(Tesses::Framework::Http::ServerContext &ctx);
~TObjectHttpServer();
};
class TDictionaryEnumerator : public TEnumerator {
bool hasStarted;
std::map<std::string, Tesses::CrossLang::TObject>::iterator ittr;
TDictionary *dict;
public:
static TDictionaryEnumerator *Create(GCList &ls, TDictionary *dict);
static TDictionaryEnumerator *Create(GCList *ls, TDictionary *dict);
bool MoveNext(std::shared_ptr<GC> ls);
TObject GetCurrent(GCList &ls);
void Mark();
};
class TClosure : public TCallable {
public:
static TClosure *Create(GCList &ls, TEnvironment *env, TFile *file,
uint32_t chunkId, bool ownScope = true);
static TClosure *Create(GCList *ls, TEnvironment *env, TFile *file,
uint32_t chunkId, bool ownScope = true);
bool ownScope;
TFileChunk *closure;
TFile *file;
uint32_t chunkId;
TEnvironment *env;
std::string className;
TObject Call(GCList &ls, std::vector<TObject> args);
void Mark();
};
class TDynamicList : public THeapObject {
public:
TCallable *cb;
static TDynamicList *Create(GCList &ls, TCallable *callable);
static TDynamicList *Create(GCList *ls, TCallable *callable);
void Mark();
int64_t Count(GCList &ls);
TObject GetAt(GCList &ls, int64_t index);
TObject SetAt(GCList &ls, int64_t index, TObject val);
TObject Add(GCList &ls, TObject v);
TObject Insert(GCList &ls, int64_t index, TObject v);
TObject RemoveAllEqual(GCList &ls, TObject v);
TObject Remove(GCList &ls, TObject v);
TObject RemoveAt(GCList &ls, int64_t v);
TObject Clear(GCList &ls);
TObject ToString(GCList &ls);
~TDynamicList();
};
class TDynamicDictionary : public THeapObject {
public:
TCallable *cb;
static TDynamicDictionary *Create(GCList &ls, TCallable *callable);
static TDynamicDictionary *Create(GCList *ls, TCallable *callable);
void Mark();
TObject GetField(GCList &ls, std::string key);
TObject SetField(GCList &ls, std::string key, TObject value);
TObject CallMethod(GCList &ls, std::string name, std::vector<TObject> args);
bool MethodExists(GCList &ls, std::string name);
TEnumerator *GetEnumerator(GCList &ls);
~TDynamicDictionary();
};
class InterperterThread;
class CallStackEntry : public THeapObject {
public:
static CallStackEntry *Create(GCList *ls);
static CallStackEntry *Create(GCList &ls);
InterperterThread *thread;
std::vector<TObject> stack;
TEnvironment *env;
TClosure *callable;
uint32_t ip;
uint32_t scopes;
int64_t srcline;
std::string srcfile;
bool mustReturn;
void Mark();
void Push(std::shared_ptr<GC> gc, TObject v);
TObject Pop(GCList &gcl);
TObject Resume(GCList &ls);
};
class TTask : public THeapObject {
TCallable *cont = nullptr;
std::exception_ptr ex = nullptr;
std::shared_ptr<GC> gc;
TObject obj = Undefined();
bool isCompleted = false;
TTask(std::shared_ptr<GC> gc);
public:
static TTask *Create(GCList &ls);
bool IsCompleted();
void ContinueWith(TCallable *callable);
TTask *ContinueWith(GCList &ls, TCallable *callable);
void SetFailed(std::exception_ptr ex);
void SetSucceeded(TObject v);
TObject Wait();
void Mark();
static TTask *FromClosure(GCList &ls, TClosure *closure);
static TTask *FromCallStackEntry(GCList &ls, CallStackEntry *ent);
static TTask *Run(GCList &ls, TCallable *callable);
static TTask *FromResult(GCList &ls, TObject v);
};
extern thread_local CallStackEntry *current_function;
class InterperterThread : public THeapObject {
private:
bool InvokeTwo(GCList &ls, TObject fn, TObject left, TObject right);
bool InvokeOne(GCList &ls, TObject fn, TObject arg);
bool InvokeMethod(GCList &ls, TObject fn, TObject instance,
std::vector<TObject> args);
bool ExecuteMethod2(std::shared_ptr<GC> gc, TObject instance,
std::string key, std::vector<TObject> args);
protected:
static void *ThreadCallback(void *ptr);
bool JumpIfDefined(std::shared_ptr<GC> gc);
bool Add(std::shared_ptr<GC> gc);
bool Sub(std::shared_ptr<GC> gc);
bool Times(std::shared_ptr<GC> gc);
bool Divide(std::shared_ptr<GC> gc);
bool Mod(std::shared_ptr<GC> gc);
bool Neg(std::shared_ptr<GC> gc);
bool Lt(std::shared_ptr<GC> gc);
bool Gt(std::shared_ptr<GC> gc);
bool Lte(std::shared_ptr<GC> gc);
bool Gte(std::shared_ptr<GC> gc);
bool Eq(std::shared_ptr<GC> gc);
bool NEq(std::shared_ptr<GC> gc);
bool LShift(std::shared_ptr<GC> gc);
bool RShift(std::shared_ptr<GC> gc);
bool BOr(std::shared_ptr<GC> gc);
bool XOr(std::shared_ptr<GC> gc);
bool LNot(std::shared_ptr<GC> gc);
bool BNot(std::shared_ptr<GC> gc);
bool BAnd(std::shared_ptr<GC> gc);
bool ExecuteFunction(std::shared_ptr<GC> gc);
bool ExecuteMethod(std::shared_ptr<GC> gc);
bool GetVariable(std::shared_ptr<GC> gc);
bool SetVariable(std::shared_ptr<GC> gc);
bool GetField(std::shared_ptr<GC> gc);
bool SetField(std::shared_ptr<GC> gc);
bool GetArray(std::shared_ptr<GC> gc);
bool SetArray(std::shared_ptr<GC> gc);
bool DeclareVariable(std::shared_ptr<GC> gc);
bool DeclareConstVariable(std::shared_ptr<GC> gc);
bool PushLong(std::shared_ptr<GC> gc);
bool PushDouble(std::shared_ptr<GC> gc);
bool PushChar(std::shared_ptr<GC> gc);
bool PushString(std::shared_ptr<GC> gc);
bool PushClosure(std::shared_ptr<GC> gc);
bool PushScopelessClosure(std::shared_ptr<GC> gc);
bool PushResource(std::shared_ptr<GC> gc);
bool Illegal(std::shared_ptr<GC> gc);
bool Throw(std::shared_ptr<GC> gc);
bool Yield(std::shared_ptr<GC> gc);
bool Jump(std::shared_ptr<GC> gc);
bool JumpConditional(std::shared_ptr<GC> gc);
bool JumpUndefined(std::shared_ptr<GC> gc);
bool Defer(std::shared_ptr<GC> gc);
bool TryCatch(std::shared_ptr<GC> gc);
bool Return(std::shared_ptr<GC> gc);
bool ScopeBegin(std::shared_ptr<GC> gc);
bool ScopeEnd(std::shared_ptr<GC> gc);
bool ScopeEndTimes(std::shared_ptr<GC> gc);
bool PushTrue(std::shared_ptr<GC> gc);
bool PushFalse(std::shared_ptr<GC> gc);
bool PushNull(std::shared_ptr<GC> gc);
bool PushUndefined(std::shared_ptr<GC> gc);
bool CreateDictionary(std::shared_ptr<GC> gc);
bool CreateArray(std::shared_ptr<GC> gc);
bool AppendList(std::shared_ptr<GC> gc);
bool AppendDictionary(std::shared_ptr<GC> gc);
bool PushRootPath(std::shared_ptr<GC> gc);
bool PushRelativePath(std::shared_ptr<GC> gc);
bool Pop(std::shared_ptr<GC> gc);
bool Dup(std::shared_ptr<GC> gc);
bool Nop(std::shared_ptr<GC> gc);
bool Breakpoint(std::shared_ptr<GC> gc);
bool PushBreak(std::shared_ptr<GC> gc);
bool PushContinue(std::shared_ptr<GC> gc);
bool JumpIfBreak(std::shared_ptr<GC> gc);
bool JumpIfContinue(std::shared_ptr<GC> gc);
bool LineInfo(std::shared_ptr<GC> gc);
bool PushResourceStream(std::shared_ptr<GC> gc);
bool PushResourceDirectory(std::shared_ptr<GC> gc);
bool PushPrivateExpression(std::shared_ptr<GC> gc);
public:
static InterperterThread *Create(GCList *ls);
static InterperterThread *Create(GCList &ls);
std::vector<CallStackEntry *> call_stack_entries;
virtual void Execute(std::shared_ptr<GC> gc);
void AddCallStackEntry(GCList &ls, TClosure *closure,
std::vector<TObject> args);
void Mark();
};
class VMException : public std::exception {
std::string error_message;
public:
VMException(std::string ex) {
error_message = "VMException: ";
error_message.append(ex);
}
const char *what() const noexcept override { return error_message.c_str(); }
};
class TAny : public THeapObject {
public:
std::any any;
TObject other;
static TAny *Create(GCList &ls);
static TAny *Create(GCList *ls);
void Mark();
};
class TNativeObject : public THeapObject {
public:
template <typename T, typename... TArgs>
static T *Create(GCList &ls, TArgs... args) {
T *obj = new T(args...);
std::shared_ptr<GC> gc = ls.GetGC();
ls.Add(obj);
gc->Watch(obj);
return obj;
}
template <typename T, typename... TArgs>
static T *Create(GCList *ls, TArgs... args) {
T *obj = new T(args...);
std::shared_ptr<GC> gc = ls->GetGC();
ls->Add(obj);
gc->Watch(obj);
return obj;
}
virtual TObject CallMethod(GCList &ls, std::string name,
std::vector<TObject> args) = 0;
virtual std::string TypeName() = 0;
virtual bool ToBool();
virtual bool Equals(std::shared_ptr<GC> gc, TObject right);
virtual ~TNativeObject();
};
class TRandom : public TNativeObject {
public:
Tesses::Framework::Random random;
TRandom();
TRandom(uint64_t seed);
std::string TypeName();
TObject CallMethod(GCList &ls, std::string name, std::vector<TObject> args);
};
class TNative : public THeapObject {
std::atomic<bool> destroyed;
void *ptr;
std::function<void(void *)> destroy;
public:
TObject other;
TNative(void *ptr, std::function<void(void *)> destroy);
bool GetDestroyed();
void *GetPointer();
void Destroy();
void Mark();
static TNative *Create(GCList &ls, void *ptr,
std::function<void(void *)> destroy);
static TNative *Create(GCList *ls, void *ptr,
std::function<void(void *)> destroy);
~TNative();
};
class ThreadHandle : public THeapObject {
public:
Tesses::Framework::Threading::Thread *thrd;
std::atomic<bool> hasInit;
std::atomic<bool> hasReturned;
std::atomic<bool> detached;
TCallable *callable;
TObject returnValue;
std::shared_ptr<GC> gc;
void Mark() {
if (this->marked)
return;
this->marked = true;
callable->Mark();
GC::Mark(returnValue);
}
~ThreadHandle() {
if (this->detached) {
this->thrd->Join();
delete this->thrd;
}
}
};
TObject ExecuteFunction(GCList &ls, TCallable *callable,
std::vector<TObject> args);
class VMByteCodeException : public std::exception {
std::string lastErrorText;
std::shared_ptr<GCList> gcList;
public:
TObject exception;
std::vector<CallStackEntry *> stack_trace;
VMByteCodeException() {}
VMByteCodeException(std::shared_ptr<GC> gc, TObject obj,
CallStackEntry *ent) {
gcList = std::make_shared<GCList>(gc);
gcList->Add(obj);
if (ent != nullptr && ent->thread != nullptr) {
this->stack_trace = ent->thread->call_stack_entries;
for (auto item : this->stack_trace)
gcList->Add(item);
}
this->exception = obj;
UpdateError();
}
void UpdateError() { lastErrorText = ToString(gcList->GetGC(), exception); }
const char *what() const noexcept override { return lastErrorText.c_str(); }
std::shared_ptr<GCList> GetGCList() { return this->gcList; }
};
class SyntaxException : public std::exception {
std::string msg = {};
LexTokenLineInfo line;
std::string message;
public:
SyntaxException(LexTokenLineInfo lineInfo, std::string message)
: line(lineInfo), message(message) {
msg.append("in file: ");
msg.append(lineInfo.filename);
msg.append(":");
msg.append(std::to_string(lineInfo.line));
msg.append(":");
msg.append(std::to_string(lineInfo.column));
msg.append(":");
msg.append(std::to_string(lineInfo.offset));
msg.append(": ");
msg.append(message);
}
const char *what() const noexcept override { return msg.c_str(); }
std::string Message() { return message; }
LexTokenLineInfo LineInfo() { return line; }
};
template <typename T> bool GetObject(TObject &obj, T &res) {
if (!std::holds_alternative<T>(obj))
return false;
res = std::get<T>(obj);
return true;
}
template <typename T>
bool GetArgument(std::vector<TObject> &args, size_t index, T &obj) {
if (index >= args.size())
return false;
return GetObject(args[index], obj);
}
template <typename T> bool GetObjectHeap(TObject &obj, T &res) {
THeapObjectHolder h;
if (!GetObject<THeapObjectHolder>(obj, h))
return false;
auto v = dynamic_cast<T>(h.obj);
if (v == nullptr)
return false;
res = v;
return true;
}
template <typename T>
bool GetArgumentHeap(std::vector<TObject> &args, size_t index, T &obj) {
if (index >= args.size())
return false;
return GetObjectHeap(args[index], obj);
}
bool GetObjectAsPath(TObject &obj, Tesses::Framework::Filesystem::VFSPath &path,
bool allowString = true);
bool GetArgumentAsPath(std::vector<TObject> &args, size_t index,
Tesses::Framework::Filesystem::VFSPath &path,
bool allowString = true);
bool ToBool(TObject obj);
bool Equals(std::shared_ptr<GC> gc, TObject left, TObject right);
typedef void (*PluginFunction)(std::shared_ptr<GC> gc, TRootEnvironment *env);
#if !defined(_WIN32)
#define DLLEXPORT
#else
#define DLLEXPORT __declspec(dllexport)
#endif
#define CROSSLANG_PLUGIN(plugin) \
DLLEXPORT extern "C" void CrossLangPluginInit(std::shared_ptr<GC> gc, \
TRootEnvironment *env) { \
plugin(gc, env); \
}
void LoadPlugin(std::shared_ptr<GC> gc, TRootEnvironment *env,
Tesses::Framework::Filesystem::VFSPath sharedObjectPath);
std::string Json_Encode(TObject o, bool indent = false);
TObject Json_Decode(GCList ls, std::string str);
std::string Json_DocEncode(TObject o, bool indent);
TObject Json_DocDecode(GCList ls, std::string str);
// DO NOT USE DIRECTLY
class SharedPtrTObject {
GCList *ls;
TObject o;
public:
SharedPtrTObject(std::shared_ptr<GC> gc, TObject o);
TObject &GetObject();
std::shared_ptr<GC> GetGC();
~SharedPtrTObject();
};
using MarkedTObject = std::shared_ptr<SharedPtrTObject>;
MarkedTObject CreateMarkedTObject(std::shared_ptr<GC> gc, TObject o);
MarkedTObject CreateMarkedTObject(GCList *gc, TObject o);
MarkedTObject CreateMarkedTObject(GCList &gc, TObject o);
std::string JoinPeriod(std::vector<std::string> &p);
TObject GetClassInfo(GCList &ls, TFile *f, uint32_t index);
extern Tesses::Framework::Filesystem::VFSPath CrossLangConfigPath;
std::shared_ptr<Tesses::Framework::Http::IHttpServer>
ToHttpServer(std::shared_ptr<GC> gc, TObject obj);
class EmbedStream : public Tesses::Framework::Streams::Stream {
size_t offset;
MarkedTObject file;
uint32_t resource;
public:
EmbedStream(std::shared_ptr<GC> gc, TFile *file, uint32_t resource);
bool CanRead();
bool CanSeek();
bool EndOfStream();
size_t Read(uint8_t *buff, size_t len);
int64_t GetPosition();
int64_t GetLength();
void Seek(int64_t pos, Tesses::Framework::Streams::SeekOrigin whence);
};
class EmbedDirectory : public Tesses::Framework::Filesystem::VFS {
MarkedTObject dir;
TObject getEntry(Tesses::Framework::Filesystem::VFSPath path);
public:
EmbedDirectory(std::shared_ptr<GC> gc, TDictionary *dict);
std::shared_ptr<Tesses::Framework::Streams::Stream>
OpenFile(Tesses::Framework::Filesystem::VFSPath path, std::string mode);
Tesses::Framework::Filesystem::VFSPathEnumerator
EnumeratePaths(Tesses::Framework::Filesystem::VFSPath path);
std::string VFSPathToSystem(Tesses::Framework::Filesystem::VFSPath path);
Tesses::Framework::Filesystem::VFSPath SystemToVFSPath(std::string path);
bool Stat(Tesses::Framework::Filesystem::VFSPath path,
Tesses::Framework::Filesystem::StatData &data);
};
namespace Programs {
int64_t CrossArchiveCreate(std::vector<std::string> &argv);
int64_t CrossArchiveExtract(std::vector<std::string> &argv);
TObject CrossLangInterperter(GCList &ls, TRootEnvironment *env,
std::vector<std::string> &argv);
TObject CrossLangShell(GCList &ls, std::vector<std::string> &argv);
TObject CrossLangVM(GCList &ls, TRootEnvironment *env,
std::vector<std::string> &argv);
void CrossLangDump(std::shared_ptr<Tesses::Framework::Streams::Stream> strm);
void CrossLangCompiler(std::vector<std::string> &argv);
} // namespace Programs
enum class TQueryableMode {
Passthrough,
Skip,
SkipWhile,
Take,
TakeWhile,
Select,
Where
};
class TQueryable : public THeapObject {
TObject parent;
TQueryableMode mode;
std::vector<TObject> args;
TQueryable(TObject parent);
TQueryable(TObject parent, TQueryableMode mode, std::vector<TObject> args);
public:
static TQueryable *Create(GCList &ls, TObject parent);
static TQueryable *Create(GCList &ls, TObject parent, TQueryableMode mode,
std::vector<TObject> args);
TQueryable *Skip(GCList &ls, int64_t no);
TQueryable *SkipWhile(GCList &ls, TCallable *call);
TQueryable *Take(GCList &ls, int64_t no);
TQueryable *TakeWhile(GCList &ls, TCallable *call);
TQueryable *Select(GCList &ls, TCallable *call);
TQueryable *Where(GCList &ls, TCallable *call);
void ForEach(std::shared_ptr<GC> gc, TCallable *call);
int64_t Count(std::shared_ptr<GC> gc, TCallable *call);
int64_t Count(std::shared_ptr<GC> gc);
bool Contains(std::shared_ptr<GC>, TObject value);
bool Any(std::shared_ptr<GC> gc, TCallable *call);
bool All(std::shared_ptr<GC> gc, TCallable *call);
TList *ToList(GCList &ls);
TEnumerator *GetEnumerator(GCList &ls);
void Mark();
};
}; // namespace Tesses::CrossLang
Reference in New Issue View Git Blame Copy Permalink