{

// m_objectPrototype has been initialized ahead of any other builtins

ASSERT(!!m_objectPrototype);

/*

#define DECLARE_BUILTIN_INIT_FUNC(OBJNAME, objName, ARG) \

initialize##objName(state);

GLOBALOBJECT_BUILTIN_OBJECT_LIST(DECLARE_BUILTIN_INIT_FUNC, )

#undef DECLARE_BUILTIN_INIT_FUNC

{

bool result = false;

Value arg = argv[0];

if (arg.isObject() && arg.asObject()->isScriptFunctionObject()) {

result = arg.asObject()->asScriptFunctionObject()->interpretedCodeBlock()->canAllocateEnvironmentOnStack();

}

return Value(result);

{

bool result = false;

Value arg = argv[0];

auto blockIndex = argv[1].toInt32(state);

if (arg.isObject() && arg.asObject()->isScriptFunctionObject()) {

auto bi = arg.asObject()->asScriptFunctionObject()->interpretedCodeBlock()->blockInfo((uint16_t)blockIndex);

if (bi) {

result = bi->canAllocateEnvironmentOnStack();

}

}

return Value(result);

{

NativeFunctionObject* fn = (NativeFunctionObject*)state.resolveCallee();

Context* realm = fn->codeBlock()->context();

return realm->globalObject()->eval(state, argv[0]);

{

ObjectHasPropertyResult hasResult = Object::hasProperty(state, P);

if (!hasResult.hasProperty() && UNLIKELY((bool)state.context()->virtualIdentifierCallback())) {

Object* target = getPrototypeObject(state);

while (target) {

ObjectHasPropertyResult targetHasProperty = target->hasProperty(state, P);

if (targetHasProperty.hasProperty()) {

return hasResult;

}

target = target->getPrototypeObject(state);

}

Value virtialIdResult = state.context()->virtualIdentifierCallback()(state, P.toPlainValue());

if (!virtialIdResult.isEmpty()) {

return ObjectHasPropertyResult(ObjectGetResult(virtialIdResult, true, true, true));

}

}

return hasResult;

{

ObjectGetResult r = Object::getOwnProperty(state, P);

if (!r.hasValue() && UNLIKELY((bool)state.context()->virtualIdentifierCallback())) {

Object* target = getPrototypeObject(state);

while (target) {

auto result = target->getOwnProperty(state, P);

if (result.hasValue()) {

return r;

}

target = target->getPrototypeObject(state);

}

Value virtialIdResult = state.context()->virtualIdentifierCallback()(state, P.toPlainValue());

if (!virtialIdResult.isEmpty())

return ObjectGetResult(virtialIdResult, true, true, true);

}

return r;

{

if (arg.isString()) {

if (UNLIKELY((bool)state.context()->securityPolicyCheckCallback())) {

Value checkMSG = state.context()->securityPolicyCheckCallback()(state, true);

if (!checkMSG.isEmpty()) {

ASSERT(checkMSG.isString());

ErrorObject::throwBuiltinError(state, ErrorCode::EvalError, checkMSG.asString());

return Value();

}

}

ScriptParser parser(state.context());

bool strictFromOutside = false;

Script* script = parser.initializeScript(nullptr, 0, arg.asString(), state.context()->staticStrings().lazyEvalCode().string(), nullptr, false, true, false, false, strictFromOutside, false, false, false, true).scriptThrowsExceptionIfParseError(state);

// In case of indirect call, use global execution context

ExtendedExecutionState stateForNewGlobal(m_context);

return script->execute(stateForNewGlobal, true, script->topCodeBlock()->isStrict());

}

return arg;

InterpretedCodeBlock* parentCodeBlock, bool inWithOperation)

{

if (arg.isString()) {

if (UNLIKELY((bool)state.context()->securityPolicyCheckCallback())) {

Value checkMSG = state.context()->securityPolicyCheckCallback()(state, true);

if (!checkMSG.isEmpty()) {

ASSERT(checkMSG.isString());

ErrorObject::throwBuiltinError(state, ErrorCode::EvalError, checkMSG.asString());

return Value();

}

}

ScriptParser parser(state.context());

ExecutionState* current = &state;

bool isRunningEvalOnFunction = state.resolveCallee();

bool strictFromOutside = state.inStrictMode();

while (current != nullptr) {

if (current->lexicalEnvironment()->record()->isDeclarativeEnvironmentRecord()) {

strictFromOutside = current->inStrictMode();

break;

} else if (current->lexicalEnvironment()->record()->isGlobalEnvironmentRecord()) {

strictFromOutside = current->inStrictMode();

break;

}

current = current->parent();

}

bool allowNewTarget = false;

auto thisEnvironment = state.getThisEnvironment();

if (thisEnvironment->isDeclarativeEnvironmentRecord() && thisEnvironment->asDeclarativeEnvironmentRecord()->isFunctionEnvironmentRecord()) {

allowNewTarget = true;

}

Script* script = parser.initializeScript(nullptr, 0, arg.asString(), state.context()->staticStrings().lazyEvalCode().string(), parentCodeBlock,

false, true, isRunningEvalOnFunction, inWithOperation, strictFromOutside, parentCodeBlock->allowSuperCall(),

parentCodeBlock->allowSuperProperty(), allowNewTarget, true)

.scriptThrowsExceptionIfParseError(state);

return script->executeLocal(state, thisValue, parentCodeBlock, script->topCodeBlock()->isStrict(), isRunningEvalOnFunction);

}

return arg;

{

int digit = -1;

if (c >= '0' && c <= '9')

digit = c - '0';

else if (c >= 'A' && c <= 'Z')

digit = c - 'A' + 10;

else if (c >= 'a' && c <= 'z')

digit = c - 'a' + 10;

if (digit >= radix)

return -1;

return digit;

{

return (length - p) >= SizeOfInfinity

&& str->charAt(p) == 'I'

&& str->charAt(p + 1) == 'n'

&& str->charAt(p + 2) == 'f'

&& str->charAt(p + 3) == 'i'

&& str->charAt(p + 4) == 'n'

&& str->charAt(p + 5) == 'i'

&& str->charAt(p + 6) == 't'

&& str->charAt(p + 7) == 'y';

{

Value ret;

// 1. Let inputString be ToString(string).

Value input = argv[0];

String* s = input.toString(state);

// 2. Let S be a newly created substring of inputString consisting of the first character that is not a StrWhiteSpaceChar

// and all characters following that character. (In other words, remove leading white space.)

unsigned p = 0;

unsigned strLen = s->length();

for (; p < strLen; p++) {

if (!(EscargotLexer::isWhiteSpaceOrLineTerminator(s->charAt(p))))

break;

}

// 3. Let sign be 1.

// 4. If S is not empty and the first character of S is a minus sign -, let sign be −1.

// 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.

double sign = 1;

if (p < strLen) {

if (s->charAt(p) == '+') {

p++;

} else if (s->charAt(p) == '-') {

sign = -1;

p++;

}

}

// 6. Let R = ToInt32(radix).

// 7. Let stripPrefix be true.

// 8. If R ≠ 0, then

// b. If R 16, let stripPrefix be false.

// 9. Else, R = 0

// a. Let R = 10.

// 10. If stripPrefix is true, then

// a. If the length of S is at least 2 and the first two characters of S are either “0x” or “0X”, then remove the first two characters from S and let R = 16.

// 11. If S contains any character that is not a radix-R digit, then let Z be the substring of S consisting of all characters

// before the first such character; otherwise, let Z be S.

int radix = 0;

if (argc >= 2) {

radix = argv[1].toInt32(state);

}

if ((radix == 0 || radix == 16) && strLen - p >= 2 && s->charAt(p) == '0' && (s->charAt(p + 1) == 'x' || s->charAt(p + 1) == 'X')) {

radix = 16;

p += 2;

}

if (radix == 0)

radix = 10;

// 8.a If R < 2 or R > 36, then return NaN.

if (radix < 2 || radix > 36)

return Value(Value::NanInit);

// 13. Let mathInt be the mathematical integer value that is represented by Z in radix-R notation,

// using the letters AZ and az for digits with values 10 through 35. (However, if R is 10 and Z contains more than 20 significant digits,

// every significant digit after the 20th may be replaced by a 0 digit, at the option of the implementation;

// and if R is not 2, 4, 8, 10, 16, or 32, then mathInt may be an implementation-dependent approximation to the mathematical integer value

// that is represented by Z in radix-R notation.)

// 14. Let number be the Number value for mathInt.

bool sawDigit = false;

double number = 0.0;

while (p < strLen) {

int digit = parseDigit(s->charAt(p), radix);

if (digit == -1)

break;

sawDigit = true;

number *= radix;

number += digit;

p++;

}

// 12. If Z is empty, return NaN.

if (!sawDigit)

return Value(Value::NanInit);

// 15. Return sign × number.

return Value(Value::DoubleToIntConvertibleTestNeeds, sign * number);

{

// 1. Let inputString be ToString(string).

Value input = argv[0];

String* s = input.toString(state);

size_t strLen = s->length();

if (strLen == 1) {

if (isdigit(s->charAt(0)))

return Value(s->charAt(0) - '0');

return Value(Value::NanInit);

}

// 2, Let trimmedString be a substring of inputString consisting of the leftmost character

// that is not a StrWhiteSpaceChar and all characters to the right of that character.

// (In other words, remove leading white space.)

unsigned p = 0;

unsigned len = s->length();

for (; p < len; p++) {

if (!(EscargotLexer::isWhiteSpaceOrLineTerminator(s->charAt(p))))

break;

}

// empty string

if (p == len)

return Value(Value::NanInit);

char16_t ch = s->charAt(p);

// HexIntegerLiteral

if (len - p > 1 && ch == '0' && toupper(s->charAt(p + 1)) == 'X')

return Value(0);

// 3. If neither trimmedString nor any prefix of trimmedString satisfies the syntax of

// a StrDecimalLiteral (see 9.3.1), return NaN.

// 4. Let numberString be the longest prefix of trimmedString, which might be trimmedString itself,

// that satisfies the syntax of a StrDecimalLiteral.

// Check the syntax of StrDecimalLiteral

switch (ch) {

case 'I':

if (isInfinity(s, p, len))

return Value(Value::PostiveInfinityInit);

break;

case '+':

if (isInfinity(s, p + 1, len))

return Value(Value::PostiveInfinityInit);

break;

case '-':

if (isInfinity(s, p + 1, len))

return Value(Value::NegativeInfinityInit);

break;

}

auto u8Str = s->substring(p, len)->toUTF8StringData();

double number = atof(u8Str.data());

if (number == 0.0 && !std::signbit(number) && !isdigit(ch) && !(len - p >= 1 && (ch == '.' || ch == '+') && isdigit(s->charAt(p + 1))))

return Value(Value::NanInit);

if (number == std::numeric_limits<double>::infinity())

return Value(Value::NanInit);

// 5. Return the Number value for the MV of numberString.

return Value(Value::DoubleToIntConvertibleTestNeeds, number);

{

double num = argv[0].toNumber(state);

if (std::isnan(num) || num == std::numeric_limits<double>::infinity() || num == -std::numeric_limits<double>::infinity())

return Value(Value::False);

else

return Value(Value::True);

{

double num = argv[0].toNumber(state);

if (std::isnan(num)) {

return Value(Value::True);

}

return Value(Value::False);

{

return ch == ';' || ch == '/' || ch == '?' || ch == ':' || ch == '@' || ch == '&'

|| ch == '=' || ch == '+' || ch == '$' || ch == ',' || ch == '#';

{

return (ch == '-' || ch == '_' || ch == '.' || ch == '!' || ch == '~' || ch == '*'

|| ch == '\'' || ch == '(' || ch == ')');

{

if (!isHexadecimalDigit(ch1) || !isHexadecimalDigit(ch2))

return false;

*res = (((ch1 & 0x10) ? (ch1 & 0xf) : ((ch1 & 0xf) + 9)) << 4)

| ((ch2 & 0x10) ? (ch2 & 0xf) : ((ch2 & 0xf) + 9));

return true;

{

ASSERT(str && str->length() > start + 2);

if (str->charAt(start) != '%')

return false;

bool succeed = twocharToHexaDecimal(str->charAt(start + 1), str->charAt(start + 2), res);

// The two most significant bits of res should be 10.

return succeed && (*res & 0xC0) == 0x80;

{

String* globalObjectString = state.context()->staticStrings().GlobalObject.string();

StringBuilder unescaped;

size_t strLen = uriString->length();

for (size_t i = 0; i < strLen; i++) {

char16_t t = uriString->charAt(i);

if (t != '%') {

unescaped.appendChar(t);

} else {

size_t start = i;

if (i + 2 >= strLen)

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

char16_t next = uriString->charAt(i + 1);

char16_t nextnext = uriString->charAt(i + 2);

// char to hex

unsigned char b = 0;

if (!twocharToHexaDecimal(next, nextnext, &b))

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

i += 2;

// most significant bit in b is 0

if (!(b & 0x80)) {

// let C be the character with code unit value B.

// if C is not in reservedSet, then let S be the String containing only the character C.

// else, C is in reservedSet, Let S be the substring of string from position start to position k included.

const char16_t c = b & 0x7f;

if (noComponent && isURIReservedOrSharp(c)) {

unescaped.appendSubString(uriString, start, start + 3);

} else {

unescaped.appendChar(c);

}

} else { // most significant bit in b is 1

unsigned char b_tmp = b;

int n = 1;

while (n < 5) {

b_tmp <<= 1;

if ((b_tmp & 0x80) == 0) {

break;

}

n++;

}

if (n == 1 || n == 5 || (i + (3 * (n - 1)) >= strLen)) {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

}

unsigned char octets[4];

octets[0] = b;

int j = 1;

while (j < n) {

if (!codeUnitToHexaDecimal(uriString, ++i, &b)) // "%XY" type

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

i += 2;

octets[j] = b;

j++;

}

ASSERT(n == 2 || n == 3 || n == 4);

unsigned int v = 0;

if (n == 2) {

v = (octets[0] & 0x1F) << 6 | (octets[1] & 0x3F);

if ((octets[0] == 0xC0) || (octets[0] == 0xC1)) {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

}

} else if (n == 3) {

v = (octets[0] & 0x0F) << 12 | (octets[1] & 0x3F) << 6 | (octets[2] & 0x3F);

if ((0xD800 <= v && v <= 0xDFFF) || ((octets[0] == 0xE0) && ((octets[1] < 0xA0) || (octets[1] > 0xBF)))) {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

}

} else if (n == 4) {

v = (octets[0] & 0x07) << 18 | (octets[1] & 0x3F) << 12 | (octets[2] & 0x3F) << 6 | (octets[3] & 0x3F);

if ((octets[0] == 0xF0) && ((octets[1] < 0x90) || (octets[1] > 0xBF))) {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

}

}

if (v >= 0x10000) {

const char16_t l = (((v - 0x10000) & 0x3ff) + 0xdc00);

const char16_t h = ((((v - 0x10000) >> 10) & 0x3ff) + 0xd800);

unescaped.appendChar(h);

unescaped.appendChar(l);

} else {

const char16_t l = v & 0xFFFF;

unescaped.appendChar(l);

}

}

}

}

return unescaped.finalize(&state);

{

if (argc == 0)

return Value();

return decode(state, argv[0].toString(state), true, state.context()->staticStrings().decodeURI.string());

{

if (argc == 0)

return Value();

return decode(state, argv[0].toString(state), false, state.context()->staticStrings().decodeURIComponent.string());

{

unsigned char dig1 = (ch & 0xF0) >> 4;

unsigned char dig2 = (ch & 0x0F);

char ch1 = (dig1 <= 9) ? dig1 + '0' : dig1 - 10 + 'A';

char ch2 = (dig2 <= 9) ? dig2 + '0' : dig2 - 10 + 'A';

escaped->pushBack('%');

escaped->pushBack(ch1);

escaped->pushBack(ch2);

return true;

{

String* globalObjectString = state.context()->staticStrings().GlobalObject.string();

auto bad = uriString->bufferAccessData();

URIBuilderString escaped;

escaped.reserve(bad.length * 1.25);

for (size_t i = 0; i < bad.length; i++) {

char16_t t = bad.charAt(i);

if (isDecimalDigit(t) || isURIAlpha(t) || isURIMark(t)

|| (noComponent && isURIReservedOrSharp(t))) {

escaped.pushBack((char)t);

} else if (t <= 0x007F) {

convertAndAppendCodeUnit(&escaped, t);

} else if (0x0080 <= t && t <= 0x07FF) {

convertAndAppendCodeUnit(&escaped, 0x00C0 + (t & 0x07C0) / 0x0040);

convertAndAppendCodeUnit(&escaped, 0x0080 + (t & 0x003F));

} else if ((0x0800 <= t && t <= 0xD7FF)

|| (0xE000 <= t /* && t <= 0xFFFF*/)) {

convertAndAppendCodeUnit(&escaped, 0x00E0 + (t & 0xF000) / 0x1000);

convertAndAppendCodeUnit(&escaped, 0x0080 + (t & 0x0FC0) / 0x0040);

convertAndAppendCodeUnit(&escaped, 0x0080 + (t & 0x003F));

} else if (0xD800 <= t && t <= 0xDBFF) {

if (i + 1 < bad.length && 0xDC00 <= bad.charAt(i + 1) && bad.charAt(i + 1) <= 0xDFFF) {

int index = (t - 0xD800) * 0x400 + (bad.charAt(i + 1) - 0xDC00) + 0x10000;

convertAndAppendCodeUnit(&escaped, 0x00F0 + (index & 0x1C0000) / 0x40000);

convertAndAppendCodeUnit(&escaped, 0x0080 + (index & 0x3F000) / 0x1000);

convertAndAppendCodeUnit(&escaped, 0x0080 + (index & 0x0FC0) / 0x0040);

convertAndAppendCodeUnit(&escaped, 0x0080 + (index & 0x003F));

i++;

} else {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

}

} else if (0xDC00 <= t && t <= 0xDFFF) {

ErrorObject::throwBuiltinError(state, ErrorCode::URIError, globalObjectString, false, funcName, ErrorObject::Messages::GlobalObject_MalformedURI);

} else {

RELEASE_ASSERT_NOT_REACHED();

}

}

size_t newLen = escaped.size();

auto ptr = escaped.takeBuffer();

return new ASCIIString(ptr, newLen, ASCIIString::FromGCBufferTag);

{

if (argc == 0)

return Value();

return encode(state, argv[0].toString(state), true, state.context()->staticStrings().encodeURI.string());

{

if (argc == 0)

return Value();

return encode(state, argv[0].toString(state), false, state.context()->staticStrings().encodeURIComponent.string());

{

unsigned char dig1 = (dec & 0xF0) >> 4;

unsigned char dig2 = (dec & 0x0F);

if (dig1 <= 9)

dig1 += 48; // 0, 48inascii

if (10 <= dig1 && dig1 <= 15)

dig1 += 65 - 10; // a, 97inascii

if (dig2 <= 9)

dig2 += 48;

if (10 <= dig2 && dig2 <= 15)

dig2 += 65 - 10;

char dig1_appended = static_cast<char>(dig1);

char dig2_appended = static_cast<char>(dig2);

result.pushBack(dig1_appended);

result.pushBack(dig2_appended);

{

char dig[4];

ASCIIStringDataNonGCStd r;

for (int i = 0; i < 4; i++) {

dig[i] = (dec & (0xF000 >> i * 4)) >> (12 - i * 4);

if (dig[i] <= 9)

dig[i] += 48; // 0, 48inascii

if (10 <= dig[i] && dig[i] <= 15)

dig[i] += 65 - 10; // a, 97inascii

result.pushBack(dig[i]);

}

{

String* str = argv[0].toString(state);

auto bad = str->bufferAccessData();

size_t length = bad.length;

URIBuilderString R;

size_t len = 0;

for (size_t i = 0; i < length; i++) {

char16_t t = bad.charAt(i);

if ((48 <= t && t <= 57) // DecimalDigit

|| (65 <= t && t <= 90) // uriAlpha - upper case

|| (97 <= t && t <= 122) // uriAlpha - lower case

|| t == '@' || t == '*' || t == '_' || t == '+' || t == '-' || t == '.' || t == '/') {

R.push_back(t);

len += 1;

} else if (t < 256) {

// %xy

R.pushBack('%');

char2hex(t, R);

len = R.size();

} else {

// %uwxyz

R.pushBack('%');

R.pushBack('u');

char2hex4digit(t, R);

len = R.size();

}

if (UNLIKELY(len > STRING_MAXIMUM_LENGTH)) {

ErrorObject::throwBuiltinError(state, ErrorCode::RangeError, ErrorObject::Messages::String_InvalidStringLength);

}

}

size_t newLen = R.size();

auto ptr = R.takeBuffer();

return new ASCIIString(ptr, newLen, ASCIIString::FromGCBufferTag);

{

char16_t dig1 = first;

char16_t dig2 = second;

if (48 <= dig1 && dig1 <= 57)

dig1 -= 48;

if (65 <= dig1 && dig1 <= 70)

dig1 -= 65 - 10;

if (97 <= dig1 && dig1 <= 102)

dig1 -= 97 - 10;

if (48 <= dig2 && dig2 <= 57)

dig2 -= 48;

if (65 <= dig2 && dig2 <= 70)

dig2 -= 65 - 10;

if (97 <= dig2 && dig2 <= 102)

dig2 -= 97 - 10;

char16_t dec = dig1 << 4;

dec |= dig2;

return dec;

{

String* str = argv[0].toString(state);

size_t length = str->length();

UTF16StringDataNonGCStd R;

bool unescapeValue = false;

bool gotNonASCIIString = false;

for (size_t i = 0; i < length; i++) {

char16_t first = str->charAt(i);

if (first == '%') {

if (length - i >= 6) {

char16_t second = str->charAt(i + 1);

char16_t third = str->charAt(i + 2);

if (second == 'u') {

char16_t fourth = str->charAt(i + 3);

char16_t fifth = str->charAt(i + 4);

char16_t sixth = str->charAt(i + 5);

// hex dig check

if (((48 <= third && third <= 57) || (65 <= third && third <= 70) || (97 <= third && third <= 102))

&& ((48 <= fourth && fourth <= 57) || (65 <= fourth && fourth <= 70) || (97 <= fourth && fourth <= 102))

&& ((48 <= fifth && fifth <= 57) || (65 <= fifth && fifth <= 70) || (97 <= fifth && fifth <= 102))

&& ((48 <= sixth && sixth <= 57) || (65 <= sixth && sixth <= 70) || (97 <= sixth && sixth <= 102))) {

char16_t l = hex2char(third, fourth) << 8;

l |= hex2char(fifth, sixth);

if (l > 128)

gotNonASCIIString = true;

R.append(&l, 1);

i += 5;

unescapeValue = true;

}

} else if (((48 <= second && second <= 57) || (65 <= second && second <= 70) || (97 <= second && second <= 102))

&& ((48 <= third && third <= 57) || (65 <= third && third <= 70) || (97 <= third && third <= 102))) {

char16_t l = hex2char(second, third);

if (l > 128)

gotNonASCIIString = true;

R.append(&l, 1);

i += 2;

unescapeValue = true;

}

} else if (length - i >= 3) {

char16_t second = str->charAt(i + 1);

char16_t third = str->charAt(i + 2);

if (((48 <= second && second <= 57) || (65 <= second && second <= 70) || (97 <= second && second <= 102))

&& ((48 <= third && third <= 57) || (65 <= third && third <= 70) || (97 <= third && third <= 102))) {

char16_t l = hex2char(second, third);

if (l > 128)

gotNonASCIIString = true;

R.append(&l, 1);

i += 2;

unescapeValue = true;

}

}

}

if (!unescapeValue) {

char16_t l = str->charAt(i);

if (l > 128)

gotNonASCIIString = true;

R.append(&l, 1);

}

unescapeValue = false;

}

if (gotNonASCIIString) {

return new UTF16String(R.data(), R.length());

} else {

ASCIIStringData data;

data.resizeWithUninitializedValues(R.length());

for (size_t i = 0; i < data.length(); i++) {

data[i] = R[i];

}

return new ASCIIString(std::move(data));

}

{

// this builtin function is shared both for Array and TypedArray (prototype.toString property)

Object* thisObject = thisValue.toObject(state);

Value toString = thisObject->get(state, state.context()->staticStrings().join).value(state, thisObject);

if (!toString.isCallable()) {

toString = state.context()->globalObject()->objectPrototypeToString();

}

return Object::call(state, toString, thisObject, 0, nullptr);

{

// Other prerequisite builtins should be installed at the start time

installOthers(state);

{

const StaticStrings* strings = &state.context()->staticStrings();

defineOwnProperty(state, strings->Infinity, ObjectPropertyDescriptor(Value(Value::PostiveInfinityInit), (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::ValuePresent)));

defineOwnProperty(state, strings->NaN, ObjectPropertyDescriptor(Value(Value::NanInit), (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::ValuePresent)));

defineOwnProperty(state, strings->undefined, ObjectPropertyDescriptor(Value(), (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::ValuePresent)));

// $18.2.1 eval (x)

m_eval = new NativeFunctionObject(state,

NativeFunctionInfo(strings->eval, builtinEval, 1, NativeFunctionInfo::Strict));

defineOwnProperty(state, ObjectPropertyName(strings->eval),

ObjectPropertyDescriptor(m_eval, (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

// $18.2.2 isFinite(number)

defineOwnProperty(state, ObjectPropertyName(strings->isFinite),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->isFinite, builtinIsFinite, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

// $18.2.3 isNaN(number)

defineOwnProperty(state, ObjectPropertyName(strings->isNaN),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->isNaN, builtinIsNaN, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->encodeURI),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->encodeURI, builtinEncodeURI, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->decodeURI),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->decodeURI, builtinDecodeURI, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->encodeURIComponent),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->encodeURIComponent, builtinEncodeURIComponent, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->decodeURIComponent),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->decodeURIComponent, builtinDecodeURIComponent, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->escape),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->escape, builtinEscape, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

defineOwnProperty(state, ObjectPropertyName(strings->unescape),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->unescape, builtinUnescape, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

m_parseInt = new NativeFunctionObject(state, NativeFunctionInfo(strings->parseInt, builtinParseInt, 2, NativeFunctionInfo::Strict));

defineOwnProperty(state, ObjectPropertyName(strings->parseInt),

ObjectPropertyDescriptor(m_parseInt,

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

m_parseFloat = new NativeFunctionObject(state, NativeFunctionInfo(strings->parseFloat, builtinParseFloat, 1, NativeFunctionInfo::Strict));

defineOwnProperty(state, ObjectPropertyName(strings->parseFloat),

ObjectPropertyDescriptor(m_parseFloat,

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));

m_arrayToString = new NativeFunctionObject(state, NativeFunctionInfo(strings->toString, builtinArrayToString, 0, NativeFunctionInfo::Strict));

#if defined(ESCARGOT_ENABLE_TEST)

AtomicString isFunctionAllocatedOnStackFunctionName(state, "isFunctionAllocatedOnStack");

defineOwnProperty(state, ObjectPropertyName(isFunctionAllocatedOnStackFunctionName),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->run, builtinIsFunctionAllocatedOnStack, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::AllPresent)));

AtomicString isBlockAllocatedOnStackFunctionName(state, "isBlockAllocatedOnStack");

defineOwnProperty(state, ObjectPropertyName(isBlockAllocatedOnStackFunctionName),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(strings->run, builtinIsBlockAllocatedOnStack, 2, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::AllPresent)));

#endif

#ifdef PROFILE_BDWGC

AtomicString dumpBackTrace(state, "dumpBackTrace");

defineOwnProperty(state, ObjectPropertyName(dumpBackTrace),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(dumpBackTrace, builtinDumpBackTrace, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::AllPresent)));

AtomicString registerLeakCheck(state, "registerLeakCheck");

defineOwnProperty(state, ObjectPropertyName(registerLeakCheck),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(registerLeakCheck, builtinRegisterLeakCheck, 2, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::AllPresent)));

AtomicString setPhaseName(state, "setPhaseName");

defineOwnProperty(state, ObjectPropertyName(setPhaseName),

ObjectPropertyDescriptor(new NativeFunctionObject(state,

NativeFunctionInfo(setPhaseName, builtinSetGCPhaseName, 1, NativeFunctionInfo::Strict)),

(ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::AllPresent)));

#endif

// https://tc39.es/ecma262/#sec-globalthis

// The initial value of globalThis is the well-known intrinsic object %GlobalThisValue%.

// This property has the attributes { [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true }.

defineOwnProperty(state, ObjectPropertyName(strings->globalThis),

ObjectPropertyDescriptor(this, (ObjectPropertyDescriptor::PresentAttribute)(ObjectPropertyDescriptor::WritablePresent | ObjectPropertyDescriptor::ConfigurablePresent)));