EncodedJSValue JSC_HOST_CALL privateFuncIsMap(ExecState* exec)
{
JSValue value = exec->uncheckedArgument(0);
return JSValue::encode(jsBoolean(value.isCell() && value.asCell()->type() == JSMapType));
}
bool JSDOMWindow::getOwnPropertyDescriptor(JSObject* object, ExecState* exec, PropertyName propertyName, PropertyDescriptor& descriptor)
{
JSDOMWindow* thisObject = jsCast<JSDOMWindow*>(object);
// Never allow cross-domain getOwnPropertyDescriptor
if (!BindingSecurity::shouldAllowAccessToDOMWindow(exec, thisObject->impl()))
return false;
const HashEntry* entry;
// We don't want any properties other than "close" and "closed" on a closed window.
if (!thisObject->impl()->frame()) {
// The following code is safe for cross-domain and same domain use.
// It ignores any custom properties that might be set on the DOMWindow (including a custom prototype).
entry = s_info.propHashTable(exec)->entry(exec, propertyName);
if (entry && !(entry->attributes() & JSC::Function) && entry->propertyGetter() == jsDOMWindowClosed) {
descriptor.setDescriptor(jsBoolean(true), ReadOnly | DontDelete | DontEnum);
return true;
}
entry = JSDOMWindowPrototype::s_info.propHashTable(exec)->entry(exec, propertyName);
if (entry && (entry->attributes() & JSC::Function) && entry->function() == jsDOMWindowPrototypeFunctionClose) {
PropertySlot slot;
slot.setCustom(thisObject, nonCachingStaticFunctionGetter<jsDOMWindowPrototypeFunctionClose, 0>);
descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum);
return true;
}
descriptor.setUndefined();
return true;
}
entry = JSDOMWindow::s_info.propHashTable(exec)->entry(exec, propertyName);
if (entry) {
PropertySlot slot;
slot.setCustom(thisObject, entry->propertyGetter());
descriptor.setDescriptor(slot.getValue(exec, propertyName), entry->attributes());
return true;
}
// 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 (thisObject->impl()->frame()->tree()->scopedChild(propertyNameToAtomicString(propertyName))) {
PropertySlot slot;
slot.setCustom(thisObject, childFrameGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum);
return true;
}
unsigned i = propertyName.asIndex();
if (i < thisObject->impl()->frame()->tree()->scopedChildCount()) {
ASSERT(i != PropertyName::NotAnIndex);
PropertySlot slot;
slot.setCustomIndex(thisObject, i, indexGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum);
return true;
}
// Allow shortcuts like 'Image1' instead of document.images.Image1
Document* document = thisObject->impl()->frame()->document();
if (document->isHTMLDocument()) {
AtomicStringImpl* atomicPropertyName = findAtomicString(propertyName);
if (atomicPropertyName && (toHTMLDocument(document)->hasNamedItem(atomicPropertyName) || document->hasElementWithId(atomicPropertyName))) {
PropertySlot slot;
slot.setCustom(thisObject, namedItemGetter);
descriptor.setDescriptor(slot.getValue(exec, propertyName), ReadOnly | DontDelete | DontEnum);
return true;
}
}
return Base::getOwnPropertyDescriptor(thisObject, exec, propertyName, descriptor);
}
// ECMA 24.1.3.1
EncodedJSValue JSC_HOST_CALL arrayBufferFuncIsView(ExecState* exec)
{
return JSValue::encode(jsBoolean(jsDynamicCast<JSArrayBufferView*>(exec->argument(0))));
}
// ECMA 15.6.1
static AJValue JSC_HOST_CALL callBooleanConstructor(ExecState* exec, AJObject*, AJValue, const ArgList& args)
{
return jsBoolean(args.at(0).toBoolean(exec));
}
EncodedJSValue JSC_HOST_CALL objectProtoFuncHasOwnProperty(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
return JSValue::encode(jsBoolean(thisValue.toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, exec->argument(0).toString(exec)))));
}
EncodedJSValue JSC_HOST_CALL arrayConstructorIsArray(ExecState* exec)
{
return JSValue::encode(jsBoolean(exec->argument(0).inherits(&JSArray::s_info)));
}
JSValue* jsStringOrFalse(const String& s)
{
if (s.isNull())
return jsBoolean(false);
return jsString(s);
}
// ECMA 15.6.2
JSObject* constructBoolean(ExecState* exec, const ArgList& args)
{
BooleanObject* obj = BooleanObject::create(exec->globalData(), asInternalFunction(exec->callee())->globalObject()->booleanObjectStructure());
obj->setInternalValue(exec->globalData(), jsBoolean(args.at(0).toBoolean(exec)));
return obj;
}
// ECMA 15.6.1
static EncodedJSValue JSC_HOST_CALL callBooleanConstructor(ExecState* exec)
{
return JSValue::encode(jsBoolean(exec->argument(0).toBoolean(exec)));
}
JSValue* JSCSSStyleDeclarationPrototypeFunction::callAsFunction(ExecState* exec, JSObject* thisObj, const List& args)
{
if (!thisObj->inherits(&JSCSSStyleDeclaration::info))
return throwError(exec, TypeError);
CSSStyleDeclaration* imp = static_cast<CSSStyleDeclaration*>(static_cast<JSCSSStyleDeclaration*>(thisObj)->impl());
switch (id) {
case JSCSSStyleDeclaration::GetPropertyValueFuncNum: {
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = jsStringOrNull(imp->getPropertyValue(propertyName));
return result;
}
case JSCSSStyleDeclaration::GetPropertyCSSValueFuncNum: {
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = toJS(exec, WTF::getPtr(imp->getPropertyCSSValue(propertyName)));
return result;
}
case JSCSSStyleDeclaration::RemovePropertyFuncNum: {
ExceptionCode ec = 0;
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = jsStringOrNull(imp->removeProperty(propertyName, ec));
setDOMException(exec, ec);
return result;
}
case JSCSSStyleDeclaration::GetPropertyPriorityFuncNum: {
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = jsStringOrNull(imp->getPropertyPriority(propertyName));
return result;
}
case JSCSSStyleDeclaration::SetPropertyFuncNum: {
ExceptionCode ec = 0;
String propertyName = args[0]->toString(exec);
String value = valueToStringWithNullCheck(exec, args[1]);
String priority = args[2]->toString(exec);
imp->setProperty(propertyName, value, priority, ec);
setDOMException(exec, ec);
return jsUndefined();
}
case JSCSSStyleDeclaration::ItemFuncNum: {
bool indexOk;
unsigned index = args[0]->toInt32(exec, indexOk);
if (!indexOk) {
setDOMException(exec, TYPE_MISMATCH_ERR);
return jsUndefined();
}
KJS::JSValue* result = jsStringOrNull(imp->item(index));
return result;
}
case JSCSSStyleDeclaration::GetPropertyShorthandFuncNum: {
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = jsStringOrNull(imp->getPropertyShorthand(propertyName));
return result;
}
case JSCSSStyleDeclaration::IsPropertyImplicitFuncNum: {
String propertyName = args[0]->toString(exec);
KJS::JSValue* result = jsBoolean(imp->isPropertyImplicit(propertyName));
return result;
}
}
return 0;
}
JSValue regExpConstructorMultiline(ExecState*, const Identifier&, const PropertySlot& slot)
{
return jsBoolean(asRegExpConstructor(slot.slotBase())->multiline());
}
void ScriptFunctionCall::appendArgument(bool argument)
{
m_arguments.append(jsBoolean(argument));
}
JSValue LiteralParser::parse(ParserState initialState)
{
ParserState state = initialState;
MarkedArgumentBuffer objectStack;
JSValue lastValue;
Vector<ParserState, 16> stateStack;
Vector<Identifier, 16> identifierStack;
while (1) {
switch(state) {
startParseArray:
case StartParseArray: {
JSArray* array = constructEmptyArray(m_exec);
objectStack.append(array);
// fallthrough
}
doParseArrayStartExpression:
case DoParseArrayStartExpression: {
TokenType lastToken = m_lexer.currentToken().type;
if (m_lexer.next() == TokRBracket) {
if (lastToken == TokComma)
return JSValue();
m_lexer.next();
lastValue = objectStack.last();
objectStack.removeLast();
break;
}
stateStack.append(DoParseArrayEndExpression);
goto startParseExpression;
}
case DoParseArrayEndExpression: {
asArray(objectStack.last())->push(m_exec, lastValue);
if (m_lexer.currentToken().type == TokComma)
goto doParseArrayStartExpression;
if (m_lexer.currentToken().type != TokRBracket)
return JSValue();
m_lexer.next();
lastValue = objectStack.last();
objectStack.removeLast();
break;
}
startParseObject:
case StartParseObject: {
JSObject* object = constructEmptyObject(m_exec);
objectStack.append(object);
TokenType type = m_lexer.next();
if (type == TokString) {
Lexer::LiteralParserToken identifierToken = m_lexer.currentToken();
// Check for colon
if (m_lexer.next() != TokColon)
return JSValue();
m_lexer.next();
identifierStack.append(Identifier(m_exec, identifierToken.stringToken));
stateStack.append(DoParseObjectEndExpression);
goto startParseExpression;
} else if (type != TokRBrace)
return JSValue();
m_lexer.next();
lastValue = objectStack.last();
objectStack.removeLast();
break;
}
doParseObjectStartExpression:
case DoParseObjectStartExpression: {
TokenType type = m_lexer.next();
if (type != TokString)
return JSValue();
Lexer::LiteralParserToken identifierToken = m_lexer.currentToken();
// Check for colon
if (m_lexer.next() != TokColon)
return JSValue();
m_lexer.next();
identifierStack.append(Identifier(m_exec, identifierToken.stringToken));
stateStack.append(DoParseObjectEndExpression);
goto startParseExpression;
}
case DoParseObjectEndExpression:
{
asObject(objectStack.last())->putDirect(identifierStack.last(), lastValue);
identifierStack.removeLast();
if (m_lexer.currentToken().type == TokComma)
goto doParseObjectStartExpression;
if (m_lexer.currentToken().type != TokRBrace)
return JSValue();
m_lexer.next();
lastValue = objectStack.last();
objectStack.removeLast();
break;
}
startParseExpression:
case StartParseExpression: {
switch (m_lexer.currentToken().type) {
case TokLBracket:
goto startParseArray;
case TokLBrace:
goto startParseObject;
case TokString: {
Lexer::LiteralParserToken stringToken = m_lexer.currentToken();
m_lexer.next();
lastValue = jsString(m_exec, stringToken.stringToken);
break;
}
case TokNumber: {
Lexer::LiteralParserToken numberToken = m_lexer.currentToken();
m_lexer.next();
lastValue = jsNumber(m_exec, numberToken.numberToken);
break;
}
case TokNull:
m_lexer.next();
lastValue = jsNull();
break;
case TokTrue:
m_lexer.next();
lastValue = jsBoolean(true);
break;
case TokFalse:
m_lexer.next();
lastValue = jsBoolean(false);
break;
default:
// Error
return JSValue();
}
break;
}
case StartParseStatement: {
switch (m_lexer.currentToken().type) {
case TokLBracket:
case TokNumber:
case TokString:
goto startParseExpression;
case TokLParen: {
m_lexer.next();
stateStack.append(StartParseStatementEndStatement);
goto startParseExpression;
}
default:
return JSValue();
}
}
case StartParseStatementEndStatement: {
ASSERT(stateStack.isEmpty());
if (m_lexer.currentToken().type != TokRParen)
return JSValue();
if (m_lexer.next() == TokEnd)
return lastValue;
return JSValue();
}
default:
ASSERT_NOT_REACHED();
}
if (stateStack.isEmpty())
return lastValue;
state = stateStack.last();
stateStack.removeLast();
continue;
}
}
JSValue QT_FASTCALL objectProtoFuncHasOwnProperty(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
return jsBoolean(thisValue.toThisObject(exec)->hasOwnProperty(exec, Identifier(exec, args.at(0).toString(exec))));
}
JSValue regExpObjectIgnoreCase(ExecState*, JSValue slotBase, PropertyName)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase());
}
EncodedJSValue regExpConstructorMultiline(ExecState*, EncodedJSValue thisValue, PropertyName)
{
return JSValue::encode(jsBoolean(asRegExpConstructor(JSValue::decode(thisValue))->multiline()));
}
JSValue regExpObjectMultiline(ExecState*, JSValue slotBase, PropertyName)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->multiline());
}
JSValue regExpObjectGlobal(ExecState*, JSValue slotBase, const Identifier&)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->global());
}
static EncodedJSValue JSC_HOST_CALL functionDFGTrue(ExecState*)
{
return JSValue::encode(jsBoolean(false));
}
JSValue regExpObjectIgnoreCase(ExecState*, JSValue slotBase, const Identifier&)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->ignoreCase());
}
// ECMA 15.6.2
AJObject* constructBoolean(ExecState* exec, const ArgList& args)
{
BooleanObject* obj = new (exec) BooleanObject(exec->lexicalGlobalObject()->booleanObjectStructure());
obj->setInternalValue(jsBoolean(args.at(0).toBoolean(exec)));
return obj;
}
JSValue regExpObjectMultiline(ExecState*, JSValue slotBase, const Identifier&)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->multiline());
}
EncodedJSValue regExpObjectMultiline(ExecState*, JSObject* slotBase, EncodedJSValue, PropertyName)
{
return JSValue::encode(jsBoolean(asRegExpObject(slotBase)->regExp()->multiline()));
}
JSValue RegExpObject::test(ExecState* exec)
{
return jsBoolean(match(exec));
}
EncodedJSValue JSC_HOST_CALL privateFuncIsSet(ExecState* exec)
{
return JSValue::encode(jsBoolean(jsDynamicCast<JSSet*>(exec->uncheckedArgument(0))));
}
void ScriptCallArgumentHandler::appendArgument(bool argument)
{
m_arguments.append(jsBoolean(argument));
}
JSValue QtInstance::booleanValue() const
{
// ECMA 9.2
return jsBoolean(getObject());
}
JSValue regExpObjectGlobal(ExecState*, JSValue slotBase, PropertyName)
{
return jsBoolean(asRegExpObject(slotBase)->regExp()->global());
}
TiValue JSC_HOST_CALL objectProtoFuncPropertyIsEnumerable(TiExcState* exec, TiObject*, TiValue thisValue, const ArgList& args)
{
return jsBoolean(thisValue.toThisObject(exec)->propertyIsEnumerable(exec, Identifier(exec, args.at(0).toString(exec))));
}
//--------------------------------------------------------------------------
// JSObjectKJSValue
//--------------------------------------------------------------------------
JSValue JSObjectKJSValue(JSUserObject* ptr)
{
JSGlueAPIEntry entry;
JSValue result = jsUndefined();
if (ptr)
{
bool handled = false;
switch (ptr->DataType())
{
case kJSUserObjectDataTypeJSValueWrapper:
{
JSValueWrapper* wrapper = (JSValueWrapper*)ptr->GetData();
if (wrapper)
{
result = wrapper->GetValue();
handled = true;
}
break;
}
case kJSUserObjectDataTypeCFType:
{
CFTypeRef cfType = (CFTypeRef*)ptr->GetData();
if (cfType)
{
CFTypeID typeID = CFGetTypeID(cfType);
if (typeID == CFStringGetTypeID())
{
result = jsString(getThreadGlobalExecState(), CFStringToUString((CFStringRef)cfType));
handled = true;
}
else if (typeID == CFNumberGetTypeID())
{
double num;
CFNumberGetValue((CFNumberRef)cfType, kCFNumberDoubleType, &num);
result = jsNumber(getThreadGlobalExecState(), num);
handled = true;
}
else if (typeID == CFBooleanGetTypeID())
{
result = jsBoolean(CFBooleanGetValue((CFBooleanRef)cfType));
handled = true;
}
else if (typeID == CFNullGetTypeID())
{
result = jsNull();
handled = true;
}
}
break;
}
}
if (!handled)
{
ExecState* exec = getThreadGlobalExecState();
result = new (exec) UserObjectImp(getThreadGlobalObject()->userObjectStructure(), ptr);
}
}
return result;
}
