本文整理汇总了C++中ASObject类的典型用法代码示例。如果您正苦于以下问题：C++ ASObject类的具体用法？C++ ASObject怎么用？C++ ASObject使用的例子？那么, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了ASObject类的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: ASFUNCTIONBODY
ASFUNCTIONBODY(Array,forEach)
{
Array* th=static_cast<Array*>(obj);
_NR<IFunction> f;
ARG_UNPACK(f);
if (f.isNull())
return NULL;
ASObject* params[3];
std::map<uint32_t, data_slot>::iterator it=th->data.begin();
for(;it != th->data.end();++it)
{
assert_and_throw(it->second.type==DATA_OBJECT);
params[0] = it->second.data;
it->second.data->incRef();
params[1] = abstract_i(it->first);
params[2] = th;
th->incRef();
ASObject *funcret;
if( argslen == 1 )
{
funcret=f->call(getSys()->getNullRef(), params, 3);
}
else
{
args[1]->incRef();
funcret=f->call(args[1], params, 3);
}
if(funcret)
funcret->decRef();
}
return NULL;
}示例2: getClass
bool ASObject::hasPropertyByMultiname(const multiname& name, bool considerDynamic)
{
//We look in all the object's levels
uint32_t validTraits=DECLARED_TRAIT;
if(considerDynamic)
validTraits|=DYNAMIC_TRAIT;
if(Variables.findObjVar(name, NO_CREATE_TRAIT, validTraits)!=NULL)
return true;
if(classdef && classdef->Variables.findObjVar(name, NO_CREATE_TRAIT, BORROWED_TRAIT)!=NULL)
return true;
//Check prototype inheritance chain
if(getClass())
{
ASObject* proto = getClass()->prototype.getPtr();
while(proto)
{
if(proto->findGettable(name, false) != NULL)
return true;
proto = proto->getprop_prototype();
}
}
//Must not ask for non borrowed traits as static class member are not valid
return false;
}示例3: ASFUNCTIONBODY
ASFUNCTIONBODY(ASObject,propertyIsEnumerable)
{
assert_and_throw(argslen==1);
multiname name;
name.name_type=multiname::NAME_STRING;
name.name_s=args[0]->toString();
name.ns.push_back(nsNameAndKind("",NAMESPACE));
name.isAttribute=false;
unsigned int index = 0;
if (obj->is<Array>()) // propertyIsEnumerable(index) isn't mentioned in the ECMA specs but is tested for
{
Array* a = static_cast<Array*>(obj);
if (a->isValidMultiname(name,index))
{
return abstract_b(index < (unsigned int)a->size());
}
}
if(obj->getClass())
{
ASObject* proto = obj->getClass()->prototype.getPtr();
if (proto->hasPropertyByMultiname(name, true))
return abstract_b(false);
}
if (obj->hasPropertyByMultiname(name,true))
return abstract_b(true);
return abstract_b(false);
}示例4: ASFUNCTIONBODY
ASFUNCTIONBODY(JSON,_stringify)
{
_NR<ASObject> value;
ARG_UNPACK(value);
std::vector<ASObject *> path;
tiny_string filter;
IFunction* replacer = NULL;
if (argslen > 1 && !args[1]->is<Null>() && !args[1]->is<Undefined>())
{
if (args[1]->is<IFunction>())
{
replacer = args[1]->as<IFunction>();
}
else if (args[1]->is<Array>())
{
filter = " ";
Array* ar = args[1]->as<Array>();
for (uint64_t i = 0; i < ar->size(); i++)
{
filter += ar->at(i)->toString();
filter += " ";
}
}
else
throwError<TypeError>(kJSONInvalidReplacer);
}
tiny_string spaces = "";
if (argslen > 2)
{
ASObject* space = args[2];
spaces = " ";
if (space->is<Number>() || space->is<Integer>() || space->is<UInteger>())
{
int32_t v = space->toInt();
if (v < 0) v = 0;
if (v > 10) v = 10;
spaces = spaces.substr_bytes(0,v);
}
else if (space->is<Boolean>() || space->is<Null>())
{
spaces = "";
}
else
{
if(space->has_toString())
{
_R<ASObject> ret = space->call_toString();
spaces = ret->toString();
}
else
spaces = space->toString();
if (spaces.numBytes() > 10)
spaces = spaces.substr_bytes(0,10);
}
}
tiny_string res = value->toJSON(path,replacer,spaces,filter);
return Class<ASString>::getInstanceS(res);
}示例5: ASFUNCTIONBODY
ASFUNCTIONBODY(Array,forEach)
{
assert_and_throw(argslen == 1 || argslen == 2);
Array* th=static_cast<Array*>(obj);
IFunction* f = static_cast<IFunction*>(args[0]);
ASObject* params[3];
for(unsigned int i=0; i < th->data.size(); i++)
{
assert_and_throw(th->data[i].type==DATA_OBJECT);
params[0] = th->data[i].data;
th->data[i].data->incRef();
params[1] = abstract_i(i);
params[2] = th;
th->incRef();
ASObject *funcret;
if( argslen == 1 )
{
funcret=f->call(new Null, params, 3);
}
else
{
args[1]->incRef();
funcret=f->call(args[1], params, 3);
}
if(funcret)
funcret->decRef();
}
return NULL;
}示例6: call_toJSON
tiny_string Vector::toJSON(std::vector<ASObject *> &path, IFunction *replacer, const tiny_string &spaces, const tiny_string &filter)
{
bool ok;
tiny_string res = call_toJSON(ok,path,replacer,spaces,filter);
if (ok)
return res;
// check for cylic reference
if (std::find(path.begin(),path.end(), this) != path.end())
throwError<TypeError>(kJSONCyclicStructure);
path.push_back(this);
res += "[";
bool bfirst = true;
tiny_string newline = (spaces.empty() ? "" : "\n");
for (unsigned int i =0; i < vec.size(); i++)
{
tiny_string subres;
ASObject* o = vec[i];
if (!o)
o = getSystemState()->getNullRef();
if (replacer != NULL)
{
ASObject* params[2];
params[0] = abstract_di(getSystemState(),i);
params[0]->incRef();
params[1] = o;
params[1]->incRef();
ASObject *funcret=replacer->call(getSystemState()->getNullRef(), params, 2);
if (funcret)
subres = funcret->toJSON(path,NULL,spaces,filter);
}
else
{
subres = o->toJSON(path,replacer,spaces,filter);
}
if (!subres.empty())
{
if (!bfirst)
res += ",";
res += newline+spaces;
bfirst = false;
res += subres;
}
}
if (!bfirst)
res += newline+spaces.substr_bytes(0,spaces.numBytes()/2);
res += "]";
path.pop_back();
return res;
}示例7: ASFUNCTIONBODY
ASFUNCTIONBODY(Vector, every)
{
Vector* th=static_cast<Vector*>(obj);
if (argslen < 1)
throwError<ArgumentError>(kWrongArgumentCountError, "Vector.some", "1", Integer::toString(argslen));
if (!args[0]->is<IFunction>())
throwError<TypeError>(kCheckTypeFailedError, args[0]->getClassName(), "Function");
IFunction* f = static_cast<IFunction*>(args[0]);
ASObject* params[3];
ASObject *funcRet;
for(unsigned int i=0; i < th->size(); i++)
{
if (th->vec[i])
{
params[0] = th->vec[i];
th->vec[i]->incRef();
}
else
params[0] = obj->getSystemState()->getNullRef();
params[1] = abstract_i(obj->getSystemState(),i);
params[2] = th;
th->incRef();
if(argslen==1)
{
funcRet=f->call(obj->getSystemState()->getNullRef(), params, 3);
}
else
{
args[1]->incRef();
funcRet=f->call(args[1], params, 3);
}
if(funcRet)
{
if (funcRet->is<Undefined>() || funcRet->is<Null>())
throwError<TypeError>(kCallOfNonFunctionError, funcRet->toString());
if(!Boolean_concrete(funcRet))
{
return funcRet;
}
funcRet->decRef();
}
}
return abstract_b(obj->getSystemState(),true);
}示例8: ASFUNCTIONBODY
ASFUNCTIONBODY(Vector, every)
{
Vector* th=static_cast<Vector*>(obj);
if (argslen < 1)
throw Class<ArgumentError>::getInstanceS("Error #1063");
if (!args[0]->is<IFunction>())
throw Class<TypeError>::getInstanceS("Error #1034");
IFunction* f = static_cast<IFunction*>(args[0]);
ASObject* params[3];
ASObject *funcRet;
for(unsigned int i=0; i < th->size(); i++)
{
if (th->vec[i])
{
params[0] = th->vec[i];
th->vec[i]->incRef();
}
else
params[0] = getSys()->getNullRef();
params[1] = abstract_i(i);
params[2] = th;
th->incRef();
if(argslen==1)
{
funcRet=f->call(getSys()->getNullRef(), params, 3);
}
else
{
args[1]->incRef();
funcRet=f->call(args[1], params, 3);
}
if(funcRet)
{
if (funcRet->is<Undefined>() || funcRet->is<Null>())
throw Class<TypeError>::getInstanceS("Error #1006");
if(!Boolean_concrete(funcRet))
{
return funcRet;
}
funcRet->decRef();
}
}
return abstract_b(true);
}示例9: assert_and_throw
ASObject* ASObject::getValueAt(int index)
{
obj_var* obj=Variables.getValueAt(index);
assert_and_throw(obj);
ASObject* ret;
if(obj->getter)
{
//Call the getter
LOG(LOG_CALLS,_("Calling the getter"));
IFunction* getter=obj->getter->getOverride();
incRef();
ret=getter->call(this,NULL,0);
ret->fake_decRef();
LOG(LOG_CALLS,_("End of getter"));
}
else
ret=obj->var;
return ret;
}示例10: ASFUNCTIONBODY
ASFUNCTIONBODY(Vector, some)
{
if (argslen < 1)
throw Class<ArgumentError>::getInstanceS("Error #1063");
if (!args[0]->is<IFunction>())
throw Class<TypeError>::getInstanceS("Error #1034");
Vector* th=static_cast<Vector*>(obj);
IFunction* f = static_cast<IFunction*>(args[0]);
ASObject* params[3];
ASObject *funcRet;
for(unsigned int i=0; i < th->size(); i++)
{
if (!th->vec[i])
continue;
params[0] = th->vec[i];
th->vec[i]->incRef();
params[1] = abstract_i(i);
params[2] = th;
th->incRef();
if(argslen==1)
{
funcRet=f->call(new Null, params, 3);
}
else
{
args[1]->incRef();
funcRet=f->call(args[1], params, 3);
}
if(funcRet)
{
if(Boolean_concrete(funcRet))
{
return funcRet;
}
funcRet->decRef();
}
}
return abstract_b(false);
}示例11: assert_and_throw
ASObject* Vector::generator(TemplatedClass<Vector>* o_class, ASObject* const* args, const unsigned int argslen)
{
assert_and_throw(argslen == 1);
assert_and_throw(args[0]->getClass());
assert_and_throw(o_class->getTypes().size() == 1);
Type* type = o_class->getTypes()[0];
if(args[0]->getClass() == Class<Array>::getClass())
{
//create object without calling _constructor
Vector* ret = o_class->getInstance(false,NULL,0);
Array* a = static_cast<Array*>(args[0]);
for(unsigned int i=0;i<a->size();++i)
{
ASObject* obj = a->at(i).getPtr();
obj->incRef();
//Convert the elements of the array to the type of this vector
ret->vec.push_back( type->coerce(obj) );
}
return ret;
}
else if(args[0]->getClass()->getTemplate() == Template<Vector>::getTemplate())
{
Vector* arg = static_cast<Vector*>(args[0]);
//create object without calling _constructor
Vector* ret = o_class->getInstance(false,NULL,0);
for(auto i = arg->vec.begin(); i != arg->vec.end(); ++i)
{
(*i)->incRef();
ret->vec.push_back( type->coerce(*i) );
}
return ret;
}
else
{
throw Class<ArgumentError>::getInstanceS("global Vector() function takes Array or Vector");
}
}示例12: ASFUNCTIONBODY
ASFUNCTIONBODY(Array,filter)
{
Array* th=static_cast<Array*>(obj);
assert_and_throw(argslen==1 || argslen==2);
IFunction* f = static_cast<IFunction*>(args[0]);
ASObject* params[3];
Array* ret=Class<Array>::getInstanceS();
ASObject *funcRet;
std::map<uint32_t, data_slot>::iterator it=th->data.begin();
for(;it != th->data.end();++it)
{
assert_and_throw(it->second.type==DATA_OBJECT);
params[0] = it->second.data;
it->second.data->incRef();
params[1] = abstract_i(it->first);
params[2] = th;
th->incRef();
if(argslen==1)
{
funcRet=f->call(getSys()->getNullRef(), params, 3);
}
else
{
args[1]->incRef();
funcRet=f->call(args[1], params, 3);
}
if(funcRet)
{
if(Boolean_concrete(funcRet))
{
it->second.data->incRef();
ret->push(_MR(it->second.data));
}
funcRet->decRef();
}
}
return ret;
}示例13: setPropertyName
void Proxy::setVariableByMultiname(const multiname& name, ASObject* o, CONST_ALLOWED_FLAG allowConst)
{
//If a variable named like this already exist, use that
if(ASObject::hasPropertyByMultiname(name, true, false) || !implEnable)
{
ASObject::setVariableByMultiname(name,o,allowConst);
return;
}
//Check if there is a custom setter defined, skipping implementation to avoid recursive calls
multiname setPropertyName(NULL);
setPropertyName.name_type=multiname::NAME_STRING;
setPropertyName.name_s_id=getSys()->getUniqueStringId("setProperty");
setPropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));
_NR<ASObject> proxySetter=getVariableByMultiname(setPropertyName,ASObject::SKIP_IMPL);
if(proxySetter.isNull())
{
ASObject::setVariableByMultiname(name,o,allowConst);
return;
}
assert_and_throw(proxySetter->getObjectType()==T_FUNCTION);
IFunction* f=static_cast<IFunction*>(proxySetter.getPtr());
ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());
namearg->setProxyProperty(name);
ASObject* args[2];
args[0]=namearg;
args[1]=o;
//We now suppress special handling
implEnable=false;
LOG(LOG_CALLS,_("Proxy::setProperty"));
incRef();
_R<ASObject> ret=_MR( f->call(this,args,2) );
assert_and_throw(ret->is<Undefined>());
implEnable=true;
}示例14: setprop_prototype
/*
* (creates and) sets the property 'prototype' to o
* 'prototype' is usually DYNAMIC_TRAIT, but on Class_base
* it is a DECLARED_TRAIT, which is gettable only
*/
void ASObject::setprop_prototype(_NR<ASObject>& o)
{
ASObject* obj = o.getPtr();
obj->incRef();
multiname prototypeName;
prototypeName.name_type=multiname::NAME_STRING;
prototypeName.name_s="prototype";
prototypeName.ns.push_back(nsNameAndKind("",NAMESPACE));
bool has_getter = false;
variable* ret=findSettable(prototypeName,false, &has_getter);
if(!ret && has_getter)
throw Class<ReferenceError>::getInstanceS("Error #1074: Illegal write to read-only property prototype");
if(!ret)
ret = Variables.findObjVar(prototypeName,DYNAMIC_TRAIT,DECLARED_TRAIT|DYNAMIC_TRAIT);
if(ret->setter)
{
this->incRef();
_MR( ret->setter->call(this,&obj,1) );
}
else
ret->setVar(obj);
}示例15: hasPropertyName
bool Proxy::hasPropertyByMultiname(const multiname& name, bool considerDynamic, bool considerPrototype)
{
if (name.normalizedName() == "isAttribute")
return true;
//If a variable named like this already exist, use that
bool asobject_has_property=ASObject::hasPropertyByMultiname(name, considerDynamic, considerPrototype);
if(asobject_has_property || !implEnable)
return asobject_has_property;
//Check if there is a custom hasProperty defined, skipping implementation to avoid recursive calls
multiname hasPropertyName(NULL);
hasPropertyName.name_type=multiname::NAME_STRING;
hasPropertyName.name_s_id=getSys()->getUniqueStringId("hasProperty");
hasPropertyName.ns.push_back(nsNameAndKind(flash_proxy,NAMESPACE));
_NR<ASObject> proxyHasProperty=getVariableByMultiname(hasPropertyName,ASObject::SKIP_IMPL);
if(proxyHasProperty.isNull())
{
return false;
}
assert_and_throw(proxyHasProperty->getObjectType()==T_FUNCTION);
IFunction* f=static_cast<IFunction*>(proxyHasProperty.getPtr());
ASObject* namearg = Class<ASString>::getInstanceS(name.normalizedName());
namearg->setProxyProperty(name);
ASObject* arg = namearg;
//We now suppress special handling
implEnable=false;
LOG(LOG_CALLS,_("Proxy::hasProperty"));
incRef();
_NR<ASObject> ret=_MNR(f->call(this,&arg,1));
implEnable=true;
Boolean* b = static_cast<Boolean*>(ret.getPtr());
return b->val;
}