Deukhoofd/PorygonLang
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Added namespaces to most classes, general cleanup
Some checks failed
continuous-integration/drone/push Build is failing
Details

Browse Source
This commit is contained in:
Deukhoofd
2019-06-17 18:35:12 +02:00
parent 21d3329c55
commit fde102d954
66 changed files with 4301 additions and 3909 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/UserData/UserData.cpp
View File

@@ -2,19 +2,21 @@
#include "UserData.hpp"
#include "UserDataStorage.hpp"
extern "C"{
void RegisterUserDataType(uint32_t id){
namespace Porygon::UserData {
extern "C" {
void RegisterUserDataType(uint32_t id) {
auto ud = new UserData({});
UserDataStorage::RegisterType(id, ud);
}
void RegisterUserDataField(uint32_t typeId, uint32_t fieldId, UserDataField* field){
void RegisterUserDataField(uint32_t typeId, uint32_t fieldId, UserDataField *field) {
auto ud = UserDataStorage::GetUserDataType(typeId);
ud -> CreateField(fieldId, field);
ud->CreateField(fieldId, field);
}
int32_t GetUserDataFieldCount(uint32_t typeId){
int32_t GetUserDataFieldCount(uint32_t typeId) {
auto ud = UserDataStorage::GetUserDataType(typeId);
return ud ->GetFieldCount();
return ud->GetFieldCount();
}
}
}

40
src/UserData/UserData.hpp
View File

@@ -5,29 +5,31 @@
#include <unordered_map>
#include "UserDataField.hpp"
class UserData {
std::unordered_map<uint32_t, UserDataField*> _fields;
public:
explicit UserData(std::unordered_map<uint32_t, UserDataField*> fields){
_fields = std::move(fields);
}
namespace Porygon::UserData {
class UserData {
std::unordered_map<uint32_t, UserDataField *> _fields;
public:
explicit UserData(std::unordered_map<uint32_t, UserDataField *> fields) {
_fields = std::move(fields);
}
bool ContainsField(uint32_t fieldId){
return _fields.find(fieldId) != _fields.end();
}
bool ContainsField(uint32_t fieldId) {
return _fields.find(fieldId) != _fields.end();
}
UserDataField* GetField(uint32_t fieldId){
return _fields[fieldId];
}
UserDataField *GetField(uint32_t fieldId) {
return _fields[fieldId];
}
void CreateField(uint32_t fieldId, UserDataField* field){
_fields.insert({fieldId, field});
}
void CreateField(uint32_t fieldId, UserDataField *field) {
_fields.insert({fieldId, field});
}
int32_t GetFieldCount(){
return _fields.size();
}
};
int32_t GetFieldCount() {
return _fields.size();
}
};
}
#endif //PORYGONLANG_USERDATA_HPP

7
src/UserData/UserDataField.cpp
View File

@@ -1,8 +1,11 @@
#include "UserDataField.hpp"
extern "C"{
UserDataField* CreateUserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){
namespace Porygon::UserData {
extern "C" {
UserDataField *
CreateUserDataField(ScriptType *type, Evaluation::EvalValue *(*getter)(void *obj), void (*setter)(void *obj, Evaluation::EvalValue *val)) {
return new UserDataField(type, getter, setter);
}
}
}

54
src/UserData/UserDataField.hpp
View File

@@ -6,37 +6,39 @@
#include "../Evaluator/EvalValues/EvalValue.hpp"
#include "../Evaluator/EvalValues/NumericEvalValue.hpp"
class UserDataField {
shared_ptr<ScriptType> _type;
EvalValue* (*_get)(void* obj);
void (*_set)(void* obj, EvalValue* val);
public:
UserDataField(ScriptType* type, EvalValue* (*getter)(void* obj), void (*setter)(void* obj, EvalValue* val)){
_type = shared_ptr<ScriptType>(type);
_get = getter;
_set = setter;
}
namespace Porygon::UserData{
class UserDataField {
shared_ptr<ScriptType> _type;
Evaluation::EvalValue* (*_get)(void* obj);
void (*_set)(void* obj, Evaluation::EvalValue* val);
public:
UserDataField(ScriptType* type, Evaluation::EvalValue* (*getter)(void* obj), void (*setter)(void* obj, Evaluation::EvalValue* val)){
_type = shared_ptr<ScriptType>(type);
_get = getter;
_set = setter;
}
shared_ptr<ScriptType> GetType(){
return _type;
}
shared_ptr<ScriptType> GetType(){
return _type;
}
bool HasGetter(){
return _get != nullptr;
}
bool HasGetter(){
return _get != nullptr;
}
EvalValue* Get(void* obj){
return this ->_get(obj);
}
Evaluation::EvalValue* Get(void* obj){
return this ->_get(obj);
}
bool HasSetter(){
return _set != nullptr;
}
bool HasSetter(){
return _set != nullptr;
}
void Set(void* obj, EvalValue* val){
this->_set(obj, val);
}
};
void Set(void* obj, Evaluation::EvalValue* val){
this->_set(obj, val);
}
};
}
#endif //PORYGONLANG_USERDATAFIELD_HPP

75
src/UserData/UserDataScriptType.hpp
View File

@@ -8,46 +8,49 @@
#include "UserData.hpp"
#include "UserDataStorage.hpp"
class UserDataScriptType : public ScriptType{
shared_ptr<UserData> _userData;
public:
explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData){
_userData = UserDataStorage::GetUserDataType(id);
}
explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData){
_userData = std::move(ud);
}
const bool CanBeIndexedWith(ScriptType* indexer) const final{
if (indexer->GetClass() != TypeClass ::String){
return false;
namespace Porygon::UserData {
class UserDataScriptType : public ScriptType {
shared_ptr<UserData> _userData;
public:
explicit UserDataScriptType(uint32_t id) : ScriptType(TypeClass::UserData) {
_userData = UserDataStorage::GetUserDataType(id);
}
auto str = (StringScriptType*)indexer;
if (!str->IsKnownAtBind())
return false;
return _userData->ContainsField(str->GetHashValue());
}
const bool CanBeIndexedWithIdentifier(uint32_t hash) const final{
return true;
}
UserDataField* GetField(uint32_t id){
return _userData -> GetField(id);
}
const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
auto stringKey = (StringScriptType*)indexer;
if (stringKey->IsKnownAtBind()){
return _userData->GetField(stringKey->GetHashValue())->GetType();
explicit UserDataScriptType(shared_ptr<UserData> ud) : ScriptType(TypeClass::UserData) {
_userData = std::move(ud);
}
throw "TODO: indexing with dynamic keys";
}
const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const final{
return _userData->GetField(hash)->GetType();
}
};
const bool CanBeIndexedWith(ScriptType *indexer) const final {
if (indexer->GetClass() != TypeClass::String) {
return false;
}
auto str = (StringScriptType *) indexer;
if (!str->IsKnownAtBind())
return false;
return _userData->ContainsField(str->GetHashValue());
}
const bool CanBeIndexedWithIdentifier(uint32_t hash) const final {
return true;
}
UserDataField *GetField(uint32_t id) {
return _userData->GetField(id);
}
const shared_ptr<ScriptType> GetIndexedType(ScriptType *indexer) const final {
auto stringKey = (StringScriptType *) indexer;
if (stringKey->IsKnownAtBind()) {
return _userData->GetField(stringKey->GetHashValue())->GetType();
}
throw "TODO: indexing with dynamic keys";
}
const shared_ptr<ScriptType> GetIndexedType(uint32_t hash) const final {
return _userData->GetField(hash)->GetType();
}
};
}
#endif //PORYGONLANG_USERDATASCRIPTTYPE_HPP

4
src/UserData/UserDataStorage.cpp
View File

@@ -1,4 +1,6 @@
#include "UserDataStorage.hpp"
UserDataStorage::_internalDataStorage UserDataStorage::_internal = UserDataStorage::_internalDataStorage();
namespace Porygon::UserData {
UserDataStorage::_internalDataStorage UserDataStorage::_internal = UserDataStorage::_internalDataStorage();
}

40
src/UserData/UserDataStorage.hpp
View File

@@ -5,26 +5,28 @@
#include <unordered_map>
#include "UserData.hpp"
class UserDataStorage {
class _internalDataStorage{
namespace Porygon::UserData {
class UserDataStorage {
class _internalDataStorage {
public:
std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
};
static _internalDataStorage _internal;
public:
std::unordered_map<uint32_t, shared_ptr<UserData>> _userData;
static void RegisterType(uint32_t i, UserData *ud) {
UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
}
static bool HasUserDataType(uint32_t i) {
return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
}
static shared_ptr<UserData> GetUserDataType(uint32_t i) {
return UserDataStorage::_internal._userData[i];
}
};
static _internalDataStorage _internal;
public:
static void RegisterType(uint32_t i, UserData* ud){
UserDataStorage::_internal._userData.insert({i, shared_ptr<UserData>(ud)});
}
static bool HasUserDataType(uint32_t i){
return UserDataStorage::_internal._userData.find(i) != UserDataStorage::_internal._userData.end();
}
static shared_ptr<UserData> GetUserDataType(uint32_t i){
return UserDataStorage::_internal._userData[i];
}
};
}
#endif //PORYGONLANG_USERDATASTORAGE_HPP

6
src/UserData/UserDataValue.cpp
View File

@@ -1,8 +1,10 @@
#include "UserDataValue.hpp"
extern "C"{
UserDataValue* CreateUserDataEvalValue(uint32_t typeHash, void* obj){
namespace Porygon::UserData {
extern "C" {
UserDataValue *CreateUserDataEvalValue(uint32_t typeHash, void *obj) {
return new UserDataValue(typeHash, obj);
}
}
}

87
src/UserData/UserDataValue.hpp
View File

@@ -7,57 +7,56 @@
#include "UserData.hpp"
#include "UserDataStorage.hpp"
class UserDataValue : public EvalValue{
const shared_ptr<UserData> _userData;
void* _obj;
public:
UserDataValue(shared_ptr<UserData> userData, void* obj)
: _userData(std::move(userData))
{
_obj = obj;
}
namespace Porygon::UserData {
class UserDataValue : public Evaluation::EvalValue {
const shared_ptr<UserData> _userData;
void *_obj;
public:
UserDataValue(shared_ptr<UserData> userData, void *obj)
: _userData(std::move(userData)) {
_obj = obj;
}
UserDataValue(uint32_t userDataId, void* obj)
: _userData(UserDataStorage::GetUserDataType(userDataId))
{
_obj = obj;
}
UserDataValue(uint32_t userDataId, void *obj)
: _userData(UserDataStorage::GetUserDataType(userDataId)) {
_obj = obj;
}
const TypeClass GetTypeClass() const final{
return TypeClass ::UserData;
}
const TypeClass GetTypeClass() const final {
return TypeClass::UserData;
}
const bool operator ==(EvalValue* b) const final {
if (b->GetTypeClass() != TypeClass::UserData)
return false;
return _obj == ((UserDataValue*)b)->_obj;
}
const bool operator==(EvalValue *b) const final {
if (b->GetTypeClass() != TypeClass::UserData)
return false;
return _obj == ((UserDataValue *) b)->_obj;
}
const shared_ptr<EvalValue> Clone() const final{
return make_shared<UserDataValue>(_userData, _obj);
}
const shared_ptr<EvalValue> Clone() const final {
return make_shared<UserDataValue>(_userData, _obj);
}
const std::size_t GetHashCode() const final{
return reinterpret_cast<intptr_t>(_obj);
}
const std::size_t GetHashCode() const final {
return reinterpret_cast<intptr_t>(_obj);
}
const shared_ptr<EvalValue> IndexValue(EvalValue* val) const final {
auto fieldId = val->GetHashCode();
auto field = _userData->GetField(fieldId);
return shared_ptr<EvalValue>(field->Get(_obj));
}
const shared_ptr<EvalValue> IndexValue(EvalValue *val) const final {
auto fieldId = val->GetHashCode();
auto field = _userData->GetField(fieldId);
return shared_ptr<EvalValue>(field->Get(_obj));
}
const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final{
auto field = _userData->GetField(hash);
return shared_ptr<EvalValue>(field->Get(_obj));
}
void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue>& value) const final{
auto fieldId = key->GetHashCode();
auto field = _userData->GetField(fieldId);
field -> Set(_obj, value.get());
}
};
const shared_ptr<EvalValue> IndexValue(uint32_t hash) const final {
auto field = _userData->GetField(hash);
return shared_ptr<EvalValue>(field->Get(_obj));
}
void SetIndexValue(EvalValue *key, const shared_ptr<EvalValue> &value) const final {
auto fieldId = key->GetHashCode();
auto field = _userData->GetField(fieldId);
field->Set(_obj, value.get());
}
};
}
#endif //PORYGONLANG_USERDATAVALUE_HPP