785 lines
29 KiB
C++
785 lines
29 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
||
*
|
||
* The contents of this file are subject to the Netscape Public
|
||
* License Version 1.1 (the "License"); you may not use this file
|
||
* except in compliance with the License. You may obtain a copy of
|
||
* the License at http://www.mozilla.org/NPL/
|
||
*
|
||
* Software distributed under the License is distributed on an "AS
|
||
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
||
* implied. See the License for the specific language governing
|
||
* rights and limitations under the License.
|
||
*
|
||
* The Original Code is the JavaScript 2 Prototype.
|
||
*
|
||
* The Initial Developer of the Original Code is Netscape
|
||
* Communications Corporation. Portions created by Netscape are
|
||
* Copyright (C) 1998 Netscape Communications Corporation. All
|
||
* Rights Reserved.
|
||
*
|
||
* Contributor(s):
|
||
*
|
||
* Alternatively, the contents of this file may be used under the
|
||
* terms of the GNU Public License (the "GPL"), in which case the
|
||
* provisions of the GPL are applicable instead of those above.
|
||
* If you wish to allow use of your version of this file only
|
||
* under the terms of the GPL and not to allow others to use your
|
||
* version of this file under the NPL, indicate your decision by
|
||
* deleting the provisions above and replace them with the notice
|
||
* and other provisions required by the GPL. If you do not delete
|
||
* the provisions above, a recipient may use your version of this
|
||
* file under either the NPL or the GPL.
|
||
*/
|
||
|
||
#ifdef _WIN32
|
||
// Turn off warnings about identifiers too long in browser information
|
||
#pragma warning(disable: 4786)
|
||
#pragma warning(disable: 4711)
|
||
#pragma warning(disable: 4710)
|
||
#endif
|
||
|
||
#include <algorithm>
|
||
|
||
#include "parser.h"
|
||
#include "numerics.h"
|
||
#include "js2runtime.h"
|
||
|
||
#include "jsstring.h"
|
||
|
||
namespace JavaScript {
|
||
namespace JS2Runtime {
|
||
|
||
|
||
js2val String_Constructor(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
js2val thatValue = thisValue;
|
||
if (JSValue::isNull(thatValue))
|
||
thatValue = String_Type->newInstance(cx);
|
||
ASSERT(JSValue::isInstance(thatValue));
|
||
JSStringInstance *strInst = checked_cast<JSStringInstance *>(JSValue::instance(thatValue));
|
||
|
||
if (argc > 0)
|
||
strInst->mValue = new String(*JSValue::string(JSValue::toString(cx, argv[0])));
|
||
else
|
||
strInst->mValue = &cx->Empty_StringAtom;
|
||
return thatValue;
|
||
}
|
||
|
||
js2val String_TypeCast(Context *cx, const js2val /*thisValue*/, js2val *argv, uint32 argc)
|
||
{
|
||
if (argc == 0)
|
||
return JSValue::newString(&cx->Empty_StringAtom);
|
||
else
|
||
return JSValue::toString(cx, argv[0]);
|
||
}
|
||
|
||
|
||
js2val String_fromCharCode(Context *cx, const js2val /*thisValue*/, js2val *argv, uint32 argc)
|
||
{
|
||
String *resultStr = new String(); // can't use cx->Empty_StringAtom; because we're modifying this below
|
||
resultStr->reserve(argc);
|
||
for (uint32 i = 0; i < argc; i++)
|
||
*resultStr += (char16)(JSValue::f64(JSValue::toUInt16(cx, argv[i])));
|
||
|
||
return JSValue::newString(resultStr);
|
||
}
|
||
|
||
static js2val String_toString(Context *cx, const js2val thisValue, js2val * /*argv*/, uint32 /*argc*/)
|
||
{
|
||
if (JSValue::getType(thisValue) != String_Type)
|
||
cx->reportError(Exception::typeError, "String.toString called on something other than a string thing");
|
||
ASSERT(JSValue::isInstance(thisValue));
|
||
JSStringInstance *strInst = checked_cast<JSStringInstance *>(JSValue::instance(thisValue));
|
||
return JSValue::newString(strInst->mValue);
|
||
}
|
||
|
||
static js2val String_valueOf(Context *cx, const js2val thisValue, js2val * /*argv*/, uint32 /*argc*/)
|
||
{
|
||
if (JSValue::getType(thisValue) != String_Type)
|
||
cx->reportError(Exception::typeError, "String.valueOf called on something other than a string thing");
|
||
ASSERT(JSValue::isInstance(thisValue));
|
||
JSStringInstance *strInst = checked_cast<JSStringInstance *>(JSValue::instance(thisValue));
|
||
return JSValue::newString(strInst->mValue);
|
||
}
|
||
|
||
/*
|
||
* 15.5.4.12 String.prototype.search (regexp)
|
||
*
|
||
* If regexp is not an object whose [[Class]] property is "RegExp", it is replaced with the result of the expression new
|
||
* RegExp(regexp). Let string denote the result of converting the this value to a string.
|
||
* The value string is searched from its beginning for an occurrence of the regular expression pattern regexp. The
|
||
* result is a number indicating the offset within the string where the pattern matched, or -1 if there was no match.
|
||
* NOTE This method ignores the lastIndex and global properties of regexp. The lastIndex property of regexp is left
|
||
* unchanged.
|
||
*/
|
||
static js2val String_search(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
ContextStackReplacement csr(cx);
|
||
|
||
js2val S = JSValue::toString(cx, thisValue);
|
||
|
||
js2val regexp = argv[0];
|
||
if ((argc == 0) || (JSValue::getType(regexp) != RegExp_Type)) {
|
||
regexp = kNullValue;
|
||
regexp = RegExp_Constructor(cx, regexp, argv, 1);
|
||
}
|
||
REState *pState = (checked_cast<JSRegExpInstance *>(JSValue::instance(regexp)))->mRegExp;
|
||
|
||
const String *str = JSValue::string(S);
|
||
REMatchState *match = REExecute(pState, str->begin(), 0, (int32)str->length(), false);
|
||
if (match)
|
||
return JSValue::newNumber((float64)(match->startIndex));
|
||
else
|
||
return JSValue::newNumber(-1.0);
|
||
|
||
}
|
||
|
||
/*
|
||
* 15.5.4.10 String.prototype.match (regexp)
|
||
*
|
||
* If regexp is not an object whose [[Class]] property is "RegExp", it is replaced with the result of the expression new
|
||
* RegExp(regexp). Let string denote the result of converting the this value to a string. Then do one of the following:
|
||
* - If regexp.global is false: Return the result obtained by invoking RegExp.prototype.exec (see section
|
||
* 15.10.6.2) on regexp with string as parameter.
|
||
* - If regexp.global is true: Set the regexp.lastIndex property to 0 and invoke RegExp.prototype.exec
|
||
* repeatedly until there is no match. If there is a match with an empty string (in other words, if the value of
|
||
* regexp.lastIndex is left unchanged), increment regexp.lastIndex by 1. Let n be the number of matches. The
|
||
* value returned is an array with the length property set to n and properties 0 through n-1 corresponding to the
|
||
* first elements of the results of all matching invocations of RegExp.prototype.exec.
|
||
*/
|
||
|
||
static js2val String_match(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
ContextStackReplacement csr(cx);
|
||
|
||
js2val S = JSValue::toString(cx, thisValue);
|
||
|
||
js2val regexp = argv[0];
|
||
if ((argc == 0) || (JSValue::getType(regexp) != RegExp_Type)) {
|
||
regexp = kNullValue;
|
||
regexp = RegExp_Constructor(cx, regexp, argv, 1);
|
||
}
|
||
|
||
REState *pState = (checked_cast<JSRegExpInstance *>(JSValue::instance(regexp)))->mRegExp;
|
||
if ((pState->flags & RE_GLOBAL) == 0) {
|
||
return RegExp_exec(cx, regexp, &S, 1);
|
||
}
|
||
else {
|
||
js2val result = Array_Type->newInstance(cx);
|
||
JSArrayInstance *A = checked_cast<JSArrayInstance *>(JSValue::instance(result));
|
||
int32 index = 0;
|
||
int32 lastIndex = 0;
|
||
while (true) {
|
||
REMatchState *match = REExecute(pState, JSValue::string(S)->begin(), lastIndex, (int32)JSValue::string(S)->length(), false);
|
||
if (match == NULL)
|
||
break;
|
||
if (lastIndex == match->endIndex)
|
||
lastIndex++;
|
||
else
|
||
lastIndex = match->endIndex;
|
||
String *matchStr = new String(JSValue::string(S)->substr((uint32)match->startIndex, (uint32)match->endIndex - match->startIndex));
|
||
A->setProperty(cx, *numberToString(index++), NULL, JSValue::newString(matchStr));
|
||
}
|
||
JSValue::instance(regexp)->setProperty(cx, cx->LastIndex_StringAtom, NULL, JSValue::newNumber((float64)lastIndex));
|
||
return result;
|
||
}
|
||
}
|
||
|
||
static const String interpretDollar(Context *cx, const String *replaceStr, uint32 dollarPos, const String *searchStr, REMatchState *match, uint32 &skip)
|
||
{
|
||
skip = 2;
|
||
const char16 *dollarValue = replaceStr->begin() + dollarPos + 1;
|
||
switch (*dollarValue) {
|
||
case '$':
|
||
return cx->Dollar_StringAtom;
|
||
case '&':
|
||
return searchStr->substr((uint32)match->startIndex, (uint32)match->endIndex - match->startIndex);
|
||
case '`':
|
||
return searchStr->substr(0, (uint32)match->startIndex);
|
||
case '\'':
|
||
return searchStr->substr((uint32)match->endIndex, (uint32)searchStr->length() - match->endIndex);
|
||
case '0':
|
||
case '1':
|
||
case '2':
|
||
case '3':
|
||
case '4':
|
||
case '5':
|
||
case '6':
|
||
case '7':
|
||
case '8':
|
||
case '9':
|
||
{
|
||
int32 num = (int32)(*dollarValue - '0');
|
||
if (num <= match->parenCount) {
|
||
if ((dollarPos < (replaceStr->length() - 2))
|
||
&& (dollarValue[1] >= '0') && (dollarValue[1] <= '9')) {
|
||
int32 tmp = (num * 10) + (dollarValue[1] - '0');
|
||
if (tmp <= match->parenCount) {
|
||
num = tmp;
|
||
skip = 3;
|
||
}
|
||
}
|
||
return searchStr->substr((uint32)(match->parens[num - 1].index), (uint32)(match->parens[num - 1].length));
|
||
}
|
||
}
|
||
// fall thru
|
||
default:
|
||
skip = 1;
|
||
return cx->Dollar_StringAtom;
|
||
}
|
||
}
|
||
|
||
/*
|
||
* 15.5.4.11 String.prototype.replace (searchValue, replaceValue)
|
||
*
|
||
* Let string denote the result of converting the this value to a string.
|
||
*
|
||
* If searchValue is a regular expression (an object whose [[Class]] property is "RegExp"), do the following: If
|
||
* searchValue.global is false, then search string for the first match of the regular expression searchValue. If
|
||
* searchValue.global is true, then search string for all matches of the regular expression searchValue. Do the search
|
||
* in the same manner as in String.prototype.match, including the update of searchValue.lastIndex. Let m
|
||
* be the number of left capturing parentheses in searchValue (NCapturingParens as specified in section 15.10.2.1).
|
||
*
|
||
* If searchValue is not a regular expression, let searchString be ToString(searchValue) and search string for the first
|
||
* occurrence of searchString. Let m be 0.
|
||
*
|
||
* If replaceValue is a function, then for each matched substring, call the function with the following m + 3 arguments.
|
||
* Argument 1 is the substring that matched. If searchValue is a regular expression, the next m arguments are all of
|
||
* the captures in the MatchResult (see section 15.10.2.1). Argument m + 2 is the offset within string where the match
|
||
* occurred, and argument m + 3 is string. The result is a string value derived from the original input by replacing each
|
||
* matched substring with the corresponding return value of the function call, converted to a string if need be.
|
||
*
|
||
* Otherwise, let newstring denote the result of converting replaceValue to a string. The result is a string value derived
|
||
* from the original input string by replacing each matched substring with a string derived from newstring by replacing
|
||
* characters in newstring by replacement text as specified in the following table. These $ replacements are done left-to-
|
||
* right, and, once such a replacement is performed, the new replacement text is not subject to further
|
||
* replacements. For example, "$1,$2".replace(/(\$(\d))/g, "$$1-$1$2") returns "$1-$11,$1-$22". A
|
||
* $ in newstring that does not match any of the forms below is left as is.
|
||
*/
|
||
|
||
|
||
static js2val String_replace(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *S = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
js2val searchValue;
|
||
js2val replaceValue;
|
||
|
||
if (argc > 0) searchValue = argv[0];
|
||
if (argc > 1) replaceValue = argv[1];
|
||
const String *replaceStr = JSValue::string(JSValue::toString(cx, replaceValue));
|
||
|
||
if (JSValue::getType(searchValue) == RegExp_Type) {
|
||
REState *pState = (checked_cast<JSRegExpInstance *>(JSValue::instance(searchValue)))->mRegExp;
|
||
REMatchState *match;
|
||
// uint32 m = pState->parenCount;
|
||
String newString;
|
||
int32 lastIndex = 0;
|
||
|
||
while (true) {
|
||
match = REExecute(pState, S->begin(), lastIndex, (int32)S->length(), false);
|
||
if (match) {
|
||
String insertString;
|
||
uint32 start = 0;
|
||
while (true) {
|
||
// look for '$' in the replacement string and interpret it as necessary
|
||
uint32 dollarPos = replaceStr->find('$', start);
|
||
if ((dollarPos != String::npos) && (dollarPos < (replaceStr->length() - 1))) {
|
||
uint32 skip;
|
||
insertString += replaceStr->substr(start, dollarPos - start);
|
||
insertString += interpretDollar(cx, replaceStr, dollarPos, S, match, skip);
|
||
start = dollarPos + skip;
|
||
}
|
||
else {
|
||
// otherwise, absorb the entire replacement string
|
||
insertString += replaceStr->substr(start, replaceStr->length() - start);
|
||
break;
|
||
}
|
||
}
|
||
// grab everything preceding the match
|
||
newString += S->substr((uint32)lastIndex, (uint32)match->startIndex - lastIndex);
|
||
// and then add the replacement string
|
||
newString += insertString;
|
||
}
|
||
else
|
||
break;
|
||
lastIndex = match->endIndex; // use lastIndex to grab remainder after break
|
||
if ((pState->flags & RE_GLOBAL) == 0)
|
||
break;
|
||
}
|
||
newString += S->substr((uint32)lastIndex, (uint32)S->length() - lastIndex);
|
||
if ((pState->flags & RE_GLOBAL) == 0)
|
||
JSValue::instance(searchValue)->setProperty(cx, cx->LastIndex_StringAtom, NULL, JSValue::newNumber((float64)lastIndex));
|
||
return JSValue::newString(new String(newString));
|
||
}
|
||
else {
|
||
const String *searchStr = JSValue::string(JSValue::toString(cx, searchValue));
|
||
REMatchState match;
|
||
uint32 pos = S->find(*searchStr, 0);
|
||
if (pos == String::npos)
|
||
return JSValue::newString(S);
|
||
match.startIndex = (int32)pos;
|
||
match.endIndex = match.startIndex + (int32)searchStr->length();
|
||
match.parenCount = 0;
|
||
String insertString;
|
||
String newString;
|
||
uint32 start = 0;
|
||
while (true) {
|
||
uint32 dollarPos = replaceStr->find('$', start);
|
||
if ((dollarPos != String::npos) && (dollarPos < (replaceStr->length() - 1))) {
|
||
uint32 skip;
|
||
insertString += replaceStr->substr(start, dollarPos - start);
|
||
insertString += interpretDollar(cx, replaceStr, dollarPos, S, &match, skip);
|
||
start = dollarPos + skip;
|
||
}
|
||
else {
|
||
insertString += replaceStr->substr(start, replaceStr->length() - start);
|
||
break;
|
||
}
|
||
}
|
||
newString += S->substr(0, (uint32)match.startIndex);
|
||
newString += insertString;
|
||
uint32 index = (uint32)match.endIndex;
|
||
newString += S->substr(index, S->length() - index);
|
||
return JSValue::newString(new String(newString));
|
||
}
|
||
}
|
||
|
||
struct MatchResult {
|
||
bool failure;
|
||
uint32 endIndex;
|
||
uint32 capturesCount;
|
||
js2val *captures;
|
||
};
|
||
|
||
static void strSplitMatch(const String *S, uint32 q, const String *R, MatchResult &result)
|
||
{
|
||
result.failure = true;
|
||
result.captures = NULL;
|
||
result.capturesCount = 0;
|
||
|
||
uint32 r = R->size();
|
||
uint32 s = S->size();
|
||
if ((q + r) > s)
|
||
return;
|
||
for (uint32 i = 0; i < r; i++) {
|
||
if ((*S)[q + i] != (*R)[i])
|
||
return;
|
||
}
|
||
result.endIndex = q + r;
|
||
result.failure = false;
|
||
}
|
||
|
||
static void regexpSplitMatch(const String *S, uint32 q, REState *RE, MatchResult &result)
|
||
{
|
||
result.failure = true;
|
||
result.captures = NULL;
|
||
|
||
REMatchState *match = REMatch(RE, S->begin() + q, (int32)(S->length() - q));
|
||
|
||
if (match) {
|
||
result.endIndex = match->startIndex + q;
|
||
result.failure = false;
|
||
result.capturesCount = (uint32)match->parenCount;
|
||
if (match->parenCount) {
|
||
result.captures = new js2val[match->parenCount];
|
||
for (int32 i = 0; i < match->parenCount; i++) {
|
||
if (match->parens[i].index != -1) {
|
||
String *parenStr = new String(S->substr((uint32)(match->parens[i].index + q),
|
||
(uint32)(match->parens[i].length)));
|
||
result.captures[i] = JSValue::newString(parenStr);
|
||
}
|
||
else
|
||
result.captures[i] = kUndefinedValue;
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
static js2val String_split(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
ContextStackReplacement csr(cx);
|
||
|
||
const String *S = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
js2val result = Array_Type->newInstance(cx);
|
||
JSArrayInstance *A = checked_cast<JSArrayInstance *>(JSValue::instance(result));
|
||
uint32 lim;
|
||
js2val separatorV = (argc > 0) ? argv[0] : kUndefinedValue;
|
||
js2val limitV = (argc > 1) ? argv[1] : kUndefinedValue;
|
||
|
||
if (JSValue::isUndefined(limitV))
|
||
lim = (uint32)(two32minus1);
|
||
else
|
||
lim = (uint32)JSValue::f64(JSValue::toUInt32(cx, limitV));
|
||
|
||
uint32 s = S->size();
|
||
uint32 p = 0;
|
||
|
||
REState *RE = NULL;
|
||
const String *R = NULL;
|
||
if (JSValue::getType(separatorV) == RegExp_Type)
|
||
RE = (checked_cast<JSRegExpInstance *>(JSValue::instance(separatorV)))->mRegExp;
|
||
else
|
||
R = JSValue::string(JSValue::toString(cx, separatorV));
|
||
|
||
if (lim == 0)
|
||
return result;
|
||
|
||
/* XXX standard requires this, but Monkey doesn't do it and the tests break
|
||
|
||
if (separatorV.isUndefined()) {
|
||
A->setProperty(cx, widenCString("0"), NULL, S);
|
||
return JSValue(A);
|
||
}
|
||
*/
|
||
if (s == 0) {
|
||
MatchResult z;
|
||
if (RE)
|
||
regexpSplitMatch(S, 0, RE, z);
|
||
else
|
||
strSplitMatch(S, 0, R, z);
|
||
if (!z.failure)
|
||
return result;
|
||
A->setProperty(cx, widenCString("0"), NULL, JSValue::newString(S));
|
||
return result;
|
||
}
|
||
|
||
while (true) {
|
||
uint32 q = p;
|
||
step11:
|
||
if (q == s) {
|
||
String *T = new String(*S, p, (s - p));
|
||
js2val v = JSValue::newString(T);
|
||
A->setProperty(cx, *numberToString(A->mLength), NULL, v);
|
||
return result;
|
||
}
|
||
MatchResult z;
|
||
if (RE)
|
||
regexpSplitMatch(S, q, RE, z);
|
||
else
|
||
strSplitMatch(S, q, R, z);
|
||
if (z.failure) {
|
||
q = q + 1;
|
||
goto step11;
|
||
}
|
||
uint32 e = z.endIndex;
|
||
if (e == p) {
|
||
q = q + 1;
|
||
goto step11;
|
||
}
|
||
String *T = new String(*S, p, (q - p));
|
||
js2val v = JSValue::newString(T);
|
||
A->setProperty(cx, *numberToString(A->mLength), NULL, v);
|
||
if (A->mLength == lim)
|
||
return result;
|
||
p = e;
|
||
|
||
for (uint32 i = 0; i < z.capturesCount; i++) {
|
||
A->setProperty(cx, *numberToString(A->mLength), NULL, z.captures[i]);
|
||
if (A->mLength == lim)
|
||
return result;
|
||
}
|
||
}
|
||
}
|
||
|
||
static js2val String_charAt(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *str = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
uint32 pos = 0;
|
||
if (argc > 0)
|
||
pos = (uint32)JSValue::f64(JSValue::toInt32(cx, argv[0]));
|
||
|
||
if ((pos < 0) || (pos >= str->size()))
|
||
return JSValue::newString(&cx->Empty_StringAtom);
|
||
else
|
||
return JSValue::newString(new String(1, (*str)[pos]));
|
||
|
||
}
|
||
|
||
static js2val String_charCodeAt(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *str = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
uint32 pos = 0;
|
||
if (argc > 0)
|
||
pos = (uint32)JSValue::f64(JSValue::toInt32(cx, argv[0]));
|
||
|
||
if ((pos < 0) || (pos >= str->size()))
|
||
return kNaNValue;
|
||
else
|
||
return JSValue::newNumber((float64)(*str)[pos]);
|
||
}
|
||
|
||
static js2val String_concat(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *str = JSValue::string(JSValue::toString(cx, thisValue));
|
||
String *result = new String(*str);
|
||
|
||
for (uint32 i = 0; i < argc; i++) {
|
||
*result += *JSValue::string(JSValue::toString(cx, argv[i]));
|
||
}
|
||
|
||
return JSValue::newString(result);
|
||
}
|
||
|
||
static js2val String_indexOf(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
if (argc == 0)
|
||
return JSValue::newNumber(-1.0);
|
||
|
||
const String *str = JSValue::string(JSValue::toString(cx, thisValue));
|
||
const String *searchStr = JSValue::string(JSValue::toString(cx, argv[0]));
|
||
uint32 pos = 0;
|
||
|
||
if (argc > 1) {
|
||
float64 fpos = JSValue::f64(JSValue::toNumber(cx, argv[1]));
|
||
if (JSDOUBLE_IS_NaN(fpos))
|
||
pos = 0;
|
||
if (fpos < 0)
|
||
pos = 0;
|
||
else
|
||
if (fpos >= str->size())
|
||
pos = str->size();
|
||
else
|
||
pos = (uint32)(fpos);
|
||
}
|
||
pos = str->find(*searchStr, pos);
|
||
if (pos == String::npos)
|
||
return JSValue::newNumber(-1.0);
|
||
return JSValue::newNumber((float64)pos);
|
||
}
|
||
|
||
static js2val String_lastIndexOf(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
if (argc == 0)
|
||
return JSValue::newNumber(-1.0);
|
||
|
||
const String *str = JSValue::string(JSValue::toString(cx, thisValue));
|
||
const String *searchStr = JSValue::string(JSValue::toString(cx, argv[0]));
|
||
uint32 pos = str->size();
|
||
|
||
if (argc > 1) {
|
||
float64 fpos = JSValue::f64(JSValue::toNumber(cx, argv[1]));
|
||
if (JSDOUBLE_IS_NaN(fpos))
|
||
pos = str->size();
|
||
else {
|
||
if (fpos < 0)
|
||
pos = 0;
|
||
else
|
||
if (fpos >= str->size())
|
||
pos = str->size();
|
||
else
|
||
pos = (uint32)(fpos);
|
||
}
|
||
}
|
||
pos = str->rfind(*searchStr, pos);
|
||
if (pos == String::npos)
|
||
return JSValue::newNumber(-1.0);
|
||
return JSValue::newNumber((float64)pos);
|
||
}
|
||
|
||
static js2val String_localeCompare(Context * /*cx*/, const js2val /*thisValue*/, js2val * /*argv*/, uint32 /*argc*/)
|
||
{
|
||
return kUndefinedValue;
|
||
}
|
||
|
||
static js2val String_toLowerCase(Context *cx, const js2val thisValue, js2val * /*argv*/, uint32 /*argc*/)
|
||
{
|
||
js2val S = JSValue::toString(cx, thisValue);
|
||
|
||
String *result = new String(*JSValue::string(S));
|
||
for (String::iterator i = result->begin(), end = result->end(); i != end; i++)
|
||
*i = toLower(*i);
|
||
|
||
return JSValue::newString(result);
|
||
}
|
||
|
||
static js2val String_toUpperCase(Context *cx, const js2val thisValue, js2val * /*argv*/, uint32 /*argc*/)
|
||
{
|
||
js2val S = JSValue::toString(cx, thisValue);
|
||
|
||
String *result = new String(*JSValue::string(S));
|
||
for (String::iterator i = result->begin(), end = result->end(); i != end; i++)
|
||
*i = toUpper(*i);
|
||
|
||
return JSValue::newString(result);
|
||
}
|
||
|
||
/*
|
||
* 15.5.4.13 String.prototype.slice (start, end)
|
||
*
|
||
* The slice method takes two arguments, start and end, and returns a substring of the result of converting this
|
||
* object to a string, starting from character position start and running to, but not including, character position end (or
|
||
* through the end of the string if end is undefined). If start is negative, it is treated as (sourceLength+start) where
|
||
* sourceLength is the length of the string. If end is negative, it is treated as (sourceLength+end) where sourceLength
|
||
* is the length of the string. The result is a string value, not a String object.
|
||
*
|
||
* The following steps are taken:
|
||
* 1. Call ToString, giving it the this value as its argument.
|
||
* 2. Compute the number of characters in Result(1).
|
||
* 3. Call ToInteger(start).
|
||
* 4. If end is undefined, use Result(2); else use ToInteger(end).
|
||
* 5. If Result(3) is negative, use max(Result(2)+Result(3),0); else use min(Result(3),Result(2)).
|
||
* 6. If Result(4) is negative, use max(Result(2)+Result(4),0); else use min(Result(4),Result(2)).
|
||
* 7. Compute max(Result(6)<29>Result(5),0).
|
||
* 8. Return a string containing Result(7) consecutive characters from Result(1) beginning with the character at
|
||
* position Result(5).
|
||
*/
|
||
|
||
static js2val String_slice(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *sourceString = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
uint32 sourceLength = sourceString->size();
|
||
uint32 start, end;
|
||
|
||
if (argc > 0) {
|
||
int32 arg0 = (int32)JSValue::f64(JSValue::toInt32(cx, argv[0]));
|
||
if (arg0 < 0) {
|
||
arg0 += sourceLength;
|
||
if (arg0 < 0)
|
||
start = 0;
|
||
else
|
||
start = toUInt32(arg0);
|
||
}
|
||
else {
|
||
if (toUInt32(arg0) < sourceLength)
|
||
start = toUInt32(arg0);
|
||
else
|
||
start = sourceLength;
|
||
}
|
||
}
|
||
else
|
||
start = 0;
|
||
|
||
if (argc > 1) {
|
||
int32 arg1 = (int32)JSValue::f64(JSValue::toInt32(cx, argv[1]));
|
||
if (arg1 < 0) {
|
||
arg1 += sourceLength;
|
||
if (arg1 < 0)
|
||
end = 0;
|
||
else
|
||
end = toUInt32(arg1);
|
||
}
|
||
else {
|
||
if (toUInt32(arg1) < sourceLength)
|
||
end = toUInt32(arg1);
|
||
else
|
||
end = sourceLength;
|
||
}
|
||
}
|
||
else
|
||
end = sourceLength;
|
||
|
||
if (start > end)
|
||
return JSValue::newString(&cx->Empty_StringAtom);
|
||
return JSValue::newString(new String(sourceString->substr(start, end - start)));
|
||
}
|
||
|
||
/*
|
||
* 15.5.4.15 String.prototype.substring (start, end)
|
||
* The substring method takes two arguments, start and end, and returns a substring of the result of converting this
|
||
* object to a string, starting from character position start and running to, but not including, character position end of
|
||
* the string (or through the end of the string is end is undefined). The result is a string value, not a String object.
|
||
* If either argument is NaN or negative, it is replaced with zero; if either argument is larger than the length of the
|
||
* string, it is replaced with the length of the string.
|
||
* If start is larger than end, they are swapped.
|
||
*
|
||
* The following steps are taken:
|
||
* 1. Call ToString, giving it the this value as its argument.
|
||
* 2. Compute the number of characters in Result(1).
|
||
* 3. Call ToInteger(start).
|
||
* 4. If end is undefined, use Result(2); else use ToInteger(end).
|
||
* 5. Compute min(max(Result(3), 0), Result(2)).
|
||
* 6. Compute min(max(Result(4), 0), Result(2)).
|
||
* 7. Compute min(Result(5), Result(6)).
|
||
* 8. Compute max(Result(5), Result(6)).
|
||
* 9. Return a string whose length is the difference between Result(8) and Result(7), containing characters from
|
||
* Result(1), namely the characters with indices Result(7) through Result(8)-1, in ascending order.
|
||
*/
|
||
|
||
static js2val String_substring(Context *cx, const js2val thisValue, js2val *argv, uint32 argc)
|
||
{
|
||
const String *sourceString = JSValue::string(JSValue::toString(cx, thisValue));
|
||
|
||
uint32 sourceLength = sourceString->size();
|
||
uint32 start, end;
|
||
|
||
if (argc > 0) {
|
||
float64 farg0 = JSValue::f64(JSValue::toNumber(cx, argv[0]));
|
||
if (JSDOUBLE_IS_NaN(farg0) || (farg0 < 0))
|
||
start = 0;
|
||
else {
|
||
if (!JSDOUBLE_IS_FINITE(farg0))
|
||
start = sourceLength;
|
||
else {
|
||
start = JSValue::float64ToUInt32(farg0);
|
||
if (start > sourceLength)
|
||
start = sourceLength;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
start = 0;
|
||
|
||
if (argc > 1) {
|
||
float64 farg1 = JSValue::f64(JSValue::toNumber(cx, argv[1]));
|
||
if (JSDOUBLE_IS_NaN(farg1) || (farg1 < 0))
|
||
end = 0;
|
||
else {
|
||
if (!JSDOUBLE_IS_FINITE(farg1))
|
||
end = sourceLength;
|
||
else {
|
||
end = JSValue::float64ToUInt32(farg1);
|
||
if (end > sourceLength)
|
||
end = sourceLength;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
end = sourceLength;
|
||
|
||
if (start > end) {
|
||
uint32 t = start;
|
||
start = end;
|
||
end = t;
|
||
}
|
||
|
||
return JSValue::newString(new String(sourceString->substr(start, end - start)));
|
||
}
|
||
|
||
|
||
Context::PrototypeFunctions *getStringProtos()
|
||
{
|
||
Context::ProtoFunDef stringProtos[] =
|
||
{
|
||
{ "toString", String_Type, 0, String_toString },
|
||
{ "valueOf", String_Type, 0, String_valueOf },
|
||
{ "charAt", String_Type, 1, String_charAt },
|
||
{ "charCodeAt", Number_Type, 1, String_charCodeAt },
|
||
{ "concat", String_Type, 1, String_concat },
|
||
{ "indexOf", Number_Type, 2, String_indexOf }, // XXX ECMA spec says 1, but tests want 2 XXX
|
||
{ "lastIndexOf", Number_Type, 2, String_lastIndexOf }, // XXX ECMA spec says 1, but tests want 2 XXX
|
||
{ "localeCompare", Number_Type, 1, String_localeCompare },
|
||
{ "match", Array_Type, 1, String_match },
|
||
{ "replace", String_Type, 2, String_replace },
|
||
{ "search", Number_Type, 1, String_search },
|
||
{ "slice", String_Type, 2, String_slice },
|
||
{ "split", Array_Type, 1, String_split }, // XXX ECMA spec says 2, but tests want 1 XXX
|
||
{ "substring", String_Type, 2, String_substring },
|
||
{ "toSource", String_Type, 0, String_toString },
|
||
{ "toLocaleUpperCase", String_Type, 0, String_toUpperCase }, // (sic)
|
||
{ "toLocaleLowerCase", String_Type, 0, String_toLowerCase }, // (sic)
|
||
{ "toUpperCase", String_Type, 0, String_toUpperCase },
|
||
{ "toLowerCase", String_Type, 0, String_toLowerCase },
|
||
{ NULL }
|
||
};
|
||
return new Context::PrototypeFunctions(&stringProtos[0]);
|
||
}
|
||
|
||
}
|
||
}
|