BOOL JavascriptBoolean::GetDiagValueString(StringBuilder<ArenaAllocator>* stringBuilder, ScriptContext* requestContext) { if (this->GetValue()) { JavascriptString* trueDisplayString = GetLibrary()->GetTrueDisplayString(); stringBuilder->Append(trueDisplayString->GetString(), trueDisplayString->GetLength()); } else { JavascriptString* falseDisplayString = GetLibrary()->GetFalseDisplayString(); stringBuilder->Append(falseDisplayString->GetString(), falseDisplayString->GetLength()); } return TRUE; }
void CProjectWizardData::UseDefaultLibraries () { int i; for (i = 0; i < GetLibraryCount (); ++i) UseLibrary (i, (GetLibrary (i)->GetSubSystemDefault () & m_subSystems) != 0); }
void Library::Finalize(JSContext* cx, JSObject* obj) { // unload the library PRLibrary* library = GetLibrary(cx, obj); if (library) PR_UnloadLibrary(library); }
Var ES5ArrayEnumerator::GetCurrentValue() { if (!doneArray && index != JavascriptArray::InvalidIndex) { Var element; if (arrayObject->GetItem(originalInstance, index, &element, GetScriptContext())) { return element; } return GetLibrary()->GetUndefined(); } else if (!doneObject) { return objectEnumerator->GetCurrentValue(); } return GetLibrary()->GetUndefined(); }
nsresult sbLocalDatabaseMediaListBase::GetFilteredPropertiesForNewItem(sbIPropertyArray* aProperties, sbIPropertyArray** _retval) { NS_ASSERTION(aProperties, "aProperties is null"); NS_ASSERTION(_retval, "_retval is null"); nsresult rv; nsCOMPtr<sbIMutablePropertyArray> mutableArray = do_CreateInstance(SB_MUTABLEPROPERTYARRAY_CONTRACTID, &rv); NS_ENSURE_SUCCESS(rv, rv); nsCOMPtr<sbILibrary> library; rv = GetLibrary(getter_AddRefs(library)); NS_ENSURE_SUCCESS(rv, rv); PRBool hasContentType = PR_FALSE; PRUint32 length; rv = aProperties->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); for (PRUint32 i = 0; i < length; i++) { nsCOMPtr<sbIProperty> property; rv = aProperties->GetPropertyAt(i, getter_AddRefs(property)); NS_ENSURE_SUCCESS(rv, rv); nsString id; rv = property->GetId(id); NS_ENSURE_SUCCESS(rv, rv); // We never want these properties to be copied to a new item. if (mFilteredProperties.GetEntry(id)) { continue; } nsString value; rv = property->GetValue(value); NS_ENSURE_SUCCESS(rv, rv); rv = mutableArray->AppendProperty(id, value); NS_ENSURE_SUCCESS(rv, rv); if (id.EqualsLiteral(SB_PROPERTY_CONTENTTYPE)) { hasContentType = PR_TRUE; } } if (!hasContentType) { // no content type given; assume audio rv = mutableArray->AppendProperty(NS_LITERAL_STRING(SB_PROPERTY_CONTENTTYPE), NS_LITERAL_STRING("audio")); } NS_ADDREF(*_retval = mutableArray); return NS_OK; }
CStdString OfflineDocIDResolver::GetOnlineLibrary( const CStdString& sDocID, const CStdString &sOfflineLibrary) const { CStdString sOfflineLib = _T("_") + sOfflineLibrary; CStdString sLib = GetLibrary(sDocID); sLib.MakeLower(); sOfflineLib.MakeLower(); sLib.Replace(sOfflineLib, _T("")); return sLib; }
Var ModuleNamespace::GetNextProperty(BigPropertyIndex& index) { PropertyId propertyId; Var result = GetLibrary()->GetUndefined(); BOOL retVal = FALSE; if (this->FindNextProperty(index, nullptr, &propertyId, nullptr)) { retVal = this->GetProperty(this, propertyId, &result, nullptr, GetScriptContext()); Assert(retVal); } return result; }
JavascriptString* BoundFunction::GetDisplayNameImpl() const { JavascriptString* displayName = GetLibrary()->GetEmptyString(); if (targetFunction != nullptr) { Var value = JavascriptOperators::GetProperty(targetFunction, PropertyIds::name, targetFunction->GetScriptContext()); if (JavascriptString::Is(value)) { displayName = JavascriptString::FromVar(value); } } return LiteralString::Concat(LiteralString::NewCopySz(_u("bound "), this->GetScriptContext()), displayName); }
void ColladaObject::GetProgramElement(VECPROGRAMELEM& vecProgram) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_PROGRAM ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecProgram.push_back( (ProgramElement*)(*it)->GetElement( i ) ); } } }
void ColladaObject::GetMaterialElement(VECMATERIALELEM& vecMaterial) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_MATERIAL ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecMaterial.push_back( (MaterialElement*)(*it)->GetElement( i ) ); } } }
void ColladaObject::GetLightElement(VECLIGHTELEM& vecLight) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_LIGHT ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecLight.push_back( (LightElement*)(*it)->GetElement( i ) ); } } }
void ColladaObject::GetControllerElement(VECCONTROLLERELEM& vecController) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_CONTROLLER ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecController.push_back( (ControllerElement*)(*it)->GetElement( i ) ); } } }
void ColladaObject::GetAnimationElement(VECANIMATIONELEM& vecAnimation) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_ANIMATION ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecAnimation.push_back( (AnimationElement*)(*it)->GetElement( i ) ); } } }
Var ES5ArrayEnumerator::GetCurrentIndex() { if (!doneArray && index != JavascriptArray::InvalidIndex) { return arrayObject->GetScriptContext()->GetIntegerString(index); } else if (!doneObject) { return objectEnumerator->GetCurrentIndex(); } return GetLibrary()->GetUndefined(); }
void ColladaObject::GetTextureElement(VECTEXTUREELEM& vecTexture) const { VECLIBRARYELEM vecLib; GetLibrary( vecLib, LibraryElement::TYPE_TEXTURE ); for( VECLIBRARYELEM::const_iterator it = vecLib.begin(); it != vecLib.end(); ++it ) { for( unsigned int i = 0; i < (*it)->GetCount(); i++ ) { vecTexture.push_back( (TextureElement*)(*it)->GetElement( i ) ); } } }
JavascriptStringObject::JavascriptStringObject(JavascriptString* value, DynamicType * type) : DynamicObject(type), value(value) { Assert(type->GetTypeId() == TypeIds_StringObject); this->GetTypeHandler()->ClearHasOnlyWritableDataProperties(); // length is non-writable if(GetTypeHandler()->GetFlags() & DynamicTypeHandler::IsPrototypeFlag) { // No need to invalidate store field caches for non-writable properties here. Since this type is just being created, it cannot represent // an object that is already a prototype. If it becomes a prototype and then we attempt to add a property to an object derived from this // object, then we will check if this property is writable, and only if it is will we do the fast path for add property. GetLibrary()->GetTypesWithOnlyWritablePropertyProtoChainCache()->Clear(); } }
BOOL RecyclableObject::GetDiagValueString(StringBuilder<ArenaAllocator>* stringBuilder, ScriptContext* requestContext) { ENTER_PINNED_SCOPE(JavascriptString, valueStr); ScriptContext *scriptContext = GetScriptContext(); switch(GetTypeId()) { case TypeIds_Undefined: valueStr = GetLibrary()->GetUndefinedDisplayString(); break; case TypeIds_Null: valueStr = GetLibrary()->GetNullDisplayString(); break; case TypeIds_Integer: valueStr = scriptContext->GetIntegerString(this); break; case TypeIds_Boolean: valueStr = JavascriptBoolean::FromVar(this)->GetValue() ? GetLibrary()->GetTrueDisplayString() : GetLibrary()->GetFalseDisplayString(); break; case TypeIds_Number: valueStr = JavascriptNumber::ToStringRadix10(JavascriptNumber::GetValue(this), scriptContext); break; case TypeIds_String: valueStr = JavascriptString::FromVar(this); break; default: valueStr = GetLibrary()->GetUndefinedDisplayString(); } stringBuilder->Append(valueStr->GetString(), valueStr->GetLength()); LEAVE_PINNED_SCOPE(); return TRUE; }
bool JniInvocation::Init(const char* library) { #ifdef __ANDROID__ char buffer[PROPERTY_VALUE_MAX]; #else char* buffer = NULL; #endif library = GetLibrary(library, buffer); handle_ = dlopen(library, RTLD_NOW); if (handle_ == NULL) { if (strcmp(library, kLibraryFallback) == 0) { // Nothing else to try. ALOGE("Failed to dlopen %s: %s", library, dlerror()); return false; } // Note that this is enough to get something like the zygote // running, we can't property_set here to fix this for the future // because we are root and not the system user. See // RuntimeInit.commonInit for where we fix up the property to // avoid future fallbacks. http://b/11463182 ALOGW("Falling back from %s to %s after dlopen error: %s", library, kLibraryFallback, dlerror()); library = kLibraryFallback; handle_ = dlopen(library, RTLD_NOW); if (handle_ == NULL) { ALOGE("Failed to dlopen %s: %s", library, dlerror()); return false; } } if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetDefaultJavaVMInitArgs_), "JNI_GetDefaultJavaVMInitArgs")) { return false; } if (!FindSymbol(reinterpret_cast<void**>(&JNI_CreateJavaVM_), "JNI_CreateJavaVM")) { return false; } if (!FindSymbol(reinterpret_cast<void**>(&JNI_GetCreatedJavaVMs_), "JNI_GetCreatedJavaVMs")) { return false; } return true; }
// enumeration order: symbol first; local exports next; nonlocal exports last. Var ModuleNamespaceEnumerator::MoveAndGetNext(PropertyId& propertyId, PropertyAttributes* attributes) { Var undefined = GetLibrary()->GetUndefined(); Var result = undefined; if (attributes != nullptr) { // all the attribute should have the same setting here in namespace object. *attributes = PropertyModuleNamespaceDefault; } if (!doneWithSymbol) { result = symbolEnumerator.MoveAndGetNext(propertyId, attributes); if (result == nullptr) { doneWithSymbol = true; } else { return result; } } if (!this->doneWithLocalExports) { currentLocalMapIndex++; JavascriptString* propertyString = nullptr; if (!nsObject->FindNextProperty(currentLocalMapIndex, &propertyString, &propertyId, attributes, this->GetScriptContext())) { // we are done with the object part; this->doneWithLocalExports = true; } else { return propertyString; } } if (this->nonLocalMap != nullptr && (currentNonLocalMapIndex + 1 < nonLocalMap->Count())) { currentNonLocalMapIndex++; result = this->GetScriptContext()->GetPropertyString(this->nonLocalMap->GetKeyAt(currentNonLocalMapIndex)); return result; } return nullptr; }
STDAPI GetRealProcAddress(LPCSTR pwszProcName, VOID** ppv) { if(!ppv) { return E_POINTER; } HMODULE hLib = GetLibrary(LIB_mscorwks); if(hLib == NULL) { return HRESULT_FROM_GetLastError(); } *ppv = (void*) GetProcAddress(hLib,pwszProcName); if(*ppv == NULL) { return HRESULT_FROM_GetLastError(); } return S_OK; }
ISystemModule *SystemWrapper::GetModule(char *interfacename, char *library, char *instancename) { ISystemModule *module = FindModule(interfacename, instancename); if (module) { return module; } library_t *lib = GetLibrary(library); if (!lib) { return nullptr; } module = (ISystemModule *)lib->createInterfaceFn(interfacename, nullptr); if (!module) { DPrintf("ERROR! System::GetModule: interface \"%s\" not found in library %s.\n", interfacename, lib->name); return nullptr; } AddModule(module, instancename); return module; }
CStdString OfflineDocIDResolver::ResolveToOfflineDocID(const CStdString &sDocID) const { CStdString sDocNum = GetDocNum( sDocID ); CStdString sVersion = GetVersion( sDocID ); CStdString sLibrary = GetLibrary( sDocID ); CStdString sOfflineDocNum; CStdString sOfflineLibrary; if(!GetOfflineDocumentInfo(GetLibraryToSearch(sDocID), sDocNum, sOfflineDocNum, sOfflineLibrary)) return sDocID; CStdString sNewDocID(_T("powerdocs://")); sNewDocID += sLibrary; sNewDocID += _T("_"); sNewDocID += sOfflineLibrary; sNewDocID += _T("/") + sOfflineDocNum; sNewDocID += _T("/") + sVersion; return sNewDocID; }
void ModuleNamespace::Initialize() { ScriptContext* scriptContext = moduleRecord->GetRealm()->GetScriptContext(); Recycler* recycler = scriptContext->GetRecycler(); SourceTextModuleRecord* sourceTextModuleRecord = static_cast<SourceTextModuleRecord*>(moduleRecord); JavascriptLibrary* library = GetLibrary(); if (scriptContext->GetConfig()->IsES6ToStringTagEnabled()) { DynamicObject::SetPropertyWithAttributes(PropertyIds::_symbolToStringTag, library->GetModuleTypeDisplayString(), PropertyConfigurable, nullptr); } DynamicType* type = library->CreateFunctionWithLengthType(&EntryInfo::SymbolIterator); RuntimeFunction* iteratorFunction = RecyclerNewEnumClass(scriptContext->GetRecycler(), library->EnumFunctionClass, RuntimeFunction, type, &EntryInfo::SymbolIterator); DynamicObject::SetPropertyWithAttributes(PropertyIds::_symbolIterator, iteratorFunction, PropertyBuiltInMethodDefaults, nullptr); ModuleImportOrExportEntryList* localExportList = sourceTextModuleRecord->GetLocalExportEntryList(); // We don't have a type handler that can handle ModuleNamespace object. We have properties that could be aliased // like {export foo as foo1, foo2, foo3}, and external properties as reexport from current module. The problem with aliasing // is that multiple propertyId can be associated with one slotIndex. We need to build from PropertyMap directly here. // there is one instance of ModuleNamespace per module file; we can always use the BigPropertyIndex for security. propertyMap = RecyclerNew(recycler, SimplePropertyDescriptorMap, recycler, sourceTextModuleRecord->GetLocalExportCount()); if (localExportList != nullptr) { localExportList->Map([=](ModuleImportOrExportEntry exportEntry) { PropertyId exportNameId = exportEntry.exportName->GetPropertyId(); PropertyId localNameId = exportEntry.localName->GetPropertyId(); const Js::PropertyRecord* exportNameRecord = scriptContext->GetThreadContext()->GetPropertyName(exportNameId); ModuleNameRecord* importRecord = nullptr; AssertMsg(exportNameId != Js::Constants::NoProperty, "should have been initialized already"); // ignore local exports that are actually indirect exports. if (sourceTextModuleRecord->GetImportEntryList() == nullptr || (sourceTextModuleRecord->ResolveImport(localNameId, &importRecord) && importRecord == nullptr)) { BigPropertyIndex index = sourceTextModuleRecord->GetLocalExportSlotIndexByExportName(exportNameId); Assert((uint)index < sourceTextModuleRecord->GetLocalExportCount()); SimpleDictionaryPropertyDescriptor<BigPropertyIndex> propertyDescriptor = { index, PropertyModuleNamespaceDefault }; propertyMap->Add(exportNameRecord, propertyDescriptor); } }); } // update the local slot to use the storage for local exports. SetNSSlotsForModuleNS(sourceTextModuleRecord->GetLocalExportSlots()); // For items that are not in the local export list, we need to resolve them to get it ExportedNames* exportedNames = sourceTextModuleRecord->GetExportedNames(nullptr); ModuleNameRecord* moduleNameRecord = nullptr; #if DBG uint unresolvableExportsCount = 0; uint localExportCount = 0; #endif if (exportedNames != nullptr) { exportedNames->Map([&](PropertyId propertyId) { if (!moduleRecord->ResolveExport(propertyId, nullptr, nullptr, &moduleNameRecord)) { // ignore ambigious resolution. #if DBG unresolvableExportsCount++; #endif return; } // non-ambiguous resolution. if (moduleNameRecord == nullptr) { JavascriptError::ThrowSyntaxError(scriptContext, JSERR_ResolveExportFailed, scriptContext->GetPropertyName(propertyId)->GetBuffer()); } if (moduleNameRecord->module == moduleRecord) { // skip local exports as they are covered in the localExportSlots. #if DBG localExportCount++; #endif return; } Assert(moduleNameRecord->module != moduleRecord); this->AddUnambiguousNonLocalExport(propertyId, moduleNameRecord); }); } #if DBG uint totalExportCount = exportedNames != nullptr ? exportedNames->Count() : 0; uint unambiguousNonLocalCount = (this->GetUnambiguousNonLocalExports() != nullptr) ? this->GetUnambiguousNonLocalExports()->Count() : 0; Assert(totalExportCount == localExportCount + unambiguousNonLocalCount + unresolvableExportsCount); #endif BOOL result = this->PreventExtensions(); Assert(result); }
Recycler * Type::GetRecycler() const { return GetLibrary()->GetRecycler(); }
ScriptContext * Type::GetScriptContext() const { return GetLibrary()->GetScriptContext(); }
PolymorphicInlineCache * PropertyString::CreateBiggerPolymorphicInlineCache(bool isLdElem) { PolymorphicInlineCache * polymorphicInlineCache = isLdElem ? GetLdElemInlineCache() : GetStElemInlineCache(); Assert(polymorphicInlineCache && polymorphicInlineCache->CanAllocateBigger()); uint16 polymorphicInlineCacheSize = polymorphicInlineCache->GetSize(); uint16 newPolymorphicInlineCacheSize = PolymorphicInlineCache::GetNextSize(polymorphicInlineCacheSize); Assert(newPolymorphicInlineCacheSize > polymorphicInlineCacheSize); PolymorphicInlineCache * newPolymorphicInlineCache = ScriptContextPolymorphicInlineCache::New(newPolymorphicInlineCacheSize, GetLibrary()); polymorphicInlineCache->CopyTo(this->propertyRecord->GetPropertyId(), GetScriptContext(), newPolymorphicInlineCache); if (isLdElem) { this->ldElemInlineCache = newPolymorphicInlineCache; } else { this->stElemInlineCache = newPolymorphicInlineCache; } #ifdef ENABLE_DEBUG_CONFIG_OPTIONS if (PHASE_VERBOSE_TRACE1(Js::PolymorphicInlineCachePhase) || PHASE_TRACE1(PropertyStringCachePhase)) { Output::Print(_u("PropertyString '%s' : Bigger PIC, oldSize = %d, newSize = %d\n"), GetString(), polymorphicInlineCacheSize, newPolymorphicInlineCacheSize); } #endif return newPolymorphicInlineCache; }
void CProjectWizardData::UseLibrary (int i, bool bUse) { GetLibrary (i)->SetSelectFlag (bUse); }
JSBool Library::Declare(JSContext* cx, uintN argc, jsval* vp) { JSObject* obj = JS_THIS_OBJECT(cx, vp); if (!obj || !IsLibrary(cx, obj)) { JS_ReportError(cx, "not a library"); return JS_FALSE; } PRLibrary* library = GetLibrary(cx, obj); if (!library) { JS_ReportError(cx, "library not open"); return JS_FALSE; } // We allow two API variants: // 1) library.declare(name, abi, returnType, argType1, ...) // declares a function with the given properties, and resolves the symbol // address in the library. // 2) library.declare(name, type) // declares a symbol of 'type', and resolves it. The object that comes // back will be of type 'type', and will point into the symbol data. // This data will be both readable and writable via the usual CData // accessors. If 'type' is a PointerType to a FunctionType, the result will // be a function pointer, as with 1). if (argc < 2) { JS_ReportError(cx, "declare requires at least two arguments"); return JS_FALSE; } jsval* argv = JS_ARGV(cx, vp); if (!JSVAL_IS_STRING(argv[0])) { JS_ReportError(cx, "first argument must be a string"); return JS_FALSE; } JSObject* fnObj = NULL; JSObject* typeObj; js::AutoObjectRooter root(cx); bool isFunction = argc > 2; if (isFunction) { // Case 1). // Create a FunctionType representing the function. fnObj = FunctionType::CreateInternal(cx, argv[1], argv[2], &argv[3], argc - 3); if (!fnObj) return JS_FALSE; root.setObject(fnObj); // Make a function pointer type. typeObj = PointerType::CreateInternal(cx, fnObj); if (!typeObj) return JS_FALSE; root.setObject(typeObj); } else { // Case 2). if (JSVAL_IS_PRIMITIVE(argv[1]) || !CType::IsCType(cx, JSVAL_TO_OBJECT(argv[1])) || !CType::IsSizeDefined(cx, JSVAL_TO_OBJECT(argv[1]))) { JS_ReportError(cx, "second argument must be a type of defined size"); return JS_FALSE; } typeObj = JSVAL_TO_OBJECT(argv[1]); if (CType::GetTypeCode(cx, typeObj) == TYPE_pointer) { fnObj = PointerType::GetBaseType(cx, typeObj); isFunction = fnObj && CType::GetTypeCode(cx, fnObj) == TYPE_function; } } void* data; PRFuncPtr fnptr; JSString* nameStr = JSVAL_TO_STRING(argv[0]); AutoCString symbol; if (isFunction) { // Build the symbol, with mangling if necessary. FunctionType::BuildSymbolName(cx, nameStr, fnObj, symbol); AppendString(symbol, "\0"); // Look up the function symbol. fnptr = PR_FindFunctionSymbol(library, symbol.begin()); if (!fnptr) { JS_ReportError(cx, "couldn't find function symbol in library"); return JS_FALSE; } data = &fnptr; } else { // 'typeObj' is another data type. Look up the data symbol. AppendString(symbol, nameStr); AppendString(symbol, "\0"); data = PR_FindSymbol(library, symbol.begin()); if (!data) { JS_ReportError(cx, "couldn't find symbol in library"); return JS_FALSE; } } JSObject* result = CData::Create(cx, typeObj, obj, data, isFunction); if (!result) return JS_FALSE; JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(result)); // Seal the CData object, to prevent modification of the function pointer. // This permanently associates this object with the library, and avoids // having to do things like reset SLOT_REFERENT when someone tries to // change the pointer value. // XXX This will need to change when bug 541212 is fixed -- CData::ValueSetter // could be called on a sealed object. if (isFunction && !JS_FreezeObject(cx, result)) return JS_FALSE; return JS_TRUE; }
bool Library::Declare(JSContext* cx, unsigned argc, Value* vp) { CallArgs args = CallArgsFromVp(argc, vp); RootedObject obj(cx, JS_THIS_OBJECT(cx, vp)); if (!obj) return false; if (!IsLibrary(obj)) { JS_ReportErrorASCII(cx, "not a library"); return false; } PRLibrary* library = GetLibrary(obj); if (!library) { JS_ReportErrorASCII(cx, "library not open"); return false; } // We allow two API variants: // 1) library.declare(name, abi, returnType, argType1, ...) // declares a function with the given properties, and resolves the symbol // address in the library. // 2) library.declare(name, type) // declares a symbol of 'type', and resolves it. The object that comes // back will be of type 'type', and will point into the symbol data. // This data will be both readable and writable via the usual CData // accessors. If 'type' is a PointerType to a FunctionType, the result will // be a function pointer, as with 1). if (args.length() < 2) { JS_ReportErrorASCII(cx, "declare requires at least two arguments"); return false; } if (!args[0].isString()) { JS_ReportErrorASCII(cx, "first argument must be a string"); return false; } RootedObject fnObj(cx, nullptr); RootedObject typeObj(cx); bool isFunction = args.length() > 2; if (isFunction) { // Case 1). // Create a FunctionType representing the function. fnObj = FunctionType::CreateInternal(cx, args[1], args[2], HandleValueArray::subarray(args, 3, args.length() - 3)); if (!fnObj) return false; // Make a function pointer type. typeObj = PointerType::CreateInternal(cx, fnObj); if (!typeObj) return false; } else { // Case 2). if (args[1].isPrimitive() || !CType::IsCType(args[1].toObjectOrNull()) || !CType::IsSizeDefined(args[1].toObjectOrNull())) { JS_ReportErrorASCII(cx, "second argument must be a type of defined size"); return false; } typeObj = args[1].toObjectOrNull(); if (CType::GetTypeCode(typeObj) == TYPE_pointer) { fnObj = PointerType::GetBaseType(typeObj); isFunction = fnObj && CType::GetTypeCode(fnObj) == TYPE_function; } } void* data; PRFuncPtr fnptr; RootedString nameStr(cx, args[0].toString()); AutoCString symbol; if (isFunction) { // Build the symbol, with mangling if necessary. FunctionType::BuildSymbolName(nameStr, fnObj, symbol); AppendString(symbol, "\0"); // Look up the function symbol. fnptr = PR_FindFunctionSymbol(library, symbol.begin()); if (!fnptr) { JS_ReportErrorASCII(cx, "couldn't find function symbol in library"); return false; } data = &fnptr; } else { // 'typeObj' is another data type. Look up the data symbol. AppendString(symbol, nameStr); AppendString(symbol, "\0"); data = PR_FindSymbol(library, symbol.begin()); if (!data) { JS_ReportErrorASCII(cx, "couldn't find symbol in library"); return false; } } RootedObject result(cx, CData::Create(cx, typeObj, obj, data, isFunction)); if (!result) return false; if (isFunction) JS_SetReservedSlot(result, SLOT_FUNNAME, StringValue(nameStr)); args.rval().setObject(*result); // Seal the CData object, to prevent modification of the function pointer. // This permanently associates this object with the library, and avoids // having to do things like reset SLOT_REFERENT when someone tries to // change the pointer value. // XXX This will need to change when bug 541212 is fixed -- CData::ValueSetter // could be called on a sealed object. if (isFunction && !JS_FreezeObject(cx, result)) return false; return true; }
int LibraryDetectionManager::LoadXmlDoc( TiXmlDocument& Doc ) { int loaded = 0; for ( TiXmlElement* Elem = Doc.FirstChildElement("library"); Elem; Elem = Elem->NextSiblingElement("library") ) { // Load the version of this set int version = 0; if ( Elem->QueryIntAttribute( "version", &version ) != TIXML_SUCCESS ) version = 0; // Load shortcode wxString ShortCode = wxString(Elem->Attribute("short_code"),wxConvUTF8); if ( ShortCode.IsEmpty() ) continue; // Load name wxString Name = wxString( Elem->Attribute("name"), wxConvUTF8 ); if ( Name.IsEmpty() ) continue; // Check if we already have setting of this library // I'm to lazy to firbid const_cast here ;) LibraryDetectionConfigSet* OldSet = const_cast< LibraryDetectionConfigSet* > ( GetLibrary( ShortCode ) ); LibraryDetectionConfigSet* NewSet = 0; if ( OldSet ) { // There are detection settings yet, we override only when there's newer // or same version already if ( OldSet->Version > version ) continue; // We do not upgrade OldSet->Categories.Clear(); OldSet->Configurations.clear(); OldSet->LibraryName.Clear(); NewSet = OldSet; } else { NewSet = new LibraryDetectionConfigSet; Libraries.Add( NewSet ); } // Setup configuration set NewSet->ShortCode = ShortCode; NewSet->Version = version; NewSet->LibraryName = Name; // Read categories of library for ( TiXmlAttribute* attr = Elem->FirstAttribute(); attr; attr = attr->Next() ) { // if ( !strncasecmp(attr->Name(),"category",8) ) if ( !strncmp(attr->Name(),"category",8) ) NewSet->Categories.Add( wxString( attr->Value(),wxConvUTF8 ) ); } // Check if there's corresponding pkg-config entry if ( IsPkgConfigEntry(ShortCode) ) { LibraryDetectionConfig Config; Config.PkgConfigVar = ShortCode; Config.Description = NewSet->LibraryName + _T(" (pkg-config)"); LibraryDetectionFilter Filter; Filter.Type = LibraryDetectionFilter::PkgConfig; Filter.Value = ShortCode; Config.Filters.push_back(Filter); loaded += AddConfig(Config,NewSet) ? 1 : 0; } // Load libraries LibraryDetectionConfig Initial; loaded += LoadXml( Elem, Initial, NewSet ); } return loaded; }