HeeroYui-deprecated/rabbit
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] start rework bad allocator ==> not work

Browse Source
This commit is contained in:
Edouard DUPIN 2018-07-05 23:37:47 +02:00
parent e62f3074cb
commit af0dae2fa5
18 changed files with 66 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
rabbit/Array.cpp
View File

@ -30,8 +30,7 @@ rabbit::Array::~Array() {
// TODO : remove this ETK_ALLOC can do it natively ...
rabbit::Array* rabbit::Array::create(rabbit::SharedState* _ss,
int64_t _ninitialsize) {
Array *newarray=(Array*)SQ_MALLOC(sizeof(Array));
new ((char*)newarray) Array(_ss, _ninitialsize);
Array *newarray = ETK_NEW(Array, _ss, _ninitialsize);
return newarray;
}
void rabbit::Array::finalize() {
@ -126,7 +125,7 @@ bool rabbit::Array::remove(int64_t _idx) {
return true;
}
void rabbit::Array::release() {
sq_delete(this, Array);
ETK_DELETE(Array, this);
}
rabbit::ObjectPtr& rabbit::Array::operator[] (const size_t _pos) {
return m_data[_pos];

2
rabbit/Class.cpp
View File

@ -87,7 +87,7 @@ void rabbit::Class::release() {
if (_hook) {
_hook(_typetag,0);
}
sq_delete(this, Class);
ETK_DELETE(Class, this);
}
bool rabbit::Class::newSlot(rabbit::SharedState *ss,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic) {

3
rabbit/Closure.cpp
View File

@ -156,8 +156,7 @@ rabbit::Closure::Closure(rabbit::SharedState *ss,rabbit::FunctionProto *func){
}
rabbit::Closure *rabbit::Closure::create(rabbit::SharedState *ss,rabbit::FunctionProto *func,rabbit::WeakRef *root){
int64_t size = _CALC_CLOSURE_SIZE(func);
rabbit::Closure *nc=(rabbit::Closure*)SQ_MALLOC(size);
new ((char*)nc) rabbit::Closure(ss,func);
rabbit::Closure *nc = ETK_NEW(rabbit::Closure, ss, func);
nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_defaultparams = &nc->_outervalues[func->_noutervalues];
nc->_root = root;

2
rabbit/FuncState.cpp
View File

@ -668,7 +668,7 @@ rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss)
void rabbit::FuncState::popChildState() {
FuncState *child = _childstates.back();
sq_delete(child, FuncState);
ETK_DELETE(FuncState, child);
_childstates.popBack();
}

2
rabbit/Generator.cpp
View File

@ -123,6 +123,6 @@ void rabbit::Generator::kill() {
}
void rabbit::Generator::release() {
sq_delete(this,Generator);
ETK_DELETE(Generator, this);
}

3
rabbit/NativeClosure.cpp
View File

@ -17,8 +17,7 @@ rabbit::NativeClosure::NativeClosure(rabbit::SharedState *ss,SQFUNCTION func) {
rabbit::NativeClosure* rabbit::NativeClosure::create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters) {
int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters);
rabbit::NativeClosure *nc=(rabbit::NativeClosure*)SQ_MALLOC(size);
new ((char*)nc) rabbit::NativeClosure(ss,func);
rabbit::NativeClosure *nc = ETK_NEW(rabbit::NativeClosure, ss, func);
nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_noutervalues = nouters;
_CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);

1
rabbit/NativeClosure.hpp
View File

@ -28,7 +28,6 @@ namespace rabbit {
rabbit::NativeClosure *clone();
~NativeClosure();
void release();
int64_t _nparamscheck;
etk::Vector<int64_t> _typecheck;
rabbit::ObjectPtr *_outervalues;

11
rabbit/Object.hpp
View File

@ -12,7 +12,6 @@
#include <rabbit/ObjectValue.hpp>
namespace rabbit {
class Object {
public:
rabbit::ObjectType _type;
@ -228,14 +227,4 @@ namespace rabbit {
void releaseRef();
void swap(rabbit::Object& _obj);
};
inline void _Swap(rabbit::Object &a,rabbit::Object &b)
{
rabbit::ObjectType tOldType = a._type;
rabbit::ObjectValue unOldVal = a._unVal;
a._type = b._type;
a._unVal = b._unVal;
b._type = tOldType;
b._unVal = unOldVal;
}
}

36
rabbit/ObjectPtr.hpp
View File

@ -14,11 +14,11 @@
#include <rabbit/Object.hpp>
namespace rabbit {
#define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class,sym) \
#define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class) \
ObjectPtr(_class * x); \
ObjectPtr& operator=(_class *x);
#define RABBIT_SCALAR_TYPE_DECLARE(type,_class,sym) \
#define RABBIT_SCALAR_TYPE_DECLARE(type,_class) \
ObjectPtr(_class x); \
ObjectPtr& operator=(_class x);
@ -28,23 +28,23 @@ namespace rabbit {
ObjectPtr(const ObjectPtr& _obj);
ObjectPtr(const Object& _obj);
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table, pTable)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class, pClass)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance, pInstance)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array, pArray)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure, pClosure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure, pNativeClosure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer, pOuter)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator, pGenerator)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String, pString)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData, pUserData)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef, pWeakRef)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine, pThread)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, rabbit::FunctionProto, pFunctionProto)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, rabbit::FunctionProto)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_INTEGER, int64_t, nInteger)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t, fFloat)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer, pUserPointer)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_INTEGER, int64_t)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer)
ObjectPtr(bool _value);
ObjectPtr& operator=(bool _value);

5
rabbit/RefCounted.cpp
View File

@ -7,6 +7,9 @@
*/
#include <rabbit/RefCounted.hpp>
#include <etk/Allocator.hpp>
#include <rabbit/WeakRef.hpp>
#include <rabbit/rabbit.hpp>
#include <rabbit/squtils.hpp>
@ -14,7 +17,7 @@
rabbit::WeakRef * rabbit::RefCounted::getWeakRef(rabbit::ObjectType type) {
if(!_weakref) {
sq_new(_weakref, WeakRef);
_weakref = ETK_NEW(WeakRef);
_weakref->_obj._unVal.raw = 0; //clean the whole union
_weakref->_obj._type = type;
_weakref->_obj._unVal.pRefCounted = this;

25
rabbit/SharedState.cpp
View File

@ -6,6 +6,9 @@
* @license MPL-2 (see license file)
*/
#include <rabbit/SharedState.hpp>
#include <etk/Allocator.hpp>
#include <rabbit/Table.hpp>
#include <rabbit/String.hpp>
#include <rabbit/StringTable.hpp>
@ -97,11 +100,10 @@ void rabbit::SharedState::init()
{
_scratchpad=NULL;
_scratchpadsize=0;
_stringtable = (rabbit::StringTable*)SQ_MALLOC(sizeof(rabbit::StringTable));
new ((char*)_stringtable) rabbit::StringTable(this);
sq_new(_metamethods,etk::Vector<rabbit::ObjectPtr>);
sq_new(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
sq_new(_types,etk::Vector<rabbit::ObjectPtr>);
_stringtable = ETK_NEW(rabbit::StringTable, this);
_metamethods = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
_systemstrings = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
_types = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
_metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1);
//adding type strings to avoid memory trashing
//types names
@ -185,12 +187,13 @@ rabbit::SharedState::~SharedState()
_instance_default_delegate.Null();
_weakref_default_delegate.Null();
_refs_table.finalize();
using tmpType = etk::Vector<rabbit::ObjectPtr>;
sq_delete(_types, tmpType);
sq_delete(_systemstrings, tmpType);
sq_delete(_metamethods, tmpType);
sq_delete(_stringtable, StringTable);
if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize);
ETK_DELETE(etk::Vector<rabbit::ObjectPtr>, _types);
ETK_DELETE(etk::Vector<rabbit::ObjectPtr>, _systemstrings);
ETK_DELETE(etk::Vector<rabbit::ObjectPtr>, _metamethods);
ETK_DELETE(rabbit::StringTable, _stringtable);
if(_scratchpad) {
SQ_FREE(_scratchpad,_scratchpadsize);
}
}

2
rabbit/Table.cpp
View File

@ -293,5 +293,5 @@ int64_t rabbit::Table::countUsed() const {
}
void rabbit::Table::release() {
sq_delete(this, Table);
ETK_DELETE(Table, this);
}

24
rabbit/VirtualMachine.cpp
View File

@ -68,7 +68,7 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabb
}
void rabbit::VirtualMachine::release() {
sq_delete(this,VirtualMachine);
ETK_DELETE(VirtualMachine, this);
}
#define _ARITH_(op,trg,o1,o2) \
@ -225,7 +225,7 @@ bool rabbit::VirtualMachine::NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectP
if(callMetaMethod(closure, MT_UNM, 1, temp_reg) == false) {
return false;
}
_Swap(trg,temp_reg);
trg.swap(temp_reg);
return true;
}
}
@ -868,17 +868,21 @@ exception_restore:
SQ_THROW();
}
STK(arg3) = o;
_Swap(TARGET,temp_reg);//TARGET = temp_reg;
TARGET.swap(temp_reg);
}
continue;
case _OP_GETK:
if (!get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) { SQ_THROW();}
_Swap(TARGET,temp_reg);//TARGET = temp_reg;
if (!get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) {
SQ_THROW();
}
TARGET.swap(temp_reg);
continue;
case _OP_MOVE: TARGET = STK(arg1); continue;
case _OP_NEWSLOT:
_GUARD(newSlot(STK(arg1), STK(arg2), STK(arg3),false));
if(arg0 != 0xFF) TARGET = STK(arg3);
if(arg0 != 0xFF) {
TARGET = STK(arg3);
}
continue;
case _OP_DELETE: _GUARD(deleteSlot(STK(arg1), STK(arg2), TARGET)); continue;
case _OP_SET:
@ -887,7 +891,7 @@ exception_restore:
continue;
case _OP_GET:
if (!get(STK(arg1), STK(arg2), temp_reg, 0,arg1)) { SQ_THROW(); }
_Swap(TARGET,temp_reg);//TARGET = temp_reg;
TARGET.swap(temp_reg);
continue;
case _OP_EQ:{
bool res;
@ -912,7 +916,7 @@ exception_restore:
if(Return(arg0, arg1, temp_reg)){
assert(traps==0);
//outres = temp_reg;
_Swap(outres,temp_reg);
outres.swap(temp_reg);
return true;
}
continue;
@ -1053,7 +1057,9 @@ exception_restore:
if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1);
_GUARD(ci->_generator->yield(this,arg2));
traps -= ci->_etraps;
if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg;
if(sarg1 != MAX_FUNC_STACKSIZE) {
STK(arg1).swap(temp_reg);
}
}
else { raise_error("trying to yield a '%s',only genenerator can be yielded", getTypeName(ci->_generator)); SQ_THROW();}
if(Return(arg0, arg1, temp_reg)){

2
rabbit/WeakRef.cpp
View File

@ -15,5 +15,5 @@ void rabbit::WeakRef::release() {
if(_obj.isRefCounted() == true) {
_obj._unVal.pRefCounted->_weakref = null;
}
sq_delete(this, WeakRef);
ETK_DELETE(WeakRef, this);
}

6
rabbit/sqapi.cpp
View File

@ -9,6 +9,7 @@
#include <rabbit/VirtualMachine.hpp>
#include <etk/Allocator.hpp>
#include <rabbit/Array.hpp>
@ -58,8 +59,7 @@ namespace rabbit {
}
rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize)
{
rabbit::SharedState *ss;
sq_new(ss, rabbit::SharedState);
rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState);
ss->init();
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
@ -140,7 +140,7 @@ void rabbit::sq_close(rabbit::VirtualMachine* v)
{
rabbit::SharedState *ss = _get_shared_state(v);
ss->_root_vm.toVirtualMachine()->finalize();
sq_delete(ss, SharedState);
ETK_DELETE(SharedState, ss);
}
int64_t rabbit::sq_getversion()

4
rabbit/sqbaselib.cpp
View File

@ -758,7 +758,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64
return false; // We'd be swapping ourselve. The compare function is incorrect
}
_Swap((*arr)[root], (*arr)[maxChild]);
(*arr)[root].swap((*arr)[maxChild]);
root = maxChild;
}
else {
@ -779,7 +779,7 @@ static bool _hsort(rabbit::VirtualMachine* v,rabbit::ObjectPtr &arr, int64_t SQ_
for (i = array_size-1; i >= 1; i--)
{
_Swap((*a)[0],(*a)[i]);
(*a)[0].swap((*a)[i]);
if(!_hsort_sift_down(v,a, 0, i-1,func)) return false;
}
return true;

1
rabbit/sqconfig.hpp
View File

@ -8,6 +8,7 @@
#pragma once
#include <etk/types.hpp>
#include <etk/Allocator.hpp>
#include <ctype.h>
#ifdef SQUSEDOUBLE
typedef double float_t;

3
rabbit/squtils.hpp
View File

@ -12,9 +12,6 @@ void *sq_vm_malloc(uint64_t size);
void *sq_vm_realloc(void *p,uint64_t oldsize,uint64_t size);
void sq_vm_free(void *p,uint64_t size);
#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new ((char*)__ptr) __type;}
#define sq_delete(__ptr,__type) {((__type*)__ptr)->~__type();sq_vm_free(__ptr,sizeof(__type));}
#define SQ_MALLOC(__size) sq_vm_malloc((__size));
#define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
#define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));