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

[DEV] continue rework ==> take big mistake, use basic pointer to all after object other data (typically C style coding)

Browse Source
This commit is contained in:
Edouard DUPIN 2018-07-06 00:08:43 +02:00
parent af0dae2fa5
commit a8ed39d3b4
15 changed files with 44 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
rabbit-std/sqstdblob.cpp
View File

@ -138,10 +138,9 @@ static int64_t _blob_constructor(rabbit::VirtualMachine* v)
if(size < 0) return rabbit::sq_throwerror(v, "cannot create blob with negative size"); if(size < 0) return rabbit::sq_throwerror(v, "cannot create blob with negative size");
//rabbit::std::Blob *b = new rabbit::std::Blob(size); //rabbit::std::Blob *b = new rabbit::std::Blob(size);
rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size); rabbit::std::Blob *b = ETK_NEW(rabbit::std::Blob, size);
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
b->~Blob(); ETK_FREE(rabbit::std::Blob, b);
rabbit::sq_free(b,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, "cannot create blob"); return rabbit::sq_throwerror(v, "cannot create blob");
} }
rabbit::sq_setreleasehook(v,1,_blob_releasehook); rabbit::sq_setreleasehook(v,1,_blob_releasehook);
@ -156,11 +155,10 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
return SQ_ERROR; return SQ_ERROR;
} }
//rabbit::std::Blob *thisone = new rabbit::std::Blob(other->Len()); //rabbit::std::Blob *thisone = new rabbit::std::Blob(other->Len());
rabbit::std::Blob *thisone = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(other->Len()); rabbit::std::Blob *thisone = ETK_NEW(rabbit::std::Blob, other->Len());
memcpy(thisone->getBuf(),other->getBuf(),thisone->Len()); memcpy(thisone->getBuf(),other->getBuf(),thisone->Len());
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
thisone->~Blob(); ETK_FREE(rabbit::std::Blob, thisone);
rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, "cannot clone blob"); return rabbit::sq_throwerror(v, "cannot clone blob");
} }
rabbit::sq_setreleasehook(v,1,_blob_releasehook); rabbit::sq_setreleasehook(v,1,_blob_releasehook);

5
rabbit-std/sqstdio.cpp
View File

@ -147,10 +147,9 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v)
return rabbit::sq_throwerror(v,"wrong parameter"); return rabbit::sq_throwerror(v,"wrong parameter");
} }
f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns); f = ETK_NEW(rabbit::std::File, newf, owns);
if(SQ_FAILED(rabbit::sq_setinstanceup(v, 1, f))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v, 1, f))) {
f->~File(); ETK_DELETE(rabbit::std::File, f);
rabbit::sq_free(f,sizeof(rabbit::std::File));
return rabbit::sq_throwerror(v, "cannot create blob with negative size"); return rabbit::sq_throwerror(v, "cannot create blob with negative size");
} }
rabbit::sq_setreleasehook(v, 1, _file_releasehook); rabbit::sq_setreleasehook(v, 1, _file_releasehook);

3
rabbit/Class.cpp
View File

@ -50,8 +50,7 @@ rabbit::Class::~Class() {
} }
rabbit::Class* rabbit::Class::create(rabbit::SharedState *ss, Class *base) { rabbit::Class* rabbit::Class::create(rabbit::SharedState *ss, Class *base) {
rabbit::Class *newclass = (Class *)SQ_MALLOC(sizeof(Class)); rabbit::Class *newclass = ETK_NEW(Class, ss, base);
new ((char*)newclass) Class(ss, base);
return newclass; return newclass;
} }

3
rabbit/Closure.cpp
View File

@ -172,8 +172,7 @@ void rabbit::Closure::release(){
_DESTRUCT_VECTOR(ObjectPtr,f->_noutervalues,_outervalues); _DESTRUCT_VECTOR(ObjectPtr,f->_noutervalues,_outervalues);
_DESTRUCT_VECTOR(ObjectPtr,f->_ndefaultparams,_defaultparams); _DESTRUCT_VECTOR(ObjectPtr,f->_ndefaultparams,_defaultparams);
__Objrelease(_function); __Objrelease(_function);
this->~Closure(); ETK_FREE(Closure, this);
sq_vm_free(this,size);
} }
void rabbit::Closure::setRoot(rabbit::WeakRef *r) { void rabbit::Closure::setRoot(rabbit::WeakRef *r) {

6
rabbit/FuncState.cpp
View File

@ -658,10 +658,8 @@ rabbit::FunctionProto* rabbit::FuncState::buildProto() {
return f; return f;
} }
rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) {
{ FuncState *child = ETK_NEW(rabbit::FuncState, ss, this, _errfunc, _errtarget);
FuncState *child = (rabbit::FuncState *)sq_malloc(sizeof(rabbit::FuncState));
new ((char*)child) FuncState(ss,this,_errfunc,_errtarget);
_childstates.pushBack(child); _childstates.pushBack(child);
return child; return child;
} }

21
rabbit/FunctionProto.cpp
View File

@ -27,8 +27,7 @@ rabbit::FunctionProto* rabbit::FunctionProto::create(rabbit::SharedState *ss,int
{ {
rabbit::FunctionProto *f; rabbit::FunctionProto *f;
//I compact the whole class and members in a single memory allocation //I compact the whole class and members in a single memory allocation
f = (rabbit::FunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams)); f = ETK_NEW(rabbit::FunctionProto, ss);
new ((char*)f) rabbit::FunctionProto(ss);
f->_ninstructions = ninstructions; f->_ninstructions = ninstructions;
f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions]; f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
f->_nliterals = nliterals; f->_nliterals = nliterals;
@ -60,9 +59,8 @@ void rabbit::FunctionProto::release(){
_DESTRUCT_VECTOR(OuterVar,_noutervalues,_outervalues); _DESTRUCT_VECTOR(OuterVar,_noutervalues,_outervalues);
//_DESTRUCT_VECTOR(rabbit::LineInfo,_nlineinfos,_lineinfos); //not required are 2 integers //_DESTRUCT_VECTOR(rabbit::LineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
_DESTRUCT_VECTOR(LocalVarInfo,_nlocalvarinfos,_localvarinfos); _DESTRUCT_VECTOR(LocalVarInfo,_nlocalvarinfos,_localvarinfos);
int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams); //int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
this->~FunctionProto(); ETK_FREE(FunctionProto, this);
sq_vm_free(this,size);
} }
const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop)
@ -93,22 +91,19 @@ int64_t rabbit::FunctionProto::getLine(rabbit::Instruction *curr)
int64_t low = 0; int64_t low = 0;
int64_t high = _nlineinfos - 1; int64_t high = _nlineinfos - 1;
int64_t mid = 0; int64_t mid = 0;
while(low <= high) while(low <= high) {
{
mid = low + ((high - low) >> 1); mid = low + ((high - low) >> 1);
int64_t curop = _lineinfos[mid]._op; int64_t curop = _lineinfos[mid]._op;
if(curop > op) if(curop > op) {
{
high = mid - 1; high = mid - 1;
} } else if(curop < op) {
else if(curop < op) {
if(mid < (_nlineinfos - 1) if(mid < (_nlineinfos - 1)
&& _lineinfos[mid + 1]._op >= op) { && _lineinfos[mid + 1]._op >= op) {
break; break;
} }
low = mid + 1; low = mid + 1;
} } else {
else { //equal //equal
break; break;
} }
} }

3
rabbit/Generator.cpp
View File

@ -107,8 +107,7 @@ rabbit::Generator::Generator(rabbit::SharedState *ss,rabbit::Closure *closure) {
} }
rabbit::Generator *rabbit::Generator::create(rabbit::SharedState *ss,rabbit::Closure *closure) { rabbit::Generator *rabbit::Generator::create(rabbit::SharedState *ss,rabbit::Closure *closure) {
rabbit::Generator *nc=(rabbit::Generator*)SQ_MALLOC(sizeof(rabbit::Generator)); rabbit::Generator *nc = ETK_NEW(rabbit::Generator, ss, closure);
new ((char*)nc) rabbit::Generator(ss,closure);
return nc; return nc;
} }

13
rabbit/Instance.cpp
View File

@ -32,7 +32,7 @@ rabbit::Instance::Instance(rabbit::SharedState *ss, rabbit::Class *c, int64_t me
_class = c; _class = c;
uint64_t nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) { for(uint64_t n = 0; n < nvalues; n++) {
new ((char*)&_values[n]) rabbit::ObjectPtr(_class->_defaultvalues[n].val); &_values[n] = ETK_NEW(rabbit::ObjectPtr, _class->_defaultvalues[n].val);
} }
init(ss); init(ss);
} }
@ -42,7 +42,7 @@ rabbit::Instance::Instance(rabbit::SharedState *ss, rabbit::Instance *i, int64_t
_class = i->_class; _class = i->_class;
uint64_t nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) { for(uint64_t n = 0; n < nvalues; n++) {
new ((char*)&_values[n]) rabbit::ObjectPtr(i->_values[n]); &_values[n] = ETK_NEW(rabbit::ObjectPtr, i->_values[n]);
} }
init(ss); init(ss);
} }
@ -80,8 +80,7 @@ bool rabbit::Instance::instanceOf(rabbit::Class *trg) {
rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class *theclass) { rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class *theclass) {
int64_t size = calcinstancesize(theclass); int64_t size = calcinstancesize(theclass);
Instance *newinst = (Instance *)SQ_MALLOC(size); Instance *newinst = ETK_NEW(Instance, ss, theclass,size);
new ((char*)newinst) Instance(ss, theclass,size);
if(theclass->_udsize) { if(theclass->_udsize) {
newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize); newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize);
} }
@ -90,8 +89,7 @@ rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class
rabbit::Instance* rabbit::Instance::clone(rabbit::SharedState *ss) { rabbit::Instance* rabbit::Instance::clone(rabbit::SharedState *ss) {
int64_t size = calcinstancesize(_class); int64_t size = calcinstancesize(_class);
Instance *newinst = (Instance *)SQ_MALLOC(size); Instance *newinst = ETK_NEW(Instance, ss, this, size);
new ((char*)newinst) Instance(ss, this,size);
if(_class->_udsize) { if(_class->_udsize) {
newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize); newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize);
} }
@ -130,7 +128,6 @@ void rabbit::Instance::release() {
return; return;
} }
int64_t size = _memsize; int64_t size = _memsize;
this->~Instance(); ETK_FREE(Instance, this);
SQ_FREE(this, size);
} }

3
rabbit/NativeClosure.cpp
View File

@ -42,6 +42,5 @@ rabbit::NativeClosure::~NativeClosure() {
void rabbit::NativeClosure::release(){ void rabbit::NativeClosure::release(){
int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
_DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues); _DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues);
this->~NativeClosure(); ETK_FREE(NativeClosure, this);
sq_free(this,size);
} }

6
rabbit/Outer.cpp
View File

@ -16,8 +16,7 @@ rabbit::Outer::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){
} }
rabbit::Outer* rabbit::Outer::create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) { rabbit::Outer* rabbit::Outer::create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) {
rabbit::Outer *nc = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer)); rabbit::Outer *nc = ETK_NEW(rabbit::Outer, ss, outer);
new ((char*)nc) rabbit::Outer(ss, outer);
return nc; return nc;
} }
@ -26,6 +25,5 @@ rabbit::Outer::~Outer() {
} }
void rabbit::Outer::release() { void rabbit::Outer::release() {
this->~Outer(); ETK_FREE(rabbit::Outer, this);
sq_vm_free(this,sizeof(rabbit::Outer));
} }

4
rabbit/RefTable.cpp
View File

@ -146,13 +146,13 @@ void rabbit::RefTable::allocNodes(uint64_t size)
for(n = 0; n < size - 1; n++) { for(n = 0; n < size - 1; n++) {
bucks[n] = NULL; bucks[n] = NULL;
temp->refs = 0; temp->refs = 0;
new ((char*)&temp->obj) ObjectPtr; &temp->obj = ETK_NEW(ObjectPtr);
temp->next = temp+1; temp->next = temp+1;
temp++; temp++;
} }
bucks[n] = NULL; bucks[n] = NULL;
temp->refs = 0; temp->refs = 0;
new ((char*)&temp->obj) ObjectPtr; &temp->obj = ETK_NEW(ObjectPtr);
temp->next = NULL; temp->next = NULL;
_freelist = nodes; _freelist = nodes;
_nodes = nodes; _nodes = nodes;

7
rabbit/StringTable.cpp
View File

@ -46,8 +46,7 @@ rabbit::String *rabbit::StringTable::add(const char *news,int64_t len)
return s; //found return s; //found
} }
rabbit::String *t = (rabbit::String *)SQ_MALLOC(sq_rsl(len)+sizeof(rabbit::String)); rabbit::String *t = ETK_NEW(rabbit::String);
new ((char*)t) rabbit::String;
t->_sharedstate = _sharedstate; t->_sharedstate = _sharedstate;
memcpy(t->_val,news,sq_rsl(len)); memcpy(t->_val,news,sq_rsl(len));
t->_val[len] = '\0'; t->_val[len] = '\0';
@ -92,9 +91,7 @@ void rabbit::StringTable::remove(rabbit::String *bs)
else else
_strings[h] = s->_next; _strings[h] = s->_next;
_slotused--; _slotused--;
int64_t slen = s->_len; ETK_FREE(String, s);
s->~String();
SQ_FREE(s,sizeof(rabbit::String) + sq_rsl(slen));
return; return;
} }
prev = s; prev = s;

7
rabbit/UserData.cpp
View File

@ -17,8 +17,7 @@ rabbit::UserData::~UserData() {
} }
rabbit::UserData* rabbit::UserData::create(rabbit::SharedState *ss, int64_t size) { rabbit::UserData* rabbit::UserData::create(rabbit::SharedState *ss, int64_t size) {
UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size); UserData* ud = ETK_NEW(UserData, ss);
new ((char*)ud) UserData(ss);
ud->m_size = size; ud->m_size = size;
ud->m_typetag = 0; ud->m_typetag = 0;
return ud; return ud;
@ -28,9 +27,7 @@ void rabbit::UserData::release() {
if (m_hook) { if (m_hook) {
m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size); m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size);
} }
int64_t tsize = m_size; ETK_FREE(UserData, this);
this->~UserData();
SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize);
} }
const int64_t& rabbit::UserData::getsize() const { const int64_t& rabbit::UserData::getsize() const {

14
rabbit/sqapi.cpp
View File

@ -61,16 +61,13 @@ rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize)
{ {
rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState); rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState);
ss->init(); ss->init();
rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
ss->_root_vm = v; ss->_root_vm = v;
if(v->init(NULL, initialstacksize)) { if(v->init(NULL, initialstacksize)) {
return v; return v;
} else { } else {
v->~VirtualMachine(); ETK_FREE(rabbit::VirtualMachine, v);
SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
return NULL; return NULL;
} }
return v; return v;
@ -80,17 +77,14 @@ rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm, i
{ {
rabbit::SharedState *ss; rabbit::SharedState *ss;
ss=_get_shared_state(friendvm); ss=_get_shared_state(friendvm);
rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
ss->_root_vm = v; ss->_root_vm = v;
if(v->init(friendvm, initialstacksize)) { if(v->init(friendvm, initialstacksize)) {
friendvm->push(v); friendvm->push(v);
return v; return v;
} else { } else {
v->~VirtualMachine(); ETK_FREE(rabbit::VirtualMachine, v);
SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
return NULL; return NULL;
} }
} }