2
* Copyright (C) 1999-2002 Harri Porten (porten@kde.org)
3
* Copyright (C) 2001 Peter Kelly (pmk@post.com)
4
* Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc. All rights reserved.
5
* Copyright (C) 2007 Cameron Zwarich (cwzwarich@uwaterloo.ca)
6
* Copyright (C) 2007 Maks Orlovich
8
* This library is free software; you can redistribute it and/or
9
* modify it under the terms of the GNU Library General Public
10
* License as published by the Free Software Foundation; either
11
* version 2 of the License, or (at your option) any later version.
13
* This library is distributed in the hope that it will be useful,
14
* but WITHOUT ANY WARRANTY; without even the implied warranty of
15
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16
* Library General Public License for more details.
18
* You should have received a copy of the GNU Library General Public License
19
* along with this library; see the file COPYING.LIB. If not, write to
20
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21
* Boston, MA 02110-1301, USA.
26
#include "JSGlobalObjectFunctions.h"
28
#include "CallFrame.h"
29
#include "Interpreter.h"
30
#include "JSFunction.h"
31
#include "JSGlobalObject.h"
33
#include "JSStringBuilder.h"
35
#include "LiteralParser.h"
41
#include <wtf/ASCIICType.h>
42
#include <wtf/Assertions.h>
43
#include <wtf/MathExtras.h>
44
#include <wtf/StringExtras.h>
45
#include <wtf/text/StringBuilder.h>
46
#include <wtf/unicode/UTF8.h>
49
using namespace Unicode;
53
static JSValue encode(ExecState* exec, const char* doNotEscape)
55
CString cstr = exec->argument(0).toString(exec)->value(exec).utf8(String::StrictConversion);
57
return throwError(exec, createURIError(exec, ASCIILiteral("String contained an illegal UTF-16 sequence.")));
59
JSStringBuilder builder;
60
const char* p = cstr.data();
61
for (size_t k = 0; k < cstr.length(); k++, p++) {
63
if (c && strchr(doNotEscape, c))
67
snprintf(tmp, sizeof(tmp), "%%%02X", static_cast<unsigned char>(c));
71
return builder.build(exec);
74
template <typename CharType>
76
static JSValue decode(ExecState* exec, const CharType* characters, int length, const char* doNotUnescape, bool strict)
78
JSStringBuilder builder;
82
const CharType* p = characters + k;
86
if (k <= length - 3 && isASCIIHexDigit(p[1]) && isASCIIHexDigit(p[2])) {
87
const char b0 = Lexer<CharType>::convertHex(p[1], p[2]);
88
const int sequenceLen = UTF8SequenceLength(b0);
89
if (sequenceLen && k <= length - sequenceLen * 3) {
90
charLen = sequenceLen * 3;
93
for (int i = 1; i < sequenceLen; ++i) {
94
const CharType* q = p + i * 3;
95
if (q[0] == '%' && isASCIIHexDigit(q[1]) && isASCIIHexDigit(q[2]))
96
sequence[i] = Lexer<CharType>::convertHex(q[1], q[2]);
103
sequence[sequenceLen] = 0;
104
const int character = decodeUTF8Sequence(sequence);
105
if (character < 0 || character >= 0x110000)
107
else if (character >= 0x10000) {
108
// Convert to surrogate pair.
109
builder.append(static_cast<UChar>(0xD800 | ((character - 0x10000) >> 10)));
110
u = static_cast<UChar>(0xDC00 | ((character - 0x10000) & 0x3FF));
112
u = static_cast<UChar>(character);
118
return throwError(exec, createURIError(exec, ASCIILiteral("URI error")));
119
// The only case where we don't use "strict" mode is the "unescape" function.
120
// For that, it's good to support the wonky "%u" syntax for compatibility with WinIE.
121
if (k <= length - 6 && p[1] == 'u'
122
&& isASCIIHexDigit(p[2]) && isASCIIHexDigit(p[3])
123
&& isASCIIHexDigit(p[4]) && isASCIIHexDigit(p[5])) {
125
u = Lexer<UChar>::convertUnicode(p[2], p[3], p[4], p[5]);
128
if (charLen && (u == 0 || u >= 128 || !strchr(doNotUnescape, u))) {
130
builder.append(static_cast<LChar>(u));
140
return builder.build(exec);
143
static JSValue decode(ExecState* exec, const char* doNotUnescape, bool strict)
145
JSStringBuilder builder;
146
String str = exec->argument(0).toString(exec)->value(exec);
149
return decode(exec, str.characters8(), str.length(), doNotUnescape, strict);
150
return decode(exec, str.characters16(), str.length(), doNotUnescape, strict);
153
bool isStrWhiteSpace(UChar c)
156
// ECMA-262-5th 7.2 & 7.3
169
return c > 0xff && isSeparatorSpace(c);
173
static int parseDigit(unsigned short c, int radix)
177
if (c >= '0' && c <= '9')
179
else if (c >= 'A' && c <= 'Z')
180
digit = c - 'A' + 10;
181
else if (c >= 'a' && c <= 'z')
182
digit = c - 'a' + 10;
189
double parseIntOverflow(const LChar* s, int length, int radix)
192
double radixMultiplier = 1.0;
194
for (const LChar* p = s + length - 1; p >= s; p--) {
195
if (radixMultiplier == std::numeric_limits<double>::infinity()) {
197
number = std::numeric_limits<double>::infinity();
201
int digit = parseDigit(*p, radix);
202
number += digit * radixMultiplier;
205
radixMultiplier *= radix;
211
double parseIntOverflow(const UChar* s, int length, int radix)
214
double radixMultiplier = 1.0;
216
for (const UChar* p = s + length - 1; p >= s; p--) {
217
if (radixMultiplier == std::numeric_limits<double>::infinity()) {
219
number = std::numeric_limits<double>::infinity();
223
int digit = parseDigit(*p, radix);
224
number += digit * radixMultiplier;
227
radixMultiplier *= radix;
234
template <typename CharType>
236
static double parseInt(const String& s, const CharType* data, int radix)
238
// 1. Let inputString be ToString(string).
239
// 2. Let S be a newly created substring of inputString consisting of the first character that is not a
240
// StrWhiteSpaceChar and all characters following that character. (In other words, remove leading white
241
// space.) If inputString does not contain any such characters, let S be the empty string.
242
int length = s.length();
244
while (p < length && isStrWhiteSpace(data[p]))
248
// 4. If S is not empty and the first character of S is a minus sign -, let sign be -1.
249
// 5. If S is not empty and the first character of S is a plus sign + or a minus sign -, then remove the first character from S.
254
else if (data[p] == '-') {
260
// 6. Let R = ToInt32(radix).
261
// 7. Let stripPrefix be true.
263
// b. If R != 16, let stripPrefix be false.
266
// 10. If stripPrefix is true, then
267
// a. If the length of S is at least 2 and the first two characters of S are either ā0x or ā0X,
268
// then remove the first two characters from S and let R = 16.
269
// 11. If S contains any character that is not a radix-R digit, then let Z be the substring of S
270
// consisting of all characters before the first such character; otherwise, let Z be S.
271
if ((radix == 0 || radix == 16) && length - p >= 2 && data[p] == '0' && (data[p + 1] == 'x' || data[p + 1] == 'X')) {
274
} else if (radix == 0)
277
// 8.a If R < 2 or R > 36, then return NaN.
278
if (radix < 2 || radix > 36)
281
// 13. Let mathInt be the mathematical integer value that is represented by Z in radix-R notation, using the letters
282
// A-Z and a-z for digits with values 10 through 35. (However, if R is 10 and Z contains more than 20 significant
283
// digits, every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation;
284
// and if R is not 2, 4, 8, 10, 16, or 32, then mathInt may be an implementation-dependent approximation to the
285
// mathematical integer value that is represented by Z in radix-R notation.)
286
// 14. Let number be the Number value for mathInt.
287
int firstDigitPosition = p;
288
bool sawDigit = false;
291
int digit = parseDigit(data[p], radix);
300
// 12. If Z is empty, return NaN.
304
// Alternate code path for certain large numbers.
305
if (number >= mantissaOverflowLowerBound) {
308
number = parseDouble(s.characters() + firstDigitPosition, p - firstDigitPosition, parsedLength);
309
} else if (radix == 2 || radix == 4 || radix == 8 || radix == 16 || radix == 32)
310
number = parseIntOverflow(s.substringSharingImpl(firstDigitPosition, p - firstDigitPosition).utf8().data(), p - firstDigitPosition, radix);
313
// 15. Return sign x number.
314
return sign * number;
317
static double parseInt(const String& s, int radix)
320
return parseInt(s, s.characters8(), radix);
321
return parseInt(s, s.characters16(), radix);
324
static const int SizeOfInfinity = 8;
326
template <typename CharType>
327
static bool isInfinity(const CharType* data, const CharType* end)
329
return (end - data) >= SizeOfInfinity
340
// See ecma-262 9.3.1
341
template <typename CharType>
342
static double jsHexIntegerLiteral(const CharType*& data, const CharType* end)
346
const CharType* firstDigitPosition = data;
349
number = number * 16 + toASCIIHexValue(*data);
353
if (!isASCIIHexDigit(*data))
356
if (number >= mantissaOverflowLowerBound)
357
number = parseIntOverflow(firstDigitPosition, data - firstDigitPosition, 16);
362
// See ecma-262 9.3.1
363
template <typename CharType>
364
static double jsStrDecimalLiteral(const CharType*& data, const CharType* end)
369
double number = parseDouble(data, end - data, parsedLength);
371
data += parsedLength;
375
// Check for [+-]?Infinity
378
if (isInfinity(data, end)) {
379
data += SizeOfInfinity;
380
return std::numeric_limits<double>::infinity();
385
if (isInfinity(data + 1, end)) {
386
data += SizeOfInfinity + 1;
387
return std::numeric_limits<double>::infinity();
392
if (isInfinity(data + 1, end)) {
393
data += SizeOfInfinity + 1;
394
return -std::numeric_limits<double>::infinity();
403
template <typename CharType>
404
static double toDouble(const CharType* characters, unsigned size)
406
const CharType* endCharacters = characters + size;
408
// Skip leading white space.
409
for (; characters < endCharacters; ++characters) {
410
if (!isStrWhiteSpace(*characters))
415
if (characters == endCharacters)
419
if (characters[0] == '0' && characters + 2 < endCharacters && (characters[1] | 0x20) == 'x' && isASCIIHexDigit(characters[2]))
420
number = jsHexIntegerLiteral(characters, endCharacters);
422
number = jsStrDecimalLiteral(characters, endCharacters);
424
// Allow trailing white space.
425
for (; characters < endCharacters; ++characters) {
426
if (!isStrWhiteSpace(*characters))
429
if (characters != endCharacters)
435
// See ecma-262 9.3.1
436
double jsToNumber(const String& s)
438
unsigned size = s.length();
444
if (isStrWhiteSpace(c))
450
return toDouble(s.characters8(), size);
451
return toDouble(s.characters16(), size);
454
static double parseFloat(const String& s)
456
unsigned size = s.length();
466
const LChar* data = s.characters8();
467
const LChar* end = data + size;
469
// Skip leading white space.
470
for (; data < end; ++data) {
471
if (!isStrWhiteSpace(*data))
479
return jsStrDecimalLiteral(data, end);
482
const UChar* data = s.characters16();
483
const UChar* end = data + size;
485
// Skip leading white space.
486
for (; data < end; ++data) {
487
if (!isStrWhiteSpace(*data))
495
return jsStrDecimalLiteral(data, end);
498
EncodedJSValue JSC_HOST_CALL globalFuncEval(ExecState* exec)
500
JSValue x = exec->argument(0);
502
return JSValue::encode(x);
504
String s = x.toString(exec)->value(exec);
507
LiteralParser<LChar> preparser(exec, s.characters8(), s.length(), NonStrictJSON);
508
if (JSValue parsedObject = preparser.tryLiteralParse())
509
return JSValue::encode(parsedObject);
511
LiteralParser<UChar> preparser(exec, s.characters16(), s.length(), NonStrictJSON);
512
if (JSValue parsedObject = preparser.tryLiteralParse())
513
return JSValue::encode(parsedObject);
516
JSGlobalObject* calleeGlobalObject = exec->callee()->globalObject();
517
EvalExecutable* eval = EvalExecutable::create(exec, makeSource(s), false);
518
JSObject* error = eval->compile(exec, calleeGlobalObject);
520
return throwVMError(exec, error);
522
return JSValue::encode(exec->interpreter()->execute(eval, exec, calleeGlobalObject->globalThis(), calleeGlobalObject));
525
EncodedJSValue JSC_HOST_CALL globalFuncParseInt(ExecState* exec)
527
JSValue value = exec->argument(0);
528
JSValue radixValue = exec->argument(1);
530
// Optimized handling for numbers:
531
// If the argument is 0 or a number in range 10^-6 <= n < INT_MAX+1, then parseInt
532
// results in a truncation to integer. In the case of -0, this is converted to 0.
534
// This is also a truncation for values in the range INT_MAX+1 <= n < 10^21,
535
// however these values cannot be trivially truncated to int since 10^21 exceeds
536
// even the int64_t range. Negative numbers are a little trickier, the case for
537
// values in the range -10^21 < n <= -1 are similar to those for integer, but
538
// values in the range -1 < n <= -10^-6 need to truncate to -0, not 0.
539
static const double tenToTheMinus6 = 0.000001;
540
static const double intMaxPlusOne = 2147483648.0;
541
if (value.isNumber()) {
542
double n = value.asNumber();
543
if (((n < intMaxPlusOne && n >= tenToTheMinus6) || !n) && radixValue.isUndefinedOrNull())
544
return JSValue::encode(jsNumber(static_cast<int32_t>(n)));
547
// If ToString throws, we shouldn't call ToInt32.
548
String s = value.toString(exec)->value(exec);
549
if (exec->hadException())
550
return JSValue::encode(jsUndefined());
552
return JSValue::encode(jsNumber(parseInt(s, radixValue.toInt32(exec))));
555
EncodedJSValue JSC_HOST_CALL globalFuncParseFloat(ExecState* exec)
557
return JSValue::encode(jsNumber(parseFloat(exec->argument(0).toString(exec)->value(exec))));
560
EncodedJSValue JSC_HOST_CALL globalFuncIsNaN(ExecState* exec)
562
return JSValue::encode(jsBoolean(isnan(exec->argument(0).toNumber(exec))));
565
EncodedJSValue JSC_HOST_CALL globalFuncIsFinite(ExecState* exec)
567
double n = exec->argument(0).toNumber(exec);
568
return JSValue::encode(jsBoolean(isfinite(n)));
571
EncodedJSValue JSC_HOST_CALL globalFuncDecodeURI(ExecState* exec)
573
static const char do_not_unescape_when_decoding_URI[] =
576
return JSValue::encode(decode(exec, do_not_unescape_when_decoding_URI, true));
579
EncodedJSValue JSC_HOST_CALL globalFuncDecodeURIComponent(ExecState* exec)
581
return JSValue::encode(decode(exec, "", true));
584
EncodedJSValue JSC_HOST_CALL globalFuncEncodeURI(ExecState* exec)
586
static const char do_not_escape_when_encoding_URI[] =
587
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
588
"abcdefghijklmnopqrstuvwxyz"
590
"!#$&'()*+,-./:;=?@_~";
592
return JSValue::encode(encode(exec, do_not_escape_when_encoding_URI));
595
EncodedJSValue JSC_HOST_CALL globalFuncEncodeURIComponent(ExecState* exec)
597
static const char do_not_escape_when_encoding_URI_component[] =
598
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
599
"abcdefghijklmnopqrstuvwxyz"
603
return JSValue::encode(encode(exec, do_not_escape_when_encoding_URI_component));
606
EncodedJSValue JSC_HOST_CALL globalFuncEscape(ExecState* exec)
608
static const char do_not_escape[] =
609
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
610
"abcdefghijklmnopqrstuvwxyz"
614
JSStringBuilder builder;
615
String str = exec->argument(0).toString(exec)->value(exec);
617
const LChar* c = str.characters8();
618
for (unsigned k = 0; k < str.length(); k++, c++) {
620
if (u && strchr(do_not_escape, static_cast<char>(u)))
621
builder.append(c, 1);
624
snprintf(tmp, sizeof(tmp), "%%%02X", u);
629
return JSValue::encode(builder.build(exec));
632
const UChar* c = str.characters16();
633
for (unsigned k = 0; k < str.length(); k++, c++) {
637
snprintf(tmp, sizeof(tmp), "%%u%04X", u);
639
} else if (u != 0 && strchr(do_not_escape, static_cast<char>(u)))
640
builder.append(c, 1);
643
snprintf(tmp, sizeof(tmp), "%%%02X", u);
648
return JSValue::encode(builder.build(exec));
651
EncodedJSValue JSC_HOST_CALL globalFuncUnescape(ExecState* exec)
653
StringBuilder builder;
654
String str = exec->argument(0).toString(exec)->value(exec);
656
int len = str.length();
659
const LChar* characters = str.characters8();
660
LChar convertedLChar;
662
const LChar* c = characters + k;
663
if (c[0] == '%' && k <= len - 6 && c[1] == 'u') {
664
if (isASCIIHexDigit(c[2]) && isASCIIHexDigit(c[3]) && isASCIIHexDigit(c[4]) && isASCIIHexDigit(c[5])) {
665
builder.append(Lexer<UChar>::convertUnicode(c[2], c[3], c[4], c[5]));
669
} else if (c[0] == '%' && k <= len - 3 && isASCIIHexDigit(c[1]) && isASCIIHexDigit(c[2])) {
670
convertedLChar = LChar(Lexer<LChar>::convertHex(c[1], c[2]));
678
const UChar* characters = str.characters16();
681
const UChar* c = characters + k;
682
UChar convertedUChar;
683
if (c[0] == '%' && k <= len - 6 && c[1] == 'u') {
684
if (isASCIIHexDigit(c[2]) && isASCIIHexDigit(c[3]) && isASCIIHexDigit(c[4]) && isASCIIHexDigit(c[5])) {
685
convertedUChar = Lexer<UChar>::convertUnicode(c[2], c[3], c[4], c[5]);
689
} else if (c[0] == '%' && k <= len - 3 && isASCIIHexDigit(c[1]) && isASCIIHexDigit(c[2])) {
690
convertedUChar = UChar(Lexer<UChar>::convertHex(c[1], c[2]));
699
return JSValue::encode(jsString(exec, builder.toString()));
702
EncodedJSValue JSC_HOST_CALL globalFuncThrowTypeError(ExecState* exec)
704
return throwVMTypeError(exec);
707
EncodedJSValue JSC_HOST_CALL globalFuncProtoGetter(ExecState* exec)
709
if (!exec->thisValue().isObject())
710
return JSValue::encode(exec->thisValue().synthesizePrototype(exec));
712
JSObject* thisObject = asObject(exec->thisValue());
713
if (!thisObject->allowsAccessFrom(exec->trueCallerFrame()))
714
return JSValue::encode(jsUndefined());
716
return JSValue::encode(thisObject->prototype());
719
EncodedJSValue JSC_HOST_CALL globalFuncProtoSetter(ExecState* exec)
721
JSValue value = exec->argument(0);
723
// Setting __proto__ of a primitive should have no effect.
724
if (!exec->thisValue().isObject())
725
return JSValue::encode(jsUndefined());
727
JSObject* thisObject = asObject(exec->thisValue());
728
if (!thisObject->allowsAccessFrom(exec->trueCallerFrame()))
729
return JSValue::encode(jsUndefined());
731
// Setting __proto__ to a non-object, non-null value is silently ignored to match Mozilla.
732
if (!value.isObject() && !value.isNull())
733
return JSValue::encode(jsUndefined());
735
if (!thisObject->isExtensible())
736
return throwVMError(exec, createTypeError(exec, StrictModeReadonlyPropertyWriteError));
738
if (!thisObject->setPrototypeWithCycleCheck(exec->globalData(), value))
739
throwError(exec, createError(exec, "cyclic __proto__ value"));
740
return JSValue::encode(jsUndefined());