ilusha/Modules
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

clean up object module

Browse source
This commit is contained in:
IlyaShurupov 2024-03-23 12:32:57 +03:00 • committed by Ilya Shurupov
parent e78885d452
commit f8c82b7e29
68 changed files with 1223 additions and 1229 deletions
Download patch file Download diff file Expand all files Collapse all files

73
Objects/public/compiler/Constants.hpp
View file

@ -1,45 +1,42 @@
#pragma once
#include "interpreter/ByteCode.hpp"
#include "core/Object.hpp"
#include "interpreter/ByteCode.hpp"
namespace obj {
namespace BCgen {
namespace tp::obj {
class ConstObject {
public:
obj::Object* mObj = nullptr;
tp::alni mConstIdx = 0;
class ConstObject {
public:
Object* mObj = nullptr;
alni mConstIdx = 0;
ConstObject();
ConstObject(obj::Object* mObj);
};
class ConstObjectsPool {
public:
tp::Map<std::string, ConstObject*> mMethods;
tp::Map<std::string, ConstObject*> mStrings;
tp::Map<tp::alni, ConstObject*> mIntegers;
tp::Map<tp::alnf, ConstObject*> mFloats;
ConstObject mBoolTrue;
ConstObject mBoolFalse;
bool mDelete = true;
tp::alni mTotalObjects = 0;
ConstObject* get(tp::alni val);
ConstObject* get(const std::string& val);
ConstObject* get(tp::alnf val);
ConstObject* get(bool val);
ConstObject* addMethod(const std::string& method_id, obj::Object* method);
ConstObject* registerObject(obj::Object* obj);
void save(tp::Buffer<ConstData>& out);
ConstObjectsPool() = default;
~ConstObjectsPool();
};
ConstObject();
ConstObject(Object* mObj);
};
};
class ConstObjectsPool {
public:
Map<std::string, ConstObject*> mMethods;
Map<std::string, ConstObject*> mStrings;
Map<alni, ConstObject*> mIntegers;
Map<alnf, ConstObject*> mFloats;
ConstObject mBoolTrue;
ConstObject mBoolFalse;
bool mDelete = true;
alni mTotalObjects = 0;
ConstObject* get(alni val);
ConstObject* get(const std::string& val);
ConstObject* get(alnf val);
ConstObject* get(bool val);
ConstObject* addMethod(const std::string& method_id, Object* method);
ConstObject* registerObject(Object* obj);
void save(Buffer<ConstData>& out);
ConstObjectsPool() = default;
~ConstObjectsPool();
};
}

32
Objects/public/compiler/Expressions.hpp
View file

@ -1,12 +1,10 @@
#pragma once
#include <string>
#include "Buffer.hpp"
#include "interpreter/OperatoinCodes.hpp"
#include <string>
namespace obj::BCgen {
namespace tp::obj {
struct Expression {
enum class Type {
@ -33,26 +31,26 @@ namespace obj::BCgen {
};
struct ExpressionList : public Expression {
tp::Buffer<Expression*> mItems;
Buffer<Expression*> mItems;
ExpressionList();
~ExpressionList() override;
};
struct ExpressionNew : public Expression {
std::string mNewType;
explicit ExpressionNew(const std::string& type);
explicit ExpressionNew(std::string type);
~ExpressionNew() override;
};
struct ExpressionLocal : public Expression {
std::string mLocalId;
explicit ExpressionLocal(const std::string& id);
explicit ExpressionLocal(std::string id);
~ExpressionLocal() override;
};
struct ExpressionFunc : public Expression {
std::string mFuncId;
explicit ExpressionFunc(const std::string& id);
explicit ExpressionFunc(std::string id);
~ExpressionFunc() override;
};
@ -60,7 +58,7 @@ namespace obj::BCgen {
Expression* mParent = nullptr;
std::string mLocalId;
bool mMethod = false;
ExpressionChild(Expression* mParent, const std::string& id);
ExpressionChild(Expression* mParent, std::string id);
~ExpressionChild() override;
};
@ -83,7 +81,7 @@ namespace obj::BCgen {
Expression* mLeft = nullptr;
Expression* mRight = nullptr;
enum class BoolType : tp::uint1 {
enum class BoolType : uint1 {
AND = 24U,
OR,
EQUAL,
@ -103,16 +101,16 @@ namespace obj::BCgen {
struct ExpressionConst : public Expression {
enum ConstType { STR, INT, BOOL, FLT } mConstType;
std::string str;
tp::alni integer = 0;
tp::alnf floating = 0;
alni integer = 0;
alnf floating = 0;
bool boolean = false;
explicit ExpressionConst(const std::string& val);
explicit ExpressionConst(std::string val);
explicit ExpressionConst(const char* val);
explicit ExpressionConst(tp::alni val);
explicit ExpressionConst(tp::int4 val);
explicit ExpressionConst(tp::flt4 val);
explicit ExpressionConst(tp::alnf val);
explicit ExpressionConst(alni val);
explicit ExpressionConst(int4 val);
explicit ExpressionConst(flt4 val);
explicit ExpressionConst(alnf val);
explicit ExpressionConst(bool val);
~ExpressionConst() override;

51
Objects/public/compiler/Functions.hpp
View file

@ -1,7 +1,5 @@
#pragma once
#include <string>
#include "List.hpp"
#include "Map.hpp"
@ -9,39 +7,38 @@
#include "Statements.hpp"
#include "Constants.hpp"
namespace obj {
#include <string>
namespace tp::obj {
struct MethodObject;
namespace BCgen {
struct FunctionDefinition {
struct FunctionDefinition {
FunctionDefinition* mPrnt = nullptr;
FunctionDefinition* mPrnt = nullptr;
// signature
std::string mFunctionId;
tp::List<ConstObject*> mArgsOrder;
// signature
std::string mFunctionId;
List<ConstObject*> mArgsOrder;
ConstObjectsPool mConstants;
tp::Map<std::string, ConstObject*> mLocals;
tp::List<Instruction> mInstructions;
ConstObjectsPool mConstants;
Map<std::string, ConstObject*> mLocals;
List<Instruction> mInstructions;
FunctionDefinition(const std::string& function_id, tp::Buffer<std::string> args, FunctionDefinition* prnt);
FunctionDefinition() {}
FunctionDefinition(const std::string& function_id, const Buffer<std::string>& args, FunctionDefinition* prnt);
FunctionDefinition() {}
void generateByteCode(ByteCode& out);
void generateByteCode(ByteCode& out);
tp::List<Instruction>::Node* inst(Instruction inst);
void EvalExpr(Expression* expr);
void EvalStatement(Statement* expr);
List<Instruction>::Node* inst(Instruction inst);
ConstObject* defineLocal(const std::string& id);
};
void EvalExpr(Expression* expr);
void EvalStatement(Statement* expr);
void init();
void deinit();
void Genereate(ByteCode& out, StatementScope* body);
bool Compile(MethodObject* obj);
ConstObject* defineLocal(const std::string& id);
};
};
void initialize();
void finalize();
void Generate(ByteCode& out, StatementScope* body);
bool Compile(MethodObject* obj);
}

69
Objects/public/compiler/Instructions.hpp
View file

@ -2,52 +2,47 @@
#pragma once
#include "interpreter/OperatoinCodes.hpp"
#include "core/Object.hpp"
#include "List.hpp"
namespace obj {
namespace BCgen {
namespace tp::obj {
class ConstObject;
class ConstObject;
class Instruction {
public:
class Instruction {
public:
OpCode mOp = OpCode::NONE;
OpCode mOp = OpCode::NONE;
enum class ArgType : ualni {
NO_ARG,
PARAM,
CONST_ARG,
} mArgType = ArgType::NO_ARG;
enum class ArgType : tp::ualni {
NO_ARG,
PARAM,
CONST_ARG,
} mArgType = ArgType::NO_ARG;
enum class InstType : ualni {
NONE,
JUMP,
JUMP_IF,
JUMP_IF_NOT,
EXEC,
PURE_CONST,
} mInstType = InstType::NONE;
enum class InstType : tp::ualni {
NONE,
JUMP,
JUMP_IF,
JUMP_IF_NOT,
EXEC,
PURE_CONST,
} mInstType = InstType::NONE;
alni mParam = 0;
alni mParamBytes = 1;
tp::alni mParam = 0;
tp::alni mParamBytes = 1;
ConstObject* mConstData = nullptr;
ConstObject* mConstData2 = nullptr;
ConstObject* mConstData = nullptr;
ConstObject* mConstData2 = nullptr;
alni mInstIdx = 0;
Instruction* mInstTarget = nullptr;
tp::alni mInstIdx = 0;
Instruction* mInstTarget = nullptr;
Instruction();
Instruction(ConstObject* constData);
Instruction(OpCode op);
Instruction(OpCode op, ConstObject* constData);
Instruction(OpCode op, ConstObject* constData, ConstObject* constData2);
Instruction(OpCode op, tp::alni param, tp::alni nBytes);
Instruction(Instruction* inst, InstType jump_type);
};
Instruction();
Instruction(ConstObject* constData);
Instruction(OpCode op);
Instruction(OpCode op, ConstObject* constData);
Instruction(OpCode op, ConstObject* constData, ConstObject* constData2);
Instruction(OpCode op, alni param, alni nBytes);
Instruction(Instruction* inst, InstType jump_type);
};
};
}

10
Objects/public/compiler/Statements.hpp
View file

@ -3,7 +3,7 @@
#include "Expressions.hpp"
namespace obj::BCgen {
namespace tp::obj {
struct Statement {
enum class Type {
@ -28,15 +28,15 @@ namespace obj::BCgen {
};
struct StatementScope : public Statement {
tp::Buffer<Statement*> mStatements;
Buffer<Statement*> mStatements;
bool mPushToScopeStack = false;
StatementScope(tp::InitialierList<Statement*> statements, bool aPushToScopeStack);
StatementScope(InitialierList<Statement*> statements, bool aPushToScopeStack);
~StatementScope() override;
};
struct StatementFuncDef : public Statement {
tp::Buffer<std::string> mArgs;
Buffer<std::string> mArgs;
std::string mFunctionId;
StatementScope* mStatements = nullptr;
@ -50,7 +50,7 @@ namespace obj::BCgen {
ExpressionConst* mConstExpr = nullptr;
bool mIsConstExpr = false;
StatementLocalDef(const std::string& id, Expression* value);
StatementLocalDef(std::string id, Expression* value);
~StatementLocalDef() override;
};

139
Objects/public/core/Object.hpp
View file

@ -10,12 +10,12 @@
#include "core/TypeGroups.hpp"
#include "core/TypeMethods.hpp"
#include "Archiver.hpp"
#include "ObjectArchiver.hpp"
#include "SizeCounter.hpp"
#include <string>
//#include "interpreter/interpreter.h"
#include "core/ObjectArchiver.hpp"
/* Steps to create custom Object:
define name of object
@ -37,80 +37,29 @@ implement construct, destruct and copy methods */
#define NDO_MEMH_FROM_NDO(ndo_ptr) (((ObjectMemHead*)ndo_ptr) - 1)
#define NDO_FROM_MEMH(ndo_ptr) ((Object*)(ndo_ptr + 1))
namespace obj {
namespace tp::obj {
template<bool tRead>
class Archiver : public tp::ArchiverTemplate<tRead> {
tp::LocalConnection mConnection;
tp::ualni mAddress = 0;
tp::ualni mFirstNotWritten = 0;
public:
Archiver() = default;
explicit Archiver(const char* location) {
mConnection.connect(tp::LocalConnection::Location(location), tp::LocalConnection::Type(tRead));
};
void writeBytes(const tp::int1* val, tp::ualni size) override {
mConnection.setPointer(mAddress);
mConnection.writeBytes(val, size);
incrementAddresses(size);
}
void readBytes(tp::int1* val, tp::ualni size) override {
mConnection.setPointer(mAddress);
mConnection.readBytes(val, size);
incrementAddresses(size);
}
tp::ualni getAddress() { return mAddress; }
void setAddress(tp::ualni addr) { mAddress = addr; }
tp::ualni getFreeAddress() { return mFirstNotWritten; }
void setFreeAddress(tp::ualni addr) { mFirstNotWritten = addr; }
bool isOpened() { return mConnection.getConnectionStatus().isOpened(); }
tp::ualni getSize() { return mConnection.size(); }
private:
void incrementAddresses(tp::ualni size) {
// if (mAddress + size > mFirstNotWritten) mFirstNotWritten = mAddress + size;
mAddress += size;
}
};
using ArchiverIn = Archiver<true>;
using ArchiverOut = Archiver<false>;
void save_string(ArchiverOut& file, const std::string& string);
tp::ualni save_string_size(const std::string& string);
void load_string(ArchiverIn& file, std::string& out);
extern tp::ModuleManifest gModuleObjects;
extern ModuleManifest gModuleObjects;
extern struct objects_api* NDO;
struct ObjectMemHead {
ObjectMemHead* up;
ObjectMemHead* down;
tp::alni flags;
tp::alni refc;
alni flags;
alni refc;
};
struct Object {
const struct ObjectType* type;
};
typedef void (*object_from_int)(Object* self, tp::alni in);
typedef void (*object_from_float)(Object* self, tp::alnf in);
typedef void (*object_from_int)(Object* self, alni in);
typedef void (*object_from_float)(Object* self, alnf in);
typedef void (*object_from_string)(Object* self, const std::string& in);
typedef std::string(*object_to_string)(Object* self);
typedef tp::alni(*object_to_int)(Object* self);
typedef tp::alnf(*object_to_float)(Object* self);
typedef alni(*object_to_int)(Object* self);
typedef alnf(*object_to_float)(Object* self);
struct ObjectTypeConversions {
object_from_int from_int;
@ -137,22 +86,22 @@ namespace obj {
typedef void (*object_destructor)(Object* self);
typedef void (*object_copy)(Object* self, const Object* target);
typedef tp::alni(*object_save_size)(Object* self);
typedef alni(*object_save_size)(Object* self);
typedef void (*object_save)(Object*, ArchiverOut&);
typedef void (*object_load)(ArchiverIn&, Object*);
typedef bool (*object_compare)(Object*, Object*);
typedef tp::Buffer<Object*> (*object_debug_all_childs_retrival)(Object*);
typedef tp::alni (*object_allocated_size)(Object*); // default value = type->size - sizeof(ObjectType*)
typedef tp::alni (*object_allocated_size_recursive)(Object*); // default value = object_allocated_size
typedef Buffer<Object*> (*object_debug_all_childs_retrival)(Object*);
typedef alni (*object_allocated_size)(Object*); // default value = type->size - sizeof(ObjectType*)
typedef alni (*object_allocated_size_recursive)(Object*); // default value = object_allocated_size
struct ObjectType {
const ObjectType* base = nullptr;
object_constructor constructor = nullptr;
object_destructor destructor = nullptr;
object_copy copy = nullptr;
tp::alni size = 0;
alni size = 0;
const char* name;
const ObjectTypeConversions* convesions = nullptr;
const ObjectTypeAriphmetics* ariphmetics = nullptr;
@ -174,7 +123,7 @@ namespace obj {
typedef void (pre_load_callback)(void* self, ArchiverIn&);
typedef void (post_save_callback)(void* self, ArchiverOut&);
typedef void (post_load_callback)(void* self, ArchiverIn&);
typedef tp::alni (slcb_size_callback)(void* self, ArchiverOut&);
typedef alni (slcb_size_callback)(void* self, ArchiverOut&);
struct save_load_callbacks {
void* self;
@ -188,8 +137,8 @@ namespace obj {
struct objects_api {
tp::Map<std::string, const ObjectType*> types;
obj::TypeGroups type_groups;
Map<std::string, const ObjectType*> types;
TypeGroups type_groups;
Interpreter* interp = nullptr;
objects_api();
@ -197,54 +146,54 @@ namespace obj {
void define(ObjectType* type);
Object* create(const std::string& name);
Object* copy(Object* self, const Object* in);
bool compare(Object* first, Object* second);
Object* instatiate(Object*);
void set(Object* self, tp::alni val);
void set(Object* self, tp::alnf val);
void set(Object* self, const std::string& val);
static Object* copy(Object* self, const Object* in);
static bool compare(Object* first, Object* second);
static Object* instantiate(Object*);
static void set(Object* self, alni val);
static void set(Object* self, alnf val);
static void set(Object* self, const std::string& val);
tp::alni toInt(Object* self);
tp::alnf toFloat(Object* self);
bool toBool(Object* self);
std::string toString(Object* self);
static alni toInt(Object* self);
static alnf toFloat(Object* self);
static bool toBool(Object* self);
static std::string toString(Object* self);
void clear_object_flags();
void destroy(Object* in);
void destroy(Object* in) const;
void refinc(Object* in);
tp::halni getrefc(Object* in);
static void increaseReferenceCount(Object* in);
static halni getReferenceCount(Object* in);
private:
void setrefc(Object* in, tp::halni refc);
static void setReferenceCount(Object* in, halni count);
public:
save_load_callbacks* sl_callbacks[SAVE_LOAD_MAX_CALLBACK_SLOTS];
tp::alni sl_callbacks_load_idx = 0;
save_load_callbacks* sl_callbacks[SAVE_LOAD_MAX_CALLBACK_SLOTS]{};
alni sl_callbacks_load_idx = 0;
void add_sl_callbacks(save_load_callbacks*);
tp::alni objsize_file(Object* self);
tp::alni objsize_file_recursive(Object* self);
alni objsize_file(Object* self);
alni objsize_file_recursive(Object* self);
tp::alni objsize_ram(Object* self);
tp::alni objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object = true);
tp::alni objsize_ram_recursive(Object* self);
alni objsize_ram(Object* self);
alni objsize_ram_recursive_util(Object* self, const ObjectType* type, bool different_object = true);
alni objsize_ram_recursive(Object* self);
bool save(Object*, const std::string& path, bool compressed = true);
Object* load(const std::string& path);
tp::alni save(ArchiverOut&, Object*);
Object* load(ArchiverIn&, tp::alni file_adress);
alni save(ArchiverOut&, Object*);
Object* load(ArchiverIn&, alni file_adress);
};
void logTypeData(const ObjectType* type);
void assertNoLeaks();
tp::ualni getObjCount();
ualni getObjCount();
Object* ndo_cast(const Object* in, const ObjectType* to_type);
template <typename Type>
Type* create() {
return (Type*)obj::NDO->create(Type::TypeData.name);
return (Type*)NDO->create(Type::TypeData.name);
}
};
}

56
Objects/public/core/ObjectArchiver.hpp Normal file
View file

@ -0,0 +1,56 @@
#pragma once
#include "ObjectArchiver.hpp"
#include "LocalConnection.hpp"
namespace tp::obj {
template<bool tRead>
class Archiver : public ArchiverTemplate<tRead> {
LocalConnection mConnection;
ualni mAddress = 0;
ualni mFirstNotWritten = 0;
public:
Archiver() = default;
explicit Archiver(const char* location) {
mConnection.connect(LocalConnection::Location(location), LocalConnection::Type(tRead));
};
void writeBytes(const int1* val, ualni size) override {
mConnection.setPointer(mAddress);
mConnection.writeBytes(val, size);
incrementAddresses(size);
}
void readBytes(int1* val, ualni size) override {
mConnection.setPointer(mAddress);
mConnection.readBytes(val, size);
incrementAddresses(size);
}
ualni getAddress() { return mAddress; }
void setAddress(ualni addr) { mAddress = addr; }
ualni getFreeAddress() { return mFirstNotWritten; }
void setFreeAddress(ualni addr) { mFirstNotWritten = addr; }
bool isOpened() { return mConnection.getConnectionStatus().isOpened(); }
ualni getSize() { return mConnection.size(); }
private:
void incrementAddresses(ualni size) {
// if (mAddress + size > mFirstNotWritten) mFirstNotWritten = mAddress + size;
mAddress += size;
}
};
using ArchiverIn = Archiver<true>;
using ArchiverOut = Archiver<false>;
void save_string(ArchiverOut& file, const std::string& string);
ualni save_string_size(const std::string& string);
void load_string(ArchiverIn& file, std::string& out);
}

12
Objects/public/core/ScriptSection.hpp
View file

@ -2,19 +2,19 @@
#include "primitives/MethodObject.hpp"
namespace obj {
namespace tp::obj {
// global singleton API for method object to manage the script
struct ScriptSection {
tp::List<Script*> mScripts;
List<Script*> mScripts;
Script* createScript();
void changeScript(Script** current_script, Script** new_script);
void abandonScript(Script* script);
tp::alni get_script_file_adress(Script* in);
Script* get_scritp_from_file_adress(tp::alni file_adress);
alni get_script_file_adress(Script* in);
Script* get_scritp_from_file_adress(alni file_adress);
~ScriptSection();
@ -31,6 +31,6 @@ namespace obj {
static void save_script_table_to_file(ScriptSection* self, ArchiverOut& file);
static void load_script_table_from_file(ScriptSection* self, ArchiverIn& file);
static tp::alni save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file);
static alni save_script_table_to_file_size(ScriptSection* self, ArchiverOut& file);
};
};
}

11
Objects/public/core/TypeGroups.hpp
View file

@ -4,7 +4,7 @@
#include "Map.hpp"
#include <string>
namespace obj {
namespace tp::obj {
struct ObjectType;
struct objects_api;
@ -13,15 +13,15 @@ namespace obj {
public:
typedef tp::Map<std::string, obj::TypeGroups*> Dict;
typedef Map<std::string, TypeGroups*> Dict;
TypeGroups();
friend struct obj::objects_api;
friend struct objects_api;
explicit TypeGroups(bool is_group);
void addType(ObjectType* type, tp::InitialierList<const char*> path, tp::alni cur_arg = 0);
void addType(ObjectType* type, InitialierList<const char*> path, alni cur_arg = 0);
void setType(ObjectType* type);
bool isGroup();
Dict* getChilds();
@ -36,5 +36,4 @@ namespace obj {
const obj::ObjectType* type;
};
};
};
}

21
Objects/public/core/TypeMethods.hpp
View file

@ -4,7 +4,7 @@
#include "Buffer.hpp"
#include <string>
namespace obj {
namespace tp::obj {
struct Interpreter;
struct Object;
@ -23,7 +23,7 @@ namespace obj {
mutable Object* self = nullptr;
Arg args[MAX_ARGS];
tp::int1 mNargs = 0;
int1 mNargs = 0;
void (*exec)(const TypeMethod* tm) = nullptr;
@ -37,14 +37,14 @@ namespace obj {
extern TypeMethod gDefaultTypeMethods[3];
struct TypeMethods {
enum : tp::int2 { MAX_TYPE_METHODS = 128 };
enum : int2 { MAX_TYPE_METHODS = 128 };
TypeMethod* methods[MAX_TYPE_METHODS];
tp::halni mNMethods = 0;
halni mNMethods = 0;
struct LookupKey {
tp::int2 key = -1;
tp::int2 type_depth = -1;
int2 key = -1;
int2 type_depth = -1;
operator bool() { return key != -1; }
};
@ -53,11 +53,10 @@ namespace obj {
void init();
tp::halni nMethods() const;
halni nMethods() const;
private:
tp::int2 presents(const std::string&) const;
const TypeMethod* getMethod(tp::int2) const;
int2 presents(const std::string&) const;
const TypeMethod* getMethod(int2) const;
};
};
}

12
Objects/public/interpreter/ByteCode.hpp
View file

@ -9,15 +9,15 @@
#include "Buffer.hpp"
#include <string>
namespace obj {
namespace tp::obj {
typedef Object* ConstData;
struct ByteCode {
tp::Buffer<ConstData> mConstants;
tp::Buffer<OpCode> mInstructions;
tp::ualni mInstructionIdx = 0;
tp::ualni mArgumentsLoaded = 0;
Buffer<ConstData> mConstants;
Buffer<OpCode> mInstructions;
ualni mInstructionIdx = 0;
ualni mArgumentsLoaded = 0;
~ByteCode() {
for (auto const_obj : mConstants) {
@ -25,4 +25,4 @@ namespace obj {
}
}
};
};
}

17
Objects/public/interpreter/CallStack.hpp
View file

@ -5,11 +5,8 @@
#include "Map.hpp"
namespace obj {
namespace tp::obj {
struct MethodObject;
};
namespace obj {
struct ByteCode;
@ -17,16 +14,16 @@ namespace obj {
struct CallFrame {
enum { CALL_DEPTH = 1024 };
obj::Object* mSelf = nullptr;
obj::MethodObject* mMethod = nullptr;
tp::ualni mIp = 0;
Object* mSelf = nullptr;
MethodObject* mMethod = nullptr;
ualni mIp = 0;
};
void enter(const CallFrame& frame);
void leave();
ByteCode* getBytecode();
[[nodiscard]] tp::halni len() const;
[[nodiscard]] halni len() const;
tp::ConstSizeBuffer<CallFrame, CallFrame::CALL_DEPTH> mStack;
ConstSizeBuffer<CallFrame, CallFrame::CALL_DEPTH> mStack;
};
};
}

12
Objects/public/interpreter/Interpreter.hpp
View file

@ -4,19 +4,19 @@
#include "ScopeStack.hpp"
#include "CallStack.hpp"
namespace obj {
namespace tp::obj {
struct Interpreter {
OperandStack mOperandsStack;
ScopeStack mScopeStack;
CallStack mCallStack;
obj::Object* mLastParent = nullptr;
Object* mLastParent = nullptr;
bool mIsTypeMethod = false;
const TypeMethod* mTypeMethod = nullptr;
typedef struct { obj::Object* obj; std::string id; } GlobalDef;
typedef struct { Object* obj; std::string id; } GlobalDef;
void exec(obj::MethodObject* method, obj::ClassObject* self = nullptr, obj::DictObject* globals = nullptr, tp::InitialierList<GlobalDef> globals2 = {});
void exec(MethodObject* method, ClassObject* self = nullptr, DictObject* globals = nullptr, InitialierList<GlobalDef> globals2 = {});
void stepBytecode();
void stepBytecodeIn();
@ -24,6 +24,6 @@ namespace obj {
bool finished();
void execAll(obj::MethodObject* method, obj::ClassObject* self = nullptr, obj::DictObject* globals = nullptr, tp::InitialierList<GlobalDef> globals2 = {});
void execAll(MethodObject* method, ClassObject* self = nullptr, DictObject* globals = nullptr, InitialierList<GlobalDef> globals2 = {});
};
};
}

11
Objects/public/interpreter/OperandsStack.hpp
View file

@ -3,21 +3,21 @@
#include "ByteCode.hpp"
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
// can be other aligned value as well
typedef obj::Object* Operand;
typedef Object* Operand;
class OperandStack {
enum : tp::alni {
enum : alni {
MAX_STACK_SIZE = 512
};
public:
Operand* mBuff;
tp::ualni mIdx;
ualni mIdx;
OperandStack();
void push(Operand operand);
@ -35,5 +35,4 @@ namespace obj {
~OperandStack();
};
};
}

18
Objects/public/interpreter/OperatoinCodes.hpp
View file

@ -12,11 +12,11 @@
// 2) Index of bytecode->ConstData from bytecode->Instruction (ConstData)
// 3) Raw Bytes from bytecode->Instruction (Param)
namespace obj {
namespace tp::obj {
extern struct OpcodeInfos gOpcodeInfos;
enum class OpCode : tp::uint1 {
enum class OpCode : uint1 {
NONE = 0x00,
HALT,
@ -118,24 +118,24 @@ namespace obj {
enum { MAX_OPERANDS = 5 };
Operand buff[MAX_OPERANDS];
tp::halni len = 0;
halni len = 0;
OperandsInfo();
OperandsInfo(tp::InitialierList<Operand> list);
OperandsInfo(InitialierList<Operand> list);
};
struct ParamsInfo {
struct Param {
const char* desc = nullptr;
tp::halni bytes = 1;
halni bytes = 1;
};
enum { MAX_PARAMS = 5 };
Param buff[MAX_PARAMS];
tp::halni len = 0;
halni len = 0;
ParamsInfo();
ParamsInfo(tp::InitialierList<Param> list);
ParamsInfo(InitialierList<Param> list);
};
struct OpInfo {
@ -144,14 +144,14 @@ namespace obj {
OperandsInfo operands;
ParamsInfo params;
tp::uint1 opsize();
uint1 opsize();
};
OpcodeInfos();
OpInfo fetch(OpCode code);
private:
OpInfo buff[(tp::alni)OpCode::END_OPCODES];
OpInfo buff[(alni)OpCode::END_OPCODES];
void add(OpCode code, const OpInfo& info);
};

25
Objects/public/interpreter/ScopeStack.hpp
View file

@ -3,11 +3,11 @@
#include "core/Object.hpp"
#include "Map.hpp"
namespace obj {
namespace tp::obj {
struct Scope {
typedef tp::Map<std::string, obj::Object*> ObjDict;
typedef tp::List<obj::Object*> ObjList;
typedef Map<std::string, Object*> ObjDict;
typedef List<Object*> ObjList;
ObjDict mLocals;
ObjList mTemps;
@ -18,29 +18,28 @@ namespace obj {
class ScopeStack {
enum : tp::alni {
enum : alni {
MAX_STACK_SIZE = 1024 * 4
};
public:
Scope* mBuff;
tp::ualni mIdx;
tp::ualni mIterIdx;
ualni mIdx;
ualni mIterIdx;
ScopeStack();
void enterScope(bool aChildReachable);
void leaveScope();
void addLocal(obj::Object* local, const std::string& id);
void addTemp(obj::Object* tmp);
void addLocal(Object* local, const std::string& id);
void addTemp(Object* tmp);
void popTemp();
void addTempReturn(obj::Object* ret);
obj::Object* getLocal(const std::string& str);
void addTempReturn(Object* ret);
Object* getLocal(const std::string& str);
Scope* getCurrentScope();
~ScopeStack();
private:
obj::Object* getLocalUtil(Scope& scope, const std::string& id);
Object* getLocalUtil(Scope& scope, const std::string& id);
};
};
}

6
Objects/public/interpreter/Script.hpp
View file

@ -2,11 +2,11 @@
#include "interpreter/ByteCode.hpp"
namespace obj {
namespace tp::obj {
struct Script {
obj::StringObject* mReadable;
StringObject* mReadable;
ByteCode mBytecode;
void compile();
};
};
}

10
Objects/public/parser/Parser.hpp
View file

@ -3,20 +3,20 @@
#include "compiler/Statements.hpp"
#include "compiler/Expressions.hpp"
namespace obj {
namespace tp::obj {
class Parser {
public:
Parser() = default;
struct Result {
obj::BCgen::StatementScope* scope = nullptr;
StatementScope* scope = nullptr;
bool isError = false;
std::string description;
tp::halni line = 0;
tp::halni column = 0;
halni line = 0;
halni column = 0;
};
Result parse(const std::string& stream);
};
};
}

14
Objects/public/primitives/BoolObject.hpp
View file

@ -3,10 +3,10 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct BoolObject : Object {
tp::alni val;
alni val;
static ObjectType TypeData;
static void constructor(BoolObject* self);
@ -14,11 +14,11 @@ namespace obj {
static BoolObject* create(bool in);
static void from_int(BoolObject* self, tp::alni in);
static void from_float(BoolObject* self, tp::alnf in);
static void from_int(BoolObject* self, alni in);
static void from_float(BoolObject* self, alnf in);
static void from_string(BoolObject* self, const std::string& in);
static std::string to_string(BoolObject* self);
static tp::alni to_int(BoolObject* self);
static tp::alnf to_float(BoolObject* self);
static alni to_int(BoolObject* self);
static alnf to_float(BoolObject* self);
};
};
}

8
Objects/public/primitives/ClassObject.hpp
View file

@ -2,7 +2,7 @@
#include "primitives/DictObject.hpp"
namespace obj {
namespace tp::obj {
struct ClassObject : Object {
@ -10,7 +10,7 @@ namespace obj {
static void copy(ClassObject* self, const ClassObject* in);
static void destructor(ClassObject* self);
static void constructor(ClassObject* self);
static tp::alni save_size(ClassObject* self);
static alni save_size(ClassObject* self);
static void save(ClassObject* self, ArchiverOut& file_self);
static void load(ArchiverIn& file_self, ClassObject* self);
@ -31,7 +31,7 @@ namespace obj {
Type* getMember(const std::string& id) {
auto idx = members->presents(id);
if (bool(idx)) {
return ((Type*)obj::ndo_cast(members->getSlotVal(idx), &Type::TypeData));
return ((Type*)ndo_cast(members->getSlotVal(idx), &Type::TypeData));
}
return NULL;
}
@ -43,4 +43,4 @@ namespace obj {
return out;
}
};
};
}

12
Objects/public/primitives/ColorObject.hpp
View file

@ -4,10 +4,10 @@
#include "core/Object.hpp"
#include "Color.hpp"
namespace obj {
namespace tp::obj {
struct ColorObject : Object {
tp::RGBA mCol;
RGBA mCol;
static ObjectType TypeData;
static ObjectTypeAriphmetics TypeAriphm;
@ -15,10 +15,10 @@ namespace obj {
static void constructor(Object* self);
static void copy(ColorObject* self, const ColorObject* in);
static void from_int(ColorObject* self, tp::alni in);
static void from_float(ColorObject* self, tp::alnf in);
static void from_int(ColorObject* self, alni in);
static void from_float(ColorObject* self, alnf in);
static std::string to_string(ColorObject* self);
static ColorObject* create(tp::RGBA in);
static ColorObject* create(RGBA in);
};
};
}

20
Objects/public/primitives/DictObject.hpp
View file

@ -2,7 +2,7 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct DictObject : Object {
static ObjectType TypeData;
@ -10,22 +10,22 @@ namespace obj {
static void destructor(Object* self);
static void constructor(Object* self);
static tp::alni save_size(DictObject* self);
static alni save_size(DictObject* self);
static void save(DictObject* self, ArchiverOut& file_self);
static void load(ArchiverIn& file_self, DictObject* self);
static tp::Buffer<Object*> childs_retrival(DictObject* self);
static tp::alni allocated_size(DictObject* self);
static tp::alni allocated_size_recursive(DictObject* self);
static Buffer<Object*> childs_retrival(DictObject* self);
static alni allocated_size(DictObject* self);
static alni allocated_size_recursive(DictObject* self);
void put(const std::string&, Object*);
void remove(const std::string&);
Object* get(const std::string&);
tp::Map<std::string, Object*>::Idx presents(const std::string&);
Object* getSlotVal(tp::Map<std::string, Object*>::Idx);
Map<std::string, Object*>::Idx presents(const std::string&);
Object* getSlotVal(Map<std::string, Object*>::Idx);
[[nodiscard]] const tp::Map<std::string, Object*>& getItems() const;
[[nodiscard]] const Map<std::string, Object*>& getItems() const;
private:
tp::Map<std::string, Object*> items;
Map<std::string, Object*> items;
};
};
}

24
Objects/public/primitives/EnumObject.hpp
View file

@ -3,32 +3,32 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct EnumObject : Object {
// one entry is 2 * sizeof(alni) in size
tp::uhalni active;
tp::uhalni nentries;
tp::alni* entries;
uhalni active;
uhalni nentries;
alni* entries;
static ObjectType TypeData;
static void constructor(EnumObject* self);
static void destructor(EnumObject* self);
static void copy(EnumObject* self, const EnumObject* in);
void init(tp::InitialierList<const char*> list);
void init(InitialierList<const char*> list);
const char* getActiveName();
const char* getItemName(tp::uhalni idx);
const char* getItemName(uhalni idx);
static void from_int(EnumObject* self, tp::alni in);
static void from_float(EnumObject* self, tp::alnf in);
static void from_int(EnumObject* self, alni in);
static void from_float(EnumObject* self, alnf in);
static void from_string(EnumObject* self, const std::string& in);
static std::string to_string(EnumObject* self);
static tp::alni to_int(EnumObject* self);
static tp::alnf to_float(EnumObject* self);
static alni to_int(EnumObject* self);
static alnf to_float(EnumObject* self);
static bool compare(EnumObject* first, EnumObject* second);
static EnumObject* create(tp::InitialierList<const char*> list);
static EnumObject* create(InitialierList<const char*> list);
};
};
}

16
Objects/public/primitives/FloatObject.hpp
View file

@ -3,10 +3,10 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct FloatObject : Object {
tp::alnf val;
alnf val;
static ObjectType TypeData;
static ObjectTypeAriphmetics TypeAriphm;
@ -14,13 +14,13 @@ namespace obj {
static void constructor(FloatObject* self);
static void copy(FloatObject* self, const FloatObject* in);
static FloatObject* create(tp::alnf in);
static FloatObject* create(alnf in);
static void from_int(FloatObject* self, tp::alni in);
static void from_float(FloatObject* self, tp::alnf in);
static void from_int(FloatObject* self, alni in);
static void from_float(FloatObject* self, alnf in);
static void from_string(FloatObject* self, const std::string& in);
static std::string to_string(FloatObject* self);
static tp::alni to_int(FloatObject* self);
static tp::alnf to_float(FloatObject* self);
static alni to_int(FloatObject* self);
static alnf to_float(FloatObject* self);
};
};
}

16
Objects/public/primitives/IntObject.hpp
View file

@ -3,23 +3,23 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct IntObject : Object {
tp::alni val;
alni val;
static ObjectType TypeData;
static ObjectTypeAriphmetics TypeAriphm;
static void constructor(Object* self);
static void copy(IntObject* self, const IntObject* in);
static IntObject* create(tp::alni in);
static IntObject* create(alni in);
static void from_int(Object* self, tp::alni in);
static void from_float(Object* self, tp::alnf in);
static void from_int(Object* self, alni in);
static void from_float(Object* self, alnf in);
static void from_string(Object* self, const std::string& in);
static std::string to_string(Object* self);
static tp::alni to_int(Object* self);
static tp::alnf to_float(Object* self);
static alni to_int(Object* self);
static alnf to_float(Object* self);
};
};
}

6
Objects/public/primitives/InterpreterObject.hpp
View file

@ -3,7 +3,7 @@
#include "interpreter/Interpreter.hpp"
#include "primitives/ClassObject.hpp"
namespace obj {
namespace tp::obj {
struct InterpreterObject : ClassObject {
static ObjectType TypeData;
Interpreter mInterpreter;
@ -12,8 +12,8 @@ namespace obj {
static void constructor(InterpreterObject* self);
static void load(ArchiverIn& file_self, InterpreterObject* self);
void exec(obj::ClassObject* self = nullptr, tp::InitialierList<Interpreter::GlobalDef> globals = {});
void exec(obj::ClassObject* self = nullptr, InitialierList<Interpreter::GlobalDef> globals = {});
void debug();
bool running();
};
};
}

13
Objects/public/primitives/LinkObject.hpp
View file

@ -3,7 +3,7 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct LinkObject : Object {
static ObjectType TypeData;
@ -12,12 +12,12 @@ namespace obj {
static void copy(Object* self, const Object* in);
static LinkObject* create(Object* in);
static tp::alni save_size(LinkObject* self);
static alni save_size(LinkObject* self);
static void save(LinkObject* self, ArchiverOut& file_self);
static void load(ArchiverIn& file_self, LinkObject* self);
static tp::alni allocated_size(LinkObject* self);
static tp::alni allocated_size_recursive(LinkObject* self);
static tp::Buffer<Object*> childs_retrival(LinkObject* self);
static alni allocated_size(LinkObject* self);
static alni allocated_size_recursive(LinkObject* self);
static Buffer<Object*> childs_retrival(LinkObject* self);
Object* getLink();
void setLink(Object* obj);
@ -25,5 +25,4 @@ namespace obj {
private:
Object* link;
};
};
}

18
Objects/public/primitives/ListObject.hpp
View file

@ -3,7 +3,7 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
enum ListMethods {
LISTOBJECT_PUSH_BACK,
@ -16,21 +16,21 @@ namespace obj {
static void copy(Object* self, const Object* in);
static void destructor(Object* self);
static tp::alni allocated_size_recursive(ListObject* self);
static tp::alni allocated_size(ListObject* self);
static tp::Buffer<Object*> childs_retrival(ListObject* self);
static alni allocated_size_recursive(ListObject* self);
static alni allocated_size(ListObject* self);
static Buffer<Object*> childs_retrival(ListObject* self);
static void load(ArchiverIn& file_self, ListObject* self);
static void save(ListObject* self, ArchiverOut& file_self);
static tp::alni save_size(ListObject* self);
static alni save_size(ListObject* self);
[[nodiscard]] const tp::List<Object*>& getItems() const;
[[nodiscard]] const List<Object*>& getItems() const;
void pushBack(Object* obj);
void pushFront(Object* obj);
void popBack();
void delNode(tp::List<Object*>::Node*);
void delNode(List<Object*>::Node*);
private:
tp::List<Object*> items;
List<Object*> items;
};
};
}

6
Objects/public/primitives/MethodObject.hpp
View file

@ -3,7 +3,7 @@
#include "primitives/StringObject.hpp"
#include "interpreter/Script.hpp"
namespace obj {
namespace tp::obj {
struct MethodObject : Object {
@ -14,7 +14,7 @@ namespace obj {
static void constructor(MethodObject* self);
static void copy(MethodObject* self, MethodObject* in);
static void destructor(MethodObject* self);
static tp::alni save_size(MethodObject* self);
static alni save_size(MethodObject* self);
static void save(MethodObject* self, ArchiverOut& file_self);
static void load(ArchiverIn& file_self, obj::MethodObject* self);
@ -25,4 +25,4 @@ namespace obj {
static MethodObject* create(const std::string& script);
};
};
}

12
Objects/public/primitives/NullObject.hpp
View file

@ -3,7 +3,7 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
extern struct NullObject* NdoNull_globalInstance;
@ -15,18 +15,18 @@ namespace obj {
static Object* null_return() {
if (!NdoNull_globalInstance) {
NdoNull_globalInstance = (NullObject*) NDO->create("null");
obj::NDO->refinc(NdoNull_globalInstance);
NDO->increaseReferenceCount(NdoNull_globalInstance);
}
return (Object*) NdoNull_globalInstance;
}
static Object* null_return_ref() {
obj::NDO->refinc(null_return());
NDO->increaseReferenceCount(null_return());
return NdoNull_globalInstance;
}
};
#define NDO_NULL obj::NullObject::null_return()
#define NDO_NULL_REF obj::NullObject::null_return_ref()
#define NDO_NULL NullObject::null_return()
#define NDO_NULL_REF NullObject::null_return_ref()
};
}

12
Objects/public/primitives/StringObject.hpp
View file

@ -3,7 +3,7 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct StringObject : Object {
std::string val;
@ -14,11 +14,11 @@ namespace obj {
static void copy(Object* self, const Object* in);
static StringObject* create(const std::string& in);
static void from_int(StringObject* self, tp::alni in);
static void from_float(StringObject* self, tp::alnf in);
static void from_int(StringObject* self, alni in);
static void from_float(StringObject* self, alnf in);
static void from_string(StringObject* self, const std::string& in);
static std::string to_string(StringObject* self);
static tp::alni to_int(StringObject* self);
static tp::alnf to_float(StringObject* self);
static alni to_int(StringObject* self);
static alnf to_float(StringObject* self);
};
};
}

5
Objects/public/primitives/TypeObject.hpp
View file

@ -3,11 +3,10 @@
#include "core/Object.hpp"
namespace obj {
namespace tp::obj {
struct TypeObject : Object {
static ObjectType TypeData;
const ObjectType* mTypeRef;
static TypeObject* create(const ObjectType* type);
};
};
}