[DEV] remote _toarray()
This commit is contained in:
parent
05107dc711
commit
966b5fdad6
@ -21,8 +21,7 @@ void rabbit::Array::extend(const rabbit::Array *a){
|
||||
}
|
||||
}
|
||||
|
||||
rabbit::Array::Array(rabbit::SharedState* _ss,
|
||||
int64_t _nsize) {
|
||||
rabbit::Array::Array(rabbit::SharedState* _ss, int64_t _nsize) {
|
||||
m_data.resize(_nsize);
|
||||
}
|
||||
rabbit::Array::~Array() {
|
||||
@ -38,8 +37,7 @@ rabbit::Array* rabbit::Array::create(rabbit::SharedState* _ss,
|
||||
void rabbit::Array::finalize() {
|
||||
m_data.resize(0);
|
||||
}
|
||||
bool rabbit::Array::get(const int64_t _nidx,
|
||||
rabbit::ObjectPtr& _val) {
|
||||
bool rabbit::Array::get(const int64_t _nidx, rabbit::ObjectPtr& _val) const {
|
||||
if( _nidx >= 0
|
||||
&& _nidx < (int64_t)m_data.size()){
|
||||
rabbit::ObjectPtr &o = m_data[_nidx];
|
||||
@ -48,7 +46,7 @@ bool rabbit::Array::get(const int64_t _nidx,
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool rabbit::Array::set(const int64_t _nidx,const rabbit::ObjectPtr& _val) {
|
||||
bool rabbit::Array::set(const int64_t _nidx,const rabbit::ObjectPtr& _val) const {
|
||||
if(_nidx>=0 && _nidx<(int64_t)m_data.size()){
|
||||
m_data[_nidx] = _val;
|
||||
return true;
|
||||
@ -70,7 +68,7 @@ int64_t rabbit::Array::next(const rabbit::ObjectPtr& _refpos,
|
||||
//nothing to iterate anymore
|
||||
return -1;
|
||||
}
|
||||
rabbit::Array* rabbit::Array::clone() {
|
||||
rabbit::Array* rabbit::Array::clone() const {
|
||||
Array *anew = create(NULL,0);
|
||||
anew->m_data = m_data;
|
||||
return anew;
|
||||
|
||||
@ -24,12 +24,12 @@ namespace rabbit {
|
||||
int64_t _ninitialsize);
|
||||
void finalize();
|
||||
bool get(const int64_t _nidx,
|
||||
rabbit::ObjectPtr& _val);
|
||||
bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val);
|
||||
rabbit::ObjectPtr& _val) const;
|
||||
bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val) const;
|
||||
int64_t next(const rabbit::ObjectPtr& _refpos,
|
||||
rabbit::ObjectPtr& _outkey,
|
||||
rabbit::ObjectPtr& _outval);
|
||||
Array* clone();
|
||||
Array* clone() const;
|
||||
int64_t size() const;
|
||||
void resize(int64_t _size);
|
||||
void resize(int64_t _size,
|
||||
@ -46,7 +46,7 @@ namespace rabbit {
|
||||
rabbit::ObjectPtr& operator[] (const size_t _pos);
|
||||
const rabbit::ObjectPtr& operator[] (const size_t _pos) const;
|
||||
private:
|
||||
etk::Vector<rabbit::ObjectPtr> m_data;
|
||||
mutable etk::Vector<rabbit::ObjectPtr> m_data;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@ -17,6 +17,121 @@ namespace rabbit {
|
||||
public:
|
||||
rabbit::ObjectType _type;
|
||||
rabbit::ObjectValue _unVal;
|
||||
|
||||
int64_t& toInteger() {
|
||||
return _unVal.nInteger;
|
||||
}
|
||||
int64_t toInteger() const {
|
||||
return _unVal.nInteger;
|
||||
}
|
||||
float_t& toFloat() {
|
||||
return _unVal.fFloat;
|
||||
}
|
||||
float_t toFloat() const {
|
||||
return _unVal.fFloat;
|
||||
}
|
||||
rabbit::String*& toString() {
|
||||
return _unVal.pString;
|
||||
}
|
||||
const rabbit::String* toString() const {
|
||||
return _unVal.pString;
|
||||
}
|
||||
rabbit::Table*& toTable() {
|
||||
return _unVal.pTable;
|
||||
}
|
||||
const rabbit::Table* toTable() const {
|
||||
return _unVal.pTable;
|
||||
}
|
||||
rabbit::Array*& toArray() {
|
||||
return _unVal.pArray;
|
||||
}
|
||||
const rabbit::Array* toArray() const {
|
||||
return _unVal.pArray;
|
||||
}
|
||||
rabbit::FunctionProto*& toFunctionProto() {
|
||||
return _unVal.pFunctionProto;
|
||||
}
|
||||
const rabbit::FunctionProto* toFunctionProto() const {
|
||||
return _unVal.pFunctionProto;
|
||||
}
|
||||
rabbit::Closure*& toClosure() {
|
||||
return _unVal.pClosure;
|
||||
}
|
||||
const rabbit::Closure* toClosure() const {
|
||||
return _unVal.pClosure;
|
||||
}
|
||||
rabbit::Outer*& toOuter() {
|
||||
return _unVal.pOuter;
|
||||
}
|
||||
const rabbit::Outer* toOuter() const {
|
||||
return _unVal.pOuter;
|
||||
}
|
||||
rabbit::Generator*& toGenerator() {
|
||||
return _unVal.pGenerator;
|
||||
}
|
||||
const rabbit::Generator* toGenerator() const {
|
||||
return _unVal.pGenerator;
|
||||
}
|
||||
rabbit::NativeClosure*& toNativeClosure() {
|
||||
return _unVal.pNativeClosure;
|
||||
}
|
||||
const rabbit::NativeClosure* toNativeClosure() const {
|
||||
return _unVal.pNativeClosure;
|
||||
}
|
||||
rabbit::Class*& toClass() {
|
||||
return _unVal.pClass;
|
||||
}
|
||||
const rabbit::Class* toClass() const {
|
||||
return _unVal.pClass;
|
||||
}
|
||||
rabbit::Instance*& toInstance() {
|
||||
return _unVal.pInstance;
|
||||
}
|
||||
const rabbit::Instance* toInstance() const {
|
||||
return _unVal.pInstance;
|
||||
}
|
||||
rabbit::Delegable*& toDelegable() {
|
||||
return _unVal.pDelegable;
|
||||
}
|
||||
const rabbit::Delegable* toDelegable() const {
|
||||
return _unVal.pDelegable;
|
||||
}
|
||||
rabbit::UserPointer& toUserPointer() {
|
||||
return _unVal.pUserPointer;
|
||||
}
|
||||
const rabbit::UserPointer toUserPointer() const {
|
||||
return _unVal.pUserPointer;
|
||||
}
|
||||
rabbit::WeakRef*& toWeakRef() {
|
||||
return _unVal.pWeakRef;
|
||||
}
|
||||
const rabbit::WeakRef* toWeakRef() const {
|
||||
return _unVal.pWeakRef;
|
||||
}
|
||||
rabbit::VirtualMachine*& toVirtualMachine() {
|
||||
return _unVal.pThread;
|
||||
}
|
||||
const rabbit::VirtualMachine* toVirtualMachine() const {
|
||||
return _unVal.pThread;
|
||||
}
|
||||
rabbit::RefCounted*& toRefCounted() {
|
||||
return _unVal.pRefCounted;
|
||||
}
|
||||
const rabbit::RefCounted* toRefCounted() const {
|
||||
return _unVal.pRefCounted;
|
||||
}
|
||||
rabbit::UserData*& toUserData() {
|
||||
return _unVal.pUserData;
|
||||
}
|
||||
const rabbit::UserData* toUserData() const {
|
||||
return _unVal.pUserData;
|
||||
}
|
||||
uint64_t& toRaw() {
|
||||
return _unVal.raw;
|
||||
}
|
||||
uint64_t toRaw() const {
|
||||
return _unVal.raw;
|
||||
}
|
||||
};
|
||||
|
||||
#define __addRef(type,unval) if(ISREFCOUNTED(type)) \
|
||||
@ -38,7 +153,6 @@ namespace rabbit {
|
||||
#define _float(obj) ((obj)._unVal.fFloat)
|
||||
#define _string(obj) ((obj)._unVal.pString)
|
||||
#define _table(obj) ((obj)._unVal.pTable)
|
||||
#define _array(obj) ((obj)._unVal.pArray)
|
||||
#define _closure(obj) ((obj)._unVal.pClosure)
|
||||
#define _generator(obj) ((obj)._unVal.pGenerator)
|
||||
#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure)
|
||||
|
||||
@ -543,7 +543,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
|
||||
if((nrefidx = _table(o1)->next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
|
||||
o4 = (int64_t)nrefidx; _FINISH(1);
|
||||
case rabbit::OT_ARRAY:
|
||||
if((nrefidx = _array(o1)->next(o4, o2, o3)) == -1) _FINISH(exitpos);
|
||||
if((nrefidx = o1.toArray()->next(o4, o2, o3)) == -1) _FINISH(exitpos);
|
||||
o4 = (int64_t) nrefidx; _FINISH(1);
|
||||
case rabbit::OT_STRING:
|
||||
if((nrefidx = _string(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos);
|
||||
@ -909,7 +909,7 @@ exception_restore:
|
||||
case _OP_NEWOBJ:
|
||||
switch(arg3) {
|
||||
case NOT_TABLE: TARGET = rabbit::Table::create(_get_shared_state(this), arg1); continue;
|
||||
case NOT_ARRAY: TARGET = rabbit::Array::create(_get_shared_state(this), 0); _array(TARGET)->reserve(arg1); continue;
|
||||
case NOT_ARRAY: TARGET = rabbit::Array::create(_get_shared_state(this), 0); TARGET.toArray()->reserve(arg1); continue;
|
||||
case NOT_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue;
|
||||
default: assert(0); continue;
|
||||
}
|
||||
@ -937,7 +937,7 @@ exception_restore:
|
||||
default: val._type = rabbit::OT_INTEGER; assert(0); break;
|
||||
|
||||
}
|
||||
_array(STK(arg0))->append(val); continue;
|
||||
STK(arg0).toArray()->append(val); continue;
|
||||
}
|
||||
case _OP_COMPARITH: {
|
||||
int64_t selfidx = (((uint64_t)arg1&0xFFFF0000)>>16);
|
||||
@ -1237,45 +1237,62 @@ bool rabbit::VirtualMachine::tailcall(rabbit::Closure *closure, int64_t parambas
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define FALLBACK_OK 0
|
||||
#define FALLBACK_NO_MATCH 1
|
||||
#define FALLBACK_ERROR 2
|
||||
#define FALLBACK_OK 0
|
||||
#define FALLBACK_NO_MATCH 1
|
||||
#define FALLBACK_ERROR 2
|
||||
|
||||
bool rabbit::VirtualMachine::get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx)
|
||||
{
|
||||
bool rabbit::VirtualMachine::get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx) {
|
||||
switch(sq_type(self)){
|
||||
case rabbit::OT_TABLE:
|
||||
if(_table(self)->get(key,dest))return true;
|
||||
break;
|
||||
case rabbit::OT_ARRAY:
|
||||
if (sq_isnumeric(key)) { if (_array(self)->get(tointeger(key), dest)) { return true; } if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) raise_Idxerror(key); return false; }
|
||||
break;
|
||||
case rabbit::OT_INSTANCE:
|
||||
if(_instance(self)->get(key,dest)) return true;
|
||||
break;
|
||||
case rabbit::OT_CLASS:
|
||||
if(_class(self)->get(key,dest)) return true;
|
||||
break;
|
||||
case rabbit::OT_STRING:
|
||||
if(sq_isnumeric(key)){
|
||||
int64_t n = tointeger(key);
|
||||
int64_t len = _string(self)->_len;
|
||||
if (n < 0) { n += len; }
|
||||
if (n >= 0 && n < len) {
|
||||
dest = int64_t(_stringval(self)[n]);
|
||||
case rabbit::OT_TABLE:
|
||||
if(_table(self)->get(key,dest)) {
|
||||
return true;
|
||||
}
|
||||
if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) raise_Idxerror(key);
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:break; //shut up compiler
|
||||
break;
|
||||
case rabbit::OT_ARRAY:
|
||||
if (sq_isnumeric(key)) {
|
||||
if (self.toArray()->get(tointeger(key), dest)) {
|
||||
return true;
|
||||
}
|
||||
if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) {
|
||||
raise_Idxerror(key);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
case rabbit::OT_INSTANCE:
|
||||
if(_instance(self)->get(key,dest)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case rabbit::OT_CLASS:
|
||||
if(_class(self)->get(key,dest)) {
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case rabbit::OT_STRING:
|
||||
if(sq_isnumeric(key)){
|
||||
int64_t n = tointeger(key);
|
||||
int64_t len = _string(self)->_len;
|
||||
if (n < 0) { n += len; }
|
||||
if (n >= 0 && n < len) {
|
||||
dest = int64_t(_stringval(self)[n]);
|
||||
return true;
|
||||
}
|
||||
if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) raise_Idxerror(key);
|
||||
return false;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break; //shut up compiler
|
||||
}
|
||||
if ((getflags & GET_FLAG_RAW) == 0) {
|
||||
switch(fallBackGet(self,key,dest)) {
|
||||
case FALLBACK_OK: return true; //okie
|
||||
case FALLBACK_NO_MATCH: break; //keep falling back
|
||||
case FALLBACK_ERROR: return false; // the metamethod failed
|
||||
case FALLBACK_OK:
|
||||
return true; //okie
|
||||
case FALLBACK_NO_MATCH:
|
||||
break; //keep falling back
|
||||
case FALLBACK_ERROR:
|
||||
return false; // the metamethod failed
|
||||
}
|
||||
if(invokeDefaultDelegate(self,key,dest)) {
|
||||
return true;
|
||||
@ -1364,7 +1381,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
|
||||
break;
|
||||
case rabbit::OT_ARRAY:
|
||||
if(!sq_isnumeric(key)) { raise_error("indexing %s with %s",getTypeName(self),getTypeName(key)); return false; }
|
||||
if(!_array(self)->set(tointeger(key),val)) {
|
||||
if(!self.toArray()->set(tointeger(key),val)) {
|
||||
raise_Idxerror(key);
|
||||
return false;
|
||||
}
|
||||
@ -1445,7 +1462,7 @@ cloned_mt:
|
||||
target = newobj;
|
||||
return true;
|
||||
case rabbit::OT_ARRAY:
|
||||
target = _array(self)->clone();
|
||||
target = self.toArray()->clone();
|
||||
return true;
|
||||
default:
|
||||
raise_error("cloning a %s", getTypeName(self));
|
||||
@ -1770,7 +1787,7 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall)
|
||||
case rabbit::OT_STRING: printf("STRING %s",_stringval(obj));break;
|
||||
case rabbit::OT_NULL: printf("NULL"); break;
|
||||
case rabbit::OT_TABLE: printf("TABLE %p[%p]",_table(obj),_table(obj)->_delegate);break;
|
||||
case rabbit::OT_ARRAY: printf("ARRAY %p",_array(obj));break;
|
||||
case rabbit::OT_ARRAY: printf("ARRAY %p",obj.toArray());break;
|
||||
case rabbit::OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break;
|
||||
case rabbit::OT_NATIVECLOSURE: printf("NATIVECLOSURE");break;
|
||||
case rabbit::OT_USERDATA: printf("USERDATA %p[%p]",_userdataval(obj),_userdata(obj)->_delegate);break;
|
||||
|
||||
@ -323,7 +323,7 @@ rabbit::Result rabbit::sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx)
|
||||
sq_aux_paramscheck(v,2);
|
||||
rabbit::ObjectPtr *arr;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
|
||||
_array(*arr)->append(v->getUp(-1));
|
||||
arr->toArray()->append(v->getUp(-1));
|
||||
v->pop();
|
||||
return SQ_OK;
|
||||
}
|
||||
@ -333,11 +333,11 @@ rabbit::Result rabbit::sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit:
|
||||
sq_aux_paramscheck(v, 1);
|
||||
rabbit::ObjectPtr *arr;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
|
||||
if(_array(*arr)->size() > 0) {
|
||||
if(arr->toArray()->size() > 0) {
|
||||
if(pushval != 0){
|
||||
v->push(_array(*arr)->top());
|
||||
v->push(arr->toArray()->top());
|
||||
}
|
||||
_array(*arr)->pop();
|
||||
arr->toArray()->pop();
|
||||
return SQ_OK;
|
||||
}
|
||||
return sq_throwerror(v, "empty array");
|
||||
@ -349,7 +349,7 @@ rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int6
|
||||
rabbit::ObjectPtr *arr;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
|
||||
if(newsize >= 0) {
|
||||
_array(*arr)->resize(newsize);
|
||||
arr->toArray()->resize(newsize);
|
||||
return SQ_OK;
|
||||
}
|
||||
return sq_throwerror(v,"negative size");
|
||||
@ -361,7 +361,7 @@ rabbit::Result rabbit::sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx)
|
||||
sq_aux_paramscheck(v, 1);
|
||||
rabbit::ObjectPtr *o;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,o);
|
||||
rabbit::Array *arr = _array(*o);
|
||||
rabbit::Array *arr = o->toArray();
|
||||
if(arr->size() > 0) {
|
||||
rabbit::ObjectPtr t;
|
||||
int64_t size = arr->size();
|
||||
@ -382,7 +382,7 @@ rabbit::Result rabbit::sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int6
|
||||
sq_aux_paramscheck(v, 1);
|
||||
rabbit::ObjectPtr *arr;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
|
||||
return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,"index out of range");
|
||||
return arr->toArray()->remove(itemidx) ? SQ_OK : sq_throwerror(v,"index out of range");
|
||||
}
|
||||
|
||||
rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos)
|
||||
@ -390,7 +390,7 @@ rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int6
|
||||
sq_aux_paramscheck(v, 1);
|
||||
rabbit::ObjectPtr *arr;
|
||||
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
|
||||
rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,"index out of range");
|
||||
rabbit::Result ret = arr->toArray()->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,"index out of range");
|
||||
v->pop();
|
||||
return ret;
|
||||
}
|
||||
@ -538,7 +538,7 @@ rabbit::Result rabbit::sq_clear(rabbit::VirtualMachine* v,int64_t idx)
|
||||
rabbit::Object &o=stack_get(v,idx);
|
||||
switch(sq_type(o)) {
|
||||
case rabbit::OT_TABLE: _table(o)->clear(); break;
|
||||
case rabbit::OT_ARRAY: _array(o)->resize(0); break;
|
||||
case rabbit::OT_ARRAY: o.toArray()->resize(0); break;
|
||||
default:
|
||||
return sq_throwerror(v, "clear only works on table and array");
|
||||
break;
|
||||
@ -739,7 +739,7 @@ int64_t rabbit::sq_getsize(rabbit::VirtualMachine* v, int64_t idx)
|
||||
switch(type) {
|
||||
case rabbit::OT_STRING: return _string(o)->_len;
|
||||
case rabbit::OT_TABLE: return _table(o)->countUsed();
|
||||
case rabbit::OT_ARRAY: return _array(o)->size();
|
||||
case rabbit::OT_ARRAY: return o.toArray()->size();
|
||||
case rabbit::OT_USERDATA: return _userdata(o)->getsize();
|
||||
case rabbit::OT_INSTANCE: return _instance(o)->_class->_udsize;
|
||||
case rabbit::OT_CLASS: return _class(o)->_udsize;
|
||||
@ -1083,7 +1083,7 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx)
|
||||
break;
|
||||
case rabbit::OT_ARRAY:{
|
||||
if(sq_isnumeric(obj)){
|
||||
if(_array(self)->get(tointeger(obj),obj)) {
|
||||
if(self.toArray()->get(tointeger(obj),obj)) {
|
||||
return SQ_OK;
|
||||
}
|
||||
}
|
||||
|
||||
@ -522,7 +522,7 @@ static int64_t array_append(rabbit::VirtualMachine* v)
|
||||
|
||||
static int64_t array_extend(rabbit::VirtualMachine* v)
|
||||
{
|
||||
_array(stack_get(v,1))->extend(_array(stack_get(v,2)));
|
||||
stack_get(v,1).toArray()->extend(stack_get(v,2).toArray());
|
||||
sq_pop(v,1);
|
||||
return 1;
|
||||
}
|
||||
@ -540,8 +540,8 @@ static int64_t array_pop(rabbit::VirtualMachine* v)
|
||||
static int64_t array_top(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o=stack_get(v,1);
|
||||
if(_array(o)->size()>0){
|
||||
v->push(_array(o)->top());
|
||||
if(o.toArray()->size()>0){
|
||||
v->push(o.toArray()->top());
|
||||
return 1;
|
||||
}
|
||||
else return sq_throwerror(v,"top() on a empty array");
|
||||
@ -552,7 +552,7 @@ static int64_t array_insert(rabbit::VirtualMachine* v)
|
||||
rabbit::Object &o=stack_get(v,1);
|
||||
rabbit::Object &idx=stack_get(v,2);
|
||||
rabbit::Object &val=stack_get(v,3);
|
||||
if(!_array(o)->insert(tointeger(idx),val))
|
||||
if(!o.toArray()->insert(tointeger(idx),val))
|
||||
return sq_throwerror(v,"index out of range");
|
||||
sq_pop(v,2);
|
||||
return 1;
|
||||
@ -564,8 +564,8 @@ static int64_t array_remove(rabbit::VirtualMachine* v)
|
||||
rabbit::Object &idx = stack_get(v, 2);
|
||||
if(!sq_isnumeric(idx)) return sq_throwerror(v, "wrong type");
|
||||
rabbit::ObjectPtr val;
|
||||
if(_array(o)->get(tointeger(idx), val)) {
|
||||
_array(o)->remove(tointeger(idx));
|
||||
if(o.toArray()->get(tointeger(idx), val)) {
|
||||
o.toArray()->remove(tointeger(idx));
|
||||
v->push(val);
|
||||
return 1;
|
||||
}
|
||||
@ -584,7 +584,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v)
|
||||
|
||||
if(sq_gettop(v) > 2)
|
||||
fill = stack_get(v, 3);
|
||||
_array(o)->resize(sz,fill);
|
||||
o.toArray()->resize(sz,fill);
|
||||
sq_settop(v, 1);
|
||||
return 1;
|
||||
}
|
||||
@ -610,9 +610,9 @@ static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,rabbit::Virtua
|
||||
static int64_t array_map(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o = stack_get(v,1);
|
||||
int64_t size = _array(o)->size();
|
||||
int64_t size = o.toArray()->size();
|
||||
rabbit::ObjectPtr ret = rabbit::Array::create(_get_shared_state(v),size);
|
||||
if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))
|
||||
if(SQ_FAILED(__map_array(ret.toArray(),o.toArray(),v)))
|
||||
return SQ_ERROR;
|
||||
v->push(ret);
|
||||
return 1;
|
||||
@ -621,7 +621,7 @@ static int64_t array_map(rabbit::VirtualMachine* v)
|
||||
static int64_t array_apply(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o = stack_get(v,1);
|
||||
if(SQ_FAILED(__map_array(_array(o),_array(o),v)))
|
||||
if(SQ_FAILED(__map_array(o.toArray(),o.toArray(),v)))
|
||||
return SQ_ERROR;
|
||||
sq_pop(v,1);
|
||||
return 1;
|
||||
@ -630,7 +630,7 @@ static int64_t array_apply(rabbit::VirtualMachine* v)
|
||||
static int64_t array_reduce(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o = stack_get(v,1);
|
||||
rabbit::Array *a = _array(o);
|
||||
rabbit::Array *a = o.toArray();
|
||||
int64_t size = a->size();
|
||||
if(size == 0) {
|
||||
return 0;
|
||||
@ -658,7 +658,7 @@ static int64_t array_reduce(rabbit::VirtualMachine* v)
|
||||
static int64_t array_filter(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o = stack_get(v,1);
|
||||
rabbit::Array *a = _array(o);
|
||||
rabbit::Array *a = o.toArray();
|
||||
rabbit::ObjectPtr ret = rabbit::Array::create(_get_shared_state(v),0);
|
||||
int64_t size = a->size();
|
||||
rabbit::ObjectPtr val;
|
||||
@ -671,7 +671,7 @@ static int64_t array_filter(rabbit::VirtualMachine* v)
|
||||
return SQ_ERROR;
|
||||
}
|
||||
if(!rabbit::VirtualMachine::IsFalse(v->getUp(-1))) {
|
||||
_array(ret)->append(val);
|
||||
ret.toArray()->append(val);
|
||||
}
|
||||
v->pop();
|
||||
}
|
||||
@ -683,7 +683,7 @@ static int64_t array_find(rabbit::VirtualMachine* v)
|
||||
{
|
||||
rabbit::Object &o = stack_get(v,1);
|
||||
rabbit::ObjectPtr &val = stack_get(v,2);
|
||||
rabbit::Array *a = _array(o);
|
||||
rabbit::Array *a = o.toArray();
|
||||
int64_t size = a->size();
|
||||
rabbit::ObjectPtr temp;
|
||||
for(int64_t n = 0; n < size; n++) {
|
||||
@ -766,7 +766,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64
|
||||
|
||||
static bool _hsort(rabbit::VirtualMachine* v,rabbit::ObjectPtr &arr, int64_t SQ_UNUSED_ARG(l), int64_t SQ_UNUSED_ARG(r),int64_t func)
|
||||
{
|
||||
rabbit::Array *a = _array(arr);
|
||||
rabbit::Array *a = arr.toArray();
|
||||
int64_t i;
|
||||
int64_t array_size = a->size();
|
||||
for (i = (array_size / 2); i >= 0; i--) {
|
||||
@ -785,9 +785,9 @@ static int64_t array_sort(rabbit::VirtualMachine* v)
|
||||
{
|
||||
int64_t func = -1;
|
||||
rabbit::ObjectPtr &o = stack_get(v,1);
|
||||
if(_array(o)->size() > 1) {
|
||||
if(o.toArray()->size() > 1) {
|
||||
if(sq_gettop(v) == 2) func = 2;
|
||||
if(!_hsort(v, o, 0, _array(o)->size()-1, func))
|
||||
if(!_hsort(v, o, 0, o.toArray()->size()-1, func))
|
||||
return SQ_ERROR;
|
||||
|
||||
}
|
||||
@ -800,7 +800,7 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
|
||||
int64_t sidx,eidx;
|
||||
rabbit::ObjectPtr o;
|
||||
if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
|
||||
int64_t alen = _array(o)->size();
|
||||
int64_t alen = o.toArray()->size();
|
||||
if(sidx < 0)sidx = alen + sidx;
|
||||
if(eidx < 0)eidx = alen + eidx;
|
||||
if(eidx < sidx)return sq_throwerror(v,"wrong indexes");
|
||||
@ -809,7 +809,7 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
|
||||
rabbit::ObjectPtr t;
|
||||
int64_t count=0;
|
||||
for(int64_t i=sidx;i<eidx;i++){
|
||||
_array(o)->get(i,t);
|
||||
o.toArray()->get(i,t);
|
||||
arr->set(count++,t);
|
||||
}
|
||||
v->push(arr);
|
||||
@ -938,7 +938,7 @@ static int64_t closure_call(rabbit::VirtualMachine* v)
|
||||
|
||||
static int64_t _closure_acall(rabbit::VirtualMachine* v,rabbit::Bool raiseerror)
|
||||
{
|
||||
rabbit::Array *aparams=_array(stack_get(v,2));
|
||||
rabbit::Array *aparams=stack_get(v,2).toArray();
|
||||
int64_t nparams=aparams->size();
|
||||
v->push(stack_get(v,1));
|
||||
for(int64_t i=0;i<nparams;i++)v->push((*aparams)[i]);
|
||||
@ -985,13 +985,13 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
|
||||
rabbit::ObjectPtr params = rabbit::Array::create(_get_shared_state(v),nparams);
|
||||
rabbit::ObjectPtr defparams = rabbit::Array::create(_get_shared_state(v),f->_ndefaultparams);
|
||||
for(int64_t n = 0; n<f->_nparameters; n++) {
|
||||
_array(params)->set((int64_t)n,f->_parameters[n]);
|
||||
params.toArray()->set((int64_t)n,f->_parameters[n]);
|
||||
}
|
||||
for(int64_t j = 0; j<f->_ndefaultparams; j++) {
|
||||
_array(defparams)->set((int64_t)j,_closure(o)->_defaultparams[j]);
|
||||
defparams.toArray()->set((int64_t)j,_closure(o)->_defaultparams[j]);
|
||||
}
|
||||
if(f->_varparams) {
|
||||
_array(params)->set(nparams-1,rabbit::String::create(_get_shared_state(v),"...",-1));
|
||||
params.toArray()->set(nparams-1,rabbit::String::create(_get_shared_state(v),"...",-1));
|
||||
}
|
||||
res->newSlot(rabbit::String::create(_get_shared_state(v),"native",-1),false);
|
||||
res->newSlot(rabbit::String::create(_get_shared_state(v),"name",-1),f->_name);
|
||||
@ -1010,7 +1010,7 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
|
||||
typecheck =
|
||||
rabbit::Array::create(_get_shared_state(v), nc->_typecheck.size());
|
||||
for(uint64_t n = 0; n<nc->_typecheck.size(); n++) {
|
||||
_array(typecheck)->set((int64_t)n,nc->_typecheck[n]);
|
||||
typecheck.toArray()->set((int64_t)n,nc->_typecheck[n]);
|
||||
}
|
||||
}
|
||||
res->newSlot(rabbit::String::create(_get_shared_state(v),"typecheck",-1),typecheck);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user