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

2
rabbit/Class.cpp
View File

@ -87,7 +87,7 @@ void rabbit::Class::release() {
if (_hook) { if (_hook) {
_hook(_typetag,0); _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) { 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){ rabbit::Closure *rabbit::Closure::create(rabbit::SharedState *ss,rabbit::FunctionProto *func,rabbit::WeakRef *root){
int64_t size = _CALC_CLOSURE_SIZE(func); int64_t size = _CALC_CLOSURE_SIZE(func);
rabbit::Closure *nc=(rabbit::Closure*)SQ_MALLOC(size); rabbit::Closure *nc = ETK_NEW(rabbit::Closure, ss, func);
new ((char*)nc) rabbit::Closure(ss,func);
nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_defaultparams = &nc->_outervalues[func->_noutervalues]; nc->_defaultparams = &nc->_outervalues[func->_noutervalues];
nc->_root = root; 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() { void rabbit::FuncState::popChildState() {
FuncState *child = _childstates.back(); FuncState *child = _childstates.back();
sq_delete(child, FuncState); ETK_DELETE(FuncState, child);
_childstates.popBack(); _childstates.popBack();
} }

2
rabbit/Generator.cpp
View File

@ -123,6 +123,6 @@ void rabbit::Generator::kill() {
} }
void rabbit::Generator::release() { 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) { rabbit::NativeClosure* rabbit::NativeClosure::create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters) {
int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters); int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters);
rabbit::NativeClosure *nc=(rabbit::NativeClosure*)SQ_MALLOC(size); rabbit::NativeClosure *nc = ETK_NEW(rabbit::NativeClosure, ss, func);
new ((char*)nc) rabbit::NativeClosure(ss,func);
nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_noutervalues = nouters; nc->_noutervalues = nouters;
_CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);

1
rabbit/NativeClosure.hpp
View File

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

11
rabbit/Object.hpp
View File

@ -12,7 +12,6 @@
#include <rabbit/ObjectValue.hpp> #include <rabbit/ObjectValue.hpp>
namespace rabbit { namespace rabbit {
class Object { class Object {
public: public:
rabbit::ObjectType _type; rabbit::ObjectType _type;
@ -228,14 +227,4 @@ namespace rabbit {
void releaseRef(); void releaseRef();
void swap(rabbit::Object& _obj); 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> #include <rabbit/Object.hpp>
namespace rabbit { namespace rabbit {
#define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class,sym) \ #define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class) \
ObjectPtr(_class * x); \ ObjectPtr(_class * x); \
ObjectPtr& operator=(_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(_class x); \
ObjectPtr& operator=(_class x); ObjectPtr& operator=(_class x);
@ -28,23 +28,23 @@ namespace rabbit {
ObjectPtr(const ObjectPtr& _obj); ObjectPtr(const ObjectPtr& _obj);
ObjectPtr(const Object& _obj); ObjectPtr(const Object& _obj);
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table, pTable) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class, pClass) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance, pInstance) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array, pArray) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure, pClosure) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure, pNativeClosure) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer, pOuter) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator, pGenerator) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String, pString) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData, pUserData) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef, pWeakRef) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine, pThread) RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine)
RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, rabbit::FunctionProto, pFunctionProto) 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_INTEGER, int64_t)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t, fFloat) RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t)
RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer, pUserPointer) RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer)
ObjectPtr(bool _value); ObjectPtr(bool _value);
ObjectPtr& operator=(bool _value); ObjectPtr& operator=(bool _value);

5
rabbit/RefCounted.cpp
View File

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

25
rabbit/SharedState.cpp
View File

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

2
rabbit/Table.cpp
View File

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

2
rabbit/WeakRef.cpp
View File

@ -15,5 +15,5 @@ void rabbit::WeakRef::release() {
if(_obj.isRefCounted() == true) { if(_obj.isRefCounted() == true) {
_obj._unVal.pRefCounted->_weakref = null; _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 <rabbit/VirtualMachine.hpp>
#include <etk/Allocator.hpp>
#include <rabbit/Array.hpp> #include <rabbit/Array.hpp>
@ -58,8 +59,7 @@ namespace rabbit {
} }
rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize) rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize)
{ {
rabbit::SharedState *ss; rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState);
sq_new(ss, rabbit::SharedState);
ss->init(); ss->init();
char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine)); 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); rabbit::SharedState *ss = _get_shared_state(v);
ss->_root_vm.toVirtualMachine()->finalize(); ss->_root_vm.toVirtualMachine()->finalize();
sq_delete(ss, SharedState); ETK_DELETE(SharedState, ss);
} }
int64_t rabbit::sq_getversion() 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 return false; // We'd be swapping ourselve. The compare function is incorrect
} }
_Swap((*arr)[root], (*arr)[maxChild]); (*arr)[root].swap((*arr)[maxChild]);
root = maxChild; root = maxChild;
} }
else { 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--) 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; if(!_hsort_sift_down(v,a, 0, i-1,func)) return false;
} }
return true; return true;

1
rabbit/sqconfig.hpp
View File

@ -8,6 +8,7 @@
#pragma once #pragma once
#include <etk/types.hpp> #include <etk/types.hpp>
#include <etk/Allocator.hpp>
#include <ctype.h> #include <ctype.h>
#ifdef SQUSEDOUBLE #ifdef SQUSEDOUBLE
typedef double float_t; 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_realloc(void *p,uint64_t oldsize,uint64_t size);
void sq_vm_free(void *p,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_MALLOC(__size) sq_vm_malloc((__size));
#define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size)); #define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
#define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size)); #define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));