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");
//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))) {
b->~Blob();
rabbit::sq_free(b,sizeof(rabbit::std::Blob));
ETK_FREE(rabbit::std::Blob, b);
return rabbit::sq_throwerror(v, "cannot create blob");
}
rabbit::sq_setreleasehook(v,1,_blob_releasehook);
@ -156,11 +155,10 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
return SQ_ERROR;
}
//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());
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
thisone->~Blob();
rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
ETK_FREE(rabbit::std::Blob, thisone);
return rabbit::sq_throwerror(v, "cannot clone blob");
}
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");
}
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))) {
f->~File();
rabbit::sq_free(f,sizeof(rabbit::std::File));
ETK_DELETE(rabbit::std::File, f);
return rabbit::sq_throwerror(v, "cannot create blob with negative size");
}
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 *newclass = (Class *)SQ_MALLOC(sizeof(Class));
new ((char*)newclass) Class(ss, base);
rabbit::Class *newclass = ETK_NEW(Class, ss, base);
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->_ndefaultparams,_defaultparams);
__Objrelease(_function);
this->~Closure();
sq_vm_free(this,size);
ETK_FREE(Closure, this);
}
void rabbit::Closure::setRoot(rabbit::WeakRef *r) {

6
rabbit/FuncState.cpp
View File

@ -658,10 +658,8 @@ rabbit::FunctionProto* rabbit::FuncState::buildProto() {
return f;
}
rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss)
{
FuncState *child = (rabbit::FuncState *)sq_malloc(sizeof(rabbit::FuncState));
new ((char*)child) FuncState(ss,this,_errfunc,_errtarget);
rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) {
FuncState *child = ETK_NEW(rabbit::FuncState, ss, this, _errfunc, _errtarget);
_childstates.pushBack(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;
//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));
new ((char*)f) rabbit::FunctionProto(ss);
f = ETK_NEW(rabbit::FunctionProto, ss);
f->_ninstructions = ninstructions;
f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
f->_nliterals = nliterals;
@ -60,9 +59,8 @@ void rabbit::FunctionProto::release(){
_DESTRUCT_VECTOR(OuterVar,_noutervalues,_outervalues);
//_DESTRUCT_VECTOR(rabbit::LineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
_DESTRUCT_VECTOR(LocalVarInfo,_nlocalvarinfos,_localvarinfos);
int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
this->~FunctionProto();
sq_vm_free(this,size);
//int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
ETK_FREE(FunctionProto, this);
}
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 high = _nlineinfos - 1;
int64_t mid = 0;
while(low <= high)
{
while(low <= high) {
mid = low + ((high - low) >> 1);
int64_t curop = _lineinfos[mid]._op;
if(curop > op)
{
if(curop > op) {
high = mid - 1;
}
else if(curop < op) {
} else if(curop < op) {
if(mid < (_nlineinfos - 1)
&& _lineinfos[mid + 1]._op >= op) {
break;
}
low = mid + 1;
}
else { //equal
} else {
//equal
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 *nc=(rabbit::Generator*)SQ_MALLOC(sizeof(rabbit::Generator));
new ((char*)nc) rabbit::Generator(ss,closure);
rabbit::Generator *nc = ETK_NEW(rabbit::Generator, ss, closure);
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;
uint64_t nvalues = _class->_defaultvalues.size();
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);
}
@ -42,7 +42,7 @@ rabbit::Instance::Instance(rabbit::SharedState *ss, rabbit::Instance *i, int64_t
_class = i->_class;
uint64_t nvalues = _class->_defaultvalues.size();
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);
}
@ -80,8 +80,7 @@ bool rabbit::Instance::instanceOf(rabbit::Class *trg) {
rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class *theclass) {
int64_t size = calcinstancesize(theclass);
Instance *newinst = (Instance *)SQ_MALLOC(size);
new ((char*)newinst) Instance(ss, theclass,size);
Instance *newinst = ETK_NEW(Instance, ss, theclass,size);
if(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) {
int64_t size = calcinstancesize(_class);
Instance *newinst = (Instance *)SQ_MALLOC(size);
new ((char*)newinst) Instance(ss, this,size);
Instance *newinst = ETK_NEW(Instance, ss, this, size);
if(_class->_udsize) {
newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize);
}
@ -130,7 +128,6 @@ void rabbit::Instance::release() {
return;
}
int64_t size = _memsize;
this->~Instance();
SQ_FREE(this, size);
ETK_FREE(Instance, this);
}

3
rabbit/NativeClosure.cpp
View File

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

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 *nc = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer));
new ((char*)nc) rabbit::Outer(ss, outer);
rabbit::Outer *nc = ETK_NEW(rabbit::Outer, ss, outer);
return nc;
}
@ -26,6 +25,5 @@ rabbit::Outer::~Outer() {
}
void rabbit::Outer::release() {
this->~Outer();
sq_vm_free(this,sizeof(rabbit::Outer));
ETK_FREE(rabbit::Outer, this);
}

4
rabbit/RefTable.cpp
View File

@ -146,13 +146,13 @@ void rabbit::RefTable::allocNodes(uint64_t size)
for(n = 0; n < size - 1; n++) {
bucks[n] = NULL;
temp->refs = 0;
new ((char*)&temp->obj) ObjectPtr;
&temp->obj = ETK_NEW(ObjectPtr);
temp->next = temp+1;
temp++;
}
bucks[n] = NULL;
temp->refs = 0;
new ((char*)&temp->obj) ObjectPtr;
&temp->obj = ETK_NEW(ObjectPtr);
temp->next = NULL;
_freelist = 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
}
rabbit::String *t = (rabbit::String *)SQ_MALLOC(sq_rsl(len)+sizeof(rabbit::String));
new ((char*)t) rabbit::String;
rabbit::String *t = ETK_NEW(rabbit::String);
t->_sharedstate = _sharedstate;
memcpy(t->_val,news,sq_rsl(len));
t->_val[len] = '\0';
@ -92,9 +91,7 @@ void rabbit::StringTable::remove(rabbit::String *bs)
else
_strings[h] = s->_next;
_slotused--;
int64_t slen = s->_len;
s->~String();
SQ_FREE(s,sizeof(rabbit::String) + sq_rsl(slen));
ETK_FREE(String, s);
return;
}
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) {
UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size);
new ((char*)ud) UserData(ss);
UserData* ud = ETK_NEW(UserData, ss);
ud->m_size = size;
ud->m_typetag = 0;
return ud;
@ -28,9 +27,7 @@ void rabbit::UserData::release() {
if (m_hook) {
m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size);
}
int64_t tsize = m_size;
this->~UserData();
SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize);
ETK_FREE(UserData, this);
}
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);
ss->init();
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
ss->_root_vm = v;
if(v->init(NULL, initialstacksize)) {
return v;
} else {
v->~VirtualMachine();
SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
ETK_FREE(rabbit::VirtualMachine, v);
return NULL;
}
return v;
@ -80,17 +77,14 @@ rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm, i
{
rabbit::SharedState *ss;
ss=_get_shared_state(friendvm);
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
ss->_root_vm = v;
if(v->init(friendvm, initialstacksize)) {
friendvm->push(v);
return v;
} else {
v->~VirtualMachine();
SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
ETK_FREE(rabbit::VirtualMachine, v);
return NULL;
}
}