Actor NewActor( const Property::Map& map ) { BaseHandle handle; // First find type and create Actor Property::Value* typeValue = map.Find( "type" ); if ( typeValue ) { TypeInfo type = TypeRegistry::Get().GetTypeInfo( typeValue->Get< std::string >() ); if ( type ) { handle = type.CreateInstance(); } } if ( !handle ) { DALI_LOG_ERROR( "Actor type not provided\n" ); return Actor(); } Actor actor( Actor::DownCast( handle ) ); if ( actor ) { // Now set the properties, or create children for ( unsigned int i = 0, mapCount = map.Count(); i < mapCount; ++i ) { const StringValuePair& pair( map.GetPair( i ) ); const std::string& key( pair.first ); if ( key == "type" ) { continue; } const Property::Value& value( pair.second ); if ( key == "actors" ) { // Create children Property::Array actorArray = value.Get< Property::Array >(); for ( Property::Array::SizeType i = 0; i < actorArray.Size(); ++i) { actor.Add( NewActor( actorArray[i].Get< Property::Map >() ) ); } } else { Property::Index index( actor.GetPropertyIndex( key ) ); if ( index != Property::INVALID_INDEX ) { actor.SetProperty( index, value ); } } } } return actor; }
// allocate a object given the classname by string RTRoot* NewType(const char *typeName) { TypeInfo *t = FindType(typeName); if (!t) return(NULL); if (t->New == 0) return(NULL); // abstract type return t->New(); }
/*Type* DeclarationNode::buildType(DeclarationSpecifiersNode::TypeInfo tInfo) const { Type* type = NULL; bool unsignedSpecified = tInfo.unsignedSpecified; int integral = tInfo.integral; bool longSpecified = tInfo.longLongSpecified; bool longLongSpecified = tInfo.longLongSpecified; if (unsignedSpecified) { if (integral==Char) type = new BuiltinType<char>(Type::uChar); else if (integral==Short) type = new BuiltinType<short>(Type::uShort); else if (integral==Int) type = new BuiltinType<int>(Type::uInt); else if (longLongSpecified) type = new BuiltinType<unsigned long long>(Type::uLongLong); else if (longSpecified) type = new BuiltinType<unsigned long>(Type::uLong); } else { if (integral==Int) { if (longLongSpecified) type = new BuiltinType<long long>(Type::Long); else if (longSpecified) type = new BuiltinType<long>(Type::Long); else type = new BuiltinType<int>(Type::Int); } else { if (integral==Char) type = new BuiltinType<char>(Type::Char); else if (Short) type = new BuiltinType<short>(Type::Short); else if (integral==Float) type = new BuiltinType<float>(Type::Float); else if (integral==Double) type = new BuiltinType<double>(Type::Double); } } return type; } */ std::string DeclarationNode::toString() const { std::string s="DeclarationNode: \n" ; TypeInfo t = declSpecifier->getTypeInfo(); s+= "\t" + t.toString() + "\n"; return s; }
/* Understands how to read the inside of an object and find all references * located within. It copies the objects pointed to, but does not follow into * those further (ie, not recursive) */ void GarbageCollector::scan_object(Object* obj) { Object* slot; // If this object's refs are weak, then add it to the weak_refs // vector and don't look at it otherwise. if(obj->RefsAreWeak) { if(!weak_refs) { weak_refs = new ObjectArray(0); } weak_refs->push_back(obj); return; } if(obj->klass() && obj->klass()->reference_p()) { slot = saw_object(obj->klass()); if(slot) object_memory->set_class(obj, slot); } if(obj->ivars() && obj->ivars()->reference_p()) { slot = saw_object(obj->ivars()); if(slot) obj->ivars(object_memory->state, slot); } TypeInfo* ti = object_memory->type_info[obj->obj_type]; assert(ti); ObjectMark mark(this); ti->mark(obj, mark); }
bool TypeInfoRepository::addType(TypeInfoGenerator* t) { if (!t) return false; std::string tname = t->getTypeName(); TypeInfo* ti = t->getTypeInfoObject(); { MutexLock lock(type_lock); if (ti && data.count(tname) && data[tname] != ti ) { cout << "Refusing to add type information for '" << tname << "': the name is already in use by another type."<<endl; return false; } } // Check for first registration, or alias: if ( ti == 0 ) ti = new TypeInfo(tname); else ti->addAlias(tname); if ( t->installTypeInfoObject( ti ) ) { delete t; } MutexLock lock(type_lock); // keep track of this type: data[ tname ] = ti; /* cout << "Registered Type '"<<tname <<"' to the Orocos Type System."<< endl; for(Transports::iterator it = transports.begin(); it != transports.end(); ++it) if ( (*it)->registerTransport( tname, ti) ) log(Info) << "Registered new '"<< (*it)->getTransportName()<<"' transport for " << tname <<endlog();*/ return true; }
int UtcDaliConfirmationPopupTypeRegistryCreation(void) { ToolkitTestApplication application; tet_infoline( " UtcDaliConfirmationPopupTypeRegistryCreation" ); TypeInfo typeInfo = TypeRegistry::Get().GetTypeInfo( "ConfirmationPopup" ); DALI_TEST_CHECK( typeInfo ) BaseHandle baseHandle = typeInfo.CreateInstance(); DALI_TEST_CHECK( baseHandle ) Toolkit::Popup popup = Toolkit::Popup::DownCast( baseHandle ); popup.SetProperty( Popup::Property::ANIMATION_DURATION, 0.0f ); Stage::GetCurrent().Add( popup ); popup.SetDisplayState( Toolkit::Popup::SHOWN ); application.SendNotification(); application.Render(); // Check the popup is shown. DALI_TEST_EQUALS( popup.GetDisplayState(), Popup::SHOWN, TEST_LOCATION ); END_TEST; }
Structure::Structure(VM& vm) : JSCell(CreatingEarlyCell) , m_prototype(vm, this, jsNull()) , m_classInfo(info()) , m_transitionWatchpointSet(IsWatched) , m_offset(invalidOffset) , m_inlineCapacity(0) , m_bitField(0) { setDictionaryKind(NoneDictionaryKind); setIsPinnedPropertyTable(false); setHasGetterSetterProperties(m_classInfo->hasStaticSetterOrReadonlyProperties()); setHasCustomGetterSetterProperties(false); setHasReadOnlyOrGetterSetterPropertiesExcludingProto(m_classInfo->hasStaticSetterOrReadonlyProperties()); setHasNonEnumerableProperties(false); setAttributesInPrevious(0); setPreventExtensions(false); setDidTransition(false); setStaticFunctionsReified(false); setHasRareData(false); TypeInfo typeInfo = TypeInfo(CellType, StructureIsImmortal); m_blob = StructureIDBlob(vm.heap.structureIDTable().allocateID(this), 0, typeInfo); m_outOfLineTypeFlags = typeInfo.outOfLineTypeFlags(); ASSERT(hasReadOnlyOrGetterSetterPropertiesExcludingProto() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); ASSERT(hasGetterSetterProperties() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); }
QVector<TypeInfo> Process::getCompletions(const QString &filename, const QByteArray& ustart, const QByteArray& uend) { QStringList args; args << "-f=csv" << "autocomplete" << filename << QString("c") + QString::number(ustart.length()); QProcess p; p.start("gocode", args); if(!p.waitForStarted(TIMEOUT)) return QVector<TypeInfo>(); p.write(ustart); p.write(uend); p.closeWriteChannel(); if(!p.waitForFinished(TIMEOUT)) return QVector<TypeInfo>(); QStringList lines = QString(p.readAllStandardOutput()).split("\n"); QVector<TypeInfo> out; out.reserve(lines.size()); TypeInfo info; for(int i = 0, e = lines.size(); i < e; ++i) if(info.parseString(lines[i])) out.push_back(info); return out; }
Structure::Structure(VM& vm, Structure* previous) : JSCell(vm, vm.structureStructure.get()) , m_prototype(vm, this, previous->storedPrototype()) , m_classInfo(previous->m_classInfo) , m_transitionWatchpointSet(IsWatched) , m_offset(invalidOffset) , m_inlineCapacity(previous->m_inlineCapacity) , m_bitField(0) { setDictionaryKind(previous->dictionaryKind()); setIsPinnedPropertyTable(previous->hasBeenFlattenedBefore()); setHasGetterSetterProperties(previous->hasGetterSetterProperties()); setHasCustomGetterSetterProperties(previous->hasCustomGetterSetterProperties()); setHasReadOnlyOrGetterSetterPropertiesExcludingProto(previous->hasReadOnlyOrGetterSetterPropertiesExcludingProto()); setHasNonEnumerableProperties(previous->hasNonEnumerableProperties()); setAttributesInPrevious(0); setPreventExtensions(previous->preventExtensions()); setDidTransition(true); setStaticFunctionsReified(previous->staticFunctionsReified()); setHasRareData(false); TypeInfo typeInfo = previous->typeInfo(); m_blob = StructureIDBlob(vm.heap.structureIDTable().allocateID(this), previous->indexingTypeIncludingHistory(), typeInfo); m_outOfLineTypeFlags = typeInfo.outOfLineTypeFlags(); ASSERT(!previous->typeInfo().structureIsImmortal()); setPreviousID(vm, previous); previous->didTransitionFromThisStructure(); if (previous->m_globalObject) m_globalObject.set(vm, this, previous->m_globalObject.get()); ASSERT(hasReadOnlyOrGetterSetterPropertiesExcludingProto() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); ASSERT(hasGetterSetterProperties() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); }
int UtcDaliStyleManagerGet(void) { ToolkitTestApplication application; tet_infoline(" UtcDaliStyleManagerGet"); // Register Type TypeInfo type; type = TypeRegistry::Get().GetTypeInfo( "StyleManager" ); DALI_TEST_CHECK( type ); BaseHandle handle = type.CreateInstance(); DALI_TEST_CHECK( handle ); StyleManager manager; manager = StyleManager::Get(); DALI_TEST_CHECK(manager); StyleManager newManager = StyleManager::Get(); DALI_TEST_CHECK(newManager); // Check that focus manager is a singleton DALI_TEST_CHECK(manager == newManager); END_TEST; }
void OutliningMetadataCollector::emitCallToOutlinedCopy( Address dest, Address src, SILType T, const TypeInfo &ti, IsInitialization_t isInit, IsTake_t isTake) const { llvm::SmallVector<llvm::Value *, 4> args; args.push_back(IGF.Builder.CreateElementBitCast(src, ti.getStorageType()) .getAddress()); args.push_back(IGF.Builder.CreateElementBitCast(dest, ti.getStorageType()) .getAddress()); addMetadataArguments(args); llvm::Constant *outlinedFn; if (isInit && isTake) { outlinedFn = IGF.IGM.getOrCreateOutlinedInitializeWithTakeFunction(T, ti, *this); } else if (isInit) { outlinedFn = IGF.IGM.getOrCreateOutlinedInitializeWithCopyFunction(T, ti, *this); } else if (isTake) { outlinedFn = IGF.IGM.getOrCreateOutlinedAssignWithTakeFunction(T, ti, *this); } else { outlinedFn = IGF.IGM.getOrCreateOutlinedAssignWithCopyFunction(T, ti, *this); } llvm::CallInst *call = IGF.Builder.CreateCall(outlinedFn, args); call->setCallingConv(IGF.IGM.DefaultCC); }
/*! Est capable de reconnaitre les templates préfixés par des namespaces, ainsi que ceux déjà identifiés comme des templates par opencxx. */ TypeTemplate* TypeTemplate::IdentifierTypeTemplate (TypeInfo informationType, Environment* environement) { rDebug("TypeTemplate::IdentifierTypeTemplate") ; switch(informationType.WhatIs()) { case TemplateType: { rDebug("whatis dit que c'ets un template") ; TemplateClass* classeTemplate = informationType.TemplateClassMetaobject() ; Base::Composition<TypeTemplate> resultat(new TypeTemplate(classeTemplate)) ; // arguments int nombreArguments = 0 ; TypeInfo typeArgument ; while(informationType.NthTemplateArgument(nombreArguments++,typeArgument)) { if (typeArgument.WhatIs() == UndefType) { rDebug("parametre n'a pas de type") ; } else resultat->_parametres.AjouterEnQueue(Type::Construire(typeArgument, environement)) ; } return resultat.Liberer() ; break ; } default: rDebug("whatis dit que c'ets autre chose") ; return NULL ; } }
TypeInfo *Interpreter::type_info( const Expr &type ) { auto iter = type_info_map.find( type ); ASSERT( iter != type_info_map.end(), "not a registered type var" ); TypeInfo *res = iter->second; res->parse_if_necessary(); return res; }
Owned<void> DynamicNew(const TypeInfo& type, DynamicInitializer) { if (!type.is_dynamically_constructible()) { return nullptr; } // Construct object return AllocateDynamicNew(type, type.get_dynamic_constructor()); }
Owned<void> DynamicNew(const TypeInfo& type) { if (!type.is_default_constructible() || !type.is_destructible()) { return nullptr; } // Construct object return AllocateDynamicNew(type, type.get_default_constructor()); }
// Properly working breakpoints on windows with msvc10 and cdb inside static-function-inside-class-inside-function? // Qt-Creator: "No, not heard." static void* Helper(rapidjson::Document::ValueType* document, char *nextName) { bool isObject = document->IsObject(); TypeInfo *typeInfo = TypeInfo::GetTypeInfo(nextName); void *next = typeInfo->New(); for (rapidjson::Document::ValueType::MemberIterator i = document->MemberBegin(); i != document->MemberEnd(); ++i) { std::string propertyName = i->name.GetString(); PropertyInfo *prop = typeInfo->FindProperty(propertyName); if (i->value.IsObject()) { prop->SetValue(next, Helper(&(i->value), prop->TypeName())); } else if( i->value.IsArray()) { for (int j = 0; j < i->value.Size(); j++) { TypeInfo *tempTypeInfo = TypeInfo::GetTypeInfo(prop->TypeName()); void *temp = tempTypeInfo->New(); tempTypeInfo->SetString(temp, i->value[j].GetString()); prop->PushValue(next, temp); delete temp; } } else { TypeInfo *tempTypeInfo = TypeInfo::GetTypeInfo(prop->TypeName()); void *temp = tempTypeInfo->New(); tempTypeInfo->SetString(temp, i->value.GetString()); prop->SetValue(next, temp); delete temp; } } return next; }
bool Object::inherits(const char* cls) const { TypeInfo* typeinfo = getTypeInfo(); for (; typeinfo; typeinfo=typeinfo->getBaseTypeInfo()) { if (Strequ(cls, typeinfo->getTypeName())) { return true; } } return false; }
// --------------------------------------------------------------------------- TypeInfo TypeInfo::combine(const TypeInfo &__lhs, const TypeInfo &__rhs) { TypeInfo __result = __lhs; __result.setConstant(__result.isConstant() || __rhs.isConstant()); __result.setVolatile(__result.isVolatile() || __rhs.isVolatile()); __result.setReference(__result.isReference() || __rhs.isReference()); __result.setIndirections(__result.indirections() + __rhs.indirections()); __result.setArrayElements(__result.arrayElements() + __rhs.arrayElements()); return __result; }
void flatten_tree (TypeInfo const& ti, TypeInfoSet& set) { set.insert (ti); for (TypeInfo::BaseIterator i = ti.begin_base (); i != ti.end_base (); i++) { flatten_tree (i->type_info (), set); } }
Object *ObjectTypeDB::instance(const String &p_type) { TypeInfo *ti; { OBJTYPE_LOCK; ti=types.getptr(p_type); ERR_FAIL_COND_V(!ti,NULL); ERR_FAIL_COND_V(ti->disabled,NULL); ERR_FAIL_COND_V(!ti->creation_func,NULL); } return ti->creation_func(); }
DebugTypeInfo DebugTypeInfo::getFromTypeInfo(DeclContext *DC, swift::Type Ty, const TypeInfo &Info) { Size size; if (Info.isFixedSize()) { const FixedTypeInfo &FixTy = *cast<const FixedTypeInfo>(&Info); size = FixTy.getFixedSize(); } else { // FIXME: Handle NonFixedTypeInfo here or assert that we won't // encounter one. size = Size(0); } return DebugTypeInfo(DC, Ty.getPointer(), Info.getStorageType(), size, Info.getBestKnownAlignment()); }
/* Understands how to read the inside of an object and find all references * located within. It copies the objects pointed to, but does not follow into * those further (ie, not recursive) */ void visit_object(Object* obj) { if(obj->klass() && obj->klass()->reference_p()) { call(obj->klass()); } if(obj->ivars() && obj->ivars()->reference_p()) { call(obj->ivars()); } TypeInfo* ti = object_memory_->type_info[obj->type_id()]; assert(ti); ti->visit(obj, *this); }
Entity* View::createEntity(const RootEntity& gent) { TypeInfo* type = getConnection()->getTypeService()->getTypeForAtlas(gent); assert(type->isBound()); FactoryStore::const_iterator F = m_factories.begin(); for (; F != m_factories.end(); ++F) { if ((*F)->accept(gent, type)) { return (*F)->instantiate(gent, type, this); } } return new ViewEntity(gent->getId(), type, this); }
inline js_type_class_t *js_get_type_from_native(T* native_obj) { js_type_class_t *typeProxy; long typeId = reinterpret_cast<long>(typeid(*native_obj).name()); HASH_FIND_INT(_js_global_type_ht, &typeId, typeProxy); if (!typeProxy) { TypeInfo *typeInfo = dynamic_cast<TypeInfo *>(native_obj); if (typeInfo) { typeId = typeInfo->getClassTypeInfo(); } else { typeId = reinterpret_cast<long>(typeid(T).name()); } HASH_FIND_INT(_js_global_type_ht, &typeId, typeProxy); } return typeProxy; }
void TestRepository::registerTest(const TypeInfo& typeInfo, const std::shared_ptr< ILatencyTest >& testInstance) { LatencyTestInfo info{ typeInfo.name(), testInstance }; m_latencyTestInfosByName.insert(std::make_pair(boost::algorithm::to_lower_copy(typeInfo.fullyQualifiedName()), info)); m_latencyTestInfosByName.insert(std::make_pair(boost::algorithm::to_lower_copy(typeInfo.name()), info)); }
Structure::Structure(VM& vm, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo, IndexingType indexingType, unsigned inlineCapacity) : JSCell(vm, vm.structureStructure.get()) , m_blob(vm.heap.structureIDTable().allocateID(this), indexingType, typeInfo) , m_outOfLineTypeFlags(typeInfo.outOfLineTypeFlags()) , m_globalObject(vm, this, globalObject, WriteBarrier<JSGlobalObject>::MayBeNull) , m_prototype(vm, this, prototype) , m_classInfo(classInfo) , m_transitionWatchpointSet(IsWatched) , m_offset(invalidOffset) , m_inlineCapacity(inlineCapacity) , m_bitField(0) { setDictionaryKind(NoneDictionaryKind); setIsPinnedPropertyTable(false); setHasGetterSetterProperties(classInfo->hasStaticSetterOrReadonlyProperties()); setHasCustomGetterSetterProperties(false); setHasReadOnlyOrGetterSetterPropertiesExcludingProto(classInfo->hasStaticSetterOrReadonlyProperties()); setHasNonEnumerableProperties(false); setAttributesInPrevious(0); setPreventExtensions(false); setDidTransition(false); setStaticFunctionsReified(false); setHasRareData(false); ASSERT(inlineCapacity <= JSFinalObject::maxInlineCapacity()); ASSERT(static_cast<PropertyOffset>(inlineCapacity) < firstOutOfLineOffset); ASSERT(!hasRareData()); ASSERT(hasReadOnlyOrGetterSetterPropertiesExcludingProto() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); ASSERT(hasGetterSetterProperties() || !m_classInfo->hasStaticSetterOrReadonlyProperties()); }
Structure::Structure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo, IndexingType indexingType, unsigned inlineCapacity) : JSCell(globalData, globalData.structureStructure.get()) , m_globalObject(globalData, this, globalObject, WriteBarrier<JSGlobalObject>::MayBeNull) , m_prototype(globalData, this, prototype) , m_classInfo(classInfo) , m_transitionWatchpointSet(InitializedWatching) , m_offset(invalidOffset) , m_typeInfo(typeInfo) , m_indexingType(indexingType) , m_inlineCapacity(inlineCapacity) , m_dictionaryKind(NoneDictionaryKind) , m_isPinnedPropertyTable(false) , m_hasGetterSetterProperties(false) , m_hasReadOnlyOrGetterSetterPropertiesExcludingProto(false) , m_hasNonEnumerableProperties(false) , m_attributesInPrevious(0) , m_specificFunctionThrashCount(0) , m_preventExtensions(false) , m_didTransition(false) , m_staticFunctionReified(false) { ASSERT(inlineCapacity <= JSFinalObject::maxInlineCapacity()); ASSERT(static_cast<PropertyOffset>(inlineCapacity) < firstOutOfLineOffset); ASSERT(!typeInfo.structureHasRareData()); }
TypeInfo registerOrGetType(const char* name, const TypeInfo& rawTypeInfo, const std::vector<TypeInfo>& baseClassList) { TypeInfoData& data = TypeInfoData::instance(); { NameToTag::const_iterator itr = data.nameToTagMap.find(name); if (itr != data.nameToTagMap.end()) return TypeInfo(itr->second); } const pair<NameToTag::iterator,bool> ret = data.nameToTagMap.insert(make_pair(name, ++data.globalIDCounter)); if (ret.second) { g_nameList[data.globalIDCounter] = name; const TypeInfo::TypeId rawId = ((rawTypeInfo.getId() == 0) ? data.globalIDCounter : rawTypeInfo.getId()); g_rawTypeList[data.globalIDCounter] = rawId; const int row = RTTR_MAX_INHERIT_TYPES_COUNT * rawId; int index = 0; // to do remove double entries for (std::vector<TypeInfo>::const_iterator itr = baseClassList.begin(); itr != baseClassList.end(); ++itr, ++index) { g_inheritList[row + index] = (*itr).getId(); } } // else cannot happen! return TypeInfo(ret.first->second); }
Structure::Structure(JSValue prototype, const TypeInfo& typeInfo, unsigned anonymousSlotCount) : m_typeInfo(typeInfo) , m_prototype(prototype) , m_specificValueInPrevious(0) , m_propertyTable(0) , m_propertyStorageCapacity(typeInfo.isFinal() ? JSFinalObject_inlineStorageCapacity : JSNonFinalObject_inlineStorageCapacity) , m_offset(noOffset) , m_dictionaryKind(NoneDictionaryKind) , m_isPinnedPropertyTable(false) , m_hasGetterSetterProperties(false) , m_hasNonEnumerableProperties(false) , m_attributesInPrevious(0) , m_specificFunctionThrashCount(0) , m_anonymousSlotCount(anonymousSlotCount) , m_isUsingSingleSlot(true) { m_transitions.m_singleTransition = 0; ASSERT(m_prototype); ASSERT(m_prototype->isObject() || m_prototype->isNull()); #ifndef NDEBUG #if ENABLE(JSC_MULTIPLE_THREADS) MutexLocker protect(ignoreSetMutex); #endif if (shouldIgnoreLeaks) ignoreSet.add(this); else structureCounter.increment(); #endif #if DUMP_STRUCTURE_ID_STATISTICS liveStructureSet.add(this); #endif }
void add_ptr_convs(TypeIndex index) { TypeInfo bare = index.get_info().class_type(); //add_conv_track<void>(bare); //add_conv_track<void const>(bare.as_const_value()); auto bottom_ptr_type = create_type_mirror("BottomPtr", size_t(0), create_bottom_ptr_type_index(), type_system->global_namespace().get_class_type()); type_system->add_class(create_bottom_ptr_type_index(), bottom_ptr_type, type_system->global_namespace()); // allow unsafe_ptr_cast to convert to any type and nil (NULL) to any pointer type add_nochange_conv(create_bottom_ptr_type_info(), bare.as_ptr_to_nonconst(), "bottom ptr unsafe cast to any ptr"); add_nochange_conv(create_bottom_ptr_type_info(), bare.as_ptr_to_const(), "bottom ptr unsafe cast to any const ptr"); // allow any ptr to be converted to void* or void const* add_nochange_conv(bare.as_ptr_to_nonconst(), TypId<void*>::restricted().get_info(), "any ptr to void ptr"); add_nochange_conv(bare.as_ptr_to_const(), TypId<void const*>::restricted().get_info(), "any ptr to const void ptr"); }