tesses50
/
tesses-webserver-cpp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
tesses-webserver-cpp/tessesscriptengine.hpp

4233 lines
141 KiB
C++
Raw Blame History

#pragma once
#include "tesseswebserver.hpp"
#if defined(INCLUDED_FROM_TESSESWEBSERVER_H)
namespace ScriptEngine
#else
namespace Tesses::WebServer::ScriptEngine
#endif
{
class Instruction
{
public:
virtual int Length()=0;
virtual void Write(uint8_t* buffer)=0;
virtual ~Instruction()
{
}
const static uint8_t ADD = 0;
const static uint8_t SUB = 1;
const static uint8_t TIMES = 2;
const static uint8_t DIVIDE = 3;
const static uint8_t MOD = 4;
const static uint8_t LEFTSHIFT = 5;
const static uint8_t RIGHTSHIFT = 6;
const static uint8_t LESSTHAN = 7;
const static uint8_t GREATERTHAN = 8;
const static uint8_t LESSTHANEQUALTO = 9;
const static uint8_t GREATERTHANEQUALTO = 10;
const static uint8_t EQUALS = 11;
const static uint8_t NOTEQUALS = 12;
const static uint8_t BITWISEOR = 13;
const static uint8_t BITWISEAND = 14;
const static uint8_t BITWISENOT = 15;
const static uint8_t EXCLUSIVEOR = 16;
const static uint8_t LOGICALNOT = 17;
const static uint8_t NEGATIVE = 18;
const static uint8_t GETVARIABLE = 19;
const static uint8_t SETVARIABLE = 20;
const static uint8_t GETFIELD = 21;
const static uint8_t SETFIELD = 22;
const static uint8_t GETARRAY = 23;
const static uint8_t SETARRAY = 24;
const static uint8_t PUSH_STRING = 25;
const static uint8_t PUSH_CHAR = 26;
const static uint8_t PUSH_LONG = 27;
const static uint8_t PUSH_DOUBLE = 28;
const static uint8_t SET_LOOP = 29; //for scoping reasons
const static uint8_t GET_LOOP = 30;
const static uint8_t DESTROY_LOOP = 31;
const static uint8_t CALL_FUNC = 32;
const static uint8_t CALL_METHOD = 33;
const static uint8_t PRINT = 34;
const static uint8_t JMPC = 35;
const static uint8_t JMP = 36;
const static uint8_t POP = 37;
const static uint8_t RET = 38;
const static uint8_t SCOPE_BEGIN = 39;
const static uint8_t SCOPE_END = 40;
const static uint8_t GET_GLOBAL_VARIABLE = 41;
const static uint8_t SET_GLOBAL_VARIABLE = 42;
const static uint8_t GET_CALLER_VARIABLE = 43;
const static uint8_t SET_CALLER_VARIABLE = 44;
const static uint8_t DECLARE_VARIABLE = 45;
const static uint8_t PUSH_NULL = 46;
const static uint8_t PUSH_UNDEFINED = 47;
const static uint8_t PUSH_FALSE = 48;
const static uint8_t PUSH_TRUE = 49;
const static uint8_t ITTR = 50;
#if defined(DEBUG)
virtual void Print()
{
}
#endif
};
class Object {
public:
virtual std::string ToString()
{
return "";
}
virtual bool ToBool()
{
return false;
}
virtual bool CanDestroy()
{
return true;
}
virtual ~Object()
{
}
};
class Undefined {
};
class Null
{
};
class ObjectType {
public:
Object* data;
ObjectType(Object* o)
{
this->data = o;
}
};
typedef std::variant<std::string,ObjectType> IttrType;
class IttrKVP {
public:
IttrType ittr;
int64_t index;
};
typedef std::variant<Undefined,Null,ObjectType,IttrKVP,std::string,int64_t,double,bool,char> ScriptType;
class Ittr : public Object {
public:
IttrType ittr;
int64_t index;
};
inline bool Equals(ScriptType& left, ScriptType& right)
{
if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
{
return std::get<std::string>(left) == std::get<std::string>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) == std::get<int64_t>(right);
}
if(std::holds_alternative<char>(left) && std::holds_alternative<char>(right))
{
return std::get<char>(left) == std::get<char>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) == std::get<double>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) == std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) == (double)std::get<int64_t>(right);
}
if(std::holds_alternative<bool>(left) && std::holds_alternative<bool>(right))
{
return std::get<bool>(left) == std::get<bool>(right);
}
if(std::holds_alternative<Undefined>(left) && std::holds_alternative<Undefined>(right))
{
return true;
}
if(std::holds_alternative<Null>(left) && std::holds_alternative<Null>(right))
{
return true;
}
if(std::holds_alternative<ObjectType>(left) && std::holds_alternative<ObjectType>(right))
{
auto objLeft = std::get<ObjectType>(left).data;
auto objRight = std::get<ObjectType>(right).data;
if(objLeft == objRight)
return true;
}
return false;
}
inline bool ConvertToBool(ScriptType& st)
{
if(std::holds_alternative<std::string>(st))
{
return std::get<std::string>(st).size() > 0;
}
if(std::holds_alternative<int64_t>(st))
{
return std::get<int64_t>(st) != 0;
}
if(std::holds_alternative<double>(st))
{
return std::get<double>(st) != 0;
}
if(std::holds_alternative<bool>(st))
{
return std::get<bool>(st);
}
if(std::holds_alternative<char>(st))
{
return std::get<char>(st) != 0;
}
if(std::holds_alternative<ObjectType>(st))
{
return std::get<ObjectType>(st).data->ToBool();
}
return false;
}
inline ScriptType IttrGetValue(ScriptType& st);
inline std::string IttrGetKey(ScriptType& st);
inline std::string ConvertToString(ScriptType& st);
inline std::string ConvertToString(ScriptType& st)
{
if(std::holds_alternative<IttrKVP>(st))
{
auto v = IttrGetValue(st);
return IttrGetKey(st) + ": " + ConvertToString(v);
}
if(std::holds_alternative<Null>(st))
{
return "null";
}
if(std::holds_alternative<std::string>(st))
{
return std::get<std::string>(st);
}
if(std::holds_alternative<int64_t>(st))
{
return std::to_string(std::get<int64_t>(st));
}
if(std::holds_alternative<double>(st))
{
return std::to_string(std::get<double>(st));
}
if(std::holds_alternative<bool>(st))
{
return std::get<bool>(st) ? "true" : "false";
}
if(std::holds_alternative<char>(st))
{
return std::string({std::get<char>(st)});
}
if(std::holds_alternative<ObjectType>(st))
{
return std::get<ObjectType>(st).data->ToString();
}
return "undefined";
}
class RootEnvironment;
class Environment {
public:
std::function<void(ScriptType)> print;
virtual bool HasObject(std::string key) = 0;
virtual bool HasObjectRecurse(std::string key) = 0;
virtual ScriptType GetValue(std::string key) = 0;
virtual void SetValue(std::string key,ScriptType val) = 0;
virtual Environment* GetRoot()=0;
virtual Environment* GetParent()=0;
virtual Environment* GetGlobal()
{
return this->GetRoot()->GetGlobal();
}
virtual void Declare(std::string key,ScriptType val)
{
SetValue(key,val);
}
Environment* GetSub();
virtual ~Environment()
{
}
};
class SubEnvironment : public Environment
{
Environment* parent;
public:
std::map<std::string,ScriptType> items;
SubEnvironment(Environment* env)
{
this->parent = env;
}
Environment* GetParent()
{
return parent;
}
Environment* GetRoot()
{
return parent->GetRoot();
}
bool HasObject(std::string key)
{
return items.count(key) > 0;
}
bool HasObjectRecurse(std::string key)
{
if(items.count(key) > 0) return true;
return this->parent->HasObjectRecurse(key);
}
ScriptType GetValue(std::string key)
{
if(HasObject(key))
{
return items[key];
}
return this->parent->GetValue(key);
}
void SetValue(std::string key,ScriptType val)
{
if(HasObject(key))
{
items[key] = val;
return;
}
if(this->parent->HasObjectRecurse(key))
{
this->parent->SetValue(key,val);
}
items[key] = val;
}
void Declare(std::string key,ScriptType val)
{
this->items[key] = val;
}
};
inline Environment* Environment::GetSub()
{
SubEnvironment* env = new SubEnvironment(this);
env->print = this->print;
return env;
}
class CallableObject : public Object
{
public:
bool useGlobalEnv=false;
virtual bool FirstArgumentIsThis()
{
return false;
}
bool CanDestroy()
{
return false;
}
virtual ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
{
return Null();
}
ScriptType Execute(Environment* callerEnv,std::initializer_list<ScriptType> args)
{
return Execute(callerEnv,std::vector<ScriptType>(args));
}
std::string ToString()
{
return "";
}
bool ToBool()
{
return true;
}
};
class ExternalFunction : public CallableObject {
public:
std::function<ScriptType(Environment*,std::vector<ScriptType>)> callback;
bool firstArgIsThis;
bool FirstArgumentIsThis()
{
return firstArgIsThis;
}
ExternalFunction(std::function<ScriptType(Environment*,std::vector<ScriptType>)> callback,bool firstArgIsThis=false)
{
this->callback = callback;
this->firstArgIsThis = firstArgIsThis;
}
ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
{
return callback(callerEnv,args);
}
~ExternalFunction()
{
}
};
class InternalFunction;
class List : public Object {
public:
std::vector<ScriptType> items;
std::string ToString()
{
return "";
}
bool ToBool()
{
return items.size() > 0;
}
};
class Dictionary : public Object {
public:
std::vector<std::pair<std::string,ScriptType>> items;
std::string ToString()
{
return "";
}
bool ToBool()
{
return items.size() > 0;
}
bool HasValue(std::string key)
{
for(auto item : items)
if(item.first == key) return true;
return false;
}
ScriptType GetValue(std::string key)
{
for(auto item : items)
if(item.first == key) return item.second;
return Undefined();
}
void SetValue(std::string key, ScriptType& value)
{
if(std::holds_alternative<Undefined>(value))
{
for(auto item = items.cbegin();item <= items.cend();item++)
{
auto myItem = *item;
if(myItem.first == key)
{
items.erase(item);
return;
}
}
}
else
{
for(auto item : items)
{
if(item.first == key)
{
item.second = value;
return;
}
}
items.push_back(std::pair<std::string,ScriptType>(key,value));
}
}
};
inline ScriptType CreateIttrFor(ScriptType& st)
{
if(std::holds_alternative<std::string>(st))
{
Ittr* ittr =new Ittr();
ittr->index = -1;
ittr->ittr = std::get<std::string>(st);
ObjectType t(ittr);
return t;
}
if(std::holds_alternative<ObjectType>(st))
{
auto ot = std::get<ObjectType>(st).data;
auto ls = dynamic_cast<List*>(ot);
auto dict = dynamic_cast<Dictionary*>(ot);
if(ls != nullptr)
{
Ittr* ittr=new Ittr();
ittr->index = -1;
ittr->ittr = ObjectType(ls);
ObjectType t(ittr);
return t;
}
if(dict != nullptr)
{
Ittr* ittr=new Ittr();
ittr->index = -1;
ittr->ittr = ObjectType(dict);
ObjectType t(ittr);
return t;
}
}
return Null();
}
inline bool IttrMoveNext(ScriptType& st)
{
if(std::holds_alternative<ObjectType>(st))
{
auto objIttr = std::get<ObjectType>(st).data;
auto ittr = dynamic_cast<Ittr*>(objIttr);
if(ittr == nullptr) return false;
if(std::holds_alternative<std::string>(ittr->ittr))
{
std::string str = std::get<std::string>(ittr->ittr);
if(ittr->index >= -1 && ittr->index + 1 < str.size())
{
(ittr->index)++;
return true;
}
}
if(std::holds_alternative<ObjectType>(ittr->ittr))
{
auto ot = std::get<ObjectType>(ittr->ittr).data;
auto ls = dynamic_cast<List*>(ot);
auto dict = dynamic_cast<Dictionary*>(ot);
if(ls != nullptr)
{
if(ittr->index >= -1 && ittr->index + 1 < ls->items.size())
{
(ittr->index)++;
return true;
}
}
if(dict != nullptr)
{
if(ittr->index >= -1 && ittr->index + 1 < dict->items.size())
{
(ittr->index)++;
return true;
}
}
}
}
return false;
}
inline ScriptType IttrCurrent(ScriptType& st)
{
if(std::holds_alternative<ObjectType>(st))
{
auto objIttr = std::get<ObjectType>(st).data;
auto ittr = dynamic_cast<Ittr*>(objIttr);
if(ittr == nullptr) return Null();
if(std::holds_alternative<std::string>(ittr->ittr))
{
std::string str = std::get<std::string>(ittr->ittr);
if(ittr->index >= 0 && ittr->index < str.size())
{
return str[ittr->index];
}
}
if(std::holds_alternative<ObjectType>(ittr->ittr))
{
auto ot = std::get<ObjectType>(ittr->ittr).data;
auto ls = dynamic_cast<List*>(ot);
auto dict = dynamic_cast<Dictionary*>(ot);
if(ls != nullptr)
{
if(ittr->index >= 0 && ittr->index < ls->items.size())
{
return ls->items[ittr->index];
}
}
if(dict != nullptr)
{
if(ittr->index >= 0 && ittr->index < dict->items.size())
{
IttrKVP kvp;
kvp.index = ittr->index;
kvp.ittr = ittr->ittr;
return kvp;
}
}
}
}
return Null();
}
inline std::string IttrGetKey(ScriptType& st)
{
if(std::holds_alternative<IttrKVP>(st))
{
auto ittr = std::get<IttrKVP>(st);
if(std::holds_alternative<ObjectType>(ittr.ittr))
{
auto ot = std::get<ObjectType>(ittr.ittr).data;
auto dict = dynamic_cast<Dictionary*>(ot);
if(dict != nullptr)
{
if(ittr.index >= 0 && ittr.index < dict->items.size())
{
return dict->items[ittr.index].first;
}
}
}
}
return std::string({});
}
inline ScriptType IttrGetValue(ScriptType& st)
{
if(std::holds_alternative<IttrKVP>(st))
{
auto ittr = std::get<IttrKVP>(st);
if(std::holds_alternative<ObjectType>(ittr.ittr))
{
auto ot = std::get<ObjectType>(ittr.ittr).data;
auto dict = dynamic_cast<Dictionary*>(ot);
if(dict != nullptr)
{
if(ittr.index >= 0 && ittr.index < dict->items.size())
{
return dict->items[ittr.index].second;
}
}
}
}
return Null();
}
inline ScriptType TypeOf(Environment* env, std::vector<ScriptType> args);
class RootEnvironment : public Environment
{
std::vector<CallableObject*> fns;
public:
RootEnvironment()
{
DeclareFunctions();
}
Environment* global=nullptr;
std::map<std::string,ScriptType> items;
Environment* GetRoot()
{
return this;
}
Environment* GetGlobal()
{
if(global != nullptr) return global;
return this;
}
Environment* GetParent()
{
return this;
}
bool HasObject(std::string key)
{
return items.count(key) > 0;
}
bool HasObjectRecurse(std::string key)
{
return items.count(key) > 0;
}
ScriptType GetValue(std::string key)
{
return items[key];
}
void SetValue(std::string key,ScriptType val)
{
items[key] = val;
}
void Free(ScriptType t,bool tree=false)
{
if(std::holds_alternative<ObjectType>(t))
{
auto myObj=std::get<ObjectType>(t);
if(tree)
{
auto ls = dynamic_cast<List*>(myObj.data);
auto dict = dynamic_cast<Dictionary*>(myObj.data);
if(ls != nullptr)
{
for(auto item : ls->items)
Free(item,true);
}
if(dict != nullptr)
{
for(auto item : dict->items)
Free(item.second,true);
}
}
if(myObj.data != nullptr && myObj.data->CanDestroy())
delete myObj.data;
}
}
void DeclareFunctions()
{
DeclareFunction("dictionary",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
Dictionary* dict=new Dictionary();
ObjectType ot(dict);
return ot;
});
DeclareFunction("list",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
List* list=new List();
ObjectType ot(list);
return ot;
});
DeclareFunction("typeof",TypeOf);
DeclareFunction("free",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
if(args.size() > 0)
{
Free(args[0]);
}
return Null();
});
DeclareFunction("free_tree",[this](Environment* env, std::vector<ScriptType> args)-> ScriptType {
if(args.size() > 0)
{
Free(args[0],true);
}
return Null();
});
}
void DeclareFunction(std::string name,std::function<ScriptType(Environment* env, std::vector<ScriptType>)> method)
{
ExternalFunction* item = new ExternalFunction(method);
fns.push_back(item);
ObjectType ot(item);
SetValue(name,ot);
}
~RootEnvironment()
{
for(auto item : fns)
delete item;
}
};
class ChunkExecuter
{
uint8_t* bytecode;
size_t bytecodeLength;
std::vector<std::string>* args;
size_t ip=0;
std::stack<ScriptType> stack;
Environment* env;
public:
ChunkExecuter(Environment* env,uint8_t* bytecode,size_t bytecodeLength,std::vector<std::string>* args)
{
this->bytecode = bytecode;
this->bytecodeLength = bytecodeLength;
this->args = args;
this->env = env;
}
ScriptType Pop()
{
if(stack.empty()) throw std::exception();
ScriptType t = stack.top();
stack.pop();
return t;
}
template<typename T>
T PopSpecific()
{
auto p = Pop();
if(std::holds_alternative<T>(p))
{
return std::get<T>(p);
}
else
{
std::vector<ScriptType> args;
args.push_back(p);
auto v = TypeOf(env,args);
this->env->print("IP: ");
this->env->print((int64_t)ip);
this->env->print("Unexpected type: ");
this->env->print(v);
this->env->print(" with value ");
this->env->print(p);
this->env->print("\n");
throw std::exception();
}
}
int64_t PopLong()
{
auto val = PopSpecific<int64_t>();
return val;
}
std::string PopString()
{
auto val = PopSpecific<std::string>();
return val;
}
ScriptType Mod(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) % std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return fmod(std::get<double>(left), (double)std::get<int64_t>(right));
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return fmod((double)std::get<int64_t>(left), std::get<double>(right));
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return fmod(std::get<double>(left),std::get<double>(right));
}
return Null();
}
ScriptType Divide(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) / std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) / (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) / std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) / std::get<double>(right);
}
return Null();
}
ScriptType Times(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) * std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) * (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) * std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) * std::get<double>(right);
}
return Null();
}
ScriptType GreaterThan(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) > std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) > (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) > std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) > std::get<double>(right);
}
return Null();
}
ScriptType LessThan(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) < std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) < (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) < std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) < std::get<double>(right);
}
return Null();
}
ScriptType GreaterThanEqualsTo(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) >= std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) >= (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) >= std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) >= std::get<double>(right);
}
return Null();
}
ScriptType LessThanEqualsTo(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) <= std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) <= (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) <= std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) <= std::get<double>(right);
}
return Null();
}
ScriptType Sub(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) - std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) - (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) - std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) - std::get<double>(right);
}
return Null();
}
ScriptType Add(ScriptType& left,ScriptType& right)
{
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<int64_t>(left) + std::get<int64_t>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<double>(left) + (double)std::get<int64_t>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<double>(right))
{
return (double)std::get<int64_t>(left) + std::get<double>(right);
}
if(std::holds_alternative<double>(left) && std::holds_alternative<double>(right))
{
return std::get<double>(left) + std::get<double>(right);
}
if(std::holds_alternative<std::string>(left) && std::holds_alternative<std::string>(right))
{
return std::get<std::string>(left) + std::get<std::string>(right);
}
if(std::holds_alternative<int64_t>(left) && std::holds_alternative<std::string>(right))
{
return std::to_string(std::get<int64_t>(left)) + std::get<std::string>(right);
}
if(std::holds_alternative<std::string>(left) && std::holds_alternative<int64_t>(right))
{
return std::get<std::string>(left) + std::to_string(std::get<int64_t>(right));
}
if(std::holds_alternative<double>(left) && std::holds_alternative<std::string>(right))
{
return std::to_string(std::get<double>(left)) + std::get<std::string>(right);
}
if(std::holds_alternative<std::string>(left) && std::holds_alternative<double>(right))
{
return std::get<std::string>(left) + std::to_string(std::get<double>(right));
}
if(std::holds_alternative<std::string>(left) && std::holds_alternative<char>(right))
{
return std::get<std::string>(left) + std::string({std::get<char>(right)});
}
if(std::holds_alternative<char>(left) && std::holds_alternative<std::string>(right))
{
return std::string({std::get<char>(left)}) + std::get<std::string>(right);
}
return Null();
}
ScriptType CallMethod(ScriptType& member, std::string key, std::vector<ScriptType>& args)
{
if(std::holds_alternative<Undefined>(member))
{
if(key == "toString")
{
return "undefined";
}
}
if(std::holds_alternative<Null>(member))
{
if(key == "toString")
{
return "null";
}
}
if(std::holds_alternative<ObjectType>(member))
{
auto obj = std::get<ObjectType>(member).data;
auto ls = dynamic_cast<List*>(obj);
auto dict = dynamic_cast<Dictionary*>(obj);
auto ittr = dynamic_cast<Ittr*>(obj);
if(ittr != nullptr)
{
if(key == "current")
{
return IttrCurrent(member);
}
if(key == "movenext")
{
return IttrMoveNext(member);
}
}
if(ls != nullptr)
{
if(key == "add" && args.size() > 0)
{
ls->items.push_back(args[0]);
}
else if(key == "remove" && args.size() > 0)
{
for(auto ittr = ls->items.cbegin();ittr<ls->items.cend();ittr++)
{
auto item = *ittr;
if(Equals(item,args[0]))
{
ls->items.erase(ittr);
break;
}
}
}
else if(key == "indexof" && args.size() > 0)
{
int64_t index = -1;
for(auto ittr = ls->items.cbegin();ittr<ls->items.cend();ittr++)
{
auto item = *ittr;
if(Equals(item,args[0]))
{
break;
}
index++;
}
return index;
}
else if(key == "insert" && args.size() > 1)
{
auto index = args[0];
if(std::holds_alternative<int64_t>(index))
{
auto myIndex=std::get<int64_t>(index);
if(myIndex >= 0 && myIndex <= ls->items.size())
{
ls->items.insert(ls->items.cbegin() + myIndex,{args[1]});
}
}
}
else if(key == "removeat" && args.size() > 0)
{
auto index = args[0];
if(std::holds_alternative<int64_t>(index))
{
auto myIndex=std::get<int64_t>(index);
if(myIndex >= 0 && myIndex < ls->items.size())
{
ls->items.erase(ls->items.cbegin() + myIndex);
}
}
}
else if(key == "count" || key == "length")
{
return (int64_t)ls->items.size();
}
else if(key == "clear") {
ls->items.clear();
}
else if(key == "at" && args.size() > 0)
{
auto index = args[0];
if(std::holds_alternative<int64_t>(index))
{
auto myIndex=std::get<int64_t>(index);
if(myIndex >= 0 && myIndex < ls->items.size())
{
return ls->items.at((size_t)myIndex);
}
}
}
else if(key == "set" && args.size() > 1)
{
auto index = args[0];
if(std::holds_alternative<int64_t>(index))
{
auto myIndex=std::get<int64_t>(index);
if(myIndex >= 0 && myIndex < ls->items.size())
{
return ls->items[(size_t)myIndex]=args[1];
}
}
}
}
if(dict != nullptr)
{
auto item = dict->GetValue(key);
if(std::holds_alternative<ObjectType>(item))
{
auto fnt = std::get<ObjectType>(item).data;
auto fn = dynamic_cast<CallableObject*>(fnt);
if(fn != nullptr)
{
if(fn->FirstArgumentIsThis())
args.insert(args.cbegin(),{member});
return fn->Execute(this->env,args);
}
}
if(key == "toString" && args.size() == 0)
{
return std::string({});
}
}
}
if(std::holds_alternative<int64_t>(member))
{
if(key == "toString")
{
return std::to_string(std::get<int64_t>(member));
}
if(key == "toDouble")
{
return (double)std::get<int64_t>(member);
}
if(key == "toDoubleBits")
{
return std::bit_cast<double>(std::get<int64_t>(member));
}
if(key == "toChar")
{
return (char)std::get<int64_t>(member);
}
}
if(std::holds_alternative<std::string>(member))
{
std::string myStr=std::get<std::string>(member);
if(key == "toString")
{
return myStr;
}
if(key == "length" || key == "count")
{
return (int64_t)myStr.size();
}
if(key == "toLower")
{
std::transform(myStr.begin(),myStr.end(),myStr.begin(),::tolower);
return myStr;
}
if(key == "toUpper")
{
std::transform(myStr.begin(),myStr.end(),myStr.begin(),::toupper);
return myStr;
}
}
if(std::holds_alternative<char>(member))
{
if(key == "toString")
{
return std::string({std::get<char>(member)});
}
if(key == "toLong")
{
return (int64_t)std::get<char>(member);
}
if(key == "toLower")
{
return (char)std::tolower(std::get<char>(member));
}
if(key == "toUpper")
{
return (char)std::toupper(std::get<char>(member));
}
}
if(std::holds_alternative<double>(member))
{
if(key == "toString")
{
return std::to_string(std::get<double>(member));
}
if(key == "toLong")
{
return (int64_t)std::get<double>(member);
}
if(key == "toLongBits")
{
return std::bit_cast<int64_t>(std::get<double>(member));
}
}
return Undefined();
}
ScriptType SetField(ScriptType& instance,std::string name,ScriptType& value)
{
if(std::holds_alternative<ObjectType>(instance))
{
auto inst = std::get<ObjectType>(instance).data;
auto dict = dynamic_cast<Dictionary*>(inst);
if(dict != nullptr)
{
auto myFuncObj = dict->GetValue(std::string("set") + name);
if(std::holds_alternative<ObjectType>(myFuncObj))
{
auto myFuncObj2 = std::get<ObjectType>(myFuncObj).data;
auto callbl = dynamic_cast<CallableObject*>(myFuncObj2);
if(callbl != nullptr)
{
if(callbl->FirstArgumentIsThis())
{
return callbl->Execute(env,{instance,value});
}
else
{
return callbl->Execute(env,{value});
}
}
}
dict->SetValue(name,value);
}
}
return value;
}
ScriptType GetField(ScriptType& instance, std::string name)
{
if(std::holds_alternative<std::string>(instance))
{
auto str = std::get<std::string>(instance);
if(name == "length" || name == "count")
{
return (int64_t)str.size();
}
}
if(std::holds_alternative<IttrKVP>(instance))
{
if(name == "key")
{
return IttrGetKey(instance);
}
if(name == "value")
{
return IttrGetValue(instance);
}
}
if(std::holds_alternative<ObjectType>(instance))
{
auto inst = std::get<ObjectType>(instance).data;
auto ls = dynamic_cast<List*>(inst);
auto dict = dynamic_cast<Dictionary*>(inst);
if(ls != nullptr)
{
if(name == "length" || name == "count")
{
return (int64_t)ls->items.size();
}
}
if(dict != nullptr)
{
auto myFuncObj = dict->GetValue(std::string("get") + name);
if(std::holds_alternative<ObjectType>(myFuncObj))
{
auto myFuncObj2 = std::get<ObjectType>(myFuncObj).data;
auto callbl = dynamic_cast<CallableObject*>(myFuncObj2);
if(callbl != nullptr)
{
if(callbl->FirstArgumentIsThis())
{
return callbl->Execute(env,{instance});
}
else
{
return callbl->Execute(env,{});
}
}
}
return dict->GetValue(name);
}
}
return Undefined();
}
ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> __args)
{
// std::cout << __args.size() << " " << this->args->size() << std::endl;
if(__args.size() != this->args->size())
{
callerEnv->print("Expected " + std::to_string((int64_t)this->args->size()) + " args, got " + std::to_string((int64_t)__args.size()) + " args.\n");
throw std::exception();
}
for(size_t i = 0;i<__args.size();i++)
{
env->Declare(this->args->at(i),__args[i]);
}
int scopes=0;
std::stack<int> loops;
while(ip < bytecodeLength)
{
uint8_t instruction = bytecode[ip];
ip++;
switch(instruction)
{
case Instruction::PUSH_FALSE:
{
stack.push(false);
}
break;
case Instruction::PUSH_TRUE:
{
stack.push(true);
}
break;
case Instruction::PUSH_NULL:
{
stack.push(Null());
}
break;
case Instruction::PUSH_UNDEFINED:
{
stack.push(Undefined());
}
break;
case Instruction::PUSH_CHAR:
{
if(ip + 1 <= bytecodeLength)
{
stack.push((char)bytecode[ip++]);
}
else
{
throw std::exception();
}
}
break;
case Instruction::CALL_FUNC:
{
int64_t lng=PopLong();
std::vector<ScriptType> _args;
for(int i = 0;i<lng;i++)
{
_args.insert(_args.cbegin(),{Pop()});
}
auto fCall = Pop();
auto myF=dynamic_cast<CallableObject*>(std::get<ObjectType>(fCall).data);
if(myF != nullptr)
{
stack.push(myF->Execute(env,_args));
}
else
{
stack.push(Null());
}
}
break;
case Instruction::CALL_METHOD:
{
int64_t lng=PopLong();
std::vector<ScriptType> _args;
for(int i = 0;i<lng;i++)
{
_args.insert(_args.cbegin(),{Pop()});
}
std::string key = PopString();
auto member = Pop();
stack.push(CallMethod(member,key,_args));
}
break;
case Instruction::EQUALS:
{
auto right = Pop();
auto left = Pop();
stack.push(Equals(left,right));
}
break;
case Instruction::NOTEQUALS:
{
auto right = Pop();
auto left = Pop();
bool v = !Equals(left,right);
stack.push(v);
}
break;
case Instruction::LESSTHAN:
{
auto right = Pop();
auto left = Pop();
stack.push(LessThan(left,right));
}
break;
case Instruction::GREATERTHAN:
{
auto right = Pop();
auto left = Pop();
stack.push(GreaterThan(left,right));
}
break;
case Instruction::LESSTHANEQUALTO:
{
auto right = Pop();
auto left = Pop();
stack.push(LessThanEqualsTo(left,right));
}
break;
case Instruction::GREATERTHANEQUALTO:
{
auto right = Pop();
auto left = Pop();
stack.push(GreaterThanEqualsTo(left,right));
}
break;
case Instruction::ADD:
{
auto right = Pop();
auto left = Pop();
stack.push(Add(left,right));
}
break;
case Instruction::SUB:
{
auto right = Pop();
auto left = Pop();
stack.push(Sub(left,right));
}
break;
case Instruction::TIMES:
{
auto right = Pop();
auto left = Pop();
stack.push(Times(left,right));
}
break;
case Instruction::DIVIDE:
{
auto right = Pop();
auto left = Pop();
stack.push(Divide(left,right));
}
break;
case Instruction::MOD:
{
auto right = Pop();
auto left = Pop();
stack.push(Mod(left,right));
}
break;
case Instruction::PUSH_LONG:
{
if(ip + 8 <= bytecodeLength)
{
uint64_t value = ((uint64_t)bytecode[ip++] << 56);
value |= ((uint64_t)bytecode[ip++] << 48);
value |= ((uint64_t)bytecode[ip++] << 40);
value |= ((uint64_t)bytecode[ip++] << 32);
value |= ((uint64_t)bytecode[ip++] << 24);
value |= ((uint64_t)bytecode[ip++] << 16);
value |= ((uint64_t)bytecode[ip++] << 8);
value |= (uint64_t)bytecode[ip++];
stack.push((int64_t)value);
}
}
break;
case Instruction::PUSH_DOUBLE:
{
if(ip + 8 <= bytecodeLength)
{
uint64_t value = ((uint64_t)bytecode[ip++] << 56);
value |= ((uint64_t)bytecode[ip++] << 48);
value |= ((uint64_t)bytecode[ip++] << 40);
value |= ((uint64_t)bytecode[ip++] << 32);
value |= ((uint64_t)bytecode[ip++] << 24);
value |= ((uint64_t)bytecode[ip++] << 16);
value |= ((uint64_t)bytecode[ip++] << 8);
value |= (uint64_t)bytecode[ip++];
stack.push(*(double*)&value);
}
}
break;
case Instruction::PUSH_STRING:
{
if(ip + 4 <= bytecodeLength)
{
size_t len = ((size_t)bytecode[ip++] << 24);
len |= ((size_t)bytecode[ip++] << 16);
len |= ((size_t)bytecode[ip++] << 8);
len |= (size_t)bytecode[ip++];;
if(ip + len <= bytecodeLength)
{
std::string str((char*)bytecode+ip,len);
ip+=len;
stack.push(str);
}
}
}
break;
case Instruction::GET_CALLER_VARIABLE:
{
auto str = PopString();
auto v=callerEnv->GetValue(str);
stack.push(v);
}
break;
case Instruction::SET_CALLER_VARIABLE:
{
auto v = Pop();
auto str = PopString();
callerEnv->SetValue(str,v);
stack.push(v);
}
break;
case Instruction::GET_GLOBAL_VARIABLE:
{
auto str = PopString();
auto v = env->GetGlobal()->GetValue(str);
stack.push(v);
}
break;
case Instruction::SET_GLOBAL_VARIABLE:
{
auto v = Pop();
auto str = PopString();
env->GetGlobal()->SetValue(str,v);
stack.push(v);
}
break;
case Instruction::GETVARIABLE:
{
auto str = PopString();
auto v = env->GetValue(str);
stack.push(v);
}
break;
case Instruction::SETVARIABLE:
{
auto v = Pop();
auto str = PopString();
env->SetValue(str,v);
stack.push(v);
}
break;
case Instruction::DECLARE_VARIABLE:
{
auto v = Pop();
auto str = PopString();
env->Declare(str,v);
stack.push(v);
}
break;
case Instruction::PRINT:
{
auto v = Pop();
callerEnv->print(v);
}
break;
case Instruction::SCOPE_BEGIN:
{
scopes++;
env = env->GetSub();
}
break;
case Instruction::SCOPE_END:
{
Environment* env2 = env;
env=env2->GetParent();
if(env != env2)
{
delete env2;
}
scopes--;
}
break;
case Instruction::SET_LOOP:
{
loops.push(scopes);
}
break;
case Instruction::GET_LOOP:
{
int myLoops = loops.top();
while(scopes > myLoops)
{
Environment* env2 = env;
env=env2->GetParent();
if(env != env2)
{
delete env2;
}
scopes--;
}
}
break;
case Instruction::DESTROY_LOOP:
{
int myLoops = loops.top();
loops.pop();
while(scopes > myLoops)
{
Environment* env2 = env;
env=env2->GetParent();
if(env != env2)
{
delete env2;
}
scopes--;
}
}
break;
case Instruction::RET:
{
auto val = Pop();
while(scopes > 0)
{
Environment* env2 = env;
env=env2->GetParent();
if(env != env2)
{
delete env2;
}
scopes--;
}
return val;
}
break;
case Instruction::JMP:
{
if(ip + 4 <= bytecodeLength)
{
size_t len = ((size_t)bytecode[ip++] << 24);
len |= ((size_t)bytecode[ip++] << 16);
len |= ((size_t)bytecode[ip++] << 8);
len |= (size_t)bytecode[ip++];
if(len < bytecodeLength)
ip = len;
else
{
std::cout << "Jump failed" << std::endl;
throw std::exception();
}
}
}
break;
case Instruction::JMPC:
{
if(ip + 4 <= bytecodeLength)
{
size_t len = ((size_t)bytecode[ip++] << 24);
len |= ((size_t)bytecode[ip++] << 16);
len |= ((size_t)bytecode[ip++] << 8);
len |= (size_t)bytecode[ip++];
if(len < bytecodeLength)
{
auto v = Pop();
if(ConvertToBool(v))
ip = len;
}
else
{
std::cout << "Jump failed" << std::endl;
throw std::exception();
}
}
}
break;
case Instruction::ITTR:
{
auto ittr=Pop();
stack.push(CreateIttrFor(ittr));
}
break;
case Instruction::GETFIELD:
{
std::string name = PopString();
auto instance = Pop();
stack.push(GetField(instance,name));
}
break;
case Instruction::SETFIELD:
{
auto val = Pop();
std::string name = PopString();
auto instance = Pop();
stack.push(SetField(instance,name,val));
}
break;
}
}
while(scopes > 0)
{
Environment* env2 = env;
env=env2->GetParent();
if(env != env2)
{
delete env2;
}
scopes--;
}
return Null();
}
};
class InternalFunction : public CallableObject
{
public:
bool isRoot=false;
uint8_t* bytecode;
size_t bytecodeLength;
std::vector<std::string> args;
Environment* env;
bool FirstArgumentIsThis()
{
return args.size() > 0 && args[0] == "this";
}
ScriptType Execute(Environment* callerEnv,std::vector<ScriptType> args)
{
Environment* env2 = isRoot ? env : env->GetSub();
ChunkExecuter exec(env2,bytecode,bytecodeLength,&this->args);
auto ret=exec.Execute(callerEnv,args);
if(!isRoot) delete env2;
return ret;
}
};
class LexToken {
public:
std::string text;
bool isString;
bool isChar;
LexToken(std::string text)
{
this->text = text;
this->isString = false;
this->isChar = false;
}
LexToken(std::string text,bool isString)
{
this->text = text;
this->isString = isString;
this->isChar = !isChar;
}
LexToken(const LexToken& tkn)
{
this->text = tkn.text;
this->isString = tkn.isString;
this->isChar = tkn.isChar;
}
};
class Node {
public:
virtual bool IsExpression() {
return false;
}
virtual ~Node()
{
}
};
class Expression : public Node {
public:
bool IsExpression()
{
return true;
}
};
class OneExpression : public Expression {
public:
Node* node;
OneExpression(Node* node)
{
this->node = node;
}
};
class TwoExpression : public Expression {
public:
Node* left;
Node* right;
TwoExpression(Node* left,Node* right)
{
this->left = left;
this->right = right;
}
};
#define LIST_OF_CONST_EXPRESSIONS \
NODE(bool,Bool) \
NODE(std::string,String) \
NODE(int64_t,Long) \
NODE(double,Double) \
NODE(char,Char)
#define LIST_OF_ONE_EXPRESSIONS \
NODE(PostfixIncrement) \
NODE(PostfixDecrement) \
NODE(PrefixIncrement) \
NODE(PrefixDecrement) \
NODE(BitwiseNot) \
NODE(LogicalNot) \
NODE(Negative) \
NODE(CompoundAssign) \
NODE(Global) \
NODE(Caller) \
NODE(Var)
#define LIST_OF_TWO_EXPRESSIONS \
NODE(Add) \
NODE(Sub) \
NODE(Times) \
NODE(Divide) \
NODE(Mod) \
NODE(LeftShift) \
NODE(RightShift) \
NODE(LessThan) \
NODE(GreaterThan) \
NODE(LessThanEqualTo) \
NODE(GreaterThanEqualTo) \
NODE(Equals) \
NODE(NotEquals) \
NODE(BitwiseOr) \
NODE(BitwiseAnd) \
NODE(ExclusiveOr) \
NODE(LogicalOr) \
NODE(LogicalAnd) \
NODE(Assign)
#define NODE(_node) class _node##Expression : public OneExpression { \
public: \
_node##Expression(Node* n) : OneExpression(n) {} ~_node##Expression() {delete node;} \
};
LIST_OF_ONE_EXPRESSIONS
#undef NODE
#define NODE(node) class node##Expression : public TwoExpression { \
public: \
node##Expression(Node* n,Node* n2) : TwoExpression(n,n2) {} ~node##Expression() {delete left; delete right;} \
};
LIST_OF_TWO_EXPRESSIONS
#undef NODE
#define NODE(ttype,tname) class Const##tname##Expression : public Expression { \
public: \
ttype value; \
Const##tname##Expression(ttype v) \
{ \
this->value = v; \
}\
};
LIST_OF_CONST_EXPRESSIONS
#undef NODE
class ConstNullExpression : public Expression {};
class ConstUndefinedExpression : public Expression {};
class GetVariableExpression : public Expression {
public:
std::string name;
GetVariableExpression(std::string name)
{
this->name = name;
}
};
class IfNode : public Node {
public:
Node* cond;
Node* yes;
Node* no;
IfNode(Node* cond,Node* yes,Node* no)
{
this->cond = cond;
this->yes = yes;
this->no = no;
}
~IfNode()
{
delete cond;
delete yes;
delete no;
}
};
class TernaryExpression : public Expression {
public:
Node* cond;
Node* yes;
Node* no;
TernaryExpression(Node* cond,Node* yes,Node* no)
{
this->cond = cond;
this->yes = yes;
this->no = no;
}
~TernaryExpression()
{
delete cond;
delete yes;
delete no;
}
};
class WhileNode : public Node {
public:
Node* cond;
Node* body;
bool isDo;
WhileNode(Node* cond,Node* body, bool isDo)
{
this->cond = cond;
this->body = body;
this->isDo = isDo;
}
~WhileNode()
{
delete cond;
delete body;
}
};
class ForNode : public Node {
public:
Node* init;
Node* cond;
Node* inc;
Node* body;
ForNode(Node* init,Node* cond,Node* inc,Node* body)
{
this->init = init;
this->cond = cond;
this->inc = inc;
this->body = body;
}
~ForNode()
{
delete init;
delete cond;
delete inc;
delete body;
}
};
class PrintNode : public Node {
public:
Node* expr;
PrintNode(Node* expr)
{
this->expr = expr;
}
~PrintNode()
{
delete expr;
}
};
class EachNode : public Node {
public:
Node* item;
Node* list;
Node* body;
EachNode(Node* item,Node* list,Node* body)
{
this->item = item;
this->list = list;
this->body = body;
}
~EachNode()
{
delete item;
delete list;
delete body;
}
};
class FunctionDeclarationNode : public Node {
public:
Node* nameAndArgs;
Node* body;
FunctionDeclarationNode(Node* nameAndArgs,Node* body)
{
this->nameAndArgs = nameAndArgs;
this->body = body;
}
~FunctionDeclarationNode()
{
delete nameAndArgs;
delete body;
}
};
class FunctionCallExpression : public Expression
{
public:
std::vector<Node*> args;
Node* name;
FunctionCallExpression(Node* name) {
this->name = name;
}
~FunctionCallExpression()
{
for(auto item : args)
{
delete item;
}
delete name;
}
};
class GetMemberExpression : public Expression
{
public:
std::string name;
Node* parent;
GetMemberExpression(Node* parent,std::string name)
{
this->parent = parent;
this->name = name;
}
~GetMemberExpression()
{
delete parent;
}
};
class GetArrayExpression : public Expression
{
public:
Node* expr;
Node* parent;
GetArrayExpression(Node* parent,Node* expr)
{
this->parent = parent;
this->expr = expr;
}
~GetArrayExpression()
{
delete expr;
delete parent;
}
};
class ReturnNode : public Node {
public:
Node* retVal;
ReturnNode(Node* retVal)
{
this->retVal = retVal;
}
~ReturnNode()
{
delete retVal;
}
};
class BreakNode : public Node {};
class ContinueNode : public Node {};
class ScopeNode : public Node {
public:
std::vector<Node*> items;
bool rootScope;
~ScopeNode()
{
for(auto item : items)
delete item;
}
};
class ScriptParser
{
size_t i = 0;
std::vector<LexToken> tokens;
std::filesystem::path path;
static std::string Template(std::filesystem::path file)
{
//convert anything out of <!--tws --> to print ""; statements
std::string myRealBuf = {};
bool inCode = false;
std::string buffer={};
FILE* fs = fopen(file.c_str(),"rb");
if(fs == NULL) return "";
uint8_t sliding_buffer[7];
size_t len=0;
auto advance = [&sliding_buffer,&len,&fs]()-> bool {
if(len > 0)
{
len--;
for(size_t i = 0;i<len;i++)
{
sliding_buffer[i] = sliding_buffer[i+1];
}
}
if(len < 7)
len+= fread(sliding_buffer+len,1,7-len,fs);
return len > 0;
};
auto flush = [&buffer,&myRealBuf,&inCode]() -> void {
if(buffer.size() == 0) return;
if(inCode)
{
myRealBuf.append(buffer);
}
else
{
myRealBuf.append("print \"");
for(auto item : buffer)
{
switch(item)
{
case '\0':
myRealBuf.append("\\0");
break;
case '\n':
myRealBuf.append("\\n");
break;
case '\r':
myRealBuf.append("\\r");
break;
case '\f':
myRealBuf.append("\\f");
break;
case '\t':
myRealBuf.append("\\t");
break;
case '\v':
myRealBuf.append("\\v");
break;
case '\b':
myRealBuf.append("\\b");
break;
case '\a':
myRealBuf.append("\\a");
break;
case '\x1B':
myRealBuf.append("\\e");
break;
case '\"':
case '\'':
case '\\':
myRealBuf.push_back('\\');
myRealBuf.push_back(item);
break;
default:
myRealBuf.push_back(item);
break;
}
}
myRealBuf.append("\";");
}
buffer = {};
};
while(advance())
{
if(memcmp(sliding_buffer,"<!--tws",7) == 0)
{
flush();
inCode=true;
len = 0;
if(advance() == false) break;
}
if(inCode && memcmp(sliding_buffer,"-->",3) == 0)
{
flush();
inCode=false;
for(int i = 0;i<3;i++)
if(advance() == false) break;
if(len == 0) break;
}
buffer.push_back((char)sliding_buffer[0]);
}
flush();
fclose(fs);
return myRealBuf;
}
static void Lex(std::filesystem::path file,std::vector<LexToken>& tokens)
{
std::string text = Template(file);
size_t offset = 0;
int peeked = -1;
auto peek = [&text,&offset,&peeked]() -> int {
if(peeked > -1) return peeked;
if(offset < text.size())
{
peeked = text[offset];
offset++;
return peeked;
}
return -1;
};
auto read = [&text,&offset,&peeked]() -> int {
if(peeked != -1)
{
int myPeek = peeked;
peeked=-1;
return myPeek;
}
if(offset < text.size())
{
int c = text[offset];
offset++;
return c;
}
return -1;
};
int myRead=-1;
int myPeek=-1;
std::string buf={};
auto flush = [&buf,&tokens]()-> void {
if(buf.size() > 0)
{
tokens.push_back(LexToken(buf));
buf.clear();
}
};
auto read_chr_ = [&read]()-> std::pair<int,bool>
{
int myC = read();
if(myC == '\\')
{
myC = read();
if(myC == 'n')
{
return std::pair<int,bool>('\n',true);
}
else if(myC == 'r')
{
return std::pair<int,bool>('\r',true);
}
else if(myC == 'v')
{
return std::pair<int,bool>('\v',true);
}
else if(myC == 't')
{
return std::pair<int,bool>('\t',true);
}
else if(myC == 'b')
{
return std::pair<int,bool>('\b',true);
}
else if(myC == 'a')
{
return std::pair<int,bool>('\a',true);
}
else if(myC == 'e')
{
return std::pair<int,bool>('\x1B',true);
}
else if(myC == '0')
{
return std::pair<int,bool>('\0',true);
}
else if(myC == 'x')
{
int x1 = read();
int x2 = read();
return std::pair<int,bool>(((HttpUtils::hex_char_to_nibble(x1) << 4) & 0xF) | (HttpUtils::hex_char_to_nibble(x2) & 0xF),true);
}
else {
return std::pair<int,bool>(myC,true);
}
}
return std::pair<int,bool>(myC,false);
};
auto read_string = [&read_chr_,&tokens]()-> void {
std::pair<int,bool> c;
std::string myStr = {};
while((c = read_chr_()).first != -1)
{
if(c.first == '\"' && !c.second) break;
myStr.push_back((char)c.first);
}
tokens.push_back(LexToken(myStr,true));
};
auto read_char = [&read_chr_,&tokens,&read]()-> void {
auto v = read_chr_();
if(v.first != -1)
{
tokens.push_back(LexToken(std::string({(char)v.first}),false));
}
read();
};
while((myRead = read()) != -1)
{
myPeek = peek();
switch(myRead)
{
case '/':
flush();
if(myPeek == '/')
{
while(true)
{
myRead = read();
if(myRead == -1) throw std::exception();
if(myRead == '\n') break;
}
}
else if(myPeek == '*')
{
read();
while(true)
{
myRead = read();
if(myRead == -1) throw std::exception();
if(myRead == '*')
{
myRead = read();
if(myRead == '/') break;
}
}
}
else if(myPeek == '=')
{
read();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
else
{
tokens.push_back(LexToken(std::string({(char)myRead})));
}
break;
case '\"':
flush();
read_string();
break;
case '\'':
flush();
read_char();
break;
case '<':
case '>':
{
if(myPeek == myRead)
{
read();
flush();
int myPeek2 = peek();
if(myPeek2 == '=')
{
read();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek,'='})));
}
else{
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
}
else if(myPeek == '=')
{
read();
flush();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
else
{
flush();
tokens.push_back(LexToken(std::string({(char)myRead})));
}
}
break;
case '+':
case '-':
case '|':
case '&':
{
if(myPeek == myRead)
{
read();
flush();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
else if(myPeek == '=')
{
read();
flush();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
else
{
flush();
tokens.push_back(LexToken(std::string({(char)myRead})));
}
}
break;
case '^':
case '*':
case '%':
case '=':
case '!':
{
if(myPeek == '=')
{
read();
flush();
tokens.push_back(LexToken(std::string({(char)myRead,(char)myPeek})));
}
else
{
flush();
tokens.push_back(LexToken(std::string({(char)myRead})));
}
}
break;
case '?':
case '.':
case ';':
case ':':
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case ',':
flush();
tokens.push_back(LexToken(std::string({(char)myRead})));
break;
case '\r':
case '\n':
case '\t':
case ' ':
flush();
break;
default:
buf.push_back((char)myRead);
break;
}
}
}
bool NextTokenIs(std::string val, bool take=true)
{
//std::cout << val << " == " << tokens[i].text << std::endl;
if(i >= tokens.size()) return false;
if(!tokens[i].isChar && !tokens[i].isString && tokens[i].text == val)
{
if(take) i++;
return true;
}
return false;
}
ScriptParser(std::filesystem::path path)
{
Lex(path,tokens);
this->path = path;
}
void Ensure(std::string val)
{
if(i >= tokens.size()) throw std::exception();
if(!tokens[i].isChar && !tokens[i].isString && tokens[i].text == val)
{
i++;
return;
}
throw std::exception();
}
bool IsAnyOf(std::initializer_list<std::string> tkns, std::string& txt)
{
if(this->i >= this->tokens.size()) return false;
for(auto item : tkns)
{
if(this->tokens[i].isString) continue;
if(this->tokens[i].isChar) continue;
if(this->tokens[i].text.compare(item) == 0)
{
this->i++;
txt = item;
return true;
}
}
return false;
}
Node* ParseValue()
{
if(i>=tokens.size()) throw std::exception();
if(tokens[i].isString)
{
auto val=tokens[i].text;
i++;
return new ConstStringExpression(val);
}
if(tokens[i].isChar)
{
auto val = tokens[i].text;
i++;
return new ConstCharExpression(val[0]);
}
std::string token = tokens[i].text;
i++;
bool hasNumber=true;
int64_t lngNum = 0;
if(token.size() == 1 && token[0] == '0')
{
lngNum = 0;
}
else
if(token.size() > 0 && token[0] == '0')
{
if(token.size() > 1 && token[1] == 'x')
{
lngNum = std::stoll(token.substr(2),nullptr,16);
}
else if(token.size() > 1 && token[1] == 'b')
{
lngNum = std::stoll(token.substr(2),nullptr,2);
}
else
{
lngNum = std::stoll(token.substr(1),nullptr,8);
}
}
else if(token.size() > 0 && token[0] >= '0' && token[0] <= '9')
{
lngNum=std::stoll(token,nullptr,10);
}
else
{
hasNumber = false;
}
Node* val = nullptr;
if(hasNumber && this->NextTokenIs(".",false) && i+1 < tokens.size() && !tokens[i+1].isChar && !tokens[i+1].isString)
{
std::string myToken = tokens[i+1].text;
if(myToken.size() > 0 && myToken[0] >= '0' && myToken[0] <= '9')
{
i+=2;
std::string myN = std::to_string(lngNum) + "." + myToken;
double v = std::stod(myN,nullptr);
val = new ConstDoubleExpression(v);
}
else
{
val = new ConstLongExpression(lngNum);
}
}
else if(hasNumber)
{
val = new ConstLongExpression(lngNum);
}
else {
if(token == "(")
{
val = ParseExpression();
Ensure(")");
}
if(token == "true")
{
val = new ConstBoolExpression(true);
}
else if(token == "false")
{
val = new ConstBoolExpression(false);
}
else if(token == "null")
{
val = new ConstNullExpression();
}
else if(token == "undefined")
{
val = new ConstUndefinedExpression();
}
else if(token == "var")
{
if(i>=tokens.size()) throw std::exception();
if(tokens[i].isString) throw std::exception();
if(tokens[i].isChar) throw std::exception();
val = new VarExpression(new GetVariableExpression(tokens[i].text));
i++;
}
else if(token == "global")
{
if(i>=tokens.size()) throw std::exception();
if(tokens[i].isString) throw std::exception();
if(tokens[i].isChar) throw std::exception();
val = new GlobalExpression(new GetVariableExpression(tokens[i].text));
i++;
}
else if(token == "caller")
{
if(i>=tokens.size()) throw std::exception();
if(tokens[i].isString) throw std::exception();
if(tokens[i].isChar) throw std::exception();
val = new CallerExpression(new GetVariableExpression(tokens[i].text));
i++;
}
else {
val = new GetVariableExpression(token);
}
}
std::string myT;
while(IsAnyOf({".","[","("},myT))
{
if(myT == ".")
{
if(i>=tokens.size()) throw std::exception();
if(tokens[i].isChar || tokens[i].isString) throw std::exception();
std::string name = tokens[i].text;
i++;
val = new GetMemberExpression(val, name);
}
if(myT == "[")
{
Node* expr=ParseExpression();
Ensure("]");
val = new GetArrayExpression(val,expr);
}
if(myT == "(")
{
auto fcall = new FunctionCallExpression(val);
while(!NextTokenIs(")",false))
{
fcall->args.push_back(ParseExpression());
if(!NextTokenIs(")",false))
Ensure(",");
}
Ensure(")");
val = fcall;
}
}
return val;
}
Node* ParseUnary()
{
if(NextTokenIs("-"))
{
return new NegativeExpression(ParseUnary());
}
if(NextTokenIs("~"))
{
return new BitwiseNotExpression(ParseUnary());
}
if(NextTokenIs("!"))
{
return new LogicalNotExpression(ParseUnary());
}
if(NextTokenIs("--"))
{
return new PrefixDecrementExpression(ParseUnary());
}
if(NextTokenIs("++"))
{
return new PrefixIncrementExpression(ParseUnary());
}
return ParseValue();
}
Node* ParseFactor()
{
Node* v = ParseUnary();
std::string tok;
while(IsAnyOf({"*","/","%"},tok))
{
if(tok == "*")
v = new TimesExpression(v,ParseUnary());
if(tok == "/")
v = new DivideExpression(v,ParseUnary());
if(tok == "%")
v = new ModExpression(v,ParseUnary());
}
return v;
}
Node* ParseSum()
{
Node* v = ParseFactor();
std::string tok;
while(IsAnyOf({"+","-"},tok))
{
if(tok == "+")
v = new AddExpression(v,ParseFactor());
if(tok == "-")
v = new SubExpression(v,ParseFactor());
}
return v;
}
Node* ParseShift()
{
Node* v = ParseSum();
std::string tok;
while(IsAnyOf({"<<",">>"},tok))
{
if(tok == "<<")
v = new LeftShiftExpression(v,ParseSum());
if(tok == ">>")
v = new RightShiftExpression(v,ParseSum());
}
return v;
}
Node* ParseRel()
{
Node* v = ParseShift();
std::string tok;
while(IsAnyOf({"<",">","<=",">="},tok))
{
if(tok == "<")
v = new LessThanExpression(v,ParseShift());
if(tok == ">")
v = new GreaterThanExpression(v,ParseShift());
if(tok == "<=")
v = new LessThanEqualToExpression(v,ParseShift());
if(tok == ">=")
v = new GreaterThanEqualToExpression(v,ParseShift());
}
return v;
}
Node* ParseEq()
{
Node* v = ParseRel();
std::string tok;
while(IsAnyOf({"!=","=="},tok))
{
if(tok == "!=")
v = new NotEqualsExpression(v,ParseRel());
if(tok == "==")
v = new EqualsExpression(v,ParseRel());
}
return v;
}
Node* ParseBAnd()
{
Node* v = ParseEq();
while(NextTokenIs("&"))
{
v = new BitwiseAndExpression(v,ParseEq());
}
return v;
}
Node* ParseXOr()
{
Node* v = ParseBAnd();
while(NextTokenIs("^"))
{
v = new ExclusiveOrExpression(v,ParseBAnd());
}
return v;
}
Node* ParseBOr()
{
Node* v = ParseXOr();
while(NextTokenIs("|"))
{
v = new BitwiseOrExpression(v,ParseXOr());
}
return v;
}
Node* ParseLAnd()
{
Node* v = ParseBOr();
while(NextTokenIs("&&"))
{
v = new LogicalAndExpression(v,ParseBOr());
}
return v;
}
Node* ParseLOr()
{
Node* v = ParseLAnd();
while(NextTokenIs("||"))
{
v = new LogicalOrExpression(v,ParseLAnd());
}
return v;
}
Node* ParseTernary()
{
Node* cond = ParseLOr();
if(NextTokenIs("?"))
{
Node* yes = ParseTernary();
Ensure(":");
Node* no = ParseTernary();
return new TernaryExpression(cond,yes,no);
}
return cond;
}
Node* ParseExpression()
{
Node* v = ParseTernary();
std::string t;
while(IsAnyOf({"=","+=","-=","*=","/=","%=","<<=",">>=","&=","^=","|="},t))
{
if(t == "=")
{
v = new AssignExpression(v,ParseTernary());
}
if (t == "+=")
{
v = new CompoundAssignExpression(new AddExpression(v,ParseTernary()));
}
if (t == "-=")
{
v = new CompoundAssignExpression(new SubExpression(v,ParseTernary()));
}
if (t == "*=")
{
v = new CompoundAssignExpression(new TimesExpression(v,ParseTernary()));
}
if (t == "/=")
{
v = new CompoundAssignExpression(new DivideExpression(v,ParseTernary()));
}
if (t == "%=")
{
v = new CompoundAssignExpression(new ModExpression(v,ParseTernary()));
}
if (t == "<<=")
{
v = new CompoundAssignExpression(new LeftShiftExpression(v,ParseTernary()));
}
if (t == ">>=")
{
v = new CompoundAssignExpression(new RightShiftExpression(v,ParseTernary()));
}
if (t == "&=")
{
v = new CompoundAssignExpression(new BitwiseAndExpression(v,ParseTernary()));
}
if (t == "^=")
{
v = new CompoundAssignExpression(new ExclusiveOrExpression(v,ParseTernary()));
}
if (t == "|=")
{
v = new CompoundAssignExpression(new BitwiseOrExpression(v,ParseTernary()));
}
}
return v;
}
Node* ParseNode(bool rootNode=false)
{
if(NextTokenIs("{") || rootNode)
{
ScopeNode* sn = new ScopeNode();
sn->rootScope = rootNode;
while(this->i < this->tokens.size() && !NextTokenIs("}"))
{
sn->items.push_back(ParseNode());
NextTokenIs(";");
}
return sn;
}
if(NextTokenIs("include"))
{
if(i < tokens.size())
{
std::filesystem::path par = this->path.parent_path();
std::string file = tokens[i].text;
i++;
Ensure(";");
ScriptParser p(par / file);
return p.ParseNode(true);
}
}
if(NextTokenIs("print"))
{
Node* n=new PrintNode(ParseExpression());
Ensure(";");
return n;
}
if(NextTokenIs("return"))
{
Node* n=new ReturnNode(ParseExpression());
Ensure(";");
return n;
}
if(NextTokenIs("break"))
{
Ensure(";");
return new BreakNode();
}
if(NextTokenIs("continue"))
{
Ensure(";");
return new ContinueNode();
}
if(NextTokenIs("if"))
{
Ensure("(");
Node* cond = ParseExpression();
Ensure(")");
Node* yes = nullptr;
if(!NextTokenIs("else",false))
{
yes = ParseNode();
NextTokenIs(";");
}
Node* no = nullptr;
if(NextTokenIs("else"))
{
no = ParseNode();
NextTokenIs(";");
}
return new IfNode(cond,yes,no);
}
if(NextTokenIs("for"))
{
Ensure("(");
Node* init = nullptr;
Node* cond = nullptr;
Node* inc = nullptr;
if(!NextTokenIs(";",false))
{
init = ParseExpression();
}
Ensure(";");
if(!NextTokenIs(";",false))
{
cond = ParseExpression();
}
Ensure(";");
if(!NextTokenIs(")",false))
{
inc = ParseExpression();
}
Ensure(")");
Node* body = ParseNode();
NextTokenIs(";");
return new ForNode(init,cond,inc,body);
}
if(NextTokenIs("while"))
{
Ensure("(");
Node* cond = ParseExpression();
Ensure(")");
Node* body = ParseNode();
NextTokenIs(";");
return new WhileNode(cond,body,false);
}
if(NextTokenIs("do"))
{
Ensure("(");
Node* cond = ParseExpression();
Ensure(")");
Node* body = ParseNode();
NextTokenIs(";");
return new WhileNode(cond,body,true);
}
if(NextTokenIs("each"))
{
Ensure("(");
Node* list = ParseExpression();
Node* item = nullptr;
if(NextTokenIs(":"))
{
item = list;
list = ParseExpression();
}
else
{
item = new GetVariableExpression("item");
}
Ensure(")");
Node* body = ParseNode();
NextTokenIs(";");
return new EachNode(item,list,body);
}
if(NextTokenIs("func"))
{
Node* fn = ParseExpression();
Node* body = ParseNode();
NextTokenIs(";");
return new FunctionDeclarationNode(fn,body);
}
Node* n= ParseExpression();
Ensure(";");
return n;
}
public:
static Node* Parse(std::filesystem::path path)
{
ScriptParser p(path);
return p.ParseNode(true);
}
};
inline ScriptType TypeOf(Environment* env, std::vector<ScriptType> args)
{
if(args.size() > 0)
{
auto item = args[0];
if(std::holds_alternative<char>(item))
{
return "char";
}
if(std::holds_alternative<std::string>(item))
{
return "string";
}
if(std::holds_alternative<int64_t>(item))
{
return "long";
}
if(std::holds_alternative<double>(item))
{
return "double";
}
if(std::holds_alternative<IttrKVP>(item))
{
return "ittrkvp";
}
if(std::holds_alternative<bool>(item))
{
return "bool";
}
if(std::holds_alternative<Undefined>(item))
{
return "undefined";
}
if(std::holds_alternative<Null>(item))
{
return "null";
}
if(std::holds_alternative<ObjectType>(item))
{
auto ot = std::get<ObjectType>(item).data;
auto ls = dynamic_cast<List*>(ot);
auto dict = dynamic_cast<Dictionary*>(ot);
auto ifunc = dynamic_cast<InternalFunction*>(ot);
auto efunc = dynamic_cast<ExternalFunction*>(ot);
auto ittr = dynamic_cast<Ittr*>(ot);
if(ittr != nullptr) return "ittr";
if(ls != nullptr) return "list";
if(dict != nullptr) return "dictionary";
if(ifunc != nullptr) return "internal_function";
if(efunc != nullptr) return "external_function";
}
}
return Null();
}
class BytecodeFile {
public:
std::map<std::string,InternalFunction*> functions;
InternalFunction* rootFunction;
~BytecodeFile()
{
delete rootFunction;
for(auto item : functions)
{
delete item.second;
}
}
};
#if defined(DEBUG)
#define INSTRUCTION_NAME(INAME) case Instruction:: INAME : printf("%s",#INAME); break;
#endif
class SimpleInstruction : public Instruction
{
public:
uint8_t instruction;
SimpleInstruction(uint8_t instruction)
{
this->instruction = instruction;
}
int Length()
{
return 1;
}
void Write(uint8_t* buffer)
{
buffer[0] = instruction;
}
#if defined(DEBUG)
void Print()
{
switch(instruction)
{
INSTRUCTION_NAME(ADD)
INSTRUCTION_NAME(SUB)
INSTRUCTION_NAME(TIMES)
INSTRUCTION_NAME(DIVIDE)
INSTRUCTION_NAME(MOD)
INSTRUCTION_NAME(LEFTSHIFT)
INSTRUCTION_NAME(RIGHTSHIFT)
INSTRUCTION_NAME(LESSTHAN)
INSTRUCTION_NAME(GREATERTHAN)
INSTRUCTION_NAME(GREATERTHANEQUALTO)
INSTRUCTION_NAME(LESSTHANEQUALTO)
INSTRUCTION_NAME(PRINT)
INSTRUCTION_NAME(SCOPE_BEGIN)
INSTRUCTION_NAME(SCOPE_END)
INSTRUCTION_NAME(POP)
INSTRUCTION_NAME(GETVARIABLE)
INSTRUCTION_NAME(SETVARIABLE)
INSTRUCTION_NAME(GETFIELD)
INSTRUCTION_NAME(SETFIELD)
INSTRUCTION_NAME(CALL_METHOD)
INSTRUCTION_NAME(CALL_FUNC)
INSTRUCTION_NAME(DESTROY_LOOP)
INSTRUCTION_NAME(ITTR)
INSTRUCTION_NAME(SET_LOOP)
INSTRUCTION_NAME(GET_LOOP)
default:
printf("UNKNOWN: %i\n",(int)instruction);
break;
}
printf("\n");
}
#endif
};
class LabelInstruction : public Instruction
{
std::string label;
public:
LabelInstruction(std::string label)
{
this->label = label;
}
std::string GetLabel()
{
return label;
}
void SetLabel(std::string lbl)
{
label = lbl;
}
int Length()
{
return 0;
}
void Write(uint8_t* buffer)
{
}
#if defined(DEBUG)
void Print()
{
printf("%s:\n",label.c_str());
}
#endif
};
class LabelableInstruction : public Instruction
{
public:
virtual std::string GetLabel()=0;
virtual void SetLabel(std::string lbl)=0;
virtual int GetPosition()=0;
virtual void SetPosition(int pos)=0;
};
class JumpInstruction : public LabelableInstruction
{
std::string label;
int position;
uint8_t instr;
public:
JumpInstruction(uint8_t instr,std::string label)
{
this->instr = instr;
this->label = label;
this->position = 0;
}
std::string GetLabel()
{
return label;
}
void SetLabel(std::string lbl)
{
label = lbl;
}
int GetPosition()
{
return position;
}
void SetPosition(int pos)
{
this->position = pos;
}
int Length() {return 5;}
void Write(uint8_t* buffer)
{
buffer[0] = instr;
buffer[1] = (uint8_t)((position >> 24) & 0xFF);
buffer[2] = (uint8_t)((position >> 16) & 0xFF);
buffer[3] = (uint8_t)((position >> 8) & 0xFF);
buffer[4] = (uint8_t)(position & 0xFF);
}
#if defined(DEBUG)
void Print()
{
switch(instr)
{
INSTRUCTION_NAME(JMP)
INSTRUCTION_NAME(JMPC)
}
printf(" %s [%i]\n", label.c_str(),this->position);
}
#endif
};
class LongInstruction : public Instruction {
public:
int64_t value;
LongInstruction(int64_t value)
{
this->value = value;
}
int Length()
{
return 9;
}
void Write(uint8_t* buffer)
{
buffer[0] = Instruction::PUSH_LONG;
buffer[1] = (uint8_t)((value >> 56) & 0xFF);
buffer[2] = (uint8_t)((value >> 48) & 0xFF);
buffer[3] = (uint8_t)((value >> 40) & 0xFF);
buffer[4] = (uint8_t)((value >> 32) & 0xFF);
buffer[5] = (uint8_t)((value >> 24) & 0xFF);
buffer[6] = (uint8_t)((value >> 16) & 0xFF);
buffer[7] = (uint8_t)((value >> 8) & 0xFF);
buffer[8] = (uint8_t)(value & 0xFF);
}
#if defined(DEBUG)
void Print()
{
std::cout << "PUSH_LONG " << value << std::endl;
}
#endif
};
class CharInstruction : public Instruction {
public:
char value;
CharInstruction(char c)
{
this->value = c;
}
int Length()
{
return 2;
}
void Write(uint8_t* buffer)
{
buffer[0] = Instruction::PUSH_CHAR;
buffer[1] = value;
}
#if defined(DEBUG)
void Print()
{
std::cout << "PUSH_CHAR \'" << value << "\'" << std::endl;
}
#endif
};
class StringInstruction : public Instruction {
public:
std::string value;
StringInstruction(std::string value)
{
this->value = value;
}
int Length()
{
return 5+value.size();
}
void Write(uint8_t* buffer)
{
buffer[0] = Instruction::PUSH_STRING;
auto sz = this->value.size();
buffer[1] = (uint8_t)((sz >> 24) & 0xFF);
buffer[2] = (uint8_t)((sz >> 16) & 0xFF);
buffer[3] = (uint8_t)((sz >> 8) & 0xFF);
buffer[4] = (uint8_t)(sz & 0xFF);
for(size_t i = 0;i<sz;i++)
{
buffer[i+5] = (uint8_t)value[i];
}
}
#if defined(DEBUG)
void Print()
{
std::cout << "PUSH_STRING \"" << value << "\"" << std::endl;
}
#endif
};
class BytecodeCompiler
{
std::string _brk={};
std::string _cont = {};
std::stack<std::string> __eachs;
int jmpId = 0;
std::string NewJumpId()
{
std::string s = "__compGen" + std::to_string(jmpId);
jmpId++;
return s;
}
void ExpressionPop(Node* n,std::vector<Instruction*>& instructions)
{
if(n == nullptr) return;
if(n->IsExpression())
instructions.push_back(new SimpleInstruction(Instruction::POP));
}
Node* n;
void GenerateFree(Node* _n,std::vector<Instruction*>& instructions)
{
GetVariableExpression fnName("free");
FunctionCallExpression fcE(&fnName);
fcE.args.push_back(_n);
Compile(&fcE,instructions);
instructions.push_back(new SimpleInstruction(Instruction::POP));
fcE.args.clear();
fcE.name=nullptr;
}
void Compile(Node* n,std::vector<Instruction*>& instructions)
{
if(n==nullptr) return;
auto addExpr = dynamic_cast<AddExpression*>(n);
auto subExpr = dynamic_cast<SubExpression*>(n);
auto timesExpr = dynamic_cast<TimesExpression*>(n);
auto divExpr = dynamic_cast<DivideExpression*>(n);
auto modExpr = dynamic_cast<ModExpression*>(n);
auto lsExpr = dynamic_cast<LeftShiftExpression*>(n);
auto rsExpr = dynamic_cast<RightShiftExpression*>(n);
auto ltExpr = dynamic_cast<LessThanExpression*>(n);
auto gtExpr = dynamic_cast<GreaterThanExpression*>(n);
auto lteExpr = dynamic_cast<LessThanEqualToExpression*>(n);
auto gteExpr = dynamic_cast<GreaterThanEqualToExpression*>(n);
auto funcDecl = dynamic_cast<FunctionDeclarationNode*>(n);
auto varDecl = dynamic_cast<VarExpression*>(n);
auto lnotExpr = dynamic_cast<LogicalNotExpression*>(n);
auto scope = dynamic_cast<ScopeNode*>(n);
auto print = dynamic_cast<PrintNode*>(n);
auto lng = dynamic_cast<ConstLongExpression*>(n);
auto str = dynamic_cast<ConstStringExpression*>(n);
auto assign = dynamic_cast<AssignExpression*>(n);
auto compound = dynamic_cast<CompoundAssignExpression*>(n);
auto varGet = dynamic_cast<GetVariableExpression*>(n);
auto memGet = dynamic_cast<GetMemberExpression*>(n);
auto arrGet = dynamic_cast<GetArrayExpression*>(n);
auto gblGet = dynamic_cast<GlobalExpression*>(n);
auto callerGet = dynamic_cast<CallerExpression*>(n);
auto fCall = dynamic_cast<FunctionCallExpression*>(n);
auto ifNode = dynamic_cast<IfNode*>(n);
auto ternary = dynamic_cast<TernaryExpression*>(n);
auto whileNode = dynamic_cast<WhileNode*>(n);
auto breakNode = dynamic_cast<BreakNode*>(n);
auto cont = dynamic_cast<ContinueNode*>(n);
auto eachLoop = dynamic_cast<EachNode*>(n);
auto forLoop = dynamic_cast<ForNode*>(n);
auto lOr = dynamic_cast<LogicalOrExpression*>(n);
auto lAnd = dynamic_cast<LogicalAndExpression*>(n);
auto retNode = dynamic_cast<ReturnNode*>(n);
auto boolExpr = dynamic_cast<ConstBoolExpression*>(n);
auto nullExpr = dynamic_cast<ConstNullExpression*>(n);
auto undefinedExpr = dynamic_cast<ConstUndefinedExpression*>(n);
auto chrExpr = dynamic_cast<ConstCharExpression*>(n);
auto equalsExpr = dynamic_cast<EqualsExpression*>(n);
auto notEqualsExpr = dynamic_cast<NotEqualsExpression*>(n);
if(equalsExpr != nullptr)
{
Compile(equalsExpr->left,instructions);
Compile(equalsExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::EQUALS));
}
if(notEqualsExpr != nullptr)
{
Compile(notEqualsExpr->left,instructions);
Compile(notEqualsExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::NOTEQUALS));
}
if(chrExpr != nullptr)
{
instructions.push_back(new CharInstruction(chrExpr->value));
}
if(boolExpr != nullptr)
{
instructions.push_back(new SimpleInstruction(boolExpr->value ? Instruction::PUSH_TRUE : Instruction::PUSH_FALSE));
}
if(nullExpr != nullptr)
{
instructions.push_back(new SimpleInstruction(Instruction::PUSH_NULL));
}
if(undefinedExpr != nullptr)
{
instructions.push_back(new SimpleInstruction(Instruction::PUSH_UNDEFINED));
}
if(retNode != nullptr)
{
while(!this->__eachs.empty())
{
auto item = this->__eachs.top();
GetVariableExpression gve(item);
GenerateFree(&gve,instructions);
this->__eachs.pop();
}
Compile(retNode->retVal,instructions);
instructions.push_back(new SimpleInstruction(Instruction::RET));
}
if(lnotExpr != nullptr)
{
Compile(lnotExpr->node,instructions);
instructions.push_back(new SimpleInstruction(Instruction::LOGICALNOT));
}
if(lOr != nullptr)
{
std::string end = this->NewJumpId();
std::string pushTrue = this->NewJumpId();
Compile(lOr->left,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,pushTrue));
Compile(lOr->right,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(pushTrue));
instructions.push_back(new SimpleInstruction(Instruction::PUSH_TRUE));
instructions.push_back(new LabelInstruction(end));
}
if(lAnd != nullptr)
{
std::string end = this->NewJumpId();
std::string pushFalse = this->NewJumpId();
std::string hndl = this->NewJumpId();
Compile(lAnd->left,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,hndl));
instructions.push_back(new JumpInstruction(Instruction::JMP,pushFalse));
instructions.push_back(new LabelInstruction(hndl));
Compile(lAnd->right,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(pushFalse));
instructions.push_back(new SimpleInstruction(Instruction::PUSH_FALSE));
instructions.push_back(new LabelInstruction(end));
}
if(breakNode != nullptr)
{
if( _brk.size() > 0)
{
instructions.push_back(new SimpleInstruction(Instruction::GET_LOOP));
instructions.push_back(new JumpInstruction(Instruction::JMP,_brk));
} else {
throw std::exception();
}
}
if(cont != nullptr)
{
if(_cont.size() > 0)
{
instructions.push_back(new SimpleInstruction(Instruction::GET_LOOP));
instructions.push_back(new JumpInstruction(Instruction::JMP, _cont));
}
else {
throw std::exception();
}
}
if(forLoop != nullptr)
{
instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
Compile(forLoop->init,instructions);
ExpressionPop(forLoop->init,instructions);
std::string oldcont = _cont;
std::string oldbrk = _brk;
std::string end = NewJumpId();
std::string begin = NewJumpId();
std::string yes = NewJumpId();
std::string cont = NewJumpId();
_cont = cont;
_brk = end;
instructions.push_back(new LabelInstruction(begin));
Compile(forLoop->cond,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(yes));
Compile(forLoop->body,instructions);
ExpressionPop(forLoop->body,instructions);
instructions.push_back(new LabelInstruction(cont));
Compile(forLoop->inc,instructions);
ExpressionPop(forLoop->inc,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
instructions.push_back(new LabelInstruction(end)); //used for break
instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
_cont = oldcont;
_brk = oldbrk;
}
if(eachLoop != nullptr)
{
instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
std::string eachIttr = NewJumpId();
__eachs.push(eachIttr);
instructions.push_back(new StringInstruction(eachIttr));
Compile(eachLoop->list,instructions);
instructions.push_back(new SimpleInstruction(Instruction::ITTR));
instructions.push_back(new SimpleInstruction(Instruction::SETVARIABLE));
instructions.push_back(new SimpleInstruction(Instruction::POP));
std::string oldcont = _cont;
std::string oldbrk = _brk;
std::string yes = NewJumpId();
std::string end = NewJumpId();
std::string begin = NewJumpId();
_cont = begin;
_brk = end;
instructions.push_back(new LabelInstruction(begin));
GetVariableExpression var(eachIttr);
GetMemberExpression mem(&var,"movenext");
FunctionCallExpression ce(&mem);
Compile(&ce,instructions);
ce.name = nullptr;
mem.parent=nullptr;
instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(yes));
GetMemberExpression mem2(&var,"current");
FunctionCallExpression ce2(&mem2);
AssignExpression assignExpr(eachLoop->item,&ce2);
Compile(&assignExpr,instructions);
ExpressionPop(&assignExpr,instructions);
mem2.parent=nullptr;
ce2.name=nullptr;
assignExpr.left=nullptr;
assignExpr.right = nullptr;
Compile(eachLoop->body,instructions);
ExpressionPop(eachLoop->body,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
instructions.push_back(new LabelInstruction(end));
__eachs.pop();
GenerateFree(&var,instructions);
instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
_cont = oldcont;
_brk = oldbrk;
}
if(whileNode != nullptr)
{
if(whileNode->isDo)
{
instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
std::string oldcont = _cont;
std::string oldbrk = _brk;
std::string end = NewJumpId();
std::string begin = NewJumpId();
_cont = begin;
_brk = end;
instructions.push_back(new LabelInstruction(begin));
Compile(whileNode->body,instructions);
ExpressionPop(whileNode->body,instructions);
Compile(whileNode->cond,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,begin));
instructions.push_back(new LabelInstruction(end)); //used for break
instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
_cont = oldcont;
_brk = oldbrk;
}
else
{
instructions.push_back(new SimpleInstruction(Instruction::SET_LOOP));
std::string oldcont = _cont;
std::string oldbrk = _brk;
std::string yes = NewJumpId();
std::string end = NewJumpId();
std::string begin = NewJumpId();
_cont = begin;
_brk = end;
instructions.push_back(new LabelInstruction(begin));
Compile(whileNode->cond,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(yes));
Compile(whileNode->body,instructions);
ExpressionPop(whileNode->body,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,begin));
instructions.push_back(new LabelInstruction(end));
instructions.push_back(new SimpleInstruction(Instruction::DESTROY_LOOP));
_cont = oldcont;
_brk = oldbrk;
}
}
if(ifNode != nullptr)
{
std::string yes = NewJumpId();
std::string end = NewJumpId();
Compile(ifNode->cond,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
Compile(ifNode->no,instructions);
ExpressionPop(ifNode->no,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(yes));
Compile(ifNode->yes,instructions);
ExpressionPop(ifNode->yes,instructions);
instructions.push_back(new LabelInstruction(end));
}
if(ternary != nullptr)
{
std::string yes = NewJumpId();
std::string end = NewJumpId();
Compile(ternary->cond,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMPC,yes));
Compile(ternary->no,instructions);
instructions.push_back(new JumpInstruction(Instruction::JMP,end));
instructions.push_back(new LabelInstruction(yes));
Compile(ternary->yes,instructions);
instructions.push_back(new LabelInstruction(end));
}
if(compound != nullptr)
{
auto twoNode = dynamic_cast<TwoExpression*>(compound->node);
if(twoNode != nullptr)
{
AssignExpression aE(twoNode->left,twoNode);
Compile(&aE,instructions);
aE.left = nullptr;
aE.right = nullptr;
}
}
if(addExpr != nullptr)
{
Compile(addExpr->left,instructions);
Compile(addExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::ADD));
}
if(subExpr != nullptr)
{
Compile(subExpr->left,instructions);
Compile(subExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SUB));
}
if(timesExpr != nullptr)
{
Compile(timesExpr->left,instructions);
Compile(timesExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::TIMES));
}
if(divExpr != nullptr)
{
Compile(divExpr->left,instructions);
Compile(divExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::DIVIDE));
}
if(modExpr != nullptr)
{
Compile(modExpr->left,instructions);
Compile(modExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::MOD));
}
if(lsExpr != nullptr)
{
Compile(lsExpr->left,instructions);
Compile(lsExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::LEFTSHIFT));
}
if(rsExpr != nullptr)
{
Compile(rsExpr->left,instructions);
Compile(rsExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::RIGHTSHIFT));
}
if(ltExpr != nullptr)
{
Compile(ltExpr->left,instructions);
Compile(ltExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::LESSTHAN));
}
if(gtExpr != nullptr)
{
Compile(gtExpr->left,instructions);
Compile(gtExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::GREATERTHAN));
}
if(lteExpr != nullptr)
{
Compile(lteExpr->left,instructions);
Compile(lteExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::LESSTHANEQUALTO));
}
if(gteExpr != nullptr)
{
Compile(gteExpr->left,instructions);
Compile(gteExpr->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::GREATERTHANEQUALTO));
}
if(funcDecl != nullptr)
{
auto fcall = dynamic_cast<FunctionCallExpression*>(funcDecl->nameAndArgs);
if(fcall != nullptr)
{
auto fname = dynamic_cast<GetVariableExpression*>(fcall->name);
if(fname != nullptr)
{
auto fn = new InternalFunction();
this->file->functions[fname->name] = fn;
for(auto arg : fcall->args)
{
auto argTXT = dynamic_cast<GetVariableExpression*>(arg);
if(argTXT != nullptr)
{
fn->args.push_back(argTXT->name);
}
}
Compile(funcDecl->body,fn);
}
}
}
if(scope != nullptr)
{
if(!scope->rootScope)
instructions.push_back(new SimpleInstruction(Instruction::SCOPE_BEGIN));
for(auto no : scope->items)
{
Compile(no,instructions);
ExpressionPop(no,instructions);
}
if(!scope->rootScope)
instructions.push_back(new SimpleInstruction(Instruction::SCOPE_END));
}
if(lng != nullptr)
{
instructions.push_back(new LongInstruction(lng->value));
}
if(str != nullptr)
{
instructions.push_back(new StringInstruction(str->value));
}
if(print != nullptr)
{
Compile(print->expr,instructions);
instructions.push_back(new SimpleInstruction(Instruction::PRINT));
}
if(varDecl != nullptr)
{
auto gvn = dynamic_cast<GetVariableExpression*>(varDecl->node);
if(gvn != nullptr)
{
instructions.push_back(new StringInstruction(gvn->name));
instructions.push_back(new SimpleInstruction(Instruction::PUSH_NULL));
instructions.push_back(new SimpleInstruction(Instruction::DECLARE_VARIABLE));
}
}
if(assign != nullptr)
{
GetVariableExpression* gVar = dynamic_cast<GetVariableExpression*>(assign->left);
GetMemberExpression* gMem = dynamic_cast<GetMemberExpression*>(assign->left);
GetArrayExpression* gArray = dynamic_cast<GetArrayExpression*>(assign->left);
VarExpression* vDecl = dynamic_cast<VarExpression*>(assign->left);
GlobalExpression* gGbl = dynamic_cast<GlobalExpression*>(assign->left);
CallerExpression* gCaller = dynamic_cast<CallerExpression*>(assign->left);
if(gVar != nullptr)
{
instructions.push_back(new StringInstruction(gVar->name));
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SETVARIABLE));
}
if(gMem != nullptr)
{
Compile(gMem->parent,instructions);
instructions.push_back(new StringInstruction(gMem->name));
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SETFIELD));
}
if(gArray != nullptr)
{
Compile(gArray->parent,instructions);
Compile(gArray->expr,instructions);
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SETARRAY));
}
if(gGbl != nullptr)
{
gVar = dynamic_cast<GetVariableExpression*>(gGbl->node);
if(gVar != nullptr)
{
instructions.push_back(new StringInstruction(gVar->name));
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SET_GLOBAL_VARIABLE));
}
}
if(gCaller != nullptr)
{
gVar = dynamic_cast<GetVariableExpression*>(gCaller->node);
if(gVar != nullptr)
{
instructions.push_back(new StringInstruction(gVar->name));
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::SET_CALLER_VARIABLE));
}
}
if(vDecl != nullptr)
{
gVar = dynamic_cast<GetVariableExpression*>(vDecl->node);
if(gVar != nullptr)
{
instructions.push_back(new StringInstruction(gVar->name));
Compile(assign->right,instructions);
instructions.push_back(new SimpleInstruction(Instruction::DECLARE_VARIABLE));
}
}
}
if(varGet != nullptr)
{
instructions.push_back(new StringInstruction(varGet->name));
instructions.push_back(new SimpleInstruction(Instruction::GETVARIABLE));
}
if(gblGet != nullptr)
{
varGet = dynamic_cast<GetVariableExpression*>(gblGet->node);
if(varGet != nullptr)
{
instructions.push_back(new StringInstruction(varGet->name));
instructions.push_back(new SimpleInstruction(Instruction::GET_GLOBAL_VARIABLE));
}
}
if(callerGet != nullptr)
{
varGet = dynamic_cast<GetVariableExpression*>(callerGet->node);
if(varGet != nullptr)
{
instructions.push_back(new StringInstruction(varGet->name));
instructions.push_back(new SimpleInstruction(Instruction::GET_CALLER_VARIABLE));
}
}
if(memGet != nullptr)
{
Compile(memGet->parent,instructions);
instructions.push_back(new StringInstruction(memGet->name));
instructions.push_back(new SimpleInstruction(Instruction::GETFIELD));
}
if(arrGet != nullptr)
{
Compile(arrGet->parent,instructions);
Compile(arrGet->expr,instructions);
instructions.push_back(new SimpleInstruction(Instruction::GETARRAY));
}
if(fCall != nullptr)
{
auto field = dynamic_cast<GetMemberExpression*>(fCall->name);
if(field != nullptr)
{
Compile(field->parent,instructions);
instructions.push_back(new StringInstruction(field->name));
for(auto item : fCall->args)
Compile(item,instructions);
instructions.push_back(new LongInstruction(fCall->args.size()));
instructions.push_back(new SimpleInstruction(Instruction::CALL_METHOD));
}
else
{
Compile(fCall->name,instructions);
for(auto item : fCall->args)
Compile(item,instructions);
instructions.push_back(new LongInstruction(fCall->args.size()));
instructions.push_back(new SimpleInstruction(Instruction::CALL_FUNC));
}
}
}
void Compile(Node* n, InternalFunction* func)
{
std::vector<Instruction*> instructions;
Compile(n,instructions);
int length=0;
std::map<std::string,int> lbls;
for(auto item : instructions)
{
auto lbl = dynamic_cast<LabelInstruction*>(item);
if(lbl != nullptr)
lbls[lbl->GetLabel()] = length;
length += item->Length();
}
func->bytecodeLength = length;
func->bytecode = new uint8_t[length];
uint8_t* buffer = func->bytecode;
#if defined(DEBUG)
printf("INSTRUCTIONS:\n\n");
#endif
size_t len2=0;
for(auto item : instructions)
{
auto lblable = dynamic_cast<LabelableInstruction*>(item);
if(lblable != nullptr)
{
lblable->SetPosition(lbls[lblable->GetLabel()]);
}
item->Write(buffer);
buffer += item->Length();
#if defined(DEBUG)
printf("OFFSET %i\n",(int)len2);
item->Print();
#endif
len2+=item->Length();
delete item;
}
#if defined(DEBUG)
printf("\n\nEND OF INSTRUCTIONS\n\n");
#endif
instructions.clear();
}
public:
BytecodeFile* file;
BytecodeCompiler(Node* root)
{
this->n = root;
file=new BytecodeFile();
file->rootFunction = new InternalFunction();
file->rootFunction->isRoot=true;
}
void Compile()
{
Compile(n,file->rootFunction);
}
};
}
Reference in New Issue View Git Blame Copy Permalink