inline bool JSActivation::symbolTablePut(ExecState* exec, PropertyName propertyName, JSValue value, bool shouldThrow)
{
VM& vm = exec->vm();
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
SymbolTableEntry entry = symbolTable()->inlineGet(propertyName.publicName());
if (entry.isNull())
return false;
if (entry.isReadOnly()) {
if (shouldThrow)
throwTypeError(exec, StrictModeReadonlyPropertyWriteError);
return true;
}
// Defend against the inspector asking for a var after it has been optimized out.
if (isTornOff() && !isValid(entry))
return false;
registerAt(entry.getIndex()).set(vm, this, value);
return true;
}
inline bool JSActivation::symbolTablePutWithAttributes(VM& vm, PropertyName propertyName, JSValue value, unsigned attributes)
{
ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
WriteBarrierBase<Unknown>* reg;
{
ConcurrentJITLocker locker(symbolTable()->m_lock);
SymbolTable::Map::iterator iter = symbolTable()->find(locker, propertyName.publicName());
if (iter == symbolTable()->end(locker))
return false;
SymbolTableEntry& entry = iter->value;
ASSERT(!entry.isNull());
if (!isValid(entry))
return false;
entry.setAttributes(attributes);
reg = ®isterAt(entry.getIndex());
}
reg->set(vm, this, value);
return true;
}
EncodedJSValue JSHTMLDocument::nameGetter(ExecState* exec, JSObject* slotBase, EncodedJSValue, PropertyName propertyName)
{
JSHTMLDocument* thisObj = jsCast<JSHTMLDocument*>(slotBase);
HTMLDocument& document = thisObj->impl();
AtomicStringImpl* atomicPropertyName = propertyName.publicName();
if (!atomicPropertyName || !document.hasDocumentNamedItem(*atomicPropertyName))
return JSValue::encode(jsUndefined());
if (UNLIKELY(document.documentNamedItemContainsMultipleElements(*atomicPropertyName))) {
RefPtr<HTMLCollection> collection = document.documentNamedItems(atomicPropertyName);
ASSERT(collection->length() > 1);
return JSValue::encode(toJS(exec, thisObj->globalObject(), WTF::getPtr(collection)));
}
Element* element = document.documentNamedItem(*atomicPropertyName);
if (UNLIKELY(is<HTMLIFrameElement>(*element))) {
if (Frame* frame = downcast<HTMLIFrameElement>(*element).contentFrame())
return JSValue::encode(toJS(exec, frame));
}
return JSValue::encode(toJS(exec, thisObj->globalObject(), element));
}
static bool jsDOMWindowPropertiesGetOwnPropertySlotNamedItemGetter(JSDOMWindowProperties* thisObject, Frame& frame, ExecState* exec, PropertyName propertyName, PropertySlot& slot)
{
// Check for child frames by name before built-in properties to match Mozilla. This does
// not match IE, but some sites end up naming frames things that conflict with window
// properties that are in Moz but not IE. Since we have some of these, we have to do it
// the Moz way.
if (auto* scopedChild = frame.tree().scopedChild(propertyNameToAtomicString(propertyName))) {
slot.setValue(thisObject, ReadOnly | DontDelete | DontEnum, toJS(exec, scopedChild->document()->domWindow()));
return true;
}
if (!BindingSecurity::shouldAllowAccessToFrame(exec, &frame, ThrowSecurityError))
return false;
// FIXME: Search the whole frame hierarchy somewhere around here.
// We need to test the correct priority order.
// Allow shortcuts like 'Image1' instead of document.images.Image1
Document* document = frame.document();
if (is<HTMLDocument>(*document)) {
auto& htmlDocument = downcast<HTMLDocument>(*document);
auto* atomicPropertyName = propertyName.publicName();
if (atomicPropertyName && htmlDocument.hasWindowNamedItem(*atomicPropertyName)) {
JSValue namedItem;
if (UNLIKELY(htmlDocument.windowNamedItemContainsMultipleElements(*atomicPropertyName))) {
Ref<HTMLCollection> collection = document->windowNamedItems(atomicPropertyName);
ASSERT(collection->length() > 1);
namedItem = toJS(exec, thisObject->globalObject(), collection);
} else
namedItem = toJS(exec, thisObject->globalObject(), htmlDocument.windowNamedItem(*atomicPropertyName));
slot.setValue(thisObject, ReadOnly | DontDelete | DontEnum, namedItem);
return true;
}
}
return false;
}
static CSSPropertyInfo cssPropertyIDForJSCSSPropertyName(PropertyName propertyName)
{
CSSPropertyInfo propertyInfo = {CSSPropertyInvalid, false};
bool hadPixelOrPosPrefix = false;
StringImpl* propertyNameString = propertyName.publicName();
if (!propertyNameString)
return propertyInfo;
unsigned length = propertyNameString->length();
if (!length)
return propertyInfo;
String stringForCache = String(propertyNameString);
typedef HashMap<String, CSSPropertyInfo> CSSPropertyInfoMap;
DEFINE_STATIC_LOCAL(CSSPropertyInfoMap, propertyInfoCache, ());
propertyInfo = propertyInfoCache.get(stringForCache);
if (propertyInfo.propertyID)
return propertyInfo;
const size_t bufferSize = maxCSSPropertyNameLength + 1;
char buffer[bufferSize];
char* bufferPtr = buffer;
const char* name = bufferPtr;
unsigned i = 0;
// Prefixes CSS, Pixel, Pos are ignored.
// Prefixes Apple, KHTML and Webkit are transposed to "-webkit-".
// The prefix "Epub" becomes "-epub-".
switch (getCSSPropertyNamePrefix(*propertyNameString)) {
case PropertyNamePrefixNone:
if (isASCIIUpper((*propertyNameString)[0]))
return propertyInfo;
break;
case PropertyNamePrefixCSS:
i += 3;
break;
case PropertyNamePrefixPixel:
i += 5;
hadPixelOrPosPrefix = true;
break;
case PropertyNamePrefixPos:
i += 3;
hadPixelOrPosPrefix = true;
break;
#if ENABLE(LEGACY_CSS_VENDOR_PREFIXES)
case PropertyNamePrefixApple:
case PropertyNamePrefixKHTML:
ASSERT(RuntimeEnabledFeatures::sharedFeatures().legacyCSSVendorPrefixesEnabled());
writeWebKitPrefix(bufferPtr);
i += 5;
break;
#endif
case PropertyNamePrefixEpub:
writeEpubPrefix(bufferPtr);
i += 4;
break;
case PropertyNamePrefixWebKit:
writeWebKitPrefix(bufferPtr);
i += 6;
break;
}
*bufferPtr++ = toASCIILower((*propertyNameString)[i++]);
char* bufferEnd = buffer + bufferSize;
char* stringEnd = bufferEnd - 1;
size_t bufferSizeLeft = stringEnd - bufferPtr;
size_t propertySizeLeft = length - i;
if (propertySizeLeft > bufferSizeLeft)
return propertyInfo;
for (; i < length; ++i) {
UChar c = (*propertyNameString)[i];
if (!c || c >= 0x7F)
return propertyInfo; // illegal character
if (isASCIIUpper(c)) {
size_t bufferSizeLeft = stringEnd - bufferPtr;
size_t propertySizeLeft = length - i + 1;
if (propertySizeLeft > bufferSizeLeft)
return propertyInfo;
*bufferPtr++ = '-';
*bufferPtr++ = toASCIILower(c);
} else
*bufferPtr++ = c;
ASSERT(bufferPtr < bufferEnd);
}
ASSERT(bufferPtr < bufferEnd);
*bufferPtr = '\0';
unsigned outputLength = bufferPtr - buffer;
#if PLATFORM(IOS)
cssPropertyNameIOSAliasing(buffer, name, outputLength);
#endif
const Property* hashTableEntry = findProperty(name, outputLength);
int propertyID = hashTableEntry ? hashTableEntry->id : 0;
if (propertyID) {
propertyInfo.hadPixelOrPosPrefix = hadPixelOrPosPrefix;
propertyInfo.propertyID = static_cast<CSSPropertyID>(propertyID);
propertyInfoCache.add(stringForCache, propertyInfo);
}
return propertyInfo;
}
static JSValue nonCachingStaticGoFunctionGetter(ExecState* exec, JSValue, PropertyName propertyName)
{
return JSFunction::create(exec, exec->lexicalGlobalObject(), 1, propertyName.publicName(), jsHistoryPrototypeFunctionGo);
}
static JSValue nonCachingStaticReloadFunctionGetter(ExecState* exec, JSValue, PropertyName propertyName)
{
return JSFunction::create(exec, exec->lexicalGlobalObject(), 0, propertyName.publicName(), jsLocationPrototypeFunctionReload);
}
JSValue objectToStringFunctionGetter(ExecState* exec, JSValue, PropertyName propertyName)
{
return JSFunction::create(exec, exec->lexicalGlobalObject(), 0, propertyName.publicName(), objectProtoFuncToString);
}
static EncodedJSValue nonCachingStaticForwardFunctionGetter(ExecState* exec, EncodedJSValue, EncodedJSValue, PropertyName propertyName)
{
return JSValue::encode(JSFunction::create(exec->vm(), exec->lexicalGlobalObject(), 0, propertyName.publicName(), jsHistoryPrototypeFunctionForward));
}
bool JSHTMLDocument::canGetItemsForName(ExecState*, HTMLDocument* document, PropertyName propertyName)
{
AtomicStringImpl* atomicPropertyName = propertyName.publicName();
return atomicPropertyName && document->hasDocumentNamedItem(*atomicPropertyName);
}
JSValue QtInstance::getMethod(ExecState* exec, PropertyName propertyName)
{
if (!getClass())
return jsNull();
MethodList methodList = m_class->methodsNamed(propertyName, this);
return RuntimeMethod::create(exec, exec->lexicalGlobalObject(), WebCore::deprecatedGetDOMStructure<RuntimeMethod>(exec), propertyName.publicName(), methodList);
}
JSValue nonCachingStaticFunctionGetter(ExecState* exec, JSValue, PropertyName propertyName)
{
return JSFunction::create(exec, exec->lexicalGlobalObject(), length, propertyName.publicName(), nativeFunction);
}
