bool JSValueIsBoolean(JSContextRef ctx, JSValueRef value) { if (!ctx) { ASSERT_NOT_REACHED(); return false; } ExecState* exec = toJS(ctx); JSLockHolder locker(exec); JSValue jsValue = toJS(exec, value); return jsValue.isBoolean(); }
static PassRefPtr<InspectorValue> jsToInspectorValue(ScriptState* scriptState, JSValue value, int maxDepth) { if (!value) { ASSERT_NOT_REACHED(); return 0; } if (!maxDepth) return 0; maxDepth--; if (value.isNull() || value.isUndefined()) return InspectorValue::null(); if (value.isBoolean()) return InspectorBasicValue::create(value.asBoolean()); if (value.isNumber()) return InspectorBasicValue::create(value.asNumber()); if (value.isString()) { String s = value.getString(scriptState); return InspectorString::create(String(s.characters(), s.length())); } if (value.isObject()) { if (isJSArray(value)) { RefPtr<InspectorArray> inspectorArray = InspectorArray::create(); JSArray* array = asArray(value); unsigned length = array->length(); for (unsigned i = 0; i < length; i++) { JSValue element = array->getIndex(scriptState, i); RefPtr<InspectorValue> elementValue = jsToInspectorValue(scriptState, element, maxDepth); if (!elementValue) return 0; inspectorArray->pushValue(elementValue); } return inspectorArray; } RefPtr<InspectorObject> inspectorObject = InspectorObject::create(); JSObject* object = value.getObject(); PropertyNameArray propertyNames(scriptState); object->methodTable()->getOwnPropertyNames(object, scriptState, propertyNames, ExcludeDontEnumProperties); for (size_t i = 0; i < propertyNames.size(); i++) { const Identifier& name = propertyNames[i]; JSValue propertyValue = object->get(scriptState, name); RefPtr<InspectorValue> inspectorValue = jsToInspectorValue(scriptState, propertyValue, maxDepth); if (!inspectorValue) return 0; inspectorObject->setValue(String(name.characters(), name.length()), inspectorValue); } return inspectorObject; } ASSERT_NOT_REACHED(); return 0; }
PredictedType predictionFromValue(JSValue value) { if (value.isInt32()) return PredictInt32; if (value.isDouble()) return PredictDouble; if (value.isCell()) return predictionFromCell(value.asCell()); if (value.isBoolean()) return PredictBoolean; ASSERT(value.isUndefinedOrNull()); return PredictOther; }
static PassRefPtr<InspectorValue> jsToInspectorValue(ScriptState* scriptState, JSValue value) { if (!value) { ASSERT_NOT_REACHED(); return 0; } if (value.isNull() || value.isUndefined()) return InspectorValue::null(); if (value.isBoolean()) return InspectorBasicValue::create(value.getBoolean()); if (value.isNumber()) return InspectorBasicValue::create(value.uncheckedGetNumber()); if (value.isString()) { UString s = value.getString(scriptState); return InspectorString::create(String(s.characters(), s.length())); } if (value.isObject()) { if (isJSArray(&scriptState->globalData(), value)) { RefPtr<InspectorArray> inspectorArray = InspectorArray::create(); JSArray* array = asArray(value); unsigned length = array->length(); for (unsigned i = 0; i < length; i++) { JSValue element = array->getIndex(i); RefPtr<InspectorValue> elementValue = jsToInspectorValue(scriptState, element); if (!elementValue) { ASSERT_NOT_REACHED(); elementValue = InspectorValue::null(); } inspectorArray->pushValue(elementValue); } return inspectorArray; } RefPtr<InspectorObject> inspectorObject = InspectorObject::create(); JSObject* object = value.getObject(); PropertyNameArray propertyNames(scriptState); object->getOwnPropertyNames(scriptState, propertyNames); for (size_t i = 0; i < propertyNames.size(); i++) { const Identifier& name = propertyNames[i]; JSValue propertyValue = object->get(scriptState, name); RefPtr<InspectorValue> inspectorValue = jsToInspectorValue(scriptState, propertyValue); if (!inspectorValue) { ASSERT_NOT_REACHED(); inspectorValue = InspectorValue::null(); } inspectorObject->setValue(String(name.characters(), name.length()), inspectorValue); } return inspectorObject; } ASSERT_NOT_REACHED(); return 0; }
inline bool predictionIsValid(JSGlobalData* globalData, JSValue value, PredictedType type) { // this takes into account only local variable predictions that get enforced // on SetLocal. if (isInt32Prediction(type)) return value.isInt32(); if (isArrayPrediction(type)) return isJSArray(globalData, value); if (isBooleanPrediction(type)) return value.isBoolean(); return true; }
PredictedType predictionFromValue(JSValue value) { if (value.isInt32()) return PredictInt32; if (value.isDouble()) { double number = value.asNumber(); if (number == number) return PredictDoubleReal; return PredictDoubleNaN; } if (value.isCell()) return predictionFromCell(value.asCell()); if (value.isBoolean()) return PredictBoolean; ASSERT(value.isUndefinedOrNull()); return PredictOther; }
void NPRuntimeObjectMap::convertJSValueToNPVariant(ExecState* exec, JSValue value, NPVariant& variant) { JSLock lock(SilenceAssertionsOnly); VOID_TO_NPVARIANT(variant); if (value.isNull()) { NULL_TO_NPVARIANT(variant); return; } if (value.isUndefined()) { VOID_TO_NPVARIANT(variant); return; } if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), variant); return; } if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), variant); return; } if (value.isString()) { CString utf8String = value.toString(exec).utf8(); // This should use NPN_MemAlloc, but we know that it uses malloc under the hood. char* utf8Characters = static_cast<char*>(malloc(utf8String.length())); memcpy(utf8Characters, utf8String.data(), utf8String.length()); STRINGN_TO_NPVARIANT(utf8Characters, utf8String.length(), variant); return; } if (value.isObject()) { NPObject* npObject = getOrCreateNPObject(asObject(value)); OBJECT_TO_NPVARIANT(npObject, variant); return; } ASSERT_NOT_REACHED(); }
static bool getBooleanFromJSON(ExecState* exec, JSObject* json, const char* key, bool& result) { Identifier identifier(exec, key); PropertySlot slot(json); if (!json->getPropertySlot(exec, identifier, slot)) return false; JSValue jsValue = slot.getValue(exec, identifier); ASSERT(!exec->hadException()); if (!jsValue.isBoolean()) { throwTypeError(exec, String::format("Expected a boolean value for \"%s\" JSON key", key)); return false; } result = jsValue.asBoolean(); return true; }
// Variant value must be released with NPReleaseVariantValue() void convertValueToNPVariant(ExecState* exec, JSValue value, NPVariant* result) { JSLock lock(SilenceAssertionsOnly); VOID_TO_NPVARIANT(*result); if (value.isString()) { UString ustring = value.toString(exec); CString cstring = ustring.utf8(); NPString string = { (const NPUTF8*)cstring.data(), static_cast<uint32_t>(cstring.length()) }; NPN_InitializeVariantWithStringCopy(result, &string); } else if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), *result); } else if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), *result); } else if (value.isNull()) { NULL_TO_NPVARIANT(*result); } else if (value.isObject()) { JSObject* object = asObject(value); if (object->classInfo() == &CRuntimeObject::s_info) { CRuntimeObject* runtimeObject = static_cast<CRuntimeObject*>(object); CInstance* instance = runtimeObject->getInternalCInstance(); if (instance) { NPObject* obj = instance->getObject(); _NPN_RetainObject(obj); OBJECT_TO_NPVARIANT(obj, *result); } } else { #ifdef ANDROID RootObject* rootObject = findRootObject(exec->dynamicGlobalObject()); if (!rootObject) rootObject = findRootObject(exec->lexicalGlobalObject()); #else JSGlobalObject* globalObject = exec->dynamicGlobalObject(); RootObject* rootObject = findRootObject(globalObject); #endif if (rootObject) { NPObject* npObject = _NPN_CreateScriptObject(0, object, rootObject); OBJECT_TO_NPVARIANT(npObject, *result); } } } }
void ValueProfile::computeStatistics(Statistics& statistics) const { for (unsigned i = 0; i < numberOfBuckets; ++i) { JSValue value = JSValue::decode(m_buckets[i]); if (!value) continue; statistics.samples++; if (value.isInt32()) statistics.int32s++; else if (value.isDouble()) statistics.doubles++; else if (value.isCell()) computeStatistics(value.asCell()->structure()->classInfo(), statistics); else if (value.isBoolean()) statistics.booleans++; } }
JSLR_API bool _cdecl JSTryConvertToBooleans(JSContextRef ctx, JSValueRef** value, size_t length, int** indices, bool** result) { auto values = *value; auto res = *result; auto ind = *indices; ExecState* exec = toJS(ctx); for (unsigned int i = 0; i < length; i++) { auto ptr = values[ind[i]]; JSValueRef js_value = *&ptr; JSValue jsValue = toJS(exec, js_value); if (!jsValue.isBoolean()) { return false; } *&res[i] = jsValue.toBoolean(exec); } return true; }
::JSType JSValueGetType(JSContextRef ctx, JSValueRef value) { ExecState* exec = toJS(ctx); APIEntryShim entryShim(exec); JSValue jsValue = toJS(exec, value); if (jsValue.isUndefined()) return kJSTypeUndefined; if (jsValue.isNull()) return kJSTypeNull; if (jsValue.isBoolean()) return kJSTypeBoolean; if (jsValue.isNumber()) return kJSTypeNumber; if (jsValue.isString()) return kJSTypeString; ASSERT(jsValue.isObject()); return kJSTypeObject; }
::JSType JSValueGetType(JSContextRef ctx, JSValueRef value) { ExecState* exec = toJS(ctx); APIEntryShim entryShim(exec); JSValue jsValue = toJS(exec, value); if (jsValue.isUndefined()) return UndefinedType; if (jsValue.isNull()) return NullType; if (jsValue.isBoolean()) return BooleanType; if (jsValue.isNumber()) return NumberType; if (jsValue.isString()) return StringType; Q_ASSERT(jsValue.isObject()); return ObjectType; }
SpeculatedType speculationFromValue(JSValue value) { if (value.isEmpty()) return SpecEmpty; if (value.isInt32()) return SpecInt32; if (value.isDouble()) { double number = value.asNumber(); if (number != number) return SpecDoubleNaN; if (value.isMachineInt()) return SpecInt52AsDouble; return SpecNonIntAsDouble; } if (value.isCell()) return speculationFromCell(value.asCell()); if (value.isBoolean()) return SpecBoolean; ASSERT(value.isUndefinedOrNull()); return SpecOther; }
JSValue jsTypeStringForValue(CallFrame* callFrame, JSValue v) { if (v.isUndefined()) return jsNontrivialString(callFrame, "undefined"); if (v.isBoolean()) return jsNontrivialString(callFrame, "boolean"); if (v.isNumber()) return jsNontrivialString(callFrame, "number"); if (v.isString()) return jsNontrivialString(callFrame, "string"); if (v.isObject()) { // Return "undefined" for objects that should be treated // as null when doing comparisons. if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined()) return jsNontrivialString(callFrame, "undefined"); CallData callData; if (asObject(v)->getCallData(callData) != CallTypeNone) return jsNontrivialString(callFrame, "function"); } return jsNontrivialString(callFrame, "object"); }
void NPRuntimeObjectMap::convertJSValueToNPVariant(ExecState* exec, JSValue value, NPVariant& variant) { JSLock lock(SilenceAssertionsOnly); VOID_TO_NPVARIANT(variant); if (value.isNull()) { NULL_TO_NPVARIANT(variant); return; } if (value.isUndefined()) { VOID_TO_NPVARIANT(variant); return; } if (value.isBoolean()) { BOOLEAN_TO_NPVARIANT(value.toBoolean(exec), variant); return; } if (value.isNumber()) { DOUBLE_TO_NPVARIANT(value.toNumber(exec), variant); return; } if (value.isString()) { NPString npString = createNPString(value.toString(exec).utf8()); STRINGN_TO_NPVARIANT(npString.UTF8Characters, npString.UTF8Length, variant); return; } if (value.isObject()) { NPObject* npObject = getOrCreateNPObject(exec->globalData(), asObject(value)); OBJECT_TO_NPVARIANT(npObject, variant); return; } ASSERT_NOT_REACHED(); }
::JSType JSValueGetType(JSContextRef ctx, JSValueRef value) { if (!ctx) { ASSERT_NOT_REACHED(); return kJSTypeUndefined; } ExecState* exec = toJS(ctx); JSLockHolder locker(exec); JSValue jsValue = toJS(exec, value); if (jsValue.isUndefined()) return kJSTypeUndefined; if (jsValue.isNull()) return kJSTypeNull; if (jsValue.isBoolean()) return kJSTypeBoolean; if (jsValue.isNumber()) return kJSTypeNumber; if (jsValue.isString()) return kJSTypeString; ASSERT(jsValue.isObject()); return kJSTypeObject; }
InferredType::Descriptor InferredType::Descriptor::forValue(JSValue value) { if (value.isBoolean()) return Boolean; if (value.isUndefinedOrNull()) return Other; if (value.isInt32()) return Int32; if (value.isNumber()) return Number; if (value.isCell()) { JSCell* cell = value.asCell(); if (cell->isString()) return String; if (cell->isSymbol()) return Symbol; if (cell->isObject()) { if (cell->structure()->transitionWatchpointSetIsStillValid()) return Descriptor(ObjectWithStructure, cell->structure()); return Object; } } return Top; }
RuntimeType TypeSet::getRuntimeTypeForValue(JSValue v) { RuntimeType ret; if (v.isFunction()) ret = TypeFunction; else if (v.isUndefined()) ret = TypeUndefined; else if (v.isNull()) ret = TypeNull; else if (v.isBoolean()) ret = TypeBoolean; else if (v.isMachineInt()) ret = TypeMachineInt; else if (v.isNumber()) ret = TypeNumber; else if (v.isString()) ret = TypeString; else if (v.isObject()) ret = TypeObject; else ret = TypeNothing; return ret; }
void JSSVGLength::setValue(ExecState* exec, JSValue value) { if (impl()->role() == AnimValRole) { setDOMException(exec, NO_MODIFICATION_ALLOWED_ERR); return; } if (!value.isUndefinedOrNull() && !value.isNumber() && !value.isBoolean()) { throwVMTypeError(exec); return; } SVGLength& podImp = impl()->propertyReference(); ExceptionCode ec = 0; SVGLengthContext lengthContext(impl()->contextElement()); podImp.setValue(value.toFloat(exec), lengthContext, ec); if (ec) { setDOMException(exec, ec); return; } impl()->commitChange(); }
//-------------------------------------------------------------------------- // KJSValueToCFTypeInternal //-------------------------------------------------------------------------- // Caller is responsible for releasing the returned CFTypeRef CFTypeRef KJSValueToCFTypeInternal(JSValue inValue, ExecState *exec, ObjectImpList* inImps) { if (!inValue) return 0; CFTypeRef result = 0; JSGlueAPIEntry entry; if (inValue.isBoolean()) { result = inValue.toBoolean(exec) ? kCFBooleanTrue : kCFBooleanFalse; RetainCFType(result); return result; } if (inValue.isString()) { UString uString = inValue.toString(exec); result = UStringToCFString(uString); return result; } if (inValue.isNumber()) { double number1 = inValue.toNumber(exec); double number2 = (double)inValue.toInteger(exec); if (number1 == number2) { int intValue = (int)number2; result = CFNumberCreate(0, kCFNumberIntType, &intValue); } else { result = CFNumberCreate(0, kCFNumberDoubleType, &number1); } return result; } if (inValue.isObject()) { if (inValue.inherits(&UserObjectImp::info)) { UserObjectImp* userObjectImp = static_cast<UserObjectImp *>(asObject(inValue)); JSUserObject* ptr = userObjectImp->GetJSUserObject(); if (ptr) { result = ptr->CopyCFValue(); } } else { JSObject *object = inValue.toObject(exec); UInt8 isArray = false; // if two objects reference each JSObject* imp = object; ObjectImpList* temp = inImps; while (temp) { if (imp == temp->imp) { return CFRetain(GetCFNull()); } temp = temp->next; } ObjectImpList imps; imps.next = inImps; imps.imp = imp; //[...] HACK since we do not have access to the class info we use class name instead #if 0 if (object->inherits(&ArrayInstanceImp::info)) #else if (object->className() == "Array") #endif { isArray = true; JSGlueGlobalObject* globalObject = static_cast<JSGlueGlobalObject*>(exec->dynamicGlobalObject()); if (globalObject && (globalObject->Flags() & kJSFlagConvertAssociativeArray)) { PropertyNameArray propNames(exec); object->getPropertyNames(exec, propNames); PropertyNameArray::const_iterator iter = propNames.begin(); PropertyNameArray::const_iterator end = propNames.end(); while(iter != end && isArray) { Identifier propName = *iter; UString ustr = propName.ustring(); const UniChar* uniChars = (const UniChar*)ustr.characters(); int size = ustr.length(); while (size--) { if (uniChars[size] < '0' || uniChars[size] > '9') { isArray = false; break; } } iter++; } } } if (isArray) { // This is an KJS array unsigned int length = object->get(exec, Identifier(exec, "length")).toUInt32(exec); result = CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks); if (result) { for (unsigned i = 0; i < length; i++) { CFTypeRef cfValue = KJSValueToCFTypeInternal(object->get(exec, i), exec, &imps); CFArrayAppendValue((CFMutableArrayRef)result, cfValue); ReleaseCFType(cfValue); } } } else { // Not an array, just treat it like a dictionary which contains (property name, property value) pairs PropertyNameArray propNames(exec); object->getPropertyNames(exec, propNames); { result = CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (result) { PropertyNameArray::const_iterator iter = propNames.begin(); PropertyNameArray::const_iterator end = propNames.end(); while(iter != end) { Identifier propName = *iter; if (object->hasProperty(exec, propName)) { CFStringRef cfKey = IdentifierToCFString(propName); CFTypeRef cfValue = KJSValueToCFTypeInternal(object->get(exec, propName), exec, &imps); if (cfKey && cfValue) { CFDictionaryAddValue((CFMutableDictionaryRef)result, cfKey, cfValue); } ReleaseCFType(cfKey); ReleaseCFType(cfValue); } iter++; } } } } } return result; } if (inValue.isUndefinedOrNull()) { result = RetainCFType(GetCFNull()); return result; } ASSERT_NOT_REACHED(); return 0; }
jvalue convertValueToJValue(ExecState* exec, RootObject* rootObject, JSValue value, JavaType javaType, const char* javaClassName) { JSLock lock(SilenceAssertionsOnly); jvalue result; memset(&result, 0, sizeof(jvalue)); switch (javaType) { case JavaTypeArray: case JavaTypeObject: { // FIXME: JavaJSObject::convertValueToJObject functionality is almost exactly the same, // these functions should use common code. if (value.isObject()) { JSObject* object = asObject(value); if (object->inherits(&JavaRuntimeObject::s_info)) { // Unwrap a Java instance. JavaRuntimeObject* runtimeObject = static_cast<JavaRuntimeObject*>(object); JavaInstance* instance = runtimeObject->getInternalJavaInstance(); if (instance) result.l = instance->javaInstance(); } else if (object->classInfo() == &RuntimeArray::s_info) { // Input is a JavaScript Array that was originally created from a Java Array RuntimeArray* imp = static_cast<RuntimeArray*>(object); JavaArray* array = static_cast<JavaArray*>(imp->getConcreteArray()); result.l = array->javaArray(); } else if (object->classInfo() == &JSArray::s_info) { // Input is a Javascript Array. We need to create it to a Java Array. result.l = convertArrayInstanceToJavaArray(exec, asArray(value), javaClassName); } else if ((!result.l && (!strcmp(javaClassName, "java.lang.Object"))) || (!strcmp(javaClassName, "netscape.javascript.JSObject"))) { // Wrap objects in JSObject instances. JNIEnv* env = getJNIEnv(); jclass jsObjectClass = env->FindClass("sun/plugin/javascript/webkit/JSObject"); jmethodID constructorID = env->GetMethodID(jsObjectClass, "<init>", "(J)V"); if (constructorID) { jlong nativeHandle = ptr_to_jlong(object); rootObject->gcProtect(object); result.l = env->NewObject(jsObjectClass, constructorID, nativeHandle); } } } // Create an appropriate Java object if target type is java.lang.Object. if (!result.l && !strcmp(javaClassName, "java.lang.Object")) { if (value.isString()) { UString stringValue = asString(value)->value(exec); JNIEnv* env = getJNIEnv(); jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length()); result.l = javaString; } else if (value.isNumber()) { double doubleValue = value.asNumber(); JNIEnv* env = getJNIEnv(); jclass clazz = env->FindClass("java/lang/Double"); jmethodID constructor = env->GetMethodID(clazz, "<init>", "(D)V"); jobject javaDouble = env->functions->NewObject(env, clazz, constructor, doubleValue); result.l = javaDouble; } else if (value.isBoolean()) { bool boolValue = value.asBoolean(); JNIEnv* env = getJNIEnv(); jclass clazz = env->FindClass("java/lang/Boolean"); jmethodID constructor = env->GetMethodID(clazz, "<init>", "(Z)V"); jobject javaBoolean = env->functions->NewObject(env, clazz, constructor, boolValue); result.l = javaBoolean; } else if (value.isUndefined()) { UString stringValue = "undefined"; JNIEnv* env = getJNIEnv(); jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length()); result.l = javaString; } } // Convert value to a string if the target type is a java.lang.String, and we're not // converting from a null. if (!result.l && !strcmp(javaClassName, "java.lang.String")) { if (!value.isNull()) { UString stringValue = value.toString(exec); JNIEnv* env = getJNIEnv(); jobject javaString = env->functions->NewString(env, (const jchar*)stringValue.characters(), stringValue.length()); result.l = javaString; } } } break; case JavaTypeBoolean: { result.z = (jboolean)value.toNumber(exec); } break; case JavaTypeByte: { result.b = (jbyte)value.toNumber(exec); } break; case JavaTypeChar: { result.c = (jchar)value.toNumber(exec); } break; case JavaTypeShort: { result.s = (jshort)value.toNumber(exec); } break; case JavaTypeInt: { result.i = (jint)value.toNumber(exec); } break; case JavaTypeLong: { result.j = (jlong)value.toNumber(exec); } break; case JavaTypeFloat: { result.f = (jfloat)value.toNumber(exec); } break; case JavaTypeDouble: { result.d = (jdouble)value.toNumber(exec); } break; case JavaTypeInvalid: case JavaTypeVoid: break; } return result; }
JSValue JSInjectedScriptHost::subtype(ExecState* exec) { if (exec->argumentCount() < 1) return jsUndefined(); JSValue value = exec->uncheckedArgument(0); if (value.isString()) return exec->vm().smallStrings.stringString(); if (value.isBoolean()) return exec->vm().smallStrings.booleanString(); if (value.isNumber()) return exec->vm().smallStrings.numberString(); if (value.isSymbol()) return exec->vm().smallStrings.symbolString(); JSObject* object = asObject(value); if (object) { if (object->isErrorInstance()) return jsNontrivialString(exec, ASCIILiteral("error")); // Consider class constructor functions class objects. JSFunction* function = jsDynamicCast<JSFunction*>(value); if (function && function->isClassConstructorFunction()) return jsNontrivialString(exec, ASCIILiteral("class")); } if (value.inherits(JSArray::info())) return jsNontrivialString(exec, ASCIILiteral("array")); if (value.inherits(DirectArguments::info()) || value.inherits(ScopedArguments::info())) return jsNontrivialString(exec, ASCIILiteral("array")); if (value.inherits(DateInstance::info())) return jsNontrivialString(exec, ASCIILiteral("date")); if (value.inherits(RegExpObject::info())) return jsNontrivialString(exec, ASCIILiteral("regexp")); if (value.inherits(JSMap::info())) return jsNontrivialString(exec, ASCIILiteral("map")); if (value.inherits(JSSet::info())) return jsNontrivialString(exec, ASCIILiteral("set")); if (value.inherits(JSWeakMap::info())) return jsNontrivialString(exec, ASCIILiteral("weakmap")); if (value.inherits(JSWeakSet::info())) return jsNontrivialString(exec, ASCIILiteral("weakset")); if (value.inherits(JSArrayIterator::info()) || value.inherits(JSMapIterator::info()) || value.inherits(JSSetIterator::info()) || value.inherits(JSStringIterator::info()) || value.inherits(JSPropertyNameIterator::info())) return jsNontrivialString(exec, ASCIILiteral("iterator")); if (object && object->getDirect(exec->vm(), exec->vm().propertyNames->builtinNames().arrayIteratorNextIndexPrivateName())) return jsNontrivialString(exec, ASCIILiteral("iterator")); if (value.inherits(JSInt8Array::info()) || value.inherits(JSInt16Array::info()) || value.inherits(JSInt32Array::info())) return jsNontrivialString(exec, ASCIILiteral("array")); if (value.inherits(JSUint8Array::info()) || value.inherits(JSUint16Array::info()) || value.inherits(JSUint32Array::info())) return jsNontrivialString(exec, ASCIILiteral("array")); if (value.inherits(JSFloat32Array::info()) || value.inherits(JSFloat64Array::info())) return jsNontrivialString(exec, ASCIILiteral("array")); return impl().subtype(exec, value); }
bool JSValueIsBoolean(JSContextRef, JSValueRef value) { JSValue* jsValue = toJS(value); return jsValue->isBoolean(); }
static std::error_code loadTrigger(ExecState& exec, const JSObject& ruleObject, Trigger& trigger) { VM& vm = exec.vm(); auto scope = DECLARE_THROW_SCOPE(vm); const JSValue triggerObject = ruleObject.get(&exec, Identifier::fromString(&exec, "trigger")); if (!triggerObject || scope.exception() || !triggerObject.isObject()) return ContentExtensionError::JSONInvalidTrigger; const JSValue urlFilterObject = triggerObject.get(&exec, Identifier::fromString(&exec, "url-filter")); if (!urlFilterObject || scope.exception() || !urlFilterObject.isString()) return ContentExtensionError::JSONInvalidURLFilterInTrigger; String urlFilter = urlFilterObject.toWTFString(&exec); if (urlFilter.isEmpty()) return ContentExtensionError::JSONInvalidURLFilterInTrigger; trigger.urlFilter = urlFilter; const JSValue urlFilterCaseValue = triggerObject.get(&exec, Identifier::fromString(&exec, "url-filter-is-case-sensitive")); if (urlFilterCaseValue && !scope.exception() && urlFilterCaseValue.isBoolean()) trigger.urlFilterIsCaseSensitive = urlFilterCaseValue.toBoolean(&exec); const JSValue resourceTypeValue = triggerObject.get(&exec, Identifier::fromString(&exec, "resource-type")); if (!scope.exception() && resourceTypeValue.isObject()) { auto typeFlagsError = getTypeFlags(exec, resourceTypeValue, trigger.flags, readResourceType); if (typeFlagsError) return typeFlagsError; } else if (!resourceTypeValue.isUndefined()) return ContentExtensionError::JSONInvalidTriggerFlagsArray; const JSValue loadTypeValue = triggerObject.get(&exec, Identifier::fromString(&exec, "load-type")); if (!scope.exception() && loadTypeValue.isObject()) { auto typeFlagsError = getTypeFlags(exec, loadTypeValue, trigger.flags, readLoadType); if (typeFlagsError) return typeFlagsError; } else if (!loadTypeValue.isUndefined()) return ContentExtensionError::JSONInvalidTriggerFlagsArray; const JSValue ifDomain = triggerObject.get(&exec, Identifier::fromString(&exec, "if-domain")); if (!scope.exception() && ifDomain.isObject()) { auto ifDomainError = getDomainList(exec, asObject(ifDomain), trigger.domains); if (ifDomainError) return ifDomainError; if (trigger.domains.isEmpty()) return ContentExtensionError::JSONInvalidDomainList; ASSERT(trigger.domainCondition == Trigger::DomainCondition::None); trigger.domainCondition = Trigger::DomainCondition::IfDomain; } else if (!ifDomain.isUndefined()) return ContentExtensionError::JSONInvalidDomainList; const JSValue unlessDomain = triggerObject.get(&exec, Identifier::fromString(&exec, "unless-domain")); if (!scope.exception() && unlessDomain.isObject()) { if (trigger.domainCondition != Trigger::DomainCondition::None) return ContentExtensionError::JSONUnlessAndIfDomain; auto unlessDomainError = getDomainList(exec, asObject(unlessDomain), trigger.domains); if (unlessDomainError) return unlessDomainError; if (trigger.domains.isEmpty()) return ContentExtensionError::JSONInvalidDomainList; trigger.domainCondition = Trigger::DomainCondition::UnlessDomain; } else if (!unlessDomain.isUndefined()) return ContentExtensionError::JSONInvalidDomainList; return { }; }