JSObject* IntlCollator::resolvedOptions(ExecState& state)
{
// 10.3.5 Intl.Collator.prototype.resolvedOptions() (ECMA-402 2.0)
// The function returns a new object whose properties and attributes are set as if
// constructed by an object literal assigning to each of the following properties the
// value of the corresponding internal slot of this Collator object (see 10.4): locale,
// usage, sensitivity, ignorePunctuation, collation, as well as those properties shown
// in Table 1 whose keys are included in the %Collator%[[relevantExtensionKeys]]
// internal slot of the standard built-in object that is the initial value of
// Intl.Collator.
if (!m_initializedCollator) {
initializeCollator(state, jsUndefined(), jsUndefined());
ASSERT(!state.hadException());
}
VM& vm = state.vm();
JSObject* options = constructEmptyObject(&state);
options->putDirect(vm, vm.propertyNames->locale, jsString(&state, m_locale));
options->putDirect(vm, vm.propertyNames->usage, jsNontrivialString(&state, ASCIILiteral(usageString(m_usage))));
options->putDirect(vm, vm.propertyNames->sensitivity, jsNontrivialString(&state, ASCIILiteral(sensitivityString(m_sensitivity))));
options->putDirect(vm, vm.propertyNames->ignorePunctuation, jsBoolean(m_ignorePunctuation));
options->putDirect(vm, vm.propertyNames->collation, jsString(&state, m_collation));
options->putDirect(vm, vm.propertyNames->numeric, jsBoolean(m_numeric));
return options;
}
EncodedJSValue JSC_HOST_CALL dateProtoFuncToISOString(ExecState* exec)
{
JSValue thisValue = exec->thisValue();
if (!thisValue.inherits(DateInstance::info()))
return throwVMTypeError(exec);
DateInstance* thisDateObj = asDateInstance(thisValue);
if (!std::isfinite(thisDateObj->internalNumber()))
return throwVMError(exec, createRangeError(exec, ASCIILiteral("Invalid Date")));
const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTimeUTC(exec);
if (!gregorianDateTime)
return JSValue::encode(jsNontrivialString(exec, String(ASCIILiteral("Invalid Date"))));
// Maximum amount of space we need in buffer: 7 (max. digits in year) + 2 * 5 (2 characters each for month, day, hour, minute, second) + 4 (. + 3 digits for milliseconds)
// 6 for formatting and one for null termination = 28. We add one extra character to allow us to force null termination.
char buffer[28];
// If the year is outside the bounds of 0 and 9999 inclusive we want to use the extended year format (ES 15.9.1.15.1).
int ms = static_cast<int>(fmod(thisDateObj->internalNumber(), msPerSecond));
if (ms < 0)
ms += msPerSecond;
int charactersWritten;
if (gregorianDateTime->year() > 9999 || gregorianDateTime->year() < 0)
charactersWritten = snprintf(buffer, sizeof(buffer), "%+07d-%02d-%02dT%02d:%02d:%02d.%03dZ", gregorianDateTime->year(), gregorianDateTime->month() + 1, gregorianDateTime->monthDay(), gregorianDateTime->hour(), gregorianDateTime->minute(), gregorianDateTime->second(), ms);
else
charactersWritten = snprintf(buffer, sizeof(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", gregorianDateTime->year(), gregorianDateTime->month() + 1, gregorianDateTime->monthDay(), gregorianDateTime->hour(), gregorianDateTime->minute(), gregorianDateTime->second(), ms);
ASSERT(charactersWritten > 0 && static_cast<unsigned>(charactersWritten) < sizeof(buffer));
if (static_cast<unsigned>(charactersWritten) >= sizeof(buffer))
return JSValue::encode(jsEmptyString(exec));
return JSValue::encode(jsNontrivialString(exec, String(buffer, charactersWritten)));
}
// ECMA 15.9.4
ErrorPrototype::ErrorPrototype(ExecState* exec, ObjectPrototype* objectPrototype, FunctionPrototype* functionPrototype)
: ErrorInstance(objectPrototype)
{
// The constructor will be added later in ErrorConstructor's constructor
putDirect(exec->propertyNames().name, jsNontrivialString(exec, "Error"), DontEnum);
putDirect(exec->propertyNames().message, jsNontrivialString(exec, "Unknown error"), DontEnum);
putDirectFunction(exec, new (exec) PrototypeFunction(exec, functionPrototype, 0, exec->propertyNames().toString, errorProtoFuncToString), DontEnum);
}
// ECMA 15.9.4
ErrorPrototype::ErrorPrototype(ExecState* exec, NonNullPassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
: ErrorInstance(structure)
{
// The constructor will be added later in ErrorConstructor's constructor
putDirectWithoutTransition(exec->propertyNames().name, jsNontrivialString(exec, "Error"), DontEnum);
putDirectWithoutTransition(exec->propertyNames().message, jsNontrivialString(exec, "Unknown error"), DontEnum);
putDirectFunctionWithoutTransition(exec, new (exec) NativeFunctionWrapper(exec, prototypeFunctionStructure, 0, exec->propertyNames().toString, errorProtoFuncToString), DontEnum);
}
JSValue WebInjectedScriptHost::type(JSC::ExecState* exec, JSC::JSValue value)
{
if (value.inherits(JSNode::info()))
return jsNontrivialString(exec, ASCIILiteral("node"));
if (value.inherits(JSNodeList::info()))
return jsNontrivialString(exec, ASCIILiteral("array"));
if (value.inherits(JSHTMLCollection::info()))
return jsNontrivialString(exec, ASCIILiteral("array"));
return jsUndefined();
}
JSValue JSJavaScriptCallFrame::type(ExecState* exec) const
{
switch (impl().type()) {
case DebuggerCallFrame::FunctionType:
return jsNontrivialString(exec, ASCIILiteral("function"));
case DebuggerCallFrame::ProgramType:
return jsNontrivialString(exec, ASCIILiteral("program"));
}
ASSERT_NOT_REACHED();
return jsNull();
}
JSString* errorDescriptionForValue(ExecState* exec, JSValue v)
{
if (v.isString())
return jsNontrivialString(exec, makeString('"', asString(v)->value(exec), '"'));
if (v.isSymbol())
return jsNontrivialString(exec, asSymbol(v)->descriptiveString());
if (v.isObject()) {
CallData callData;
JSObject* object = asObject(v);
if (object->methodTable()->getCallData(object, callData) != CallType::None)
return exec->vm().smallStrings.functionString();
return jsString(exec, JSObject::calculatedClassName(object));
}
return v.toString(exec);
}
EncodedJSValue JSC_HOST_CALL dateProtoFuncToTimeString(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&DateInstance::s_info))
return throwVMTypeError(exec);
DateInstance* thisDateObj = asDateInstance(thisValue);
const GregorianDateTime* gregorianDateTime = thisDateObj->gregorianDateTime(exec);
if (!gregorianDateTime)
return JSValue::encode(jsNontrivialString(exec, "Invalid Date"));
DateConversionBuffer time;
formatTime(*gregorianDateTime, time);
return JSValue::encode(jsNontrivialString(exec, time));
}
JSObject* IntlPluralRules::resolvedOptions(ExecState& exec)
{
VM& vm = exec.vm();
auto scope = DECLARE_THROW_SCOPE(vm);
// 13.4.4 Intl.PluralRules.prototype.resolvedOptions ()
// https://tc39.github.io/ecma402/#sec-intl.pluralrules.prototype.resolvedoptions
if (UNLIKELY(!m_initializedPluralRules)) {
throwTypeError(&exec, scope, "Intl.PluralRules.prototype.resolvedOptions called on value that's not an object initialized as a PluralRules"_s);
return nullptr;
}
JSObject* options = constructEmptyObject(&exec);
options->putDirect(vm, vm.propertyNames->locale, jsNontrivialString(&exec, m_locale));
options->putDirect(vm, Identifier::fromString(&vm, "type"), jsNontrivialString(&exec, m_type == UPLURAL_TYPE_ORDINAL ? "ordinal"_s : "cardinal"_s));
options->putDirect(vm, Identifier::fromString(&vm, "minimumIntegerDigits"), jsNumber(m_minimumIntegerDigits));
options->putDirect(vm, Identifier::fromString(&vm, "minimumFractionDigits"), jsNumber(m_minimumFractionDigits));
options->putDirect(vm, Identifier::fromString(&vm, "maximumFractionDigits"), jsNumber(m_maximumFractionDigits));
if (m_minimumSignificantDigits) {
options->putDirect(vm, Identifier::fromString(&vm, "minimumSignificantDigits"), jsNumber(m_minimumSignificantDigits.value()));
options->putDirect(vm, Identifier::fromString(&vm, "maximumSignificantDigits"), jsNumber(m_maximumSignificantDigits.value()));
}
#if HAVE(ICU_PLURALRULES_KEYWORDS)
JSGlobalObject* globalObject = exec.jsCallee()->globalObject(vm);
JSArray* categories = JSArray::tryCreate(vm, globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous), 0);
if (UNLIKELY(!categories)) {
throwOutOfMemoryError(&exec, scope);
return nullptr;
}
UErrorCode status = U_ZERO_ERROR;
auto keywords = std::unique_ptr<UEnumeration, UEnumerationDeleter>(uplrules_getKeywords(m_pluralRules.get(), &status));
ASSERT(U_SUCCESS(status));
int32_t resultLength;
// Category names are always ASCII, so use char[].
unsigned index = 0;
while (const char* result = uenum_next(keywords.get(), &resultLength, &status)) {
ASSERT(U_SUCCESS(status));
categories->putDirectIndex(&exec, index++, jsNontrivialString(&exec, String(result, resultLength)));
RETURN_IF_EXCEPTION(scope, { });
}
options->putDirect(vm, Identifier::fromString(&vm, "pluralCategories"), categories);
#endif
RELEASE_AND_RETURN(scope, options);
}
void ErrorPrototype::finishCreation(VM& vm)
{
Base::finishCreation(vm);
ASSERT(inherits(vm, info()));
putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("Error"))), DontEnum);
putDirect(vm, vm.propertyNames->message, jsEmptyString(&vm), DontEnum);
}
EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState* exec)
{
VM& vm = exec->vm();
JSValue thisValue = exec->thisValue().toThis(exec, StrictMode);
if (thisValue.isUndefinedOrNull())
return JSValue::encode(thisValue.isUndefined() ? vm.smallStrings.undefinedObjectString() : vm.smallStrings.nullObjectString());
JSObject* thisObject = thisValue.toObject(exec);
JSValue stringTag = thisObject->get(exec, exec->propertyNames().toStringTagSymbol);
if (stringTag.isString()) {
JSRopeString::RopeBuilder<RecordOverflow> ropeBuilder(vm);
ropeBuilder.append(vm.smallStrings.objectStringStart());
ropeBuilder.append(jsCast<JSString*>(stringTag));
ropeBuilder.append(vm.smallStrings.singleCharacterString(']'));
if(ropeBuilder.hasOverflowed())
return JSValue::encode(throwOutOfMemoryError(exec));
return JSValue::encode(ropeBuilder.release());
}
JSString* result = thisObject->structure(vm)->objectToStringValue();
if (!result) {
RefPtr<StringImpl> newString = WTF::tryMakeString("[object ", thisObject->methodTable(exec->vm())->className(thisObject), "]");
if (!newString)
return JSValue::encode(throwOutOfMemoryError(exec));
result = jsNontrivialString(&vm, newString.release());
thisObject->structure(vm)->setObjectToStringValue(vm, result);
}
return JSValue::encode(result);
}
EncodedJSValue JSC_HOST_CALL regExpProtoFuncToString(ExecState* exec)
{
JSValue thisValue = exec->hostThisValue();
if (!thisValue.inherits(&RegExpObject::s_info)) {
if (thisValue.inherits(&RegExpPrototype::s_info))
return JSValue::encode(jsNontrivialString(exec, "//"));
return throwVMTypeError(exec);
}
RegExpObject* thisObject = asRegExpObject(thisValue);
StringRecursionChecker checker(exec, thisObject);
if (EncodedJSValue earlyReturnValue = checker.earlyReturnValue())
return earlyReturnValue;
char postfix[5] = { '/', 0, 0, 0, 0 };
int index = 1;
if (thisObject->get(exec, exec->propertyNames().global).toBoolean(exec))
postfix[index++] = 'g';
if (thisObject->get(exec, exec->propertyNames().ignoreCase).toBoolean(exec))
postfix[index++] = 'i';
if (thisObject->get(exec, exec->propertyNames().multiline).toBoolean(exec))
postfix[index] = 'm';
UString source = thisObject->get(exec, exec->propertyNames().source).toString(exec);
// If source is empty, use "/(?:)/" to avoid colliding with comment syntax
return JSValue::encode(jsMakeNontrivialString(exec, "/", source.length() ? source : UString("(?:)"), postfix));
}
EncodedJSValue JSC_HOST_CALL numberProtoFuncToString(ExecState* exec)
{
double doubleValue;
if (!toThisNumber(exec->thisValue(), doubleValue))
return throwVMTypeError(exec);
int32_t radix = extractRadixFromArgs(exec);
if (radix < 2 || radix > 36)
return throwVMError(exec, createRangeError(exec, ASCIILiteral("toString() radix argument must be between 2 and 36")));
int32_t integerValue = static_cast<int32_t>(doubleValue);
if (integerValue == doubleValue)
return integerValueToString(exec, radix, integerValue);
if (radix == 10) {
VM* vm = &exec->vm();
return JSValue::encode(jsString(vm, vm->numericStrings.add(doubleValue)));
}
if (!std::isfinite(doubleValue))
return JSValue::encode(jsNontrivialString(exec, String::numberToStringECMAScript(doubleValue)));
RadixBuffer s;
return JSValue::encode(jsString(exec, toStringWithRadix(s, doubleValue, radix)));
}
// ECMA 15.9.2
static EncodedJSValue JSC_HOST_CALL callDate(ExecState* exec)
{
VM& vm = exec->vm();
GregorianDateTime ts;
msToGregorianDateTime(vm, currentTimeMS(), false, ts);
return JSValue::encode(jsNontrivialString(&vm, formatDateTime(ts, DateTimeFormatDateAndTime, false)));
}
static EncodedJSValue formateDateInstance(ExecState* exec, DateTimeFormat format, bool asUTCVariant)
{
JSValue thisValue = exec->thisValue();
if (!thisValue.inherits(DateInstance::info()))
return throwVMTypeError(exec);
DateInstance* thisDateObj = asDateInstance(thisValue);
const GregorianDateTime* gregorianDateTime = asUTCVariant
? thisDateObj->gregorianDateTimeUTC(exec)
: thisDateObj->gregorianDateTime(exec);
if (!gregorianDateTime)
return JSValue::encode(jsNontrivialString(exec, String(ASCIILiteral("Invalid Date"))));
return JSValue::encode(jsNontrivialString(exec, formatDateTime(*gregorianDateTime, format, asUTCVariant)));
}
template<> void JSTestInterfaceConstructor::initializeProperties(VM& vm, JSDOMGlobalObject& globalObject)
{
putDirect(vm, vm.propertyNames->prototype, JSTestInterface::prototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestInterface"))), ReadOnly | DontEnum);
putDirect(vm, vm.propertyNames->length, jsNumber(1), ReadOnly | DontEnum);
reifyStaticProperties(vm, JSTestInterfaceConstructorTableValues, *this);
}
// toExponential converts a number to a string, always formatting as an expoential.
// This method takes an optional argument specifying a number of *decimal places*
// to round the significand to (or, put another way, this method optionally rounds
// to argument-plus-one significant figures).
EncodedJSValue JSC_HOST_CALL numberProtoFuncToExponential(ExecState* exec)
{
double x;
if (!toThisNumber(exec->thisValue(), x))
return throwVMTypeError(exec);
// Get the argument.
int decimalPlacesInExponent;
bool isUndefined;
if (!getIntegerArgumentInRange(exec, 0, 20, decimalPlacesInExponent, isUndefined))
return throwVMError(exec, createRangeError(exec, ASCIILiteral("toExponential() argument must be between 0 and 20")));
// Handle NaN and Infinity.
if (!std::isfinite(x))
return JSValue::encode(jsNontrivialString(exec, String::numberToStringECMAScript(x)));
// Round if the argument is not undefined, always format as exponential.
char buffer[WTF::NumberToStringBufferLength];
DoubleConversionStringBuilder builder(buffer, WTF::NumberToStringBufferLength);
const DoubleToStringConverter& converter = DoubleToStringConverter::EcmaScriptConverter();
builder.Reset();
isUndefined
? converter.ToExponential(x, -1, &builder)
: converter.ToExponential(x, decimalPlacesInExponent, &builder);
return JSValue::encode(jsString(exec, String(builder.Finalize())));
}
static JSCell* formatLocaleDate(ExecState* exec, DateInstance* dateObject, double, LocaleDateTimeFormat format)
{
const GregorianDateTime* gregorianDateTime = dateObject->gregorianDateTime(exec);
if (!gregorianDateTime)
return jsNontrivialString(exec, ASCIILiteral("Invalid Date"));
return formatLocaleDate(exec, *gregorianDateTime, format);
}
JSValue JSC_HOST_CALL dateProtoFuncToGMTString(ExecState* exec, JSObject*, JSValue thisValue, const ArgList&)
{
if (!thisValue.isObject(&DateInstance::info))
return throwError(exec, TypeError);
const bool utc = true;
DateInstance* thisDateObj = asDateInstance(thisValue);
double milli = thisDateObj->internalNumber();
if (isnan(milli))
return jsNontrivialString(exec, "Invalid Date");
GregorianDateTime t;
thisDateObj->msToGregorianDateTime(milli, utc, t);
return jsNontrivialString(exec, formatDateUTCVariant(t) + " " + formatTime(t, utc));
}
JSValue JSC_HOST_CALL stringProtoFuncLink(ExecState* exec, JSObject*, JSValue thisValue, const ArgList& args)
{
UString s = thisValue.toThisString(exec);
JSValue a0 = args.at(0);
UString linkText = a0.toString(exec);
unsigned linkTextSize = linkText.size();
unsigned stringSize = s.size();
unsigned bufferSize = 15 + linkTextSize + stringSize;
UChar* buffer = static_cast<UChar*>(tryFastMalloc(bufferSize * sizeof(UChar)));
if (!buffer)
return jsUndefined();
buffer[0] = '<';
buffer[1] = 'a';
buffer[2] = ' ';
buffer[3] = 'h';
buffer[4] = 'r';
buffer[5] = 'e';
buffer[6] = 'f';
buffer[7] = '=';
buffer[8] = '"';
memcpy(&buffer[9], linkText.data(), linkTextSize * sizeof(UChar));
buffer[9 + linkTextSize] = '"';
buffer[10 + linkTextSize] = '>';
memcpy(&buffer[11 + linkTextSize], s.data(), stringSize * sizeof(UChar));
buffer[11 + linkTextSize + stringSize] = '<';
buffer[12 + linkTextSize + stringSize] = '/';
buffer[13 + linkTextSize + stringSize] = 'a';
buffer[14 + linkTextSize + stringSize] = '>';
return jsNontrivialString(exec, UString(buffer, bufferSize, false));
}
static JSCell* formatLocaleDate(ExecState* exec, DateInstance*, double timeInMilliseconds, LocaleDateTimeFormat format)
{
CFDateFormatterStyle dateStyle = (format != LocaleTime ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);
CFDateFormatterStyle timeStyle = (format != LocaleDate ? kCFDateFormatterLongStyle : kCFDateFormatterNoStyle);
bool useCustomFormat = false;
String customFormatString;
String arg0String = exec->argument(0).toString(exec)->value(exec);
if (arg0String == "custom" && !exec->argument(1).isUndefined()) {
useCustomFormat = true;
customFormatString = exec->argument(1).toString(exec)->value(exec);
} else if (format == LocaleDateAndTime && !exec->argument(1).isUndefined()) {
dateStyle = styleFromArgString(arg0String, dateStyle);
timeStyle = styleFromArgString(exec->argument(1).toString(exec)->value(exec), timeStyle);
} else if (format != LocaleTime && !exec->argument(0).isUndefined())
dateStyle = styleFromArgString(arg0String, dateStyle);
else if (format != LocaleDate && !exec->argument(0).isUndefined())
timeStyle = styleFromArgString(arg0String, timeStyle);
CFAbsoluteTime absoluteTime = floor(timeInMilliseconds / msPerSecond) - kCFAbsoluteTimeIntervalSince1970;
auto formatter = adoptCF(CFDateFormatterCreate(kCFAllocatorDefault, adoptCF(CFLocaleCopyCurrent()).get(), dateStyle, timeStyle));
if (useCustomFormat)
CFDateFormatterSetFormat(formatter.get(), customFormatString.createCFString().get());
return jsNontrivialString(exec, adoptCF(CFDateFormatterCreateStringWithAbsoluteTime(kCFAllocatorDefault, formatter.get(), absoluteTime)).get());
}
EncodedJSValue JSC_HOST_CALL errorProtoFuncToString(ExecState* exec)
{
JSObject* thisObj = exec->hostThisValue().toThisObject(exec);
JSValue name = thisObj->get(exec, exec->propertyNames().name);
JSValue message = thisObj->get(exec, exec->propertyNames().message);
// Mozilla-compatible format.
if (!name.isUndefined()) {
if (!message.isUndefined())
return JSValue::encode(jsMakeNontrivialString(exec, name.toString(exec), ": ", message.toString(exec)));
return JSValue::encode(jsNontrivialString(exec, name.toString(exec)));
}
if (!message.isUndefined())
return JSValue::encode(jsMakeNontrivialString(exec, "Error: ", message.toString(exec)));
return JSValue::encode(jsNontrivialString(exec, "Error"));
}
// ECMA 15.9.2
static JSValue* callDate(ExecState* exec, JSObject*, JSValue*, const ArgList&)
{
time_t localTime = time(0);
tm localTM;
getLocalTime(&localTime, &localTM);
GregorianDateTime ts(localTM);
return jsNontrivialString(exec, formatDate(ts) + " " + formatTime(ts, false));
}
TiValue JSC_HOST_CALL booleanProtoFuncToString(TiExcState* exec, TiObject*, TiValue thisValue, const ArgList&)
{
if (thisValue == jsBoolean(false))
return jsNontrivialString(exec, "false");
if (thisValue == jsBoolean(true))
return jsNontrivialString(exec, "true");
if (!thisValue.inherits(&BooleanObject::info))
return throwError(exec, TypeError);
if (asBooleanObject(thisValue)->internalValue() == jsBoolean(false))
return jsNontrivialString(exec, "false");
ASSERT(asBooleanObject(thisValue)->internalValue() == jsBoolean(true));
return jsNontrivialString(exec, "true");
}
ErrorPrototype::ErrorPrototype(TiExcState* exec, TiGlobalObject* globalObject, Structure* structure)
: ErrorInstance(&exec->globalData(), structure)
{
putDirectWithoutTransition(exec->globalData(), exec->propertyNames().name, jsNontrivialString(exec, "Error"), DontEnum);
ASSERT(inherits(&s_info));
putAnonymousValue(globalObject->globalData(), 0, globalObject);
}
void JSTestNodeConstructor::finishCreation(VM& vm, JSDOMGlobalObject& globalObject)
{
Base::finishCreation(vm);
ASSERT(inherits(info()));
putDirect(vm, vm.propertyNames->prototype, JSTestNode::getPrototype(vm, &globalObject), DontDelete | ReadOnly | DontEnum);
putDirect(vm, vm.propertyNames->name, jsNontrivialString(&vm, String(ASCIILiteral("TestNode"))), ReadOnly | DontEnum);
putDirect(vm, vm.propertyNames->length, jsNumber(0), ReadOnly | DontEnum);
}
JSValue* booleanProtoFuncToString(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&)
{
if (thisValue == jsBoolean(false))
return jsNontrivialString(exec, "false");
if (thisValue == jsBoolean(true))
return jsNontrivialString(exec, "true");
if (!thisValue->isObject(&BooleanObject::info))
return throwError(exec, TypeError);
if (asBooleanObject(thisValue)->internalValue() == jsBoolean(false))
return jsNontrivialString(exec, "false");
ASSERT(asBooleanObject(thisValue)->internalValue() == jsBoolean(true));
return jsNontrivialString(exec, "true");
}
// ECMA-262 5.1, 15.11.4.4
EncodedJSValue JSC_HOST_CALL errorProtoFuncToString(ExecState* exec)
{
// 1. Let O be the this value.
JSValue thisValue = exec->hostThisValue();
// 2. If Type(O) is not Object, throw a TypeError exception.
if (!thisValue.isObject())
return throwVMTypeError(exec);
JSObject* thisObj = asObject(thisValue);
// Guard against recursion!
StringRecursionChecker checker(exec, thisObj);
if (JSValue earlyReturnValue = checker.earlyReturnValue())
return JSValue::encode(earlyReturnValue);
// 3. Let name be the result of calling the [[Get]] internal method of O with argument "name".
JSValue name = thisObj->get(exec, exec->propertyNames().name);
if (exec->hadException())
return JSValue::encode(jsUndefined());
// 4. If name is undefined, then let name be "Error"; else let name be ToString(name).
String nameString;
if (name.isUndefined())
nameString = ASCIILiteral("Error");
else {
nameString = name.toString(exec)->value(exec);
if (exec->hadException())
return JSValue::encode(jsUndefined());
}
// 5. Let msg be the result of calling the [[Get]] internal method of O with argument "message".
JSValue message = thisObj->get(exec, exec->propertyNames().message);
if (exec->hadException())
return JSValue::encode(jsUndefined());
// (sic)
// 6. If msg is undefined, then let msg be the empty String; else let msg be ToString(msg).
// 7. If msg is undefined, then let msg be the empty String; else let msg be ToString(msg).
String messageString;
if (message.isUndefined())
messageString = String();
else {
messageString = message.toString(exec)->value(exec);
if (exec->hadException())
return JSValue::encode(jsUndefined());
}
// 8. If name is the empty String, return msg.
if (!nameString.length())
return JSValue::encode(message.isString() ? message : jsString(exec, messageString));
// 9. If msg is the empty String, return name.
if (!messageString.length())
return JSValue::encode(name.isString() ? name : jsNontrivialString(exec, nameString));
// 10. Return the result of concatenating name, ":", a single space character, and msg.
return JSValue::encode(jsMakeNontrivialString(exec, nameString, ": ", messageString));
}
JSObject* JSLazyEventListener::initializeJSFunction(ScriptExecutionContext* executionContext) const
{
ASSERT(executionContext);
ASSERT(executionContext->isDocument());
if (!executionContext)
return 0;
Document* document = static_cast<Document*>(executionContext);
if (!document->frame())
return 0;
if (!document->contentSecurityPolicy()->allowInlineEventHandlers())
return 0;
ScriptController* script = document->frame()->script();
if (!script->canExecuteScripts(AboutToExecuteScript) || script->isPaused())
return 0;
JSDOMGlobalObject* globalObject = toJSDOMGlobalObject(executionContext, isolatedWorld());
if (!globalObject)
return 0;
ExecState* exec = globalObject->globalExec();
MarkedArgumentBuffer args;
args.append(jsNontrivialString(exec, stringToUString(m_eventParameterName)));
args.append(jsString(exec, m_code));
JSObject* jsFunction = constructFunctionSkippingEvalEnabledCheck(exec, exec->lexicalGlobalObject(), args, Identifier(exec, stringToUString(m_functionName)), stringToUString(m_sourceURL), m_position); // FIXME: is globalExec ok?
if (exec->hadException()) {
reportCurrentException(exec);
exec->clearException();
return 0;
}
JSFunction* listenerAsFunction = jsCast<JSFunction*>(jsFunction);
if (m_originalNode) {
if (!wrapper()) {
// Ensure that 'node' has a JavaScript wrapper to mark the event listener we're creating.
JSLock lock(SilenceAssertionsOnly);
// FIXME: Should pass the global object associated with the node
setWrapper(exec->globalData(), asObject(toJS(exec, globalObject, m_originalNode)));
}
// Add the event's home element to the scope
// (and the document, and the form - see JSHTMLElement::eventHandlerScope)
listenerAsFunction->setScope(exec->globalData(), jsCast<JSNode*>(wrapper())->pushEventHandlerScope(exec, listenerAsFunction->scope()));
}
// Since we only parse once, there's no need to keep data used for parsing around anymore.
m_functionName = String();
m_code = String();
m_eventParameterName = String();
m_sourceURL = String();
return jsFunction;
}
JSValue* regExpProtoFuncToString(ExecState* exec, JSObject*, JSValue* thisValue, const ArgList&)
{
if (!thisValue->isObject(&RegExpObject::info)) {
if (thisValue->isObject(&RegExpPrototype::info))
return jsNontrivialString(exec, "//");
return throwError(exec, TypeError);
}
UString result = "/" + asRegExpObject(thisValue)->get(exec, exec->propertyNames().source)->toString(exec);
result.append('/');
if (asRegExpObject(thisValue)->get(exec, exec->propertyNames().global)->toBoolean(exec))
result.append('g');
if (asRegExpObject(thisValue)->get(exec, exec->propertyNames().ignoreCase)->toBoolean(exec))
result.append('i');
if (asRegExpObject(thisValue)->get(exec, exec->propertyNames().multiline)->toBoolean(exec))
result.append('m');
return jsNontrivialString(exec, result);
}